STM32F103ZET6移植FATFS文件体系教程（W25Q32）

一、FATFS核心特性

跨平台支持‌
支持FAT12/FAT16/FAT32格式，兼容Windows文件体系‌；
接纳标准C语言编写，代码量小且支持RTOS‌。
设置灵活性‌
通过宏界说实现功能裁剪，比方：
FF_FS_READONLY：设为1时禁用写使用相干函数（如f_write()、f_unlink()）‌；
FF_FS_MINIMIZE：设置差异精简级别（0-3），逐步移除非须要API（如目次使用、文件统计等）‌。

二、移植关键步调

存储介质初始化‌
需初始化底层存储装备（如SD卡、SPI Flash），涉及存储地址映射与读写函数实现‌；
在user_diskio.c中实现底层接口：disk_initialize（初始化）、disk_read（读）、disk_write（写）‌。
文件体系挂载‌
调用f_mount()函数挂载存储装备（如f_mount(fs, "0:", 1)），分配逻辑驱动器号（如"0:"）‌。
三、应用层使用

文件读写流程‌
创建文件‌：f_open(&file, "0:/file.txt", FA_CREATE_ALWAYS | FA_WRITE)‌；
数据写入‌：使用f_write()时需将非字符范例数据（如int/float）转换为字符格式‌；
资源开释‌：使用完成后需调用f_close()关闭文件‌。
辅助功能设置‌
支持长文件名需启用FF_USE_LFN并选择编码方式（如UTF-8）‌；
多卷管理需设置FF_VOLUMES参数‌。

四、注意事项


存储介质格式化‌：初次使用前需通过工具或代码格式化，以创建文件分配表和目次布局‌；
内存管理‌：合理分配缓冲区以避免内存溢出，尤其在动态内存模式下‌；
实时性优化‌：在RTOS中需确保文件体系使用与使命调理兼容‌。

开始移植

我们先使用STM32CubeMX创建一个纯净的工程

设置好SPI1

然后在初始化一个片选引脚（PC13）

之后在中心件里设置好FATFS（选择User-defind就好，其他的可以不消改）

末了选择MDK-ARM，生成工程

底层驱动兼容SFUD


一、通用驱动兼容性


广泛硬件支持‌：兼容市面主流SPI Flash芯片（如W25Q64、SST25VF等），支持SPI/QSPI接口的底子读写擦除使用，无需针对差异芯片重复开辟驱动‌。
接口标准化‌：通过同一API（如sfud_read、sfud_erase）屏蔽底层硬件差异，低沉代码与硬件的耦合度‌。

二、参数自动检测


动态识别本领‌：运行时自动读取Flash的厂商ID、容量、擦除粒度等参数，镌汰因芯片停产或型号变动导致的维护风险‌。
SFDP协议支持‌：基于JEDEC标准的SFDP（Serial Flash Discoverable Parameters）规范，自动剖析装备特性表，避免手动设置‌。

三、轻量级设计


低资源占用‌：标准模式代码量约5.5KB ROM/0.2KB RAM，最小模式可压缩至3.6KB ROM/0.1KB RAM，实用于STM32等资源受限的MCU‌。
可裁剪性‌：通过宏界说关闭非须要功能（如QSPI支持），进一步优化存储和运行服从‌。

四、扩展性与易用性


多装备管理‌：支持通过注册机制同时驱动多个Flash装备，实用于多存储介质的复杂场景（如主控+备份存储）‌。
分层架构设计‌：与FAL（Flash抽象层）组件无缝集成，提供同一的Flash访问接口，简化文件体系（如FATFS）或OTA升级功能的实现‌。

五、开辟服从提拔


快速移植‌：仅需实现底层SPI接口函数（如spi_send、spi_recv），收缩从零开辟驱动的时间‌。
动态适配上风‌：新增Flash型号时无需修改驱动代码，仅需更新装备参数表或依赖SFDP自动识别‌。

场景‌	SFUD作用‌
外部存储扩展（如W25Q32）	提供同一接口，简化文件体系（FATFS）或日志存储的实现流程
多Flash装备管理	通过注册机制区分差异存储介质，支持并行使用    ‌

特性‌	嵌入式开辟价值‌
兼容性‌	覆盖90%以上主流SPI Flash型号，低沉硬件选型限定
低资源斲丧‌	适配低端MCU（如STM32F103），节流ROM/RAM资源
维护本钱低‌	动态参数检测镌汰代码修改频率，提拔长期项目可持续性

移植SFUD


SFUD会检测单片机上的Flash芯片，以是我们这里选择SFUD驱动做一个兼容，就算更换芯片后也不需要修改底层代码。
SFUD: https://github.com/armink/SFUD.git - Gitee.com
把代码克隆到本地，然后把sfud文件夹复制出来，放到工程目次下，内里共有3个目次（inc，port，src）

将port和src内的C文件加到Keil工程内 

然后添加inc路径

我们只需要实现底层的函数接口
进入到sfud_port.c文件内，实现spi_write_read函数

1. #include <sfud.h>
2. #include <stdarg.h>
3. #include "main.h"
5. static char log_buf[256];
7. extern SPI_HandleTypeDef hspi1;
9. #define SPI_Start() (HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET))
10. #define SPI_Stop() (HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET))
12. void sfud_log_debug(const char* file, const long line, const char* format, ...);
14. /**
15. * SPI write data then read data
16. */
17. static sfud_err spi_write_read(const sfud_spi* spi, const uint8_t* write_buf, size_t write_size, uint8_t* read_buf, size_t read_size) {
18.     sfud_err result = SFUD_SUCCESS;
19.     uint8_t send_data, read_data;
21.     /**
22.      * add your spi write and read code
23.      */
25.     SPI_Start();
27.     if (write_size > 0) {
28.         if (HAL_OK != HAL_SPI_Transmit(&hspi1, (uint8_t*)write_buf, write_size, 1000))
29.             result = SFUD_ERR_TIMEOUT;
30.     }
32.     if (read_size > 0) {
33.         if (HAL_OK != HAL_SPI_Receive(&hspi1, (uint8_t*)read_buf, read_size, 1000))
34.             result = SFUD_ERR_TIMEOUT;
35.     }
37.     SPI_Stop();
39.     return result;
40. }

复制代码

实现sfud_spi_port_init函数，表明反面提示Required的都是需要设置的
关于delay的设置，就恣意用软件的方式延时一下就好了

1. void delay(void) {
2.     uint16_t count = 10000;
3.     while (count--) {
4.         __NOP();
5.     }
6. }
8. sfud_err sfud_spi_port_init(sfud_flash* flash) {
9.     sfud_err result = SFUD_SUCCESS;
11.     /**
12.      * add your port spi bus and device object initialize code like this:
13.      * 1. rcc initialize
14.      * 2. gpio initialize
15.      * 3. spi device initialize
16.      * 4. flash->spi and flash->retry item initialize
17.      *    flash->spi.wr = spi_write_read; //Required
18.      *    flash->spi.qspi_read = qspi_read; //Required when QSPI mode enable
19.      *    flash->spi.lock = spi_lock;
20.      *    flash->spi.unlock = spi_unlock;
21.      *    flash->spi.user_data = &spix;
22.      *    flash->retry.delay = null;
23.      *    flash->retry.times = 10000; //Required
24.      */
26.     flash->spi.wr = spi_write_read;
27.     flash->retry.delay = delay;
28.     flash->retry.times = 10000;
30.     return result;
31. }

复制代码

测试SFUD和芯片是否移植乐成
在main.c内引入 sfud.h文件

1. int fputc(int ch, FILE* f) {
2.     HAL_UART_Transmit(&huart1, (uint8_t*)&ch, 1, 1000);
3.     return ch;
4. }
6. // sfud测试
7. void es(void) {
8.     printf("擦除数据\r\n");
9.     const sfud_flash* flash = sfud_get_device(0);
10.     sfud_erase(flash, 0, 100);
11. }
13. void ws(void) {
14.     //获取到设备Flash
15.     const sfud_flash* flash = sfud_get_device(0);
16.     uint8_t buff[300] = {0};
17.     for (uint16_t i = 0; i < 300; i++) {
18.         buff[i] = i;
19.     }
20.     //先擦除在写入
21.     sfud_erase_write(flash, 0, 300, buff);
22. }
24. void rs(void) {
25.     const sfud_flash* flash = sfud_get_device(0);
26.     uint8_t buff[300] = {0};
27.     sfud_read(flash, 0, 300, buff);
28.     for (uint16_t i = 0; i < 300; i++) {
29.         printf("%d ", buff[i]);
30.         if (i % 10 == 0) {
31.             printf("\r\n");
32.         }
33.     }
34. }
35. // sfud测试
37. int main(void) {
38.     /* USER CODE BEGIN 1 */
40.     /* USER CODE END 1 */
42.     /* MCU Configuration--------------------------------------------------------*/
44.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
45.     HAL_Init();
47.     /* USER CODE BEGIN Init */
49.     /* USER CODE END Init */
51.     /* Configure the system clock */
52.     SystemClock_Config();
54.     /* USER CODE BEGIN SysInit */
56.     /* USER CODE END SysInit */
58.     /* Initialize all configured peripherals */
59.     MX_GPIO_Init();
60.     MX_SPI1_Init();
61.     //MX_FATFS_Init();
62.     MX_USART1_UART_Init();
63.     /* USER CODE BEGIN 2 */
64.     sfud_init();
66.     rs();
67.     HAL_Delay(1000);
68.     ws();
69.     HAL_Delay(1000);
70.     rs();
71.     /* USER CODE END 2 */
73.     /* Infinite loop */
74.     /* USER CODE BEGIN WHILE */
75.     while (1) {
76.         /* USER CODE END WHILE */
78.         /* USER CODE BEGIN 3 */
79.     }
80.     /* USER CODE END 3 */
81. }

复制代码

先读取数据在写入数据，再读出来，看看数据是否同等，读取数据就是把1变0，擦除就是把0变1，以是默认都是1，以是读出来都是255

设置FATFS

打开user_diskio.c 文件，修改USER_initialize和USER_status函数

1. /**
2. * @brief  Initializes a Drive
3. * @param  pdrv: Physical drive number (0..)
4. * @retval DSTATUS: Operation status
5. */
6. DSTATUS USER_initialize(
7.     BYTE pdrv /* Physical drive nmuber to identify the drive */
8. ) {
9.     /* USER CODE BEGIN INIT */
10.     Stat &= ~STA_NOINIT;
11.     return Stat;
12.     /* USER CODE END INIT */
13. }
15. /**
16. * @brief  Gets Disk Status
17. * @param  pdrv: Physical drive number (0..)
18. * @retval DSTATUS: Operation status
19. */
20. DSTATUS USER_status(
21.     BYTE pdrv /* Physical drive number to identify the drive */
22. ) {
23.     /* USER CODE BEGIN STATUS */
24.     Stat &= ~STA_NOINIT;
25.     return Stat;
26.     /* USER CODE END STATUS */
27. }

复制代码

实现USER_read函数

1. DRESULT USER_read(
2.     BYTE pdrv,    /* Physical drive nmuber to identify the drive */
3.     BYTE* buff,   /* Data buffer to store read data */
4.     DWORD sector, /* Sector address in LBA */
5.     UINT count    /* Number of sectors to read */
6. ) {
7.     /* USER CODE BEGIN READ */
8.     const sfud_flash* flash = sfud_get_device(0);
9.     uint32_t read_addr = sector * 4096;
11.     sfud_read(flash, read_addr, count * 4096, buff);
13.     return RES_OK;
14.     /* USER CODE END READ */
15. }

复制代码

 实现USER_write函数

1. DRESULT USER_write(
2.     BYTE pdrv,        /* Physical drive nmuber to identify the drive */
3.     const BYTE* buff, /* Data to be written */
4.     DWORD sector,     /* Sector address in LBA */
5.     UINT count        /* Number of sectors to write */
6. ) {
7.     /* USER CODE BEGIN WRITE */
8.     const sfud_flash* flash = sfud_get_device(0);
9.     uint32_t write_addr = sector * 4096;
11.     sfud_erase_write(flash, write_addr, count * 4096, buff);
12.     /* USER CODE HERE */
13.     return RES_OK;
14.     /* USER CODE END WRITE */
15. }

复制代码

实现USER_ioctl函数

1. DRESULT USER_ioctl(
2.     BYTE pdrv, /* Physical drive nmuber (0..) */
3.     BYTE cmd,  /* Control code */
4.     void* buff /* Buffer to send/receive control data */
5. ) {
6.     /* USER CODE BEGIN IOCTL */
7.     DRESULT res = RES_OK;
8.     switch (cmd) {
9.         case CTRL_SYNC:
10.             break;
11.         case GET_SECTOR_COUNT:
12.             *((DWORD*)buff) = 1024;
13.             break;
14.         case GET_SECTOR_SIZE:
15.             *((WORD*)buff) = 4096;
16.             break;
17.         case GET_BLOCK_SIZE:
18.             *((DWORD*)buff) = 1;
19.             break;
20.         default:
21.             res = RES_PARERR;
22.     }
23.     return res;
24.     /* USER CODE END IOCTL */
25. }

复制代码

 打开ffconf.h文件，修改__MAX_SS为4096

进去到fatfs.c文件，USERPath是文件的起始路径，这里使用 \，前面在转义一下

如果我们这里设置起始路径的话，在ff_gen_drv.c文件内需要表明掉path代码，如果不设置的话会给我们一个默认的起始路径，这里就不需要表明掉了 

 回到main.c文件内，取消表明FATFS初始化函数

 测试FATFS文件体系

1. // fatfs测试
2. void mkfs(void) {
3.     uint8_t res = f_mkfs(USERPath, 1, _MAX_SS);
4.     printf("mkfs res: %d\r\n", res);
5. }
7. FATFS fs;
9. void mnt(void) {
10.     uint8_t res = f_mount(&fs, USERPath, 1);
11.     printf("mnt res: %d\r\n", res);
12. }
14. FIL file;
16. void create_file(char* file_name, char* content) {
17.     int res = 0;
18.     int bwritten = 0;
19.     printf("Create file :%s\r\n", file_name);
20.     // 创建一个a.txt文件
21.     res = f_open(&file, file_name, FA_WRITE | FA_CREATE_ALWAYS);
22.     printf("Create file res:%d\r\n", res);
23.     // 写入数据到文件中
24.     res = f_write(&file, content, strlen(content), (UINT*)&bwritten);
25.     printf("write file res:%d\r\n", res);
26.     // 关闭文件
27.     f_close(&file);
28. }
30. void list_files(char* path) {
31.     printf("file list:\r\n");
32.     FILINFO fno;
33.     DIR dir;
34.     FRESULT res;
35.     res = f_opendir(&dir, path);
36.     if (res == FR_OK) {
37.         while (1) {
38.             res = f_readdir(&dir, &fno);
39.             if (res != FR_OK || fno.fname[0] == 0)
40.                 break;
41.             printf("%s\r\n", fno.fname);
42.         }
43.         f_closedir(&dir);
44.     }
45. }
47. void read_file(char* file_name, char* content) {
48.     int res = 0;
49.     int bread = 0;
50.     printf("Show File Content:%s\r\n", file_name);
52.     res = f_open(&file, file_name, FA_READ);
54.     printf("Open file res : %d\r\n", res);
56.     res = f_read(&file, content, 100, (UINT*)&bread);
58.     printf("Read file res : %d\r\n", res);
60.     f_close(&file);
61. }
62. // fatfs测试
64. int main(void) {
65.     /* USER CODE BEGIN 1 */
67.     /* USER CODE END 1 */
69.     /* MCU Configuration--------------------------------------------------------*/
71.     /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
72.     HAL_Init();
74.     /* USER CODE BEGIN Init */
76.     /* USER CODE END Init */
78.     /* Configure the system clock */
79.     SystemClock_Config();
81.     /* USER CODE BEGIN SysInit */
83.     /* USER CODE END SysInit */
85.     /* Initialize all configured peripherals */
86.     MX_GPIO_Init();
87.     MX_SPI1_Init();
88.     MX_FATFS_Init();
89.     MX_USART1_UART_Init();
90.     /* USER CODE BEGIN 2 */
91.     sfud_init();
93.     mnt();
94.     mkfs();
96.     char content_a[100] = "hello world\r\nhello fatfs\r\nhello violet\r\n";
97.     create_file("a.txt", content_a);
98.     char content_b[100] = "37193719731831300\r\n";
99.     create_file("b.txt", content_b);
100.     char content_c[100] = "dadajdlajldjajajflajf\r\n";
101.     create_file("c.txt", content_c);
102.     list_files(USERPath);
103.     char read_content[100] = {0};
104.     read_file("a.txt", read_content);
105.     printf("%s\r\n", read_content);
106.     memset(read_content, 0, sizeof(read_content));
107.     read_file("b.txt", read_content);
108.     printf("%s\r\n", read_content);
109.     memset(read_content, 0, sizeof(read_content));
110.     read_file("c.txt", read_content);
111.     printf("%s\r\n", read_content);
113.     // rs();
114.     // HAL_Delay(1000);
115.     // ws();
116.     // HAL_Delay(1000);
117.     // rs();
118.     /* USER CODE END 2 */
120.     /* Infinite loop */
121.     /* USER CODE BEGIN WHILE */
122.     while (1) {
123.         /* USER CODE END WHILE */
125.         /* USER CODE BEGIN 3 */
126.     }
127.     /* USER CODE END 3 */
128. }

复制代码

效果

测试乐成，完成了对FATFS的移植了，喜好的话点个关注吧。