FAT16图文详解

hexiaolong2008

注：FAT16驱动代码不是本人编写的，是从网上下载的，本人只是对该代码进行研读学习，并做下笔记。该FAT16驱动应该是比较老的了，猜测应该在DOS时代比较流行，但放在今天，对于刚刚进阶FAT16的小伙伴来说，还是很适合初学者学习的好资料！笔者也相信，只要小伙伴们静下心来，慢慢读懂该代码，相信很快就能在脑海中形成一张FAT16的总览图了。
笔者对代码进行了简单测试，在STM32平台上对2G SD卡进行了读写TXT操作，没有问题。当然，这个代码功能还是很简单的，只有创建、读、写文件3个操作，而且写操作不能修改文件的大小，即没有追加功能，文件的大小是由CreateFile一开始创建好了的。

以下为源码部分：

1. #include "stm32f10x.h"
   
2. #include "fat16.h"
   
3. #include "sd.h"
   
4. 
   
5. //****************************************************************************************************
   
6. //全局变量定义
   
7. u16 BytesPerSector;
   
8. u16 ResvdSectors;
   
9. u16 RootDirCnt;
   
10. u16 SectorsPerFAT;
    
11. u16 DirStartSector;
    
12. u16 DataStartSector;
    
13. u16 DBRStartSector;
    
14. u8 SectorsPerClus;
    
15. u8 FATCount;
    
16. u8 SectorBuf[512];
    
17. 
    
18. //读取一个逻辑扇区
    
19. static u8 ReadBlock(u16 LBA)
    
20. {
    
21.         return SD_ReadSector(SectorBuf, LBA + DBRStartSector, 1);
    
22. }
    
23. 
    
24. //写入一个逻辑扇区
    
25. static u8 WriteBlock(u16 LBA)
    
26. {
    
27.         return SD_WriteSector(SectorBuf, LBA + DBRStartSector, 1);
    
28. }
    
29. 
    
30. //将文件名格式化成标准的DOS 8.3格式的文件名
    
31. static void NameFormat(const char* SrcName, char* DstName)
    
32. {
    
33.         u8 i, j;
    
34. 
    
35.         //首先用空格初始化目标缓冲区
    
36.         for(i = 0; i < 11; i++)
    
37.                 *(DstName + i) = 0x20;
    
38. 
    
39.         //其次拷贝文件名
    
40.         for(i = 0, j = 0; i < 8; i++, j++)
    
41.         {
    
42.                 if((*SrcName) == '.')          
    
43.                 {
    
44.                         SrcName++;
    
45.                         break;
    
46.                 }
    
47.                 else
    
48.                 {
    
49.                         *(DstName + j) = *SrcName++;
    
50.                 }
    
51.         }
    
52. 
    
53.         //最后拷贝扩展名
    
54.         for(i = 0, j = 8; i < 3; i++, j++)
    
55.         {
    
56.                 if((*SrcName) == 0)          break;
    
57.                 else        
    
58.                 {
    
59.                         *(DstName + j) = *SrcName++;
    
60.                 }
    
61.         }
    
62. }
    
63. 
    
64. //比较两个缓冲区的前size个字节是否完全相同
    
65. static u8 IsEqual(void* Src1, void* Src2, u32 size)
    
66. {
    
67.         u8 *p1, *p2;
    
68. 
    
69.         p1 = Src1;
    
70.         p2 = Src2;
    
71.         for(; size--; )
    
72.         {
    
73.                 if((*p1++) != (*p2++))
    
74.                         return 0;
    
75. 
    
76.         }
    
77.         return 1;
    
78. }
    
79. 
    
80. //将簇号转换为逻辑扇区号
    
81. static u16 Clus2Sector(u16 clus)
    
82. {
    
83.         return (DataStartSector + ((clus - 2) * SectorsPerClus));
    
84. }
    
85. 
    
86. //读取主引导记录MBR
    
87. static u8 ReadMBR(void)
    
88. {
    
89.         tMBR *pmbr = (tMBR *)SectorBuf;
    
90. 
    
91.         //因为此时的DBRStartSector还未被赋值，等于0，所以这里读取的是物理扇区0
    
92.         if(0 == ReadBlock(0))        return 0;
    
93.         if(0xAA55 != pmbr->Flag)        return 0;
    
94.         //通过磁盘分区表DPT字段来获取系统引导扇区DBR的扇区偏移量
    
95.         DBRStartSector = (pmbr->DPT[0].LBAoffest[1] << 16) + pmbr->DPT[0].LBAoffest[0];        
    
96. 
    
97.         return 1;
    
98. }
    
99. 
    
100. //读取系统引导扇区DBR
     
101. static u8 ReadDBR(void)
     
102. {
     
103.         tDBR *pdbr = (tDBR*)SectorBuf;
     
104. 
     
105.         if(0 == ReadBlock(0)) return 0;
     
106.         if(0xAA55 != pdbr->Flag)        return 0;
     
107. 
     
108.         //通过系统引导扇区中的BPB字段，计算磁盘的相关参数
     
109.         BytesPerSector = (pdbr->BPB.BytesPerSector[1] << 8) + pdbr->BPB.BytesPerSector[0];
     
110.         SectorsPerClus = pdbr->BPB.SectorsPerClus;
     
111.         ResvdSectors = (pdbr->BPB.ResvdSectors[1] << 8) + pdbr->BPB.ResvdSectors[0];
     
112.         FATCount = pdbr->BPB.FATCount;
     
113.         RootDirCnt = (pdbr->BPB.DirCount[1] << 8) + pdbr->BPB.DirCount[0];
     
114.         SectorsPerFAT = (pdbr->BPB.SectorsPerFAT[1] << 8) + pdbr->BPB.SectorsPerFAT[0];
     
115.         DirStartSector = ResvdSectors + SectorsPerFAT * FATCount;
     
116.         DataStartSector = DirStartSector + 32;
     
117. 
     
118.         return 1;
     
119. }
     
120. 
     
121. //读取FAT表项的值
     
122. static u16 ReadFAT(u16 Index)
     
123. {
     
124.         u16 *pItem = (u16*)&SectorBuf[0];
     
125. 
     
126.         //因为1扇区 = 256个FAT表项，所以Index >> 8表示从FAT开始的扇区偏移
     
127.         if(0 == ReadBlock((Index >> 8) + ResvdSectors)) return 0;
     
128.         //Index % 256 表示扇区内的字偏移
     
129.         return *(pItem + (Index % 256));
     
130. }
     
131. 
     
132. //写入某一FAT表项的值
     
133. static u16 WriteFAT(u16 Index, u16 val)
     
134. {
     
135.         u16 *pItem = (u16*)&SectorBuf[0];
     
136.         //计算Index所在的逻辑扇区号
     
137.         u16 sector = (Index >> 8) + ResvdSectors;
     
138. 
     
139.         if(0 == ReadBlock(sector)) return 0;
     
140.         //Index % 256 表示扇区内的字偏移
     
141.         *(pItem + (Index % 256)) = val;
     
142.         if(0 == WriteBlock(sector)) return 0;
     
143.         return 1;
     
144. }
     
145. 
     
146. //将FAT1的某一扇区拷贝到FAT2所对应的扇区
     
147. //sector表示从FAT1开始的扇区偏移
     
148. static u8 CopyFAT(u16 sector)
     
149. {
     
150.         if(!ReadBlock(ResvdSectors + sector)) return 0;
     
151.         if(!WriteBlock(ResvdSectors + SectorsPerFAT + sector)) return 0;
     
152.         return 1;
     
153. }
     
154. 
     
155. //FAT16初始化
     
156. u8 FAT_Init(void)
     
157. {
     
158.         //先读取MBR，找到系统引导扇区的位置
     
159.         if(0 == ReadMBR()) return 0;
     
160.         //再读取系统引导扇区中的BPB，获取磁盘的相关参数
     
161.         if(0 == ReadDBR()) return 0;
     
162. 
     
163.         return 1;        
     
164. }
     
165. 
     
166. //查找根目录下是否存在name所对应的文件，如果存在则将该文件信息存放到dir所指向的结构体中
     
167. u8 GetFileDir(const char* name, tDIR *dir)
     
168. {
     
169.         u8 i, j;
     
170.         tDIR *pDir;
     
171.         char DOSname[11];
     
172. 
     
173.         //第一步要将name格式化成标准8.3格式的文件名
     
174.         NameFormat(name, DOSname);
     
175. 
     
176.         //因为根目录区总共占32个扇区
     
177.         for(j = 0; j < 32; j++)
     
178.         {
     
179.                 if(0 == ReadBlock(DirStartSector + j)) return 0;
     
180.                 //而每个扇区又包含16个目录项
     
181.                 for(i = 0; i < 16; i++)
     
182.                 {
     
183.                         //每个目录项又占32个字节，所以这里用i << 5表示目录项在一个扇区中的字节偏移
     
184.                         pDir = (tDIR *)&SectorBuf[i << 5];
     
185.                         //通过文件名来查找文件
     
186.                         if(IsEqual(DOSname, pDir->Name, 11))
     
187.                         {
     
188.                                 *dir = *pDir;
     
189.                                 return 1;        
     
190.                         }
     
191.                 }
     
192.         }
     
193.         return 0;
     
194. }
     
195. 
     
196. //将文件信息写入Index所指定的目录项中
     
197. static u8 WriteDir(u16 Index, tDIR *dir)
     
198. {
     
199.         tDIR *pDir;
     
200.         //计算Index所在的逻辑扇区偏移，Index / 16表示从目录区开始的扇区偏移量
     
201.         u16 sector = Index / 16 + DirStartSector;
     
202. 
     
203.         if(!ReadBlock(sector)) return 0;
     
204.         pDir = (tDIR*)&SectorBuf[0];
     
205.         //Index % 16表示1个扇区内的目录项偏移
     
206.         *(pDir + (Index % 16)) = *dir;
     
207.         if(!WriteBlock(sector)) return 0;
     
208. 
     
209.         return 1;
     
210. }
     
211. 
     
212. //从根目录区中获取一个空的目录项
     
213. static u16 GetEmptyDir(void)
     
214. {
     
215.         u8 j, i;
     
216.         u16 index = 0;
     
217. 
     
218.         //因为根目录区总共占32个扇区
     
219.         for(i = 0; i < 32; i++)
     
220.         {
     
221.                 if(!ReadBlock(DirStartSector + i)) return 0xffff;
     
222.                 //而每个扇区又包含16个目录项
     
223.                 for(j = 0; j < 16; j++)
     
224.                 {
     
225.                         //每个目录项又占32个字节，所以这里用j * 32表示目录项在一个扇区中的字节偏移
     
226.                         if(0 == SectorBuf[j * 32])
     
227.                                 return index;
     
228.                         index++;        
     
229.                 }
     
230.         }
     
231. 
     
232.         return 0xffff;
     
233. }
     
234. 
     
235. //获取一个空的FAT表项，即一个空簇的簇号
     
236. static u16 GetEmptyFAT(void)
     
237. {
     
238.         u16 i, j;
     
239.         u16 *pItem;
     
240. 
     
241.         //遍历FAT表所占的每个扇区
     
242.         for(i = 0; i < SectorsPerFAT; i++)
     
243.         {
     
244.                 if(0 == ReadBlock(i + ResvdSectors)) return 0;
     
245.                 pItem = (u16*)&SectorBuf[0];
     
246.                 //遍历扇区内的每个FAT表项
     
247.                 for(j = 0; j < 256; j++)
     
248.                 {
     
249.                         if(*(pItem + j) == 0) return ((i << 8) + j);
     
250.                 }
     
251.         }
     
252.         return 0;
     
253. }
     

复制代码

FAT总览图：

 

FAT16初始化：

 

创建文件：

1. //新建一个文件
   
2. //注意：文件的大小已固定为size字节，即使新建的文件没有写任何内容，文件的大小始终为size大小；
   
3. //                即使对该文件写入了超过size大小的内容，文件的大小依然不改变
   
4. //该函数有待进一步优化，对于大文件的创建，该函数速度非常缓慢
   
5. u8 CreateFile(const char* name, u32 size)
   
6. {
   
7.         tDIR dir = {0};        //一定要初始化为0，否则在WINDOWS系统下无法识别文件
   
8.         u16 ClusID;
   
9.         u16 i;
   
10.         u16 FATSector;
    
11.         //计算一簇所占的字节数
    
12.         u32 BytesPerClus = BytesPerSector * SectorsPerClus;
    
13. 
    
14.         //文件已存在，则返回
    
15.         if(GetFileDir(name, &dir)) return 0;
    
16. 
    
17.         //首先从根目录区获取一个空的目录项
    
18.         i = GetEmptyDir();
    
19.         if(i == 0xffff) return 0;
    
20. 
    
21.         //从FAT表中获取一个空的FAT表项
    
22.         ClusID = GetEmptyFAT();
    
23.         //立即将该空的FAT表项填充为0xFFFF，以免后面再次获取空的FAT表项时错误的分配到同一表项
    
24.         if(0 == WriteFAT(ClusID, 0xFFFF)) return 0;
    
25. 
    
26.         //然后给该目录项填充文件信息
    
27.         NameFormat(name, dir.Name);
    
28.         dir.Attri = 0;
    
29.         dir.FirstClus = ClusID;
    
30.         dir.Length[0] = size;
    
31.         dir.Length[1] = size >> 16;
    
32.         //将目录信息回写到目录表中
    
33.         if(0 == WriteDir(i, &dir)) return 0;
    
34. 
    
35.         //计算分配到的FAT表项在FAT表中的扇区偏移
    
36.         FATSector = ClusID / 256;
    
37.         for(/*文件所占簇个数*/i = size / BytesPerClus; i != 0; i--)
    
38.         {
    
39.                 u16 NextClus;
    
40. 
    
41.                 //获取下一个空簇的簇号
    
42.                 NextClus = GetEmptyFAT();
    
43.                 if(!NextClus) return 0;
    
44.                 //此部分有待优化
    
45.                 if(0 == WriteFAT(ClusID, NextClus)) return 0;
    
46.                 if(0 == WriteFAT(NextClus, 0xFFFF)) return 0;
    
47.                 //当下一FAT表项所在位置不在当前FAT扇区时，立即将当前FAT1扇区的内容拷贝到对应的FAT2中
    
48.                 if(FATSector != (NextClus / 256))
    
49.                 {
    
50.                         CopyFAT(FATSector);
    
51.                         //并将下一FAT表项所在扇区偏移赋值给FATSector
    
52.                         FATSector = NextClus / 256;
    
53.                 }
    
54.                 ClusID = NextClus;
    
55.         }
    
56.         //将最后一扇区拷贝到FAT2中的相应位置
    
57.         CopyFAT(FATSector);
    
58. 
    
59.         return 1;
    
60. }                                
    

复制代码

 


读文件：

1. //读取文件
   
2. u8 ReadFile(const char* name, u32 offest, void* dst, u32 len)
   
3. {
   
4.         tDIR dir;
   
5.         u16 ClusID;
   
6.         u16 StartSector;
   
7.         u32 FileSize;
   
8.         u32 PtrByteOffest, PtrSectorOffest, PtrClusOffest;
   
9.         u16 i;
   
10.         u8 *pDst = (u8*)dst;
    
11. 
    
12.         //首先找到文件对应的目录项
    
13.         if(!GetFileDir(name, &dir)) return 0;
    
14. 
    
15.         FileSize = (dir.Length[1] << 16) + dir.Length[0];
    
16.         //文件指针超出文件尾则返回
    
17.         if(offest > FileSize) return 0;
    
18.         //len大于文件长度的情况
    
19.         if((offest + len) > FileSize)
    
20.                 len = FileSize - offest;
    
21. 
    
22.         ClusID = dir.FirstClus;
    
23.         //文件指针相对于文件头的扇区偏移
    
24.         trSectorOffest = offest / BytesPerSector;
    
25.         //文件指针相对于当前扇区的字节偏移
    
26.         trByteOffest = offest % BytesPerSector;
    
27.         //文件指针相对于文件头的簇偏移
    
28.         trClusOffest = PtrSectorOffest / SectorsPerClus;
    
29. 
    
30.         //找到文件指针所在簇号
    
31.         for(i = 0; i < PtrClusOffest; i++)
    
32.                 ClusID = ReadFAT(ClusID);
    
33.         //文件指针相对于系统分区的扇区偏移
    
34.         StartSector = Clus2Sector(ClusID) + PtrSectorOffest;
    
35. 
    
36.         while(1)
    
37.         {
    
38.                 //2.从指针所在的扇区开始，遍历文件的每个扇区
    
39.                 for(; PtrSectorOffest < SectorsPerClus; PtrSectorOffest++)
    
40.                 {
    
41.                         if(!ReadBlock(StartSector++)) return 0;
    
42. 
    
43.                         //1.从指针所在扇区的字节偏移开始，遍历扇区的每个字节
    
44.                         for(; PtrByteOffest < BytesPerSector; PtrByteOffest++)
    
45.                         {
    
46.                                 *pDst++        = SectorBuf[PtrByteOffest];
    
47.                                 len--;
    
48.                                 if(0 == len) return 1;
    
49.                         }
    
50.                         trByteOffest = 0;
    
51.                 }
    
52.                 //读取下一簇号
    
53.                 ClusID = ReadFAT(ClusID);
    
54.                 //获取下一簇所在的扇区号
    
55.                 StartSector = Clus2Sector(ClusID);
    
56.                 PtrSectorOffest = 0;
    
57.         }
    
58. }
    

复制代码

 

写文件：

1. //写文件
   
2. u8 WriteFile(const char* name, u32 offest, void* src, u32 len)
   
3. {
   
4.         tDIR dir;
   
5.         u16 ClusID;
   
6.         u16 StartSector;
   
7.         u32 FileSize;
   
8.         u32 PtrByteOffest, PtrSectorOffest, PtrClusOffest;
   
9.         u16 i;
   
10.         u8 *pSrc = (u8*)src;
    
11. 
    
12.         if(!GetFileDir(name, &dir)) return 0;
    
13. 
    
14.         FileSize = (dir.Length[1] << 16) + dir.Length[0];
    
15.         //文件指针超出文件尾则返回
    
16.         if(offest > FileSize) return 0;
    
17.         //len大于文件长度的情况
    
18.         if((offest + len) > FileSize)
    
19.                 len = FileSize - offest;
    
20. 
    
21.         ClusID = dir.FirstClus;
    
22.         //文件指针相对于文件头的扇区偏移
    
23.         trSectorOffest = offest / BytesPerSector;
    
24.         //文件指针相对于当前扇区的字节偏移
    
25.         trByteOffest = offest % BytesPerSector;
    
26.         //文件指针相对于文件头的簇偏移
    
27.         trClusOffest = PtrSectorOffest / SectorsPerClus;
    
28. 
    
29.         //找到文件指针所在簇号
    
30.         for(i = 0; i < PtrClusOffest; i++)
    
31.                 ClusID = ReadFAT(ClusID);
    
32.         //文件指针相对于系统分区的扇区偏移
    
33.         StartSector = Clus2Sector(ClusID) + PtrSectorOffest;
    
34. 
    
35.         while(1)
    
36.         {
    
37.                 //2.从指针所在的扇区开始，遍历文件的每个扇区
    
38.                 for(; PtrSectorOffest < SectorsPerClus; PtrSectorOffest++)
    
39.                 {
    
40.                         if(!ReadBlock(StartSector)) return 0;
    
41. 
    
42.                         //1.从指针所在扇区的字节偏移开始，遍历扇区的每个字节
    
43.                         for(; PtrByteOffest < BytesPerSector; PtrByteOffest++)
    
44.                         {
    
45.                                 SectorBuf[PtrByteOffest] = *pSrc++;
    
46.                                 len--;
    
47.                                 if(0 == len)
    
48.                                 {
    
49.                                         if(!WriteBlock(StartSector)) return 0;
    
50.                                         else return 1;
    
51.                                 }
    
52.                         }
    
53.                         if(!WriteBlock(StartSector++)) return 0;
    
54.                         trByteOffest = 0;
    
55.                 }
    
56.                 //读取下一簇号
    
57.                 ClusID = ReadFAT(ClusID);
    
58.                 //获取下一簇所在的扇区号
    
59.                 StartSector = Clus2Sector(ClusID);
    
60.                 PtrSectorOffest = 0;
    
61.         }
    
62. }
    

复制代码

 


源码下载：  FAT16.zip

图文PDF下载：  FAT16模块详解.pdf

LTKKS

不明觉厉

正点原子

不错，cool。

paullenoard

最可惜的这给的源码和pdf 下载不了

shibusha

不错的分析！