21ic电子技术开发论坛 › 综合技术交流 › RISC-V › 第一百零八章、CH32V103应用教程——文件系统FatFs ...
返回列表 发新帖我要提问

[RISC-V MCU 应用开发] 第一百零八章、CH32V103应用教程——文件系统FatFs

[复制链接]
11134|18
 楼主| RISCVLAR 发表于 2021-8-19 17:12 | 显示全部楼层 |阅读模式
FATFS, ST, pi, flash, spi, status
本帖最后由 RISCVLAR 于 2021-8-19 17:12 编辑

CH32V103应用教程——文件系统FatFs

前面教程中介绍过SPI读写FLASH，此外在论坛中看到很多朋友在此基础上运行FatFs文件系统，参考各位朋友帖子，整理汇总一下，写一个帖子。

1、FatFs简介
FatFs是一个通用的文件系统(FAT/exFAT)模块，用于在小型嵌入式系统中实现FAT文件系统。 FatFs 组件的编写遵循ANSI C(C89)，完全分离于磁盘 I/O 层,因此不依赖于硬件平台。它可以嵌入到资源有限的微控制器中，如 8051, PIC, AVR, ARM, Z80, RX等等，不需要做任何修改。
关于FatFs的具体介绍以及FatFs文件系统的源码，可去FatFs官网浏览下载，链接如下：http://elm-chan.org/fsw/ff/00index_e.html
下载解压打开文件系统源码文件，可以看见里面包含两个文件夹，如下图。其中，documents文件夹下是一些帮助文档，source文件夹下是文件系统源码。本章教程主要用到source文件夹下源码文件，因此对其做主要介绍。
图片1.png
图片2.png
diskio.c文件：是FatFs和disk I/O模块接口文件，是与平台相关的代码，需要用户根据存储介质来编写函数。
diskio.h文件：是FatFs和disk I/O模块的公共包含文件，不需要用户修改。
ff.c文件：是FatFs模块源码，不需要用户修改。
ff.h文件：是FatFs和应用程序模块的通用包含文件，不需要用户修改。
ffconf.h文件：是FatFs模块的配置文件，需要用户根据需求来配置。
ffsystem.c文件，是可选的操作系统对接的各接口相关实现示例。
ffunicode.c文件，是可选的Unicode相关的转换函数，包含了多语言支持需要用到的文件和转换函数。
根据上述描述，因此我们在使用FatFs的时候只需要对diskio.c、ffconf.h、ffunicode.c三个文件进行配置修改即可。

2、硬件设计
本章教程使用SPI读写FLASH，由原理图可知，其片选信号通过电阻R11连接，但开发板默认R11是断开的，因此在使用FLASH之前需将R11短接。
图片3.png

3、软件设计
本次教程在SPI读写FLASH程序基础上进行，本章教程将FatFs源码添加到工程之后对diskio.c、ffconf.h、ffunicode.c三个文件进行配置修改，在此只介绍diskio.c文件的修改，其他见工程。
diskio.c文件
复制
  1. /*-----------------------------------------------------------------------*/
    

  2. /* Low level disk I/O module SKELETON for FatFs     (C)ChaN, 2019        */
    

  3. /*-----------------------------------------------------------------------*/
    

  4. /* If a working storage control module is available, it should be        */
    

  5. /* attached to the FatFs via a glue function rather than modifying it.   */
    

  6. /* This is an example of glue functions to attach various exsisting      */
    

  7. /* storage control modules to the FatFs module with a defined API.       */
    

  8. /*-----------------------------------------------------------------------*/
    


  9. 

  10. #include "diskio.h"     /* Declarations of disk functions */
    


  11. 

  12. /* Definitions of physical drive number for each drive */
    

  13. //#define DEV_RAM       0   /* Example: Map Ramdisk to physical drive 0 */
    

  14. //#define DEV_MMC       1   /* Example: Map MMC/SD card to physical drive 1 */
    

  15. //#define DEV_USB       2   /* Example: Map USB MSD to physical drive 2 */
    


  16. 

  17. /* 为每个设备定义一个物理编号 */
    

  18. #define ATA             1     // 预留SD卡使用
    

  19. #define SPI_FLASH       0     // 外部SPI Flash
    

  20. /*-----------------------------------------------------------------------*/
    

  21. /* Get Drive Status                                                      */
    

  22. /*-----------------------------------------------------------------------*/
    


  23. 

  24. DSTATUS disk_status (
    

  25.     BYTE pdrv       /* Physical drive nmuber to identify the drive */
    

  26. )
    

  27. {
    


  28. 

  29.     DSTATUS status = STA_NOINIT;
    


  30. 

  31.     switch (pdrv)
    

  32.     {
    

  33.         case ATA:   /* SD CARD */
    

  34.             break;
    


  35. 

  36.         case SPI_FLASH:
    

  37.           /* SPI Flash状态检测：读取SPI Flash 设备ID */
    

  38.           if(W25Q16 == SPI_Flash_ReadID())
    

  39.           {
    

  40.             /* 设备ID读取结果正确 */
    

  41.             status &= ~STA_NOINIT;
    

  42.           }
    

  43.           else
    

  44.           {
    

  45.             /* 设备ID读取结果错误 */
    

  46.             status = STA_NOINIT;;
    

  47.           }
    

  48.           break;
    


  49. 

  50.         default:
    

  51.             status = STA_NOINIT;
    

  52.             break;
    

  53.     }
    

  54.     return status;
    

  55. }
    


  56. 


  57. 


  58. 

  59. /*-----------------------------------------------------------------------*/
    

  60. /* Inidialize a Drive                                                    */
    

  61. /*-----------------------------------------------------------------------*/
    


  62. 

  63. DSTATUS disk_initialize (
    

  64.     BYTE pdrv               /* Physical drive nmuber to identify the drive */
    

  65. )
    

  66. {
    

  67.       DSTATUS status = STA_NOINIT;
    

  68.       switch (pdrv)
    

  69.       {
    

  70.           case ATA:            /* SD CARD */
    

  71.               break;
    


  72. 

  73.           case SPI_FLASH:    /* SPI Flash */
    

  74.             /* 初始化SPI Flash */
    

  75.               SPI_Flash_Init();
    

  76.             /* 获取SPI Flash芯片状态 */
    

  77.             status=disk_status(SPI_FLASH);
    

  78.             break;
    


  79. 

  80.           default:
    

  81.             status = STA_NOINIT;
    

  82.             break;
    

  83.       }
    

  84.       return status;
    

  85. }
    


  86. 


  87. 


  88. 

  89. /*-----------------------------------------------------------------------*/
    

  90. /* Read Sector(s)                                                        */
    

  91. /*-----------------------------------------------------------------------*/
    


  92. 

  93. DRESULT disk_read (
    

  94.     BYTE pdrv,      /* Physical drive nmuber to identify the drive */
    

  95.     BYTE *buff,     /* Data buffer to store read data */
    

  96.     LBA_t sector,   /* Start sector in LBA */
    

  97.     UINT count      /* Number of sectors to read */
    

  98. )
    

  99. {
    

  100.     DRESULT status = RES_PARERR;
    

  101.     switch (pdrv)
    

  102.     {
    

  103.         case ATA:   /* SD CARD */
    

  104.             break;
    


  105. 

  106.         case SPI_FLASH:
    

  107.             SPI_Flash_Read(buff, sector <<12, count<<12);
    

  108.           status = RES_OK;
    

  109.             break;
    


  110. 

  111.         default:
    

  112.             status = RES_PARERR;
    

  113.             break;
    

  114.     }
    

  115.     return status;
    

  116. }
    


  117. 


  118. 


  119. 

  120. /*-----------------------------------------------------------------------*/
    

  121. /* Write Sector(s)                                                       */
    

  122. /*-----------------------------------------------------------------------*/
    


  123. 

  124. #if FF_FS_READONLY == 0
    


  125. 

  126. DRESULT disk_write (
    

  127.     BYTE pdrv,          /* Physical drive nmuber to identify the drive */
    

  128.     const BYTE *buff,   /* Data to be written */
    

  129.     LBA_t sector,       /* Start sector in LBA */
    

  130.     UINT count          /* Number of sectors to write */
    

  131. )
    

  132. {
    

  133.       DRESULT status = RES_PARERR;
    

  134.       if (!count) {
    

  135.           return RES_PARERR;      /* Check parameter */
    

  136.       }
    


  137. 

  138.       switch (pdrv)
    

  139.       {
    

  140.           case ATA:   /* SD CARD */
    

  141.               break;
    


  142. 

  143.           case SPI_FLASH:
    

  144.             SPI_Flash_Erase_Sector(sector);
    

  145.             SPI_Flash_Write((uint8_t *)buff,sector<<12,count<<12);
    

  146.             status = RES_OK;
    

  147.             break;
    


  148. 

  149.           default:
    

  150.             status = RES_PARERR;
    

  151.             break;
    

  152.       }
    

  153.       return status;
    

  154. }
    


  155. 

  156. #endif
    


  157. 


  158. 

  159. /*-----------------------------------------------------------------------*/
    

  160. /* Miscellaneous Functions                                               */
    

  161. /*-----------------------------------------------------------------------*/
    


  162. 

  163. DRESULT disk_ioctl (
    

  164.     BYTE pdrv,      /* Physical drive nmuber (0..) */
    

  165.     BYTE cmd,       /* Control code */
    

  166.     void *buff      /* Buffer to send/receive control data */
    

  167. )
    

  168. {
    

  169.     DRESULT status = RES_PARERR;
    

  170.     switch (pdrv)
    

  171.     {
    

  172.         case ATA:   /* SD CARD */
    

  173.             break;
    


  174. 

  175.         case SPI_FLASH:
    

  176.             switch (cmd)
    

  177.             {
    

  178.                 /* 扇区数量：1536*4096/1024/1024=6(MB) */
    

  179.                 case GET_SECTOR_COUNT:
    

  180.                     *(DWORD * )buff = 512;
    

  181.                     break;
    

  182.                 /* 扇区大小  */
    

  183.                 case GET_SECTOR_SIZE :
    

  184.                     *(WORD * )buff = 4096;
    

  185.                     break;
    

  186.                 /* 同时擦除扇区个数 */
    

  187.                 case GET_BLOCK_SIZE :
    

  188.                     *(DWORD * )buff = 1;
    

  189.                     break;
    

  190.             }
    

  191.             status = RES_OK;
    

  192.             break;
    


  193. 

  194.         default:
    

  195.             status = RES_PARERR;
    

  196.             break;
    

  197.     }
    

  198.     return status;
    

  199. }
    


  200. 

  201. DWORD get_fattime(void) {
    

  202.     /* 返回当前时间戳 */
    

  203.     return    ((DWORD)(2015 - 1980) << 25)  /* Year 2015 */
    

  204.             | ((DWORD)1 << 21)              /* Month 1 */
    

  205.             | ((DWORD)1 << 16)              /* Mday 1 */
    

  206.             | ((DWORD)0 << 11)              /* Hour 0 */
    

  207.             | ((DWORD)0 << 5)                 /* Min 0 */
    

  208.             | ((DWORD)0 >> 1);              /* Sec 0 */
    

  209. }
关于程序理解可见注释。
Main.c文件
复制
  1. /********************************** (C) COPYRIGHT *******************************
    

  2. * File Name          : main.c
    

  3. * Author             : WCH
    

  4. * Version            : V1.0.0
    

  5. * Date               : 2020/04/30
    

  6. * Description        : Main program body.
    

  7. *******************************************************************************/
    

  8. #include "debug.h"
    

  9. #include "spi.h"
    

  10. #include "diskio.h"     /* FatFs lower layer API */
    

  11. #include "ff.h"         /* FatFs lower layer API */
    

  12. #include "string.h"
    


  13. 

  14. FATFS fs;                         /* FatFs文件系统对象 */
    

  15. FIL fnew;                         /* 文件对象 */
    

  16. FRESULT res_flash;                /* 文件操作结果 */
    

  17. DIR dire;                         // 目录对象
    

  18. FILINFO fnow;                     // 定义静态文件信息结构对象
    

  19. UINT fnum;                        /* 文件成功读写数量 */
    

  20. BYTE ReadBuffer[1024]={0};        /* 读缓冲区 */
    

  21. BYTE WriteBuffer[] =              /* 写缓冲区*/
    

  22. "这是一个基于CH32V103串行Flash的fatfs的评测实验\r\n";
    


  23. 

  24. BYTE work[FF_MAX_SS];
    


  25. 

  26. FRESULT scan_files (
    

  27.     char* path        /* Start node to be scanned (***also used as work area***) */
    

  28. );
    

  29. /*******************************************************************************
    

  30. * Function Name  : main
    

  31. * Description    : Main program.
    

  32. * Input          : None
    

  33. * Return         : None
    

  34. *******************************************************************************/
    

  35. int main(void)
    

  36. {
    

  37.     char pathBuff[256]; //定义路径数组
    

  38.     char filename[20];
    


  39. 

  40.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    

  41.     Delay_Init();
    

  42.     USART_Printf_Init(115200);
    

  43.     SPI_Flash_Init();
    


  44. 

  45.     printf("****** 这是一个SPI FLASH 文件系统实验 ******\r\n");
    

  46.     printf("FLASH正在整体擦除....\r\n");
    

  47.     SPI_Flash_Erase_Chip();
    

  48.     printf("FLASH整体擦除完毕....\r\n");
    


  49. 

  50.     //在外部SPI Flash挂载文件系统，文件系统挂载时会对SPI设备初始化
    

  51.     //初始化函数调用流程如下
    

  52.     //f_mount()->find_volume()->disk_initialize->SPI_FLASH_Init()
    

  53.     //f_mount:注册或注销一个工作区域
    

  54.     //f_mount 函数有三个形参，
    

  55.     //第 一个参数是指向 FATFS 变量指针，如果赋值为 NULL 可以取消物理设备挂载。
    

  56.     //第二个参数为逻辑设备编号，使用设备根路径表示，与物理设备编号挂钩，在diskio.c文件中我们定义 SPI Flash 芯片物理编号为 0，所以这里使用“0：”。
    

  57.     //第三个参数可选 0 或 1， 1 表示立即挂载， 0 表示不立即挂载，延迟挂载。
    

  58.     //f_mount 函数会返回一个 FRESULT 类型值，指示运行情况。
    

  59.     //返回值：FR_OK (0)，函数成功     FR_INVALID_DRIVE，驱动器无效
    

  60.     res_flash = f_mount(&fs,"0:",1);
    


  61. 

  62.     if(res_flash==FR_OK)
    

  63.     {
    

  64.       printf("》文件系统挂载成功\r\n");
    

  65.     }
    

  66.     else
    

  67.     {
    

  68.       printf("！！文件系统挂载失败：(%d)\r\n",res_flash);
    

  69.     }
    


  70. 

  71.     /*----------------------- 格式化测试 -----------------*/
    

  72.     /* 如果没有文件系统就格式化创建创建文件系统 */
    

  73.     //如果 f_mount 函数返回值为 FR_NO_FILESYSTEM，说明没有 FAT 文件系统，比如新出厂的 SPI Flash 芯片就没有 FAT 文件系统。我们就必须对物理设备进行格式化处理。
    

  74.     if(res_flash == FR_NO_FILESYSTEM)
    

  75.     {
    

  76.         printf("》FLASH还没有文件系统，即将进行格式化...\r\n");
    

  77.         /* 格式化 */
    

  78.         //f_mkfs:在驱动器上创建一个文件系统
    

  79.         //f_mkfs 函数有三个形参，
    

  80.         //第一个参数为逻辑设备编号；
    

  81.         //第二参数可选 0 或者 1， 0 表示设备为一般硬盘， 1 表示设备为软盘。
    

  82.         //第三个参数指定扇区大小，如果为 0，表示通过代码 disk_ioctl 函数获取。格式化成功后需要先取消挂载原来设备，再重新挂载设备
    

  83.         res_flash=f_mkfs("0:",0,work,sizeof(work));
    


  84. 

  85.         if(res_flash == FR_OK)
    

  86.         {
    

  87.             printf("》FLASH已成功格式化文件系统。\r\n");
    

  88.             /* 格式化后，先取消挂载 */
    

  89.             res_flash = f_mount(NULL,"0:",1);
    

  90.             /* 重新挂载   */
    

  91.             res_flash = f_mount(&fs,"0:",1);
    

  92.         }
    

  93.         else
    

  94.         {
    

  95.             printf("《《格式化失败。》》\r\n");
    

  96.             while(1);
    

  97.         }
    


  98. 

  99.     }
    

  100.     else if(res_flash!=FR_OK)
    

  101.     {
    

  102.         printf("！！外部Flash挂载文件系统失败。(%d)\r\n",res_flash);
    

  103.         printf("！！可能原因：SPI Flash初始化不成功。\r\n");
    

  104.         while(1);
    

  105.     }
    

  106.     else
    

  107.     {
    

  108.         printf("》文件系统挂载成功，可以进行读写测试\r\n");
    

  109.     }
    


  110. 

  111.     /*----------------------- 文件系统测试：创建文件目录 -------------------*/
    

  112.     //strcpy:strcpy把含有'\0'结束符的字符串复制到另一个地址空间，返回值的类型为char*
    

  113.     strcpy(filename, "123");
    

  114.     //f_mkdir:创建一个目录
    

  115.     res_flash = f_mkdir(filename);
    

  116.     if(res_flash==FR_OK)
    

  117.     {
    

  118.         printf("》文件夹%s创建成功\r\n",filename);
    

  119.     }
    

  120.     else if(res_flash==FR_EXIST)
    

  121.     {
    

  122.         printf("！！文件夹已存在：(%d)\r\n",res_flash);
    

  123.     }
    

  124.     else
    

  125.     {
    

  126.         printf("！！文件夹创建失败：(%d)\r\n",res_flash);
    

  127.     }
    


  128. 

  129.     strcpy(filename, "123/456");
    

  130.     res_flash = f_mkdir(filename);
    

  131.     if(res_flash==FR_OK)
    

  132.     {
    

  133.         printf("》文件夹%s创建成功\r\n",filename);
    

  134.     }
    

  135.     else if(res_flash==FR_EXIST)
    

  136.     {
    

  137.         printf("！！文件夹已存在：(%d)\r\n",res_flash);
    

  138.     }
    

  139.     else
    

  140.     {
    

  141.         printf("！！文件夹创建失败：(%d)\r\n",res_flash);
    

  142.     }
    


  143. 

  144.     strcpy(filename, "123/456/789");
    

  145.     res_flash = f_mkdir(filename);
    

  146.     if(res_flash==FR_OK)
    

  147.     {
    

  148.         printf("》文件夹%s创建成功\r\n",filename);
    

  149.     }
    

  150.     else if(res_flash==FR_EXIST)
    

  151.     {
    

  152.         printf("！！文件夹已存在：(%d)\r\n",res_flash);
    

  153.     }
    

  154.     else
    

  155.     {
    

  156.         printf("！！文件夹创建失败：(%d)\r\n",res_flash);
    

  157.     }
    


  158. 

  159.     /*----------------------- 文件系统测试：写测试 -------------------*/
    

  160.     /* 打开文件，每次都以新建的形式打开，属性为可写 */
    

  161.     printf("\r\n****** 即将进行文件写入测试... ******\r\n");
    

  162.     //f_open:打开或创建一个文件     FA_CREATE_ALWAYS:创建一个新文件，如果文件已存在，则它将被被截断并覆盖
    

  163.     res_flash = f_open(&fnew, "0:123/456/789/CH32V103x.txt",FA_CREATE_ALWAYS | FA_WRITE );
    

  164.     if ( res_flash == FR_OK )
    

  165.     {
    

  166.         printf("》打开/创建CH32V103x.txt文件成功，向文件写入数据。\r\n");
    

  167.         /* 将指定存储区内容写入到文件内 */
    

  168.         //f_write:写文件
    

  169.         res_flash=f_write(&fnew,WriteBuffer,sizeof(WriteBuffer),&fnum);
    

  170.     if(res_flash==FR_OK)
    

  171.     {
    

  172.         printf("》文件写入成功，写入字节数据：%d\r\n",fnum);
    

  173.         printf("》向文件写入的数据为：\r\n%s\r\n",WriteBuffer);
    

  174.     }
    

  175.     else
    

  176.     {
    

  177.         printf("！！文件写入失败：(%d)\n",res_flash);
    

  178.     }
    

  179.         /* 不再读写，关闭文件 */
    

  180.         //f_close:关闭一个文件
    

  181.         f_close(&fnew);
    

  182.     }
    

  183.     else
    

  184.     {
    

  185.         printf("！！打开/创建文件失败。\r\n");
    

  186.     }
    


  187. 

  188.     /*------------------- 文件系统测试：读测试 --------------------------*/
    

  189.     printf("****** 即将进行文件读取测试... ******\r\n");
    

  190.     //f_open:打开或创建一个文件     FA_OPEN_EXISTING:打开一个文件，如果文件不存在，则打开失败（默认）
    

  191.     res_flash = f_open(&fnew, "0:123/456/789/CH32V103x.txt",FA_OPEN_EXISTING | FA_READ);
    

  192.     if(res_flash == FR_OK)
    

  193.     {
    

  194.         printf("》打开文件成功。\r\n");
    

  195.         //f_read:读文件
    

  196.         res_flash = f_read(&fnew, ReadBuffer, sizeof(ReadBuffer), &fnum);
    

  197.     if(res_flash==FR_OK)
    

  198.     {
    

  199.         printf("》文件读取成功,读到字节数据：%d\r\n",fnum);
    

  200.         printf("》读取得的文件数据为：\r\n%s \r\n", ReadBuffer);
    

  201.     }
    

  202.     else
    

  203.     {
    

  204.         printf("！！文件读取失败：(%d)\n",res_flash);
    

  205.     }
    

  206.     }
    

  207.     else
    

  208.     {
    

  209.         printf("！！打开文件失败。\r\n");
    

  210.     }
    

  211.     /* 不再读写，关闭文件 */
    

  212.     f_close(&fnew);
    


  213. 

  214.     printf("*************** 文件信息获取测试 **************\r\n");
    

  215.      /* 操作完成，停机 */
    

  216.     printf("》开始扫描文件目录....\r\n");
    

  217.     strcpy(pathBuff, "");
    

  218.     scan_files(pathBuff);
    


  219. 

  220.     /* 不再使用文件系统，取消挂载文件系统 */
    

  221.     //f_mount：注册或注销一个工作区域
    

  222.     f_mount(NULL,"0:",1);
    

  223.     while(1)
    

  224.     {
    


  225. 

  226.     }
    

  227. }
    


  228. 

  229. FRESULT scan_files (
    

  230.     char* path        /* Start node to be scanned (***also used as work area***) */
    

  231. )
    

  232. {
    

  233.     FRESULT res;
    

  234.     DIR dir;
    

  235.     UINT i;
    

  236.     static FILINFO fno;
    


  237. 

  238.     //f_opendir:打开一个目录
    

  239.     res = f_opendir(&dir, path);                       /* Open the directory */
    

  240.     if (res == FR_OK)
    

  241.     {
    

  242.         for (;;)
    

  243.         {
    

  244.             //f_readdir:读取目录条目
    

  245.             res = f_readdir(&dir, &fno);                   /* Read a directory item */
    

  246.             if (res != FR_OK || fno.fname[0] == 0) break;  /* Break on error or end of dir */
    

  247.             if (fno.fattrib & AM_DIR)//假如是文件夹
    

  248.             {
    

  249.                 /* It is a directory */
    

  250.                 i = strlen(path);                          //计算出路径长度
    

  251.                 sprintf(&path[i], "/%s", fno.fname);       //文件名加到路径后面
    

  252.                 res = scan_files(path);                    /* Enter the directory */
    

  253.                 if (res != FR_OK) break;
    

  254.                 path[i] = 0;
    

  255.             }
    

  256.             else
    

  257.             {                                       /* It is a file. */
    

  258.                 printf("%s/%s\r\n", path, fno.fname);
    

  259.             }
    

  260.         }
    

  261.         //f_closedir:关闭一个已经打开的目录
    

  262.         f_closedir(&dir);
    

  263.     }
    

  264.     return res;
    

  265. }
    


  266.
Main.c文件主要进行文件创建、读写测试等。

4、下载验证
将编译好的程序下载到开发板并复位，串口打印如下：
图片4.png

107、Flash-FatFs.rar

1.32 MB, 下载次数: 62
回复

收藏1 举报

相关帖子
kkzz 发表于 2021-10-2 11:47 | 显示全部楼层
fatfs 会很费单片机内存吗  
回复

收藏1 举报

hudi008 发表于 2021-10-2 11:47 | 显示全部楼层
fatfs单片机能读写csv文件吗
回复

收藏1 举报

lzmm 发表于 2021-10-2 11:47 | 显示全部楼层
znfat 与fatfs哪个好  
回复

收藏1 举报

minzisc 发表于 2021-10-2 11:47 | 显示全部楼层
有什么适合单片机的文件系统？  
回复

收藏1 举报

selongli 发表于 2021-10-2 11:48 | 显示全部楼层
用sd卡 存储单片机数据  
回复

收藏1 举报

fentianyou 发表于 2021-10-2 11:48 | 显示全部楼层
用FATFS文件系统   
回复

收藏1 举报

xiaoyaodz 发表于 2021-10-2 11:48 | 显示全部楼层
怎么对单片机内部flash进行坏块检测？
回复

收藏1 举报

febgxu 发表于 2021-10-2 11:48 | 显示全部楼层
单片机一般提供的ROM和RAM都比较小。  
回复

收藏1 举报

pixhw 发表于 2021-10-2 11:49 | 显示全部楼层
FAT文件系统的SD卡单片机读写方法详解
回复

收藏1 举报

sdlls 发表于 2021-10-2 11:49 | 显示全部楼层
支持sd卡和flash吗？        
回复

收藏1 举报

评论

RISCVLAR
支持  发表于 2021-10-8 10:59
kkzz 发表于 2022-11-3 21:43 | 显示全部楼层
fatfs会占用多大的内存？如何降低ram占用量
回复

收藏1 举报

wilhelmina2 发表于 2022-11-3 21:59 | 显示全部楼层
能不能利用FatFs和ch32实现U盘的功能呢?
回复

收藏1 举报

modesty3jonah 发表于 2022-11-5 09:49 | 显示全部楼层
FatFs支持多大的sd卡呢？              
回复

收藏1 举报

geraldbetty 发表于 2022-11-5 10:15 | 显示全部楼层
ch32v307是否有sdio的接口呢？
回复

收藏1 举报

PeerS01 发表于 2023-1-14 22:16 | 显示全部楼层
应该出个 u盘的读写就好了
回复

收藏1 举报

trucyw 发表于 2024-3-20 14:22 | 显示全部楼层
Spi flash file system.
f_mount disk0 =3!
!!文件系统挂载失败:(3)
!!外部Flash挂载文件系统失败.(3)
!!可能原因:SPI Flash初始化不成功.
提示如上的原因是什么呢？？？
回复

收藏1 举报

forgot 发表于 2024-3-21 14:13 | 显示全部楼层
FatFs是一个通用的文件系统(FAT/exFAT)模块，用于在小型嵌入式系统中实现FAT文件系统。
回复

收藏1 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

RISCVLAR

133

主题

296

帖子

45

粉丝
快速回复 在线客服 返回列表 返回顶部