FATFS嵌入式系统设计

灰太狼 2022-12-09 03:11 339阅读 0赞

http://blog.chinaunix.net/uid-20766895-id-2827635.html

  1. int main(void)
  2. {        
  3.      u32 total,free;
  4.     u8 t=0;    
  5.     u8 res=0;    
  6.     u8 *data_nanme=0;    
  7.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
  8.     delay_init(168);  //初始化延时函数
  9.     uart_init(115200);        //初始化串口波特率为115200
  10.     LED_Init();                    //初始化LED 
  11.     usmart_dev.init(84);        //初始化USMART
  12.      LCD_Init();                    //LCD初始化  
  13.      KEY_Init();                    //按键初始化 
  14.     W25QXX_Init();                //初始化W25Q128
  15.     my_mem_init(SRAMIN);        //初始化内部内存池 
  16.     my_mem_init(SRAMCCM);        //初始化CCM内存池
  18.      POINT_COLOR=RED;//设置字体为红色 
  19.     LCD_ShowString(30,50,200,16,16,"Explorer STM32F4");    
  20.     LCD_ShowString(30,70,200,16,16,"FATFS TEST");    
  21.     LCD_ShowString(30,90,200,16,16,"ATOM@ALIENTEK");
  22.     LCD_ShowString(30,110,200,16,16,"2014/5/15");   
  23.     LCD_ShowString(30,130,200,16,16,"Use USMART for test");       
  24.      while(SD_Init())//检测不到SD卡
  25.     {
  26.         LCD_ShowString(30,150,200,16,16,"SD Card Error!");
  27.         delay_ms(500);                    
  28.         LCD_ShowString(30,150,200,16,16,"Please Check! ");
  29.         delay_ms(500);
  30.         LED0=!LED0;//DS0闪烁
  31.     }
  32.      exfuns_init();                            //为fatfs相关变量申请内存                 
  33.       f_mount(fs[0],"0:",1);                     //挂载SD卡 
  34.      res=f_mount(fs[1],"1:",1);                 //挂载FLASH.    
  35.     if(res==0X0D)//FLASH磁盘,FAT文件系统错误,重新格式化FLASH
  36.     {
  37.         LCD_ShowString(30,150,200,16,16,"Flash Disk Formatting...");    //格式化FLASH
  38.         res=f_mkfs("1:",1,4096);//格式化FLASH,1,盘符;1,不需要引导区,8个扇区为1个簇
  39.         if(res==0)
  40.         {
  41.             f_setlabel((const TCHAR *)"1:ALIENTEK");    //设置Flash磁盘的名字为：ALIENTEK
  42.             LCD_ShowString(30,150,200,16,16,"Flash Disk Format Finish");    //格式化完成
  43.         }else LCD_ShowString(30,150,200,16,16,"Flash Disk Format Error ");    //格式化失败
  44.         delay_ms(1000);
  45.     }                                                        
  46.     LCD_Fill(30,150,240,150+16,WHITE);        //清除显示              
  47.     while(exf_getfree("0",&total,&free))    //得到SD卡的总容量和剩余容量
  48.     {
  49.         LCD_ShowString(30,150,200,16,16,"SD Card Fatfs Error!");
  50.         delay_ms(200);
  51.         LCD_Fill(30,150,240,150+16,WHITE);    //清除显示              
  52.         delay_ms(200);
  53.         LED0=!LED0;//DS0闪烁
  54.     }                                                                      
  55.      POINT_COLOR=BLUE;//设置字体为蓝色       
  56.     LCD_ShowString(30,150,200,16,16,"FATFS OK!");     
  57.     LCD_ShowString(30,170,200,16,16,"SD Total Size:     MB");     
  58.     LCD_ShowString(30,190,200,16,16,"SD  Free Size:     MB");         
  59.      LCD_ShowNum(30+8*14,170,total>>10,5,16);                //显示SD卡总容量 MB
  60.      LCD_ShowNum(30+8*14,190,free>>10,5,16);                    //显示SD卡剩余容量 MB                
  61.     while(1)
  62.     {
  63.         t++; 
  64.     //    delay_ms(200);                        
  65.         LED0=0;
  66. //        *data_nanme=f_typetell("test");
  67. //        printf(data_nanme);
  68. //        LCD_ShowString(30,290,200,16,16,*u8 data_nanme) ;
  70. //        sprintf(write_buff,"%04d\r\n",ad_value[i]*3300/4096);
  71. //res_ad=f_lseek(&fil_ad,f_size(&fil_ad));
  72. //res_ad=f_write(&fil_ad,write_buff,6,&bww_ad);
  74. //    if(KEY_Scan(1)==KEY0_PRES)
  75.         if(KEY0==0)    
  76.     {
  79.         LED0=1;
  81. //    f_mount(0, &fs);
  82.             //如果data.txt存在，则打开；否则，创建一个新文件
  83. //    res = f_open(&file, "0:/data.txt",FA_OPEN_ALWAYS|FA_READ|FA_WRITE ); 
  84.         //(const TCHAR*)  转换为字符串
  85.            /* f_open函数：创建文件
  86.         fp：文件指针
  87.         1:test.txt：文件名
  88.         第三个参数是文件操作的权限，读/写/不管文件是否存在都创建（存在就覆盖）
  89.         */
  92.                  //     /* 打开文件 */
  93.         res=f_open(&fsrc, (const TCHAR*)filename, FA_CREATE_ALWAYS | FA_WRITE);            
  95.                 if(res!=FR_OK)                          //判断是否打开成功
  96.         {
  97.             LCD_ShowString(10,230,tftlcd_data.width,tftlcd_data.height,16,"f_open error!"); 
  98.             LCD_ShowString(30,230,200,16,16,"f_open error!");     
  99.         }    
  102.         /* 将缓冲区的数据写到文件中 */
  103.         res = f_write(&fsrc, wtext, sizeof(wtext), &bw);     
  104.             /* f_close：关闭文件，使用f_open必须使用f_close，不然会有缓存
  105.         fp：文件指针
  106.         */
  107.         f_close(&fsrc);                         //关闭文件   
  108.              /* f_write函数：向文件中写入数据
  109.         fp：文件指针
  110.         write_buf：要写入文件的数据
  111.         第三个参数：写入多少个字节
  112.         第四个参数：指针，返回已经写入到文件的字节数
  113.         */
  114. /*        
  115. 1.打开文件
  117. f_open(filescr2, "0:/201711022.txt", FA_OPEN_DEFAULT);
  119. 2.写数据
  121. f_write(filescr1, test_buff0, sizeof(test_buff0), &bw1);
  123. 3.关闭文件
  125. f_close(filescr1);//一定要关闭
  127. 第二次写入数据
  129. 1.打开文件
  131. f_open(filescr2, "0:/201711022.txt", FA_OPEN_DEFAULT);
  132. 2.按照文件现有大小移动指针
  134. f_lseek(filescr1,filescr1->fptr+filescr1->fsize);
  136. 3.写数据
  138. f_write(filescr1, test_buff0, sizeof(test_buff0), &bw1);
  140. 4.关闭文件
  142. f_close(filescr1);//一定要关闭
  144. 其实，多次写入的时候就是需要将指针移动，
  145. 这样的h我们就可以根据自己的需求进行在相同文件内连续写入数据了。
  146. 但是如果要在指定行进行修改就比较麻烦了，
  147. 就需要计算指针移动的位置，者相比于面向对象的编程语言而言要麻烦的多。        
  148. */    
  149.         //f_lseek(&fsrc,(&fsrc)->fsize);
  150.     //    f_lseek(&fsrc,(&fsrc)->fptr-1);
  155.     /*注册一个工作区域*/
  156. //    f_mount(0,&fs);                  
  157.     /* 打开创建一个新文件 */
  158.     res=f_open(&fdst,"0:/DATA.CSV",FA_CREATE_NEW | FA_WRITE);   
  159.     /* 写入标题数据 */
  160.     res=f_write(&fdst,"年-月-日-时-分-秒,fix,track\n",29,&bw); 
  161.     /* 关闭文件 */
  162.     f_close(&fdst);
  163.      /* 数据转换 */
  164.  //   size = format_data(text,324,12585);
  165.      /* 打开文件 */
  166.     res=f_open(&fdst,"0:/DATA.CSV",FA_OPEN_EXISTING | FA_WRITE); 
  167.     /* 查找文件的结尾 */
  168.     res=f_lseek(&fdst,f_size(&fdst)); 
  169.     /* 写入数据 */
  170.     res=f_write(&fdst,text,sizeof(text),&bw);
  171.     /* 关闭文件 */
  172.     f_close(&fdst);
  178.     if ( res == FR_OK )
  179.       { 
  180.          //     /* 打开文件 */
  181.         res=f_open(&fsrc, (const TCHAR*)filename, FA_CREATE_ALWAYS | FA_WRITE);                      
  182.         f_lseek(&fsrc, f_size(&fsrc)); //将文件指针移动到文件末尾 
  183.         /* 将缓冲区的数据写到文件中 */
  184.         res = f_write(&fsrc, wtext, sizeof(wtext), &bw);     
  185.             /* f_close：关闭文件，使用f_open必须使用f_close，不然会有缓存
  186.         fp：文件指针
  187.         */
  188.         f_close(&fsrc);                         //关闭文件   
  189.       }   
  191. //        res=f_write(&fsrc, wtext, sizeof(wtext), &bw);          //向SD卡指定路径写入数据
  192.         //LCD_ShowString(30,230,200,16,16,res); 
  193.         if(res!=FR_OK)                          //判断是否写入成功
  194.         {
  195.             LCD_ShowString(10,230,tftlcd_data.width,tftlcd_data.height,16,"f_write error!"); 
  196.             LCD_ShowString(30,230,200,16,16,"f_write error!");     
  197.         }else
  198.         {
  199.         LCD_ShowString(10,230,tftlcd_data.width,tftlcd_data.height,16,"f_write ok!"); 
  200.         }
  202.         }
  203.     //if(KEY_Scan(1)==KEY1_PRES)
  204.         if(KEY1==0)    
  205.     {
  206. res=f_open(&fsrc, (const TCHAR*)filename, FA_READ);     //打开文件，如果文件不存在，则创建该文件
  207. if(res!=FR_OK)                          //判断是否打开成功
  208. {
  209.     LCD_ShowString(10,220,tftlcd_data.width,tftlcd_data.height,16,"f_open error!"); 
  210. }
  211. res=f_read(&fsrc, buffer, sizeof(buffer), &br);         //读取SD卡指定路径的内容，并存放在buffer数组中
  212. if(res!=FR_OK)                          //判断是否读取成功
  213. {
  214.     LCD_ShowString(10,240,tftlcd_data.width,tftlcd_data.height,16,"f_read error!"); 
  215. }
  216. else                                    //如果读取成功，则使用LCD显示
  217. {
  218.         LCD_ShowString(10,240,tftlcd_data.width,tftlcd_data.height,16,"f_read ok!"); 
  219.     LCD_ShowString(10,260,tftlcd_data.width,tftlcd_data.height,16,buffer); 
  220. }
  221. f_close(&fsrc);         
  223.     }    
  224.     } 
  225. }
  229. FatFs 模块为应用程序提供了下列函数：
  231. 1.f_mount  
  233. 在 FatFs 模块上注册 / 注销一个工作区 ( 文件系统对象 )  
  235. FRESULT f_mount ( 
  237.   BYTE  Drive,             /*  逻辑驱动器号  */ 
  239.   FATFS*  FileSystemObject /*  工作区指针  */ 
  241. );
  243. 参数   
  245. Drive  
  247. 注册 / 注销工作区的逻辑驱动器号 (0-9) 。   
  249. FileSystemObject  
  251. 工作区 ( 文件系统对象 ) 指针。
  253. 返回值   
  255. FR_OK (0)  
  257. 函数成功。   
  259. FR_INVALID_DRIVE  
  261. 驱动器号无效   
  265. f_mount 函数在 FatFs 模块上注册 / 注销一个工作区。 在使用任何其他文件函数之前，必须使用该函数为每个卷注册一个工作区。要注销一个工作区，只要指定 FileSystemObject 为 NULL 即可，然后该工作区可以被丢弃。  
  267. 该函数只初始化给定的工作区，以及将该工作区的地址注册到内部表中，不访问磁盘 I/O 层。卷装入过程是在f_mount 函数后或存储介质改变后的第一次文件访问时完成的。
  270. 2.f_open  
  272. 创建 / 打开一个用于访问文件的文件对象   
  274. FRESULT f_open ( 
  276.   FIL* FileObject,         /*  空白文件对象结构指针  */ 
  278.   const XCHAR* FileName,   /*  文件名指针  */ 
  280.   BYTE ModeFlags           /*  模式标志  */ 
  282. ); 
  284. 参数   
  286. FileObject  
  288. 将被创建的文件对象结构的指针。   
  290. FileName  
  292. NULL 结尾的字符串指针，该字符串指定了将被创建或打开的文件名。   
  294. ModeFlags  
  296. 指定文件的访问类型和打开方法。它是由下列标志的一个组合指定的。
  298. 模式
  301.   描述 
  303. FA_READ    
  306. 指定读访问对象。可以从文件中读取数据。与 FA_WRITE 结合可以进行读写访问。
  308. FA_WRITE    
  311. 指定写访问对象。可以向文件中写入数据。与 FA_READ 结合可以进行读写访问。
  313. FA_OPEN_EXISTING   
  316. 打开文件。如果文件不存在，则打开失败。 ( 默认 )
  318. FA_OPEN_ALWAYS   
  321. 如果文件存在，则打开；否则，创建一个新文件。
  323. FA_CREATE_NEW   
  326. 创建一个新文件。如果文件已存在，则创建失败。
  328. FA_CREATE_ALWAYS  
  331. 创建一个新文件。如果文件已存在，则它将被截断并覆盖。
  333. 注意：当  _FS_READONLY == 1  时，模式标志  FA_WRITE, FA_CREATE_ALWAYS, FA_CREATE_NEW, FA_OPEN_ALWAYS  是无效的。 
  337. 返回值  
  339. FR_OK (0)  
  341. 函数成功，该文件对象有效。   
  343. FR_NO_FILE  
  345. 找不到该文件。   
  347. FR_NO_PATH  
  349. 找不到该路径。   
  351. FR_INVALID_NAME  
  353. 文件名无效。   
  355. FR_INVALID_DRIVE  
  357. 驱动器号无效。   
  359. FR_EXIST  
  361. 该文件已存在。   
  363. FR_DENIED  
  365. 由于下列原因，所需的访问被拒绝： 
  367. n  ▲ 以写模式打开一个只读文件。   
  369. n  ▲ 由于存在一个同名的只读文件或目录，而导致文件无法被创建。   
  371. n  ▲ 由于目录表或磁盘已满，而导致文件无法被创建。   
  373. FR_NOT_READY  
  375. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  377. FR_WRITE_PROTECTED  
  379. 在存储介质被写保护的情况下，以写模式打开或创建文件对象。   
  381. FR_DISK_ERR  
  383. 由于底层磁盘 I/O 接口函数中的一个错误，而导致该函数失败。   
  385. FR_INT_ERR  
  387. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  389. FR_NOT_ENABLED  
  391. 逻辑驱动器没有工作区。
  393. FR_NO_FILESYSTEM  
  395. 磁盘上没有有效地 FAT 卷。 
  399. 如果函数成功，则创建一个文件对象。该文件对象被后续的读 / 写函数用来访问文件。如果想要关闭一个打开的文件对象，则使用 f_close 函数。如果不关闭修改后的文件，那么文件可能会崩溃。在使用任何文件函数之前，必须使用 f_mount 函数为驱动器注册一个工作区。只有这样，其他文件函数才能正常工作。  
  401. 3.f_close  
  403. 关闭一个打开的文件   
  405. FRESULT f_close ( 
  407.   FIL* FileObject          /*  文件对象结构的指针  */ 
  409. ); 
  411. 参数   
  413. FileObject  
  415. 指向将被关闭的已打开的文件对象结构的指针。   
  417. 返回值   
  419. FR_OK (0)  
  421. 文件对象已被成功关闭。  
  423. FR_DISK_ERR  
  425. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。
  427. FR_INT_ERR  
  429. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  431. FR_NOT_READY  
  433. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  435. FR_INVALID_OBJECT  
  437. 文件对象无效。
  441. f_close 函数关闭一个打开的文件对象。无论向文件写入任何数据，文件的缓存信息都将被写回到磁盘。该函数成功后，文件对象不再有效，并且可以被丢弃。如果文件对象是在只读模式下打开的，不需要使用该函数，也能被丢弃。 
  445. 4.f_read  
  447. 从一个文件读取数据   
  449. FRESULT f_read ( 
  451.   FIL* FileObject,         /*  文件对象结构的指针  */ 
  453.   void* Buffer,            /*  存储读取数据的缓冲区的指针  */ 
  455.   UINT ByteToRead,         /*  要读取的字节数  */ 
  457.   UINT* ByteRead           /*  返回已读取字节数变量的指针  */ 
  459. ); 
  461. 参数   
  463. FileObject  
  465. 指向将被读取的已打开的文件对象结构的指针。   
  467. Buffer  
  469. 指向存储读取数据的缓冲区的指针。   
  471. ByteToRead  
  473. 要读取的字节数， UINT 范围内。   
  475. ByteRead  
  477. 指向返回已读取字节数的 UINT 变量的指针。在调用该函数后，无论结果如何，数值都是有效的。
  481. 返回值   
  483. FR_OK (0)  
  485. 函数成功。   
  487. FR_DENIED  
  489. 由于文件是以非读模式打开的，而导致该函数被拒绝。   
  491. FR_DISK_ERR  
  493. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  495. FR_INT_ERR  
  497. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  499. FR_NOT_READY  
  501. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  503. FR_INVALID_OBJECT  文件对象无效。 
  507. 文件对象中的读 / 写指针以已读取字节数增加。该函数成功后，应该检查  *ByteRead  来检测文件是否结束。在读操作过程中，一旦  *ByteRead < ByteToRead  ，则读 / 写指针到达了文件结束位置。
  511. 5.f_write  
  513. 写入数据到一个文件   
  515. FRESULT f_write ( 
  517.   FIL* FileObject,         /*  文件对象结构的指针  */ 
  519.   const void* Buffer,      /*  存储写入数据的缓冲区的指针  */ 
  521.   UINT ByteToWrite,        /*  要写入的字节数  */ 
  523.   UINT* ByteWritten        /*  返回已写入字节数变量的指针  */ 
  525. ); 
  527. 参数   
  529. FileObject  
  531. 指向将被写入的已打开的文件对象结构的指针。   
  533. Buffer  
  535. 指向存储写入数据的缓冲区的指针。
  537. ByteToRead  
  539. 要写入的字节数， UINT 范围内。   
  541. ByteRead  
  543. 指向返回已写入字节数的 UINT 变量的指针。在调用该函数后，无论结果如何，数值都是有效的。   
  545. 返回值   
  547. FR_OK (0)  
  549. 函数成功。   
  551. FR_DENIED  
  553. 由于文件是以非写模式打开的，而导致该函数被拒绝。   
  555. FR_DISK_ERR  
  557. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  559. FR_INT_ERR  
  561. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  563. FR_NOT_READY  
  565. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  567. FR_INVALID_OBJECT  文件对象无效。   
  571. 文件对象中的读 / 写指针以已写入字节数增加。该函数成功后，应该检查  *ByteWritten  来检测磁盘是否已满。在写操作过程中，一旦  *ByteWritten < *ByteToWritten  ，则意味着该卷已满。 
  575. 6.f_lseek  
  577. 移动一个打开的文件对象的文件读 / 写指针。也可以被用来扩展文件大小 ( 簇预分配 ) 。   
  579. FRESULT f_lseek ( 
  581.   FIL* FileObject,         /*  文件对象结构指针  */ 
  583.   DWORD Offset             /*  文件字节偏移  */ 
  585. ); 
  587. 参数   
  589. FileObject  
  591. 打开的文件对象的指针   
  593. Offset  
  595. 相对于文件起始处的字节数   
  597. 返回值   
  599. FR_OK (0)  
  601. 函数成功。   
  603. FR_DISK_ERR  
  605. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  607. FR_INT_ERR  
  609. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  611. FR_NOT_READY  
  613. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  615. FR_INVALID_OBJECT  文件对象无效。   
  619. f_lseek 函数当 FS_MINIMIZE <= 2 时可用。offset 只能被指定为相对于文件起始处的字节数。当在写模式下指定了一个超过文件大小的 offset 时，文件的大小将被扩展，并且该扩展的区域中的数据是未定义的。这适用于为快速写操作迅速地创建一个大的文件。f_lseek 函数成功后，为了确保读 / 写指针已被正确地移动，必须检查文件对象中的成员 fptr 。如果 fptr 不是所期望的值，则发生了下列情况之一。   
  621. n   ★ 文件结束。指定的 offset 被钳在文件大小，因为文件已被以只读模式打开。   
  623. n   ★ 磁盘满。卷上没有足够的空闲空间去扩展文件大小。   
  625. 7.f_truncate 
  627. 截断文件大小   
  629. FRESULT f_truncate ( 
  631.   FIL* FileObject          /*  文件对象结构指针  */ 
  633. ); 
  635. 参数   
  637. FileObject  
  639. 待截断的打开的文件对象的指针。   
  641. 返回值   
  643. FR_OK (0  
  645. 函数成功。   
  647. FR_DENIED  
  649. 由于文件是以非写模式打开的，而导致该函数被拒绝。   
  651. FR_DISK_ERR  
  653. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  655. FR_INT_ERR  
  657. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  659. FR_NOT_READY  
  661. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  663. FR_INVALID_OBJECT  文件对象无效。
  669. f_truncate 函数当 _FS_READONLY == 0  并且  _FS_MINIMIZE == 0 时可用。  
  671. f_truncate 函数截断文件到当前的文件读 / 写指针。当文件读 / 写指针已经指向文件结束时，该函数不起作用。
  675. 8.f_sync
  677. 冲洗一个写文件的缓存信息   
  679. FRESULT f_sync ( 
  681.   FIL* FileObject          /*  文件对象结构的指针  */ 
  683. ); 
  685. 参数   
  687. FileObject  
  689. 待冲洗的打开的文件对象的指针。   
  691. 返回值   
  693. FR_OK (0)  
  695. 函数成功。   
  697. FR_DISK_ERR  
  699. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  701. FR_INT_ERR  
  703. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  705. FR_NOT_READY  
  707. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  709. FR_INVALID_OBJECT  文件对象无效。  
  715. f_sync 函数当 _FS_READONLY == 0 时可用。  
  717. f_sync 函数和 f_close 函数执行同样的过程，但是文件仍处于打开状态，并且可以继续对文件执行读 / 写 / 移动指针操作。这适用于以写模式长时间打开文件，比如数据记录器。定期的或 f_write 后立即执行 f_sync 可以将由于突然断电或移去磁盘而导致数据丢失的风险最小化。在 f_close 前立即执行 f_sync 没有作用，因为在 f_close 中执行了 f_sync 。换句话说，这两个函数的差异就是文件对象是不是无效的。   
  719. 9.f_opendir 
  721. 打开一个目录   
  723. FRESULT f_opendir ( 
  725.   DIR* DirObject,          /*  空白目录对象结构的指针  */ 
  727.   const XCHAR* DirName     /*  目录名的指针  */ 
  729. ); 
  731. 参数   
  733. DirObject  
  735. 待创建的空白目录对象的指针。   
  737. DirName  
  739. '\0' 结尾的字符串指针，该字符串指定了将被打开的目录名。   
  741. 返回值   
  743. FR_OK (0)  
  745. 函数成功，目录对象被创建。该目录对象被后续调用，用来读取目录项。   
  747. FR_NO_PATH  
  749. 找不到路径。   
  751. FR_INVALID_NAME  
  753. 路径名无效。   
  755. FR_INVALID_DRIVE  
  757. 驱动器号无效。   
  759. FR_NOT_READY  
  761. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  763. FR_DISK_ERR  
  765. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  767. FR_INT_ERR  
  769. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  771. FR_NOT_ENABLED  
  773. 逻辑驱动器没有工作区。   
  775. FR_NO_FILESYSTEM  
  777. 磁盘上没有有效的 FAT 卷。   
  781. f_opendir 函数当 _FS_MINIMIZE <= 1 时可用。  
  783. f_opendir 函数打开一个已存在的目录，并为后续的调用创建一个目录对象。该目录对象结构可以在任何时候不经任何步骤而被丢弃。   
  785. 10.f_readdir 
  787. 读取目录项   
  789. FRESULT f_readdir (DIR* DirObject,          /*  指向打开的目录对象结构的指针  */ 
  791.   FILINFO* FileInfo        /*  指向文件信息结构的指针  */ 
  793. ); 
  795. 参数   
  797. DirObject  
  799. 打开的目录对象的指针。   
  801. FileInfo  
  803. 存储已读取项的文件信息结构指针。   
  805. 返回值   
  807. FR_OK (0)  
  809. 函数成功。   
  811. FR_DISK_ERR  
  813. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  815. FR_INT_ERR  
  817. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  819. FR_NOT_READY  
  821. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  823. FR_INVALID_OBJECT  文件对象无效。   
  827. f_readdir 函数当 _FS_MINIMIZE <= 1 时可用。  
  829. f_readdir 函数顺序读取目录项。目录中的所有项可以通过重复调用 f_readdir 函数被读取。当所有目录项已被读取并且没有项要读取时，该函数没有任何错误地返回一个空字符串到 f_name[] 成员中。当 FileInfo 给定一个空指针时，目录对象的读索引将被回绕。  
  831. 当 LFN 功能被使能时，在使用 f_readdir 函数之前，文件信息结构中的 lfname 和 lfsize 必须被初始化为有效数值。 lfname 是一个返回长文件名的字符串缓冲区指针。 lfsize 是以字符为单位的字符串缓冲区的大小。如果读缓冲区或 LFN 工作缓冲区的大小 ( 对于 LFN) 不足，或者对象没有 LFN ，则一个空字符串将被返回到 LFN 读缓冲区。如果 LFN 包含任何不能被转换为 OEM 代码的字符，则一个空字符串将被返回，但是这不是 Unicode API配置的情况。当 lfname 是一个空字符串时，没有 LFN 的任何数据被返回。当对象没有 LFN 时，任何小型大写字母可以被包含在 SFN 中。  
  833. 当相对路径功能被使能 (_FS_RPATH == 1) 时， "." 和 ".." 目录项不会被过滤掉，并且它将出现在读目录项中。   
  835. 11.f_getfree 
  837. 获取空闲簇的数目   
  839. FRESULT f_getfree ( 
  841.   const XCHAR* Path,       /*  驱动器的根目录  */ 
  843.   DWORD* Clusters,         /*  存储空闲簇数目变量的指针  */ 
  845.   FATFS** FileSystemObject /*  文件系统对象指针的指针  */ 
  847. ); 
  849. 参数   
  851. Path  
  853. '\0' 结尾的字符串指针，该字符串指定了逻辑驱动器的目录。   
  855. Clusters  
  857. 存储空闲簇数目的 DWORD 变量的指针。
  859. FileSystemObject  
  861. 相应文件系统对象指针的指针。   
  863. 返回值   
  865. FR_OK (0)  
  867. 函数成功。 *Clusters 表示空闲簇的数目，并且 *FileSystemObject 指向文件系统对象。   
  869. FR_INVALID_DRIVE  
  871. 驱动器号无效。   
  873. FR_NOT_READY  
  875. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  877. FR_DISK_ERR  
  879. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  881. FR_INT_ERR  
  883. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  885. FR_NOT_ENABLED  
  887. 逻辑驱动器没有工作区。   
  889. FR_NO_FILESYSTEM  
  891. 磁盘上没有有效的 FAT 卷。   
  895. f_getfree 函数当 _FS_READONLY == 0 并且 _FS_MINIMIZE == 0 时有效。  
  897. f_getfree 函数获取驱动器上空闲簇的数目。文件系统对象中的成员 csize 是每簇中的扇区数，因此，以扇区为单位的空闲空间可以被计算出来。当 FAT32 卷上的 FSInfo 结构不同步时，该函数返回一个错误的空闲簇计数。   
  899. 12.f_stat 
  901. 获取文件状态   
  903. FRESULT f_stat ( 
  905.   const XCHAR* FileName,   /*  文件名或目录名的指针  */ 
  907.   FILINFO* FileInfo        /* FILINFO 结构的指针  */ 
  909. ); 
  911. 参数   
  913. FileName  
  915. '\0' 结尾的字符串指针，该字符串指定了待获取其信息的文件或目录。   
  917. FileInfo  
  919. 存储信息的空白 FILINFO 结构的指针。   
  921. 返回值   
  923. FR_OK (0)  
  925. 函数成功。   
  927. FR_NO_FILE  
  929. 找不到文件或目录。   
  931. FR_NO_PATH  
  933. 找不到路径。   
  935. FR_INVALID_NAME  
  937. 路径名无效。   
  939. FR_INVALID_DRIVE  
  941. 驱动器号无效。   
  943. FR_NOT_READY  
  945. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  947. FR_DISK_ERR  
  949. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  951. FR_INT_ERR  
  953. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  955. FR_NOT_ENABLED  
  957. 逻辑驱动器没有工作区。   
  959. FR_NO_FILESYSTEM  
  961. 磁盘上没有有效的 FAT 卷。   
  965. f_stat 函数当 _FS_MINIMIZE == 0 时可用。  
  967. f_stat 函数获取一个文件或目录的信息。信息的详情，请参考 FILINFO 结构和 f_readdir 函数。   
  969. 13.f_mkdir 
  971. 创建一个目录   
  973. FRESULT f_mkdir ( 
  975.   const XCHAR* DirName /*  目录名的指针  */ 
  977. ); 
  979. 参数   
  981. DirName  
  983. '\0' 结尾的字符串指针，该字符串指定了待创建的目录名。   
  985. 返回值   
  987. FR_OK (0)  
  989. 函数成功。   
  991. FR_NO_PATH  
  993. 找不到路径。   
  995. FR_INVALID_NAME  
  997. 路径名无效。   
  999. FR_INVALID_DRIVE  
  1001. 驱动器号无效。   
  1003. FR_DENIED  
  1005. 由于目录表或磁盘满，而导致目录不能被创建。   
  1007. FR_EXIST  
  1009. 已经存在同名的文件或目录。   
  1011. FR_NOT_READY  
  1013. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  1015. FR_WRITE_PROTECTED  
  1017. 存储介质被写保护。   
  1019. FR_DISK_ERR  
  1021. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  1023. FR_INT_ERR  
  1025. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  1027. FR_NOT_ENABLED  
  1029. 逻辑驱动器没有工作区。   
  1031. FR_NO_FILESYSTEM  
  1033. 磁盘上没有有效的 FAT 卷。   
  1037. f_mkdir 函数当 _FS_READONLY == 0 并且 _FS_MINIMIZE == 0 时可用。  
  1039. f_mkdir 函数创建一个新目录。   
  1041. 14.f_unlink 
  1043. 移除一个对象   
  1045. FRESULT f_unlink ( 
  1047.   const XCHAR* FileName  /*  对象名的指针  */ 
  1049. ); 
  1051. 参数   
  1053. FileName  
  1055. '\0' 结尾的字符串指针，该字符串指定了一个待移除的对象。
  1057. 返回值   
  1059. FR_OK (0)  
  1061. 函数成功。   
  1063. FR_NO_FILE  
  1065. 找不到文件或目录。   
  1067. FR_NO_PATH  
  1069. 找不到路径。   
  1071. FR_INVALID_NAME  
  1073. 路径名无效。   
  1075. FR_INVALID_DRIVE  
  1077. 驱动器号无效。   
  1079. FR_DENIED  
  1081. 由于下列原因之一，而导致该函数被拒绝： 
  1083. n   ★对象具有只读属性   
  1085. n   ★目录不是空的   
  1087. FR_NOT_READY  
  1089. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  1091. FR_WRITE_PROTECTED  
  1093. 存储介质被写保护。   
  1095. FR_DISK_ERR  
  1097. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  1099. FR_INT_ERR  
  1101. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  1103. FR_NOT_ENABLED  
  1105. 逻辑驱动器没有工作区。   
  1107. FR_NO_FILESYSTEM  
  1109. 磁盘上没有有效的 FAT 卷。   
  1113. f_unlink 函数当 _FS_READONLY == 0 并且 _FS_MINIMIZE == 0 时可用。  
  1115. f_unlink 函数移除一个对象。不要移除打开的对象或当前目录。
  1117. 15.f_chmod 
  1119. 修改一个文件或目录的属性。   
  1121. FRESULT f_chmod ( 
  1123.   const XCHAR* FileName, /*  文件或目录的指针  */ 
  1125.   BYTE Attribute,        /*  属性标志  */ 
  1127.   BYTE AttributeMask     /*  属性掩码  */ 
  1129. ); 
  1131. 参数   
  1133. FileName  
  1135. '\0' 结尾的字符串指针，该字符串指定了一个待被修改属性的文件或目录。   
  1137. Attribute  
  1139. 待被设置的属性标志，可以是下列标志的一个或任意组合。指定的标志被设置，其他的被清除。
  1141. 属性       描述 
  1143. AM_RDO    只读 
  1145. AM_ARC    存档 
  1147. AM_SYS    系统 
  1149. AM_HID    隐藏 
  1151. AttributeMask  
  1153. 属性掩码，指定修改哪个属性。指定的属性被设置或清除。   
  1155. 返回值   
  1157. FR_OK (0)  
  1159. 函数成功。   
  1161. FR_NO_FILE  
  1163. 找不到文件或目录。   
  1165. FR_NO_PATH  
  1167. 找不到路径。   
  1169. FR_INVALID_NAME  
  1171. 路径名无效。   
  1173. FR_INVALID_DRIVE  
  1175. 驱动器号无效。   
  1177. FR_NOT_READY
  1179. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  1181. FR_WRITE_PROTECTED  
  1183. 存储介质被写保护。   
  1185. FR_DISK_ERR  
  1187. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  1189. FR_INT_ERR  
  1191. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  1193. FR_NOT_ENABLED  
  1195. 逻辑驱动器没有工作区。   
  1197. FR_NO_FILESYSTEM  
  1199. 磁盘上没有有效的 FAT 卷。   
  1203. f_chmod 函数当 _FS_READONLY == 0 并且 _FS_MINIMIZE == 0 时可用。  
  1205. f_chmod 函数修改一个文件或目录的属性。   
  1207. 16.f_utime 
  1209. f_utime 函数修改一个文件或目录的时间戳。   
  1211. FRESULT f_utime ( 
  1213.   const XCHAR* FileName,   /*  文件或目录路径的指针  */ 
  1215.   const FILINFO* TimeDate  /*  待设置的时间和日期  */ 
  1217. ); 
  1219. 参数   
  1221. FileName  
  1223. '\0' 结尾的字符串的指针，该字符串指定了一个待修改时间戳的文件或目录。   
  1225. TimeDate  
  1227. 文件信息结构指针，其中成员 ftime 和 fdata 存储了一个待被设置的的时间戳。不关心任何其他成员。 
  1229. 返回值   
  1231. FR_OK (0)  
  1233. 函数成功。   
  1235. FR_NO_FILE  
  1237. 找不到文件或目录。   
  1239. FR_NO_PATH  
  1241. 找不到路径。   
  1243. FR_INVALID_NAME  
  1245. 路径名无效。   
  1247. FR_INVALID_DRIVE  
  1249. 驱动器号无效。   
  1251. FR_NOT_READY  
  1253. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  1255. FR_WRITE_PROTECTED  
  1257. 存储介质被写保护。   
  1259. FR_DISK_ERR  
  1261. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  1263. FR_INT_ERR  
  1265. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  1267. FR_NOT_ENABLED  
  1269. 逻辑驱动器没有工作区。   
  1271. FR_NO_FILESYSTEM  
  1273. 磁盘上没有有效的 FAT 卷。   
  1277. f_utime 函数当 _FS_READONLY == 0 并且 _FS_MINIMIZE == 0 时可用。  
  1279. f_utime 函数修改一个文件或目录的时间戳。
  1283. 17.f_rename 
  1285. 重命名一个对象。   
  1287. FRESULT f_rename (const XCHAR* OldName, /*  原对象名的指针  */ 
  1289.   const XCHAR* NewName  /*  新对象名的指针  */ 
  1291. ); 
  1293. 参数   
  1295. OldName  
  1297. '\0' 结尾的字符串的指针，该字符串指定了待被重命名的原对象名。   
  1299. NewName  
  1301. '\0' 结尾的字符串的指针，该字符串指定了重命名后的新对象名，不能包含驱动器号。   
  1303. 返回值   
  1305. FR_OK (0)  
  1307. 函数成功。   
  1309. FR_NO_FILE  
  1311. 找不到原名。   
  1313. FR_NO_PATH  
  1315. 找不到路径。   
  1317. FR_INVALID_NAME  
  1319. 文件名无效。   
  1321. FR_INVALID_DRIVE  
  1323. 驱动器号无效。   
  1325. FR_NOT_READY  
  1327. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  1329. FR_EXIST  
  1331. 新名和一个已存在的对象名冲突。   
  1333. FR_DENIED  
  1335. 由于任何原因，而导致新名不能被创建。   
  1337. FR_WRITE_PROTECTED  
  1339. 存储介质被写保护。   
  1341. FR_DISK_ERR  
  1343. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。
  1345. FR_INT_ERR  
  1347. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  1349. FR_NOT_ENABLED  
  1351. 逻辑驱动器没有工作区。   
  1353. FR_NO_FILESYSTEM  
  1355. 磁盘上没有有效的 FAT 卷。   
  1359. f_rename 函数当 _FS_READONLY == 0 并且 _FS_MINIMIZE == 0 时可用。  
  1361. f_rename 函数重命名一个对象，并且也可以将对象移动到其他目录。逻辑驱动器号由原名决定，新名不能包含一个逻辑驱动器号。不要重命名打开的对象。   
  1363. 18.f_mkfs 
  1365. 在驱动器上创建一个文件系统   
  1367. FRESULT f_mkfs ( 
  1369.   BYTE  Drive,            /*  逻辑驱动器号  */ 
  1371.   BYTE  PartitioningRule, /*  分区规则  */ 
  1373.   WORD  AllocSize         /*  分配单元大小  */ 
  1375. ); 
  1377. 参数   
  1379. Drive  
  1381. 待格式化的逻辑驱动器号 (0-9) 。   
  1383. PartitioningRule  
  1385. 当给定 0 时，首先在驱动器上的第一个扇区创建一个分区表，然后文件系统被创建在分区上。这被称为FDISK 格式化，用于硬盘和存储卡。当给定 1 时，文件系统从第一个扇区开始创建，而没有分区表。这被称为超级软盘 (SFD) 格式化，用于软盘和可移动磁盘。   
  1387. AllocSize  
  1389. 指定每簇中以字节为单位的分配单元大小。数值必须是 0 或从 512 到 32K 之间 2 的幂。当指定 0 时，簇大小取决于卷大小。   
  1391. 返回值   
  1393. FR_OK (0)  
  1395. 函数成功。   
  1397. FR_INVALID_DRIVE  
  1399. 驱动器号无效。   
  1401. FR_NOT_READY  
  1403. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  1405. FR_WRITE_PROTECTED  
  1407. 驱动器被写保护。   
  1409. FR_NOT_ENABLED  
  1411. 逻辑驱动器没有工作区。   
  1413. FR_DISK_ERR  
  1415. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  1417. FR_MKFS_ABORTED  
  1419. 由于下列原因之一，而导致函数在开始格式化前终止： 
  1421. n  ★ 磁盘容量太小   
  1423. n  ★ 参数无效   
  1425. n  ★ 该驱动器不允许的簇大小。   
  1429. f_mkfs 函数当 _FS_READOLNY == 0 并且 _USE_MKFS == 1 时可用。  
  1431. f_mkfs 函数在驱动器中创建一个 FAT 文件系统。对于可移动媒介，有两种分区规则： FDISK 和 SFD ，通过参数PartitioningRule 选择。 FDISK 格式在大多数情况下被推荐使用。该函数当前不支持多分区，因此，物理驱动器上已存在的分区将被删除，并且重新创建一个占据全部磁盘空间的新分区。  
  1433. 根据 Microsoft 发布的 FAT 规范， FAT 分类： FAT12/FAT16/FAT32 ，由驱动器上的簇数决定。因此，选择哪种 FAT 分类，取决于卷大小和指定的簇大小。簇大小影响文件系统的性能，并且大簇会提高性能。 
  1437. 19.f_forward 
  1439. 读取文件数据并将其转发到数据流设备。   
  1441. FRESULT f_forward ( 
  1443.   FIL* FileObject,                 /*  文件对象  */ 
  1445.   UINT (*Func)(const BYTE*,UINT),  /*  数据流函数  */ 
  1447.   UINT ByteToFwd,                  /*  要转发的字节数  */ 
  1449.   UINT* ByteFwd                    /*  已转发的字节数  */ 
  1451. ); 
  1453. 参数   
  1455. FileObject  
  1457. 打开的文件对象的指针。   
  1459. Func  
  1461. 用户定义的数据流函数的指针。详情参考示例代码。   
  1463. ByteToFwd  
  1465. 要转发的字节数， UINT 范围内。   
  1467. ByteFwd  
  1469. 返回已转发的字节数的 UINT 变量的指针。   
  1471. 返回值   
  1473. FR_OK (0)  
  1475. 函数成功。   
  1477. FR_DENIED  
  1479. 由于文件已经以非读模式打开，而导致函数失败。   
  1481. FR_DISK_ERR  
  1483. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  1485. FR_INT_ERR  
  1487. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  1489. FR_NOT_READY  
  1491. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  1493. FR_INVALID_OBJECT  
  1495. 文件对象无效。   
  1499. f_forward 函数当 _USE_FORWARD == 1 并且 _FS_TINY == 1 时可用。  
  1501. f_forward 函数从文件中读取数据并将数据转发到输出流，而不使用数据缓冲区。这适用于小存储系统，因为它在应用模块中不需要任何数据缓冲区。文件对象的文件指针以转发的字节数增加。如果 *ByteFwd < ByteToFwd 并且没有错误，则意味着由于文件结束或在数据传输过程中流忙，请求的字节不能被传输。   
  1503. 20.f_chdir 
  1505. f_chdir 函数改变一个驱动器的当前目录。   
  1507. FRESULT f_chdir ( 
  1509.   const XCHAR* Path /*  路径名的指针  */
  1511. ); 
  1513. 参数   
  1515. Path  
  1517. '\0' 结尾的字符串的指针，该字符串指定了将要进去的目录。   
  1519. 返回值   
  1521. FR_OK (0)  
  1523. 函数成功。   
  1525. FR_NO_PATH  
  1527. 找不到路径。   
  1529. FR_INVALID_NAME 
  1531. 路径名无效。   
  1533. FR_INVALID_DRIVE  
  1535. 驱动器号无效。   
  1537. FR_NOT_READY  
  1539. 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。   
  1541. FR_DISK_ERR  
  1543. 由于底层磁盘 I/O 函数中的错误，而导致该函数失败。   
  1545. FR_INT_ERR  
  1547. 由于一个错误的 FAT 结构或一个内部错误，而导致该函数失败。   
  1549. FR_NOT_ENABLED  
  1551. 逻辑驱动器没有工作区。   
  1553. FR_NO_FILESYSTEM  
  1555. 磁盘上没有有效的 FAT 卷。   
  1559. f_chdir 函数当 _FS_RPATH == 1 时可用。  
  1561. f_chdir 函数改变一个逻辑驱动器的当前目录。当一个逻辑驱动器被自动挂载时，它的当前目录被初始化为根目录。注意：当前目录被保存在每个文件系统对象中，因此它也影响使用同一逻辑驱动器的其它任务。   
  1563. 21.f_chdrive 
  1565. f_chdrive 函数改变当前驱动器。   
  1567. FRESULT f_chdrive ( 
  1569.   BYTE Drive /*  逻辑驱动器号  */ 
  1571. ); 
  1573. Drive  
  1575. 指定将被设置为当前驱动器的逻辑驱动器号。   
  1577. 返回值   
  1579. FR_OK (0)  
  1581. 函数成功。   
  1583. FR_INVALID_DRIVE  
  1585. 驱动器号无效。   
  1589. f_chdrive 函数当 _FS_RPATH == 1 时可用。  
  1591. f_chdrive 函数改变当前驱动器。当前驱动器号初始值为 0 ，注意：当前驱动器被保存为一个静态变量，因此它也影响使用文件函数的其它任务。   
  1593. 22.f_gets 
  1595. f_gets 从文件中读取一个字符串。   
  1597. char* f_gets ( 
  1599.   char* Str,        /*  读缓冲区  */ 
  1601.   int Size,         /*  读缓冲区大小  */ 
  1603.   FIL* FileObject   /*  文件对象  */ 
  1605. ); 
  1607. 参数   
  1609. Str  
  1611. 存储读取字符串的读缓冲区指针。   
  1613. Size  
  1615. 读缓冲区大小。   
  1617. FileObject  
  1619. 打开的文件对象结构指针。   
  1621. 返回值   
  1623. 当函数成功后， Str 将被返回。   
  1627. f_gets 函数当 _USE_STRFUNC == 1 或者 _USE_STRFUNC == 2 时可用。如果 _USE_STRFUNC == 2 ，文件中包含的 '\r' 则被去除。  
  1629. f_gets 函数是 f_read 的一个封装函数。当读取到 '\n' 、文件结束或缓冲区被填冲了 Size - 1 个字符时，读操作结束。读取的字符串以 '\0' 结束。当文件结束或读操作中发生了任何错误， f_gets() 返回一个空字符串。可以使用宏 f_eof() 和 f_error() 检查 EOF 和错误状态。
  1633. 23.f_putc 
  1635. f_putc 函数向文件中写入一个字符。   
  1637. int f_putc ( 
  1639.   int Chr,          /*  字符  */ 
  1641.   FIL* FileObject   /*  文件对象  */ 
  1643. ); 
  1645. 参数   
  1647. Chr  
  1649. 待写入的字符。   
  1651. FileObject  
  1653. 打开的文件对象结构的指针。   
  1655. 返回值   
  1657. 当字符被成功地写入后，函数返回该字符。由于磁盘满或任何错误而导致函数失败，将返回 EOF 。   
  1659. 描述   
  1661. f_putc 函数当 (_FS_READONLY == 0)&&(_USE_STRFUNC == 1 || _USE_STRFUNC == 2) 时可用。当_USE_STRFUNC == 2 时，字符 '\n' 被转换为 "\r\n" 写入文件中。  
  1663. f_putc 函数是 f_write 的一个封装函数。
  1667. 24.f_puts 
  1669. f_puts 函数向文件中写入一个字符串。   
  1671. int f_puts ( 
  1673.   const char* Str,  /*  字符串指针  */ 
  1675.   FIL* FileObject   /*  文件对象指针  */
  1677. );
  1679. 参数   
  1681. Str  
  1683. 待写入的 '\0' 结尾的字符串的指针。 '\0' 字符不会被写入。   
  1685. FileObject  
  1687. 打开的文件对象结构的指针。   
  1689. 返回值   
  1691. 函数成功后，将返回写入的字符数。由于磁盘满或任何错误而导致函数失败，将返回 EOF 。  
  1695. f_puts() 当 (_FS_READONLY == 0)&&(_USE_STRFUNC == 1 || _USE_STRFUNC == 2) 时可用。当_USE_STRFUNC == 2 时，字符串中的 '\n' 被转换为 "\r\n" 写入文件中。  
  1697. f_puts() 是 f_putc() 的一个封装函数。
  1701. 25.f_printf 
  1703. f_printf 函数向文件中写入一个格式化字符串。  
  1705. int f_printf ( 
  1707.   FIL* FileObject,     /*  文件对象指针  */ 
  1709.   const char* Foramt,  /*  格式化字符串指针  */ 
  1711.   ... 
  1713. ); 
  1715. 参数   
  1717. FileObject  
  1719. 已打开的文件对象结构的指针。   
  1721. Format  
  1723. '\0' 结尾的格式化字符串指针。   
  1725. ...  
  1727. 可选参数   
  1731. 返回值   
  1733. 函数成功后，将返回写入的字符数。由于磁盘满或任何错误而导致函数失败，将返回 EOF 。  
  1737. f_printf 函数当 (_FS_READONLY == 0)&&(_USE_STRFUNC == 1 || _USE_STRFUNC == 2) 时可用。当 _USE_STRFUNC == 2 时，包含在格式化字符串中的 '\n' 将被转换成 "\r\n" 写入文件中。 f_printf 函数是 f_putc 和 f_puts 的一个封装函数。如下所示，格式控制符是标准库的一个子集：
  1739. 类型： c s d u X 
  1741. 大小： l 
  1743. 标志： 0 
  1745. 磁盘I/O接口  
  1747. 由于FatFs模块完全与磁盘I/O层分开，因此底层磁盘I/O需要下列函数去读/写物理磁盘以及获取当前时间。由于底层磁盘I/O模块并不是FatFs的一部分，因此它必须由用户提供。  
  1749. 26.disk_initialize 
  1751. 初始化磁盘驱动器   
  1753. DSTATUS disk_initialize ( 
  1755.   BYTE Drive           /*  物理驱动器号  */ 
  1757. ); 
  1759. 参数   
  1761. Drive  
  1763. 指定待初始化的物理驱动器号。   
  1765. 返回值   
  1767. disk_initialize 函数返回一个磁盘状态作为结果。磁盘状态的详情，参考 disk_status 函数。   
  1769. disk_initialize 函数初始化一个物理驱动器。函数成功后，返回值中的 STA_NOINIT 标志被清除。disk_initialize 函数被 FatFs 模块在卷挂载过程中调用，去管理存储介质的改变。当 FatFs 模块起作用时，或卷上的 FAT 结构可以被瓦解时，应用程序不能调用该函数。可以使用 f_mount 函数去重新初始化文件系统。
  1773. 27.disk_status 
  1775. 获取当前磁盘的状态   
  1777. DSTATUS disk_status ( 
  1779.   BYTE Drive     /*  物理驱动器号 */ 
  1781. );
  1783. 参数   
  1785. Drive  
  1787. 指定待确认的物理驱动器号。   
  1789. 返回值   
  1791. 磁盘状态，是下列标志的组合：  STA_NOINIT 指示磁盘驱动器还没有被初始化。当系统复位、磁盘移除和 disk_initialize 函数失败时，该标志被设置；当 disk_initialize 函数成功时，该标志被清除。 STA_NODISK 指示驱动器中没有存储介质。当安装了磁盘驱动器后，该标志始终被清除。   
  1793. STA_PROTECTED  
  1795. 指示存储介质被写保护。在不支持写保护缺口的驱动器上，该标志始终被清除。当 STA_NODISK 被设置时，该标志无效。   
  1797. 28.disk_read 
  1799. 从磁盘驱动器中读取扇区   
  1801. DRESULT disk_read ( 
  1803.   BYTE Drive,          /*  物理驱动器号  */ 
  1805.   BYTE* Buffer,        /*  读取数据缓冲区的指针  */ 
  1807.   DWORD SectorNumber,  /*  起始扇区号  */ 
  1809.   BYTE SectorCount     /*  要读取的扇区数  */ 
  1811. ); 
  1813. 参数   
  1815. Drive  
  1817. 指定物理驱动器号。   
  1819. Buffer  
  1821. 存储读取数据的缓冲区的指针。该缓冲区大小需要满足要读取的字节数 ( 扇区大小  *  扇区总数。由上层指定的存储器地址可能会也可能不会以字边界对齐。 SectorNumber  指定在逻辑块地址 (LBA) 中的起始扇区号。   
  1823. SectorCount  
  1825. 指定要读取的扇区数 (1-255) 。   
  1827. 返回值   
  1829. RES_OK (0)  
  1831. 函数成功   
  1833. RES_ERROR  
  1835. 在读操作过程中发生了不能恢复的硬错误。   
  1837. RES_PARERR  
  1839. 无效的参数。   
  1841. RES_NOTRDY  
  1843. 磁盘驱动器还没被初始化。   
  1845. 29.disk_write 
  1847. 向磁盘驱动器中写入扇区   
  1849. DRESULT disk_write ( 
  1851.   BYTE Drive,          /*  物理驱动器号  */ 
  1853.   const BYTE* Buffer,  /*  写入数据缓冲区的指针 ( 可能未对齐 ) */ 
  1855.   DWORD SectorNumber,  /*  起始扇区号  */ 
  1857.   BYTE SectorCount     /*  要写入的扇区数  */ 
  1859. ); 
  1861. 参数   
  1863. Drive  
  1865. 指定物理驱动器号。   
  1867. Buffer  
  1869. 存储写入数据的缓冲区的指针。由上层指定的存储器地址可能会也可能不会以字边界对齐。   
  1871. SectorNumber  
  1873. 指定在逻辑块地址 (LBA) 中的起始扇区号。   
  1875. SectorCount  
  1877. 指定要写入的扇区数 (1-255) 。   
  1879. 返回值   
  1881. RES_OK (0)  
  1883. 函数成功   
  1885. RES_ERROR  
  1887. 在读操作过程中发生了不能恢复的硬错误。   
  1889. RES_WRPRT  
  1891. 存储介质被写保护。   
  1893. RES_PARERR  
  1895. 无效的参数。   
  1897. RES_NOTRDY  
  1899. 磁盘驱动器还没被初始化。   
  1903. 在只读配置中，不需要此函数。   
  1905. 30.disk_ioctl 
  1907. 控制设备特定的功能以及磁盘读写以外的其它功能。   
  1909. DRESULT disk_ioctl ( 
  1911.   BYTE Drive,      /*  驱动器号  */ 
  1913.   BYTE Command,    /*  控制命令代码  */ 
  1915.   void* Buffer     /*  数据传输缓冲区  */ 
  1917. ); 
  1919. 参数   
  1921. Drive  
  1923. 指定驱动器号 (1-9) 。   
  1925. Command  
  1927. 指定命令代码。   
  1929. Buffer  
  1931. 取决于命令代码的参数缓冲区的指针。当不使用时，指定一个 NULL 指针。   
  1933. 返回值   
  1935. RES_OK (0)  
  1937. 函数成功。   
  1939. RES_ERROR  
  1941. 发生错误。   
  1943. RES_PARERR  
  1945. 无效的命令代码。   
  1947. RES_NOTRDY  
  1949. 磁盘驱动器还没被初始化。   
  1953. FatFs 模块只使用下述与设备无关的命令，没有使用任何设备相关功能。
  1955. 命令  
  1958. 描述 
  1960. GET_SECTOR_SIZE 
  1963.  返回驱动器的扇区大小赋给 Buffer 指向的 WORD 变量。在单个扇区大小配置中(_MAX_SS  为  512) ，不需要该命令。
  1965. GET_SECTOR_COUNT  
  1968. 返回总扇区数赋给 Buffer 指向的 DWORD 变量。只在 f_mkfs 函数中，使用了该命令。 
  1970. GET_BLOCK_SIZE  
  1973. 返回以扇区为单位的存储阵列的擦除块大小赋给 Buffer 指向的 DWORD 变量。当擦除块大小未知或是磁盘设备时，返回 1 。只在 f_mkfs 函数中，使用了该命令。
  1975. 31.get_fattime 
  1977. 获取当前时间   
  1979. DWORD get_fattime (void); 
  1981. 返回值   
  1983. 返回的当前时间被打包进一个 DWORD 数值。各位域定义如下：  
  1985. bit31:25  
  1987. 年，从 1980 年开始算起 (0..127)  
  1989. bit24:21  
  1991. 月 (1..12)  
  1993. bit20:16  
  1995. 日 (1..31)  
  1997. bit15:11  
  1999. 时 (0..23)  
  2001. bit10:5  
  2003. 分 (0..59)  
  2005. bit4:0  
  2007. 秒 /2(0..29) ，由此可见 FatFs 的时间分辨率为 2 秒   
  2009. get_fattime 函数必须返回任何有效的时间，即使系统不支持实时时钟。如果返回一个 0 ，则文件将没有一个有效的时间。在只读配置中，不需要此函数。

发表评论

表情：
评论列表 （有 0 条评论，339人围观）

还没有评论，来说两句吧...

相关阅读