FatFsVersion0.01源码分析 - amanlikethis - 博客园
https://www.cnblogs.com/amanlikethis/p/3793077.html
FatFsVersion0.01源码分析 目录
一、API的函数功能简述
二、FATFS主要数据结构
1、FAT32文件系统的结构
2、FATFS主要数据结构
①FATFS
②DIR
③FIL
④FILINFO
⑤win[512]
⑥buffer
三、函数功能与实现详细分析
0、move_window
1、f_mountdrv
2、f_open
3、f_read
4、f_write
5、f_sync
6、f_opendir
7、f_mkdir
8、f_unlink
9、f_lseek
10、f_readdir
四、FATFS文件系统解惑
1、win[]和buffer
2、无缓冲区模式
3、_FS_READONLY模式
五、FATFS文件系统函数使用注意事项
FATfs源码解析_hanchaoman的专栏-CSDN博客_fatfs详解
https://blog.csdn.net/hanchaoman/article/details/53022584
关键函数 图文结合更易理解和使用。
一、介绍：本文以网上开源文件系统FatFs 0.01为研究对象，剖析FatFs文件系统的核心操作。FatFs目前最新版本已更新到0.10a版本，而我之所以选择0.01版本，是因为这是最早的发布版本，与最新的版本相比，去掉了很多高级应用，且代码量相对较小，宏开关也少了许多，易于阅读和理解，用来研究它的雏形再合适不过了，所以笔者选择0.01版本进行剖析。当大家了解了0.01的核心思想后，再回去看最新的版本，也就容易理解多了。
FatFs历史版本下载：http://elm-chan.org/fsw/ff/00index_e.html在官网的最下面，能找到所有版本的下载链接。
二、重点：1. FatFs中有两个重要的缓冲区：win[]和buffer。win[]在FATFS结构体中，buffer在FIL结构体中。
win[]：系统缓冲区。当操作MBR，DBR，FAT表，根目录区时，使用该缓冲区；
buffer：文件缓冲区。当对文件的内容进行操作时，如读、写、修改时，才使用该缓冲区。
2. 在对文件的f_read和f_write过程中（不考虑f_lseek的情况），只有需要读写的最后一个扇区（内容小于512字节）才会被暂存到buffer中，而前面的扇区内容是直接通过磁盘驱动disk_read/disk_write在用户缓冲区和物理磁盘之间进行交互的。
注意：FatFs 0.01与最新的版本还是不少差异的，如在0.01中，buffer只是个指针，需要用户自己定义文件缓冲区，并将buffer指向该缓冲区。而最新版本中，FIL已经有自己的buf[_MAX_SS]。在0.01中没有f_mount()函数，所以需要手动将全局指针FatFs指向自己定义的变量fs。具体的操作流程可参考官网上的示例代码。
例如：
三、关键函数总结：1. f_open
f_open()2. f_read
{
1. 初始化SD卡，初始化FATFS对象；
2. 查找文件的目录项；
3. 填充文件结构体FIL。
}
f_read()
{
1. 从物理磁盘直接读取所需扇区到用户缓冲区，这个过程中未使用buffer缓冲区；
2. 如果最后一扇区要读取的字节数少于512，则先将最后一扇区读到buffer中，然后再从buffer拷贝需要的字节到用户缓冲区中。
}
文章图片
3. f_write
f_write()
{
1. 从用户缓冲区直接写入到物理磁盘，这个过程中未使用buffer缓冲区；
2. 如果要写入的最后一扇区内容少于512字节，则先从物理磁盘读取最后一扇区的内容到buffer中，然后修改buffer中的相应内容，并设置回写标记，这样下次调用f_close/f_write时，就会将buffer回写到物理磁盘中。
}
文章图片
4. f_close
关键是调用了f_sync函数。5. f_sync
f_sync()
{
1. 将buffer回写到物理磁盘中；
2. 读取文件对应的目录项到win[]中，更新参数，并回写。
}
文章图片
5. move_window
move_window专用于操作win[]系统缓冲区。调用前：
move_window(B);
文章图片
执行中：
文章图片
调用后：
文章图片
四、源码注释本人在不破坏源码逻辑的前提下，对FatFs 0.01源代码进行了中文注释，个别函数重新修改了排版布局，以方便阅读。结合以上示意图即伪代码，相信大家会很快理解FatFs 0.01的核心思想及架构。
#include #include "ff.h"/* FatFs declarations */ #include "diskio.h"/* Include file for user provided functions */ FATFS *FatFs; /* Pointer to the file system object */ /*------------------------------------------------------------------------- Module Private Functions -------------------------------------------------------------------------*/ /*----------------------*/ /* Change Window Offset */ //读取新的扇区内容到临时缓冲区win[]， //如果sector为0，则只需要把win[]的内容写入对应的物理扇区即可 static BOOL move_window ( DWORD sector/* Sector number to make apperance in the FatFs->win */ )/* Move to zero only writes back dirty window */ { DWORD wsect; //wsect用于检索FAT备份表的相应扇区 FATFS *fs = FatFs; wsect = FatFs->winsect; /*首先检查目标扇区号是否与win[]对应的扇区号相同，如果相同则不进行任何操作。*/ if (wsect != sector) { /* Changed current window */ #ifndef _FS_READONLY BYTE n; //首先检测win[]的内容是否做过修改，如果修改过，则需要先将其写入SD卡中。 if (FatFs->dirtyflag) { /* Write back dirty window if needed */ if (disk_write(FatFs->win, wsect, 1) != RES_OK) return FALSE; //清除修改标记 FatFs->dirtyflag = 0; /*如果当前操作的是FAT表，那么需要将修改后的FAT表拷贝到对应的FAT备份中*/ if (wsect < (FatFs->fatbase + FatFs->sects_fat)) { /* In FAT area */ for (n = FatFs->n_fats; n >= 2; n--) { /* Refrect the change to all FAT copies */ wsect += FatFs->sects_fat; if (disk_write(FatFs->win, wsect, 1) != RES_OK) break; } } } #endif //然后再读取新的扇区内容到win[]中 if (sector) { if (disk_read(FatFs->win, sector, 1) != RES_OK) return FALSE; FatFs->winsect = sector; //更新当前缓冲区的扇区号 } } return TRUE; } /*--------------------------------------------------------------------------*/ /* Public Funciotns*/ /*--------------------------------------------------------------------------*/ /*----------------------------------------------------------*/ /* Load File System Information and Initialize FatFs Module */ //本函数做三件事: // 1.初始化SD卡 // 2.检查文件系统类型，FAT16还是FAT32 // 3.填充FatFs对象，即记录物理磁盘的相关参数 FRESULT f_mountdrv () { BYTE fat; DWORD sect, fatend; FATFS *fs = FatFs; if (!fs) return FR_NOT_ENABLED; //首先对文件系统对象清空 /* Initialize file system object */ memset(fs, 0, sizeof(FATFS)); //然后初始化SD卡 /* Initialize disk drive */ if (disk_initialize() & STA_NOINIT) return FR_NOT_READY; //接着收搜索DBR系统引导记录，先检查第0扇区是否就是DBR(无MBR的SD卡)，如果是则检查文件系统的类型； //如果不是则说明第0扇区是MBR，则根据MBR中的信息定位到DBR所在扇区，并检查该文件系统的类型 /* Search FAT partition */ fat = check_fs(sect = 0); /* Check sector 0 as an SFD format */ if (!fat) {/* Not a FAT boot record, it will be an FDISK format */ /* Check a pri-partition listed in top of the partition table */ if (fs->win[0x1C2]) {/* Is the partition existing? */ sect = LD_DWORD(&(fs->win[0x1C6])); /* Partition offset in LBA */ fat = check_fs(sect); /* Check the partition */ } } if (!fat) return FR_NO_FILESYSTEM; /* No FAT patition */ //初始化文件系统对象，根据DBR参数信息对Fs成员赋值 /* Initialize file system object */ //文件系统类型:FAT16/FAT32 fs->fs_type = fat; /* FAT type */ //单个FAT表所占的扇区数 fs->sects_fat =/* Sectors per FAT */ (fat == FS_FAT32) ? LD_DWORD(&(fs->win[0x24])) : LD_WORD(&(fs->win[0x16])); //单个簇所占的扇区数 fs->sects_clust = fs->win[0x0D]; /* Sectors per cluster */ //FAT表总数 fs->n_fats = fs->win[0x10]; /* Number of FAT copies */ //FAT表起始扇区(物理扇区) fs->fatbase = sect + LD_WORD(&(fs->win[0x0E])); /* FAT start sector (physical) */ //根目录项数 fs->n_rootdir = LD_WORD(&(fs->win[0x11])); /* Nmuber of root directory entries */ //计算根目录起始扇区、数据起始扇区(物理扇区地址) fatend = fs->sects_fat * fs->n_fats + fs->fatbase; if (fat == FS_FAT32) { fs->dirbase = LD_DWORD(&(fs->win[0x2C])); /* Directory start cluster */ fs->database = fatend; /* Data start sector (physical) */ } else { fs->dirbase = fatend; /* Directory start sector (physical) */ fs->database = fs->n_rootdir / 16 + fatend; /* Data start sector (physical) */ } //最大簇号 fs->max_clust =/* Maximum cluster number */ (LD_DWORD(&(fs->win[0x20])) - fs->database + sect) / fs->sects_clust + 2; return FR_OK; } /*-----------------------*/ /* Open or Create a File */ FRESULT f_open ( FIL *fp,/* Pointer to the buffer of new file object to create */ const char *path, /* Pointer to the file path */ BYTE mode/* Access mode and file open mode flags */ ) { FRESULT res; BYTE *dir; DIR dirscan; char fn[8+3+1]; //8.3 DOS文件名 FATFS *fs = FatFs; /*首先初始化SD卡，检测文件系统类型，初始化FATFS对象*/ if ((res = check_mounted()) != FR_OK) return res; #ifndef _FS_READONLY //如果磁盘设置为写保护，则返回错误码:FR_WRITE_PROTECTED if ((mode & (FA_WRITE|FA_CREATE_ALWAYS)) && (disk_status() & STA_PROTECT)) return FR_WRITE_PROTECTED; #endif //根据用户提供的文件路径path，将文件名对应的目录项及其整个扇区读取到win[]中， //并填充目录项dirscan、标准格式的文件名fn，以及目录项在win[]中的字节偏移量dir res = trace_path(&dirscan, fn, path, &dir); /* Trace the file path */ #ifndef _FS_READONLY /* Create or Open a File */ if (mode & (FA_CREATE_ALWAYS|FA_OPEN_ALWAYS)) { DWORD dw; //如果文件不存在，则强制新建文件 if (res != FR_OK) {/* No file, create new */ mode |= FA_CREATE_ALWAYS; if (res != FR_NO_FILE) return res; dir = reserve_direntry(&dirscan); /* Reserve a directory entry */ if (dir == NULL) return FR_DENIED; memcpy(dir, fn, 8+3); /* Initialize the new entry */ *(dir+12) = fn[11]; memset(dir+13, 0, 32-13); } else {/* File already exists */ if ((dir == NULL) || (*(dir+11) & (AM_RDO|AM_DIR))) /* Could not overwrite (R/O or DIR) */ return FR_DENIED; //如果文件存在，但又以FA_CREATE_ALWAYS方式打开文件，则重写文件 if (mode & FA_CREATE_ALWAYS) { /* Resize it to zero */ dw = fs->winsect; /* Remove the cluster chain */ if (!remove_chain(((DWORD)LD_WORD(dir+20) << 16) | LD_WORD(dir+26)) || !move_window(dw) ) return FR_RW_ERROR; ST_WORD(dir+20, 0); ST_WORD(dir+26, 0); /* cluster = 0 */ ST_DWORD(dir+28, 0); /* size = 0 */ } } //如果是强制新建文件操作，则还需更新时间和日期 if (mode & FA_CREATE_ALWAYS) { *(dir+11) = AM_ARC; dw = get_fattime(); ST_DWORD(dir+14, dw); /* Created time */ ST_DWORD(dir+22, dw); /* Updated time */ fs->dirtyflag = 1; } } /* Open a File */ else { #endif if (res != FR_OK) return res; /* Trace failed */ //如果打开的是一个目录文件，则返回错误码:FR_NO_FILE if ((dir == NULL) || (*(dir+11) & AM_DIR)) /* It is a directory */ return FR_NO_FILE; #ifndef _FS_READONLY //如果以FA_WRITE方式打开Read-Only属性的文件，则返回错误码:FR_DENIED if ((mode & FA_WRITE) && (*(dir+11) & AM_RDO)) /* R/O violation */ return FR_DENIED; } #endif //填充FIL文件结构体参数 #ifdef _FS_READONLY fp->flag = mode & (FA_UNBUFFERED|FA_READ); #else fp->flag = mode & (FA_UNBUFFERED|FA_WRITE|FA_READ); fp->dir_sect = fs->winsect; /* Pointer to the directory entry */ fp->dir_ptr = dir; #endif fp->org_clust = ((DWORD)LD_WORD(dir+20) << 16) | LD_WORD(dir+26); /* File start cluster */ fp->fsize = LD_DWORD(dir+28); /* File size */ fp->fptr = 0; /* File ptr */ //这一步很重要，它将直接导致f_read和f_write操作中的逻辑顺序 fp->sect_clust = 1; /* Sector counter */ fs->files++; return FR_OK; } /*-----------*/ /* Read File */ //文件读操作 FRESULT f_read ( FIL *fp,/* Pointer to the file object */ BYTE *buff,/* Pointer to data buffer */ WORD btr,/* Number of bytes to read */ WORD *br/* Pointer to number of bytes read */ ) { DWORD clust, sect, ln; WORD rcnt; /*已经读取的字节数*/ BYTE cc; /*实际单次要读取的连续最大扇区数*/ FATFS *fs = FatFs; *br = 0; //错误处理 if (!fs) return FR_NOT_ENABLED; if ((disk_status() & STA_NOINIT) || !fs->fs_type) return FR_NOT_READY; /* Check disk ready */ if (fp->flag & FA__ERROR) return FR_RW_ERROR; /* Check error flag */ if (!(fp->flag & FA_READ)) return FR_DENIED; /* Check access mode */ //检查要读取的字节数是否超出了剩余的文件长度，如果超出了，则只读取剩余字节长度 ln = fp->fsize - fp->fptr; if (btr > ln) btr = ln; /* Truncate read count by number of bytes left */ //该循环以簇为单位，每循环一次就读完一个簇的内容 /* Repeat until all data transferred */ for ( ; btr; buff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) {//当文件指针与扇区边界对齐时(如:刚打开文件时)，执行以下操作； //否则(如:调用了f_lseek函数)只将当前buffer中需要的内容直接copy到目标缓冲区，然后进入下一次循环。 if ((fp->fptr & 511) == 0)/* On the sector boundary */ { //如果还没有读完当前簇的所有扇区，则将下一个扇区号赋给变量sect。 //注意，当第一次读取文件时，由于f_open函数中，已经将sect_clust赋值为1， //所以应该执行else语句 if (--(fp->sect_clust))/* Decrement sector counter */ { //一般走到这里就意味着只剩下最后一个扇区需要读取，且要读取的内容小于512字节 sect = fp->curr_sect + 1; /* Next sector */ } //如果已经读完当前簇的所有扇区，则计算下一个簇的起始位置， //并更新FIL中的当前簇号curr_clust和当前簇剩余扇区数sect_clust else/* Next cluster */ { //如果当前文件指针在起始簇内，则将clust设置为起始簇号； //否则，将clust设置为下一簇号 clust = (fp->fptr == 0) ? fp->org_clust : get_cluster(fp->curr_clust); if ((clust < 2) || (clust >= fs->max_clust)) goto fr_error; fp->curr_clust = clust; /* Current cluster */ sect = clust2sect(clust); /* Current sector */ fp->sect_clust = fs->sects_clust; /* Re-initialize the sector counter */ }#ifndef _FS_READONLY //如果buffer中的内容被修改过，则需要先将buffer中的内容回写到物理磁盘中 if (fp->flag & FA__DIRTY)/* Flush file I/O buffer if needed */ { if (disk_write(fp->buffer, fp->curr_sect, 1) != RES_OK) goto fr_error; fp->flag &= ~FA__DIRTY; } #endif //更新当前扇区号 fp->curr_sect = sect; /* Update current sector */ //计算需要读取部分的剩余扇区数cc(最后一个扇区内容若不满512字节则不计入cc中) cc = btr / 512; //只要当前扇区不是最后一个扇区，则执行连续的读操作，然后直接进入下一次循环 /* When left bytes >= 512 */ /* Read maximum contiguous sectors */ if (cc) { //如果cc小于当前簇的剩余扇区数sect_clust，则连续读取cc个扇区； //如果cc大于当前簇的剩余扇区数sect_clust，则只读取当前簇的剩余扇区 if (cc > fp->sect_clust) cc = fp->sect_clust; //执行实际的磁盘读操作，读取当前簇的剩余扇区内容到目标缓冲区中 //注意，是直接读到目标接收缓冲区的，而不是到buffer中 if (disk_read(buff, sect, cc) != RES_OK) goto fr_error; //更新当前簇的剩余扇区数 //该语句实际为:sect_clust = sect_clust - (cc - 1) = sect_clust - cc + 1; //之所以+1是因为当cc == sect_clust时，sect_clust = sect_clust - sect_clust + 1 = 1； //所以当下一次循环执行到 if (--(fp->sect_clust)) 时直接进入else语句。 fp->sect_clust -= cc - 1; //更新当前扇区号，扇区号是基于0索引的，所以这里要-1 fp->curr_sect += cc - 1; //更新已读的字节数 rcnt = cc * 512; //直接进入下一次循环 continue; } if (fp->flag & FA_UNBUFFERED)/* Reject unaligned access when unbuffered mode */ return FR_ALIGN_ERROR; //对于文件的最后一个扇区，则先将内容读取到buffer中，然后将需要的内容拷贝到目标缓冲区中，并退出循环 if (disk_read(fp->buffer, sect, 1) != RES_OK) /* Load the sector into file I/O buffer */ goto fr_error; }//end if ((fp->fptr & 511) == 0) //计算从buffer中实际要读取的字节数rcnt rcnt = 512 - (fp->fptr & 511); if (rcnt > btr) rcnt = btr; //最后将buffer中的指定数据拷贝到目标缓冲区中 memcpy(buff, &fp->buffer[fp->fptr & 511], rcnt); /* Copy fractional bytes from file I/O buffer */ //一般走到这里就说明已经读完了最后一扇区，下一步将退出循环; //如果还没有读完最后一扇，则有可能是在调用f_lseek后第一次调用f_read，那么将进入下一次循环 }//end for(...) return FR_OK; fr_error: /* Abort this file due to an unrecoverable error */ fp->flag |= FA__ERROR; return FR_RW_ERROR; } FRESULT f_write ( FIL *fp,/* Pointer to the file object */ const BYTE *buff, /* Pointer to the data to be written */ WORD btw,/* Number of bytes to write */ WORD *bw/* Pointer to number of bytes written */ ) { DWORD clust, sect; WORD wcnt; /*已经写入的字节数*/ BYTE cc; /*实际单次要写入的连续最大扇区数*/ FATFS *fs = FatFs; *bw = 0; //错误处理 if (!fs) return FR_NOT_ENABLED; if ((disk_status() & STA_NOINIT) || !fs->fs_type) return FR_NOT_READY; if (fp->flag & FA__ERROR) return FR_RW_ERROR; /* Check error flag */ if (!(fp->flag & FA_WRITE)) return FR_DENIED; /* Check access mode *///保证写入后整个文件大小不得超过4GB if (fp->fsize + btw < fp->fsize) btw = 0; /* File size cannot reach 4GB */ //该循环以簇为单位，每循环一次就写完一个簇的内容 /* Repeat until all data transferred */ for ( ; btw; buff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) { //当文件指针与扇区边界对齐时(如:刚打开文件时)，执行以下操作； //否则(如:调用了f_lseek函数)只将当前扇区所需要的内容copy到buffer中，然后进入下一次循环。 if ((fp->fptr & 511) == 0)/* On the sector boundary */ { //如果还没有写完当前簇的所有扇区，则将下一个扇区号赋给变量sect。 //注意，当第一次写文件时，由于f_open函数中，已经将sect_clust赋值为1， //所以应该执行else语句 if (--(fp->sect_clust))/* Decrement sector counter */ { //一般走到这里就意味着只剩下最后一个扇区需要写入，且要写入的内容小于512字节 sect = fp->curr_sect + 1; /* Next sector */ } //如果已经写完当前簇的所有扇区，则计算下一个簇的起始位置， //并更新FIL中的当前簇号curr_clust和当前簇剩余扇区数sect_clust else/* Next cluster */ { //如果当前文件指针在起始簇内，则将当前簇设置为起始簇； if (fp->fptr == 0)/* Top of the file */ { clust = fp->org_clust; //如果文件不存在，则先创建一个新的簇，并将该簇号设置为当前簇号 if (clust == 0)/* No cluster is created */ fp->org_clust = clust = create_chain(0); /* Create a new cluster chain */ } //如果当前文件指针不在起始簇内，则将下一簇号设置为当前簇号 else/* Middle or end of file */ { clust = create_chain(fp->curr_clust); /* Trace or streach cluster chain */ } if ((clust < 2) || (clust >= fs->max_clust)) break; fp->curr_clust = clust; /* Current cluster */ sect = clust2sect(clust); /* Current sector */ fp->sect_clust = fs->sects_clust; /* Re-initialize the sector counter */ }//如果buffer中的内容被修改过，则需要先将buffer中的内容回写到物理磁盘中 if (fp->flag & FA__DIRTY)/* Flush file I/O buffer if needed */ { if (disk_write(fp->buffer, fp->curr_sect, 1) != RES_OK) goto fw_error; fp->flag &= ~FA__DIRTY; }//更新当前扇区号 fp->curr_sect = sect; /* Update current sector */ //计算需要写入部分的剩余扇区数cc(最后一个扇区内容若不满512字节则不计入cc中) cc = btw / 512; //只要当前扇区不是最后一个扇区，则执行连续的写操作，然后直接进入下一次循环 /* When left bytes >= 512 */ /* Write maximum contiguous sectors */ if (cc) { //如果cc小于当前簇的剩余扇区数sect_clust，则连续写入cc个扇区； //如果cc大于当前簇的剩余扇区数sect_clust，则只将当前簇的剩余扇区写入物理磁盘中 if (cc > fp->sect_clust) cc = fp->sect_clust; //执行实际的磁盘写操作，将源缓冲区中的内容写入到当前簇的剩余扇区中 //注意，是直接从源缓冲区写到物理磁盘中的，没有经过buffer if (disk_write(buff, sect, cc) != RES_OK) goto fw_error; //更新当前簇的剩余扇区数 //该语句实际为:sect_clust = sect_clust - (cc - 1) = sect_clust - cc + 1; //之所以+1是因为当cc == sect_clust时，sect_clust = sect_clust - sect_clust + 1 = 1； //所以当下一次循环执行到 if (--(fp->sect_clust)) 时直接进入else语句。 fp->sect_clust -= cc - 1; //更新当前扇区号，扇区号是基于0索引的，所以这里要-1 fp->curr_sect += cc - 1; //更新已写的字节数 wcnt = cc * 512; //直接进入下一次循环 continue; }if (fp->flag & FA_UNBUFFERED)/* Reject unalighend access when unbuffered mode */ return FR_ALIGN_ERROR; //如果已经写到最后一个扇区了，则先将SD卡中所对应扇区的原始内容读取到buffer中，然后修改buffer中的内容，再从buffer回写到物理磁盘中 if ((fp->fptr < fp->fsize) && (disk_read(fp->buffer, sect, 1) != RES_OK)) /* Fill sector buffer with file data if needed */ goto fw_error; }//end if ((fp->fptr & 511) == 0) //计算实际要写入的字节数wcnt wcnt = 512 - (fp->fptr & 511); /* Copy fractional bytes to file I/O buffer */ if (wcnt > btw) wcnt = btw; //将源缓冲区中的数据拷贝到buffer中的指定位置 memcpy(&fp->buffer[fp->fptr & 511], buff, wcnt); //设置buffer回写标记，当调用f_close或执行下一次循环操作时，执行buffer回写操作 fp->flag |= FA__DIRTY; //一般走到这里就说明已经写完了最后一扇区，下一步将退出循环; //如果还没有写完最后一扇，则有可能是在调用f_lseek后第一次调用f_write，那么将进入下一次循环 }//end for(; btw; buff += wcnt,...) //如果对原始文件增加了新的内容，则需要更新文件的大小，并设置文件大小更新标记FA__WRITTEN if (fp->fptr > fp->fsize) fp->fsize = fp->fptr; /* Update file size if needed */ fp->flag |= FA__WRITTEN; /* Set file changed flag */ return FR_OK; fw_error: /* Abort this file due to an unrecoverable error */ fp->flag |= FA__ERROR; return FR_RW_ERROR; } FRESULT f_sync ( FIL *fp/* Pointer to the file object */ ) { BYTE *ptr; FATFS *fs = FatFs; if (!fs) return FR_NOT_ENABLED; if ((disk_status() & STA_NOINIT) || !fs->fs_type) return FR_INCORRECT_DISK_CHANGE; //检查文件是否增加了新的内容，如果是则需要修改目录项 /* Has the file been written? */ if (fp->flag & FA__WRITTEN) { //如果buffer的内容被修改了，则需要先将buffer的内容回写到物理磁盘中去 /* Write back data buffer if needed */ if (fp->flag & FA__DIRTY) { if (disk_write(fp->buffer, fp->curr_sect, 1) != RES_OK) return FR_RW_ERROR; fp->flag &= ~FA__DIRTY; } /*************由于更改了文件长度，所以需要修改文件对应的目录项************/ //首先读取文件对应的根目录扇区到win[] /* Update the directory entry */ if (!move_window(fp->dir_sect)) return FR_RW_ERROR; //然后修改根目录项 ptr = fp->dir_ptr; *(ptr+11) |= AM_ARC; /* Set archive bit */ ST_DWORD(ptr+28, fp->fsize); /* Update file size */ ST_WORD(ptr+26, fp->org_clust); /* Update start cluster */ ST_WORD(ptr+20, fp->org_clust >> 16); ST_DWORD(ptr+22, get_fattime()); /* Updated time */ //设置win[]回写标志 fs->dirtyflag = 1; //清除文件大小更改标记 fp->flag &= ~FA__WRITTEN; } //将win[]中的根目录信息回写到对应的物理扇区 if (!move_window(0)) return FR_RW_ERROR; return FR_OK; }
FAT16图文详解
FAT16图文详解_hexiaolong2009的专栏-CSDN博客_fat-16详解注：FAT16驱动代码不是本人编写的，是从网上下载的，本人只是对该代码进行研读学习，并做下笔记。该FAT16驱动应该是比较老的了，猜测应该在DOS时代比较流行，但放在今天，对于刚刚进阶FAT16的小伙伴来说，还是很适合初学者学习的好资料！笔者也相信，只要小伙伴们静下心来，慢慢读懂该代码，相信很快就能在脑海中形成一张FAT16的总览图了。
https://blog.csdn.net/hexiaolong2009/article/details/17592583
学习一下16位的FAT驱动代码
笔者对代码进行了简单测试，在STM32平台上对2G SD卡进行了读写TXT操作，没有问题。当然，这个代码功能还是很简单的，只有创建、读、写文件3个操作，而且写操作不能修改文件的大小，即没有追加功能，文件的大小是由CreateFile一开始创建好了的。
以下为源码部分：
//****************************************************************************************************
//文件名：FAT16.c
//来源：网络
//注释：hexiaolong2009(http://blog.csdn.net/hexiaolong2009)
//****************************************************************************************************
#include "stm32f10x.h"
#include "fat16.h"
#include "sd.h"
//****************************************************************************************************
//全局变量定义
u16 BytesPerSector;
u16 ResvdSectors;
u16 RootDirCnt;
u16 SectorsPerFAT;
u16 DirStartSector;
u16 DataStartSector;
u16 DBRStartSector;
u8 SectorsPerClus;
u8 FATCount;
u8 SectorBuf[512];
//读取一个逻辑扇区
static u8 ReadBlock(u16 LBA)
{
return SD_ReadSector(SectorBuf, LBA + DBRStartSector, 1);
}
//写入一个逻辑扇区
static u8 WriteBlock(u16 LBA)
{
return SD_WriteSector(SectorBuf, LBA + DBRStartSector, 1);
}
//将文件名格式化成标准的DOS 8.3格式的文件名
static void NameFormat(const char* SrcName, char* DstName)
{
u8 i, j;
//首先用空格初始化目标缓冲区
for(i = 0;
i < 11;
i++)
*(DstName + i) = 0x20;
//其次拷贝文件名
for(i = 0, j = 0;
i < 8;
i++, j++)
{
if((*SrcName) == '.')
{
SrcName++;
break;
}
else
{
*(DstName + j) = *SrcName++;
}
}
//最后拷贝扩展名
for(i = 0, j = 8;
i < 3;
i++, j++)
{
if((*SrcName) == 0)break;
else
{
*(DstName + j) = *SrcName++;
}
}
}
//比较两个缓冲区的前size个字节是否完全相同
static u8 IsEqual(void* Src1, void* Src2, u32 size)
{
u8 *p1, *p2;
p1 = Src1;
p2 = Src2;
for(;
size--;
)
{
if((*p1++) != (*p2++))
return 0;
}
return 1;
}
//将簇号转换为逻辑扇区号
static u16 Clus2Sector(u16 clus)
{
return (DataStartSector + ((clus - 2) * SectorsPerClus));
}
//读取主引导记录MBR
static u8 ReadMBR(void)
{
tMBR *pmbr = (tMBR *)SectorBuf;
//因为此时的DBRStartSector还未被赋值，等于0，所以这里读取的是物理扇区0
if(0 == ReadBlock(0)) return 0;
if(0xAA55 != pmbr->Flag) return 0;
//通过磁盘分区表DPT字段来获取系统引导扇区DBR的扇区偏移量
DBRStartSector = (pmbr->DPT[0].LBAoffest[1] << 16) + pmbr->DPT[0].LBAoffest[0];
return 1;
}
//读取系统引导扇区DBR
static u8 ReadDBR(void)
{
tDBR *pdbr = (tDBR*)SectorBuf;
if(0 == ReadBlock(0)) return 0;
if(0xAA55 != pdbr->Flag) return 0;
//通过系统引导扇区中的BPB字段，计算磁盘的相关参数
BytesPerSector = (pdbr->BPB.BytesPerSector[1] << 8) + pdbr->BPB.BytesPerSector[0];
SectorsPerClus = pdbr->BPB.SectorsPerClus;
ResvdSectors = (pdbr->BPB.ResvdSectors[1] << 8) + pdbr->BPB.ResvdSectors[0];
FATCount = pdbr->BPB.FATCount;
RootDirCnt = (pdbr->BPB.DirCount[1] << 8) + pdbr->BPB.DirCount[0];
SectorsPerFAT = (pdbr->BPB.SectorsPerFAT[1] << 8) + pdbr->BPB.SectorsPerFAT[0];
DirStartSector = ResvdSectors + SectorsPerFAT * FATCount;
DataStartSector = DirStartSector + 32;
return 1;
}
//读取FAT表项的值
static u16 ReadFAT(u16 Index)
{
u16 *pItem = (u16*)&SectorBuf[0];
//因为1扇区 = 256个FAT表项，所以Index >> 8表示从FAT开始的扇区偏移
if(0 == ReadBlock((Index >> 8) + ResvdSectors)) return 0;
//Index % 256 表示扇区内的字偏移
return *(pItem + (Index % 256));
}
//写入某一FAT表项的值
static u16 WriteFAT(u16 Index, u16 val)
{
u16 *pItem = (u16*)&SectorBuf[0];
//计算Index所在的逻辑扇区号
u16 sector = (Index >> 8) + ResvdSectors;
if(0 == ReadBlock(sector)) return 0;
//Index % 256 表示扇区内的字偏移
*(pItem + (Index % 256)) = val;
if(0 == WriteBlock(sector)) return 0;
return 1;
}
//将FAT1的某一扇区拷贝到FAT2所对应的扇区
//sector表示从FAT1开始的扇区偏移
static u8 CopyFAT(u16 sector)
{
if(!ReadBlock(ResvdSectors + sector)) return 0;
if(!WriteBlock(ResvdSectors + SectorsPerFAT + sector)) return 0;
return 1;
}
//FAT16初始化
u8 FAT_Init(void)
{
//先读取MBR，找到系统引导扇区的位置
if(0 == ReadMBR()) return 0;
//再读取系统引导扇区中的BPB，获取磁盘的相关参数
if(0 == ReadDBR()) return 0;
return 1;
}
//查找根目录下是否存在name所对应的文件，如果存在则将该文件信息存放到dir所指向的结构体中
u8 GetFileDir(const char* name, tDIR *dir)
{
u8 i, j;
tDIR *pDir;
char DOSname[11];
//第一步要将name格式化成标准8.3格式的文件名
NameFormat(name, DOSname);
//因为根目录区总共占32个扇区
for(j = 0;
j < 32;
j++)
{
if(0 == ReadBlock(DirStartSector + j)) return 0;
//而每个扇区又包含16个目录项
for(i = 0;
i < 16;
i++)
{
//每个目录项又占32个字节，所以这里用i << 5表示目录项在一个扇区中的字节偏移
pDir = (tDIR *)&SectorBuf[i << 5];
//通过文件名来查找文件
if(IsEqual(DOSname, pDir->Name, 11))
{
*dir = *pDir;
return 1;
}
}
}
return 0;
}
//将文件信息写入Index所指定的目录项中
static u8 WriteDir(u16 Index, tDIR *dir)
{
tDIR *pDir;
//计算Index所在的逻辑扇区偏移，Index / 16表示从目录区开始的扇区偏移量
u16 sector = Index / 16 + DirStartSector;
if(!ReadBlock(sector)) return 0;
pDir = (tDIR*)&SectorBuf[0];
//Index % 16表示1个扇区内的目录项偏移
*(pDir + (Index % 16)) = *dir;
if(!WriteBlock(sector)) return 0;
return 1;
}
//从根目录区中获取一个空的目录项
static u16 GetEmptyDir(void)
{
u8 j, i;
u16 index = 0;
//因为根目录区总共占32个扇区
for(i = 0;
i < 32;
i++)
{
if(!ReadBlock(DirStartSector + i)) return 0xffff;
//而每个扇区又包含16个目录项
for(j = 0;
j < 16;
j++)
{
//每个目录项又占32个字节，所以这里用j * 32表示目录项在一个扇区中的字节偏移
if(0 == SectorBuf[j * 32])
return index;
index++;
}
}
return 0xffff;
}
//获取一个空的FAT表项，即一个空簇的簇号
static u16 GetEmptyFAT(void)
{
u16 i, j;
u16 *pItem;
//遍历FAT表所占的每个扇区
for(i = 0;
i < SectorsPerFAT;
i++)
{
if(0 == ReadBlock(i + ResvdSectors)) return 0;
pItem = (u16*)&SectorBuf[0];
//遍历扇区内的每个FAT表项
for(j = 0;
j < 256;
j++)
{
if(*(pItem + j) == 0) return ((i << 8) + j);
}
}
return 0;
}
//新建一个文件
//注意：文件的大小已固定为size字节，即使新建的文件没有写任何内容，文件的大小始终为size大小；
//即使对该文件写入了超过size大小的内容，文件的大小依然不改变
//该函数有待进一步优化，对于大文件的创建，该函数速度非常缓慢
u8 CreateFile(const char* name, u32 size)
{
tDIR dir = {0};
//一定要初始化为0，否则在WINDOWS系统下无法识别文件
u16 ClusID;
u16 i;
u16 FATSector;
//计算一簇所占的字节数
u32 BytesPerClus = BytesPerSector * SectorsPerClus;
//文件已存在，则返回
if(GetFileDir(name, &dir)) return 0;
//首先从根目录区获取一个空的目录项
i = GetEmptyDir();
if(i == 0xffff) return 0;
//从FAT表中获取一个空的FAT表项
ClusID = GetEmptyFAT();
//立即将该空的FAT表项填充为0xFFFF，以免后面再次获取空的FAT表项时错误的分配到同一表项
if(0 == WriteFAT(ClusID, 0xFFFF)) return 0;
//然后给该目录项填充文件信息
NameFormat(name, dir.Name);
dir.Attri = 0;
dir.FirstClus = ClusID;
dir.Length[0] = size;
dir.Length[1] = size >> 16;
//将目录信息回写到目录表中
if(0 == WriteDir(i, &dir)) return 0;
//计算分配到的FAT表项在FAT表中的扇区偏移
FATSector = ClusID / 256;
for(/*文件所占簇个数*/i = size / BytesPerClus;
i != 0;
i--)
{
u16 NextClus;
//获取下一个空簇的簇号
NextClus = GetEmptyFAT();
if(!NextClus) return 0;
//此部分有待优化
if(0 == WriteFAT(ClusID, NextClus)) return 0;
if(0 == WriteFAT(NextClus, 0xFFFF)) return 0;
//当下一FAT表项所在位置不在当前FAT扇区时，立即将当前FAT1扇区的内容拷贝到对应的FAT2中
if(FATSector != (NextClus / 256))
{
CopyFAT(FATSector);
//并将下一FAT表项所在扇区偏移赋值给FATSector
FATSector = NextClus / 256;
}
ClusID = NextClus;
}
//将最后一扇区拷贝到FAT2中的相应位置
CopyFAT(FATSector);
return 1;
}
//读取文件
u8 ReadFile(const char* name, u32 offest, void* dst, u32 len)
{
tDIR dir;
u16 ClusID;
u16 StartSector;
u32 FileSize;
u32 PtrByteOffest, PtrSectorOffest, PtrClusOffest;
u16 i;
u8 *pDst = (u8*)dst;
//首先找到文件对应的目录项
if(!GetFileDir(name, &dir)) return 0;
FileSize = (dir.Length[1] << 16) + dir.Length[0];
//文件指针超出文件尾则返回
if(offest > FileSize) return 0;
//len大于文件长度的情况
if((offest + len) > FileSize)
len = FileSize - offest;
ClusID = dir.FirstClus;
//文件指针相对于文件头的扇区偏移
PtrSectorOffest = offest / BytesPerSector;
//文件指针相对于当前扇区的字节偏移
PtrByteOffest = offest % BytesPerSector;
//文件指针相对于文件头的簇偏移
PtrClusOffest = PtrSectorOffest / SectorsPerClus;
//找到文件指针所在簇号
for(i = 0;
i < PtrClusOffest;
i++)
ClusID = ReadFAT(ClusID);
//文件指针相对于系统分区的扇区偏移
StartSector = Clus2Sector(ClusID) + PtrSectorOffest;
while(1)
{
//2.从指针所在的扇区开始，遍历文件的每个扇区
for(;
PtrSectorOffest < SectorsPerClus;
PtrSectorOffest++)
{
if(!ReadBlock(StartSector++)) return 0;
//1.从指针所在扇区的字节偏移开始，遍历扇区的每个字节
for(;
PtrByteOffest < BytesPerSector;
PtrByteOffest++)
{
*pDst++ = SectorBuf[PtrByteOffest];
len--;
if(0 == len) return 1;
}
PtrByteOffest = 0;
}
//读取下一簇号
ClusID = ReadFAT(ClusID);
//获取下一簇所在的扇区号
StartSector = Clus2Sector(ClusID);
PtrSectorOffest = 0;
}
}
//写文件
u8 WriteFile(const char* name, u32 offest, void* src, u32 len)
{
tDIR dir;
u16 ClusID;
u16 StartSector;
u32 FileSize;
u32 PtrByteOffest, PtrSectorOffest, PtrClusOffest;
u16 i;
u8 *pSrc = https://www.it610.com/article/(u8*)src;
if(!GetFileDir(name, &dir)) return 0;
FileSize = (dir.Length[1] << 16) + dir.Length[0];
//文件指针超出文件尾则返回
if(offest> FileSize) return 0;
//len大于文件长度的情况
if((offest + len) > FileSize)
len = FileSize - offest;
ClusID = dir.FirstClus;
//文件指针相对于文件头的扇区偏移
PtrSectorOffest = offest / BytesPerSector;
//文件指针相对于当前扇区的字节偏移
PtrByteOffest = offest % BytesPerSector;
//文件指针相对于文件头的簇偏移
PtrClusOffest = PtrSectorOffest / SectorsPerClus;
//找到文件指针所在簇号
for(i = 0;
i < PtrClusOffest;
i++)
ClusID = ReadFAT(ClusID);
//文件指针相对于系统分区的扇区偏移
StartSector = Clus2Sector(ClusID) + PtrSectorOffest;
while(1)
{
//2.从指针所在的扇区开始，遍历文件的每个扇区
for(;
PtrSectorOffest < SectorsPerClus;
PtrSectorOffest++)
{
if(!ReadBlock(StartSector)) return 0;
//1.从指针所在扇区的字节偏移开始，遍历扇区的每个字节
for(;
PtrByteOffest < BytesPerSector;
PtrByteOffest++)
{
SectorBuf[PtrByteOffest] = *pSrc++;
len--;
if(0 == len)
{
if(!WriteBlock(StartSector)) return 0;
else return 1;
}
}
if(!WriteBlock(StartSector++)) return 0;
PtrByteOffest = 0;
}
//读取下一簇号
ClusID = ReadFAT(ClusID);
//获取下一簇所在的扇区号
StartSector = Clus2Sector(ClusID);
PtrSectorOffest = 0;
}
}
文章图片
文章图片
文章图片
文章图片
文章图片
【FATfs源码解析】
