CubeMX配置STM32实现FatFS文件系统（五）_dresult user_write

作者：我家小花儿 | 2024-04-21 16:44:44

踩

dresult user_write

CubeMX配置STM32实现FatFS文件系统

引言
CubeMX配置FatFS功能
驱动移植
案例演示
代码解析
总结

引言

在前四篇文章中自己介绍了如何配置freeRTOS以及如何配置LWIP，并使用lwip实现一个httpd服务器，使浏览器可以访问，并利用CGI功能，实现通过网页来控制单片机的一个LED灯的电平翻转。
在这篇文章中，本人使用CubeMX软件配置STM32驱动FLASH实现文件系统，为以后使用FTP远程登录做准备。

自己写的另外三篇文章
从零开始Cubemx配置STM32搭载freeRTOS实现多路ADC（一）
从零开始Cubemx配置STM32搭载freeRTOS以及lwip实现tcp网络通信（二）
从零开始使用CubeMX配置STM32使用lwip实现httpd服务器以及使用vscode编辑阅读keil代码（三）
CubeMX配置STM32实现httpd服务器CGI功能并使用网页控制STM32单片机（四）

CubeMX配置FatFS功能

配置过程主要看了这位大佬的文章 STM32CUBEIDE之SPI读写FLASH进阶串行FLASH文件系统FatFs以及野火的课程https://www.bilibili.com/video/BV18X4y1M763?p=64&spm_id_from=pageDriver的P57讲的部分，在这里表示感谢，我这篇文章主要自己做了一遍，然后根据自己的理解总结一下。
在这里插入图片描述
移植基本不需要怎么改动，需要改动的是将编码改成简体中文，打开长文件名选项。由于我的程序带有操作系统，因此我就放在HEAP也就是堆中了。

放在HEAP中的话记得把HEAP的大小改大。

W25Q128是16M spi flash，一共有256个block ，每个Block 64KB。
一个Block可以分割为16个扇区（small sector），每个扇区4096字节

由于我用的是野火的板级支持包，因此SPI通信的FLASH我就不配置了，直接移植就可以了。其他的型号按照如何驱动存储介质的操作进行驱动就行了，这一部分一般是驱动工程师的工作。

驱动移植

上面的东西配置完成后，生成代码。
在这里插入图片描述
代码部分需要我们做的主要是驱动的移植。我们打开user_diskio.c文件。我们的驱动文件就移植到这个文件里面。

#ifdef USE_OBSOLETE_USER_CODE_SECTION_0
/* 
 * Warning: the user section 0 is no more in use (starting from CubeMx version 4.16.0)
 * To be suppressed in the future. 
 * Kept to ensure backward compatibility with previous CubeMx versions when 
 * migrating projects. 
 * User code previously added there should be copied in the new user sections before 
 * the section contents can be deleted.
 */
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
#endif

/* USER CODE BEGIN DECL */

/* Includes ------------------------------------------------------------------*/
#include <string.h>
#include "ff_gen_drv.h"
#include "bsp_spi_flash.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define SPI_FLASH		0     // 外部SPI Flash
/* Private variables ---------------------------------------------------------*/
/* Disk status */
static volatile DSTATUS Stat = STA_NOINIT;

/* USER CODE END DECL */

/* Private function prototypes -----------------------------------------------*/
DSTATUS USER_initialize (BYTE pdrv);
DSTATUS USER_status (BYTE pdrv);
DRESULT USER_read (BYTE pdrv, BYTE *buff, DWORD sector, UINT count);
#if _USE_WRITE == 1
  DRESULT USER_write (BYTE pdrv, const BYTE *buff, DWORD sector, UINT count);  
#endif /* _USE_WRITE == 1 */
#if _USE_IOCTL == 1
  DRESULT USER_ioctl (BYTE pdrv, BYTE cmd, void *buff);
#endif /* _USE_IOCTL == 1 */

Diskio_drvTypeDef  USER_Driver =
{
  USER_initialize,
  USER_status,
  USER_read, 
#if  _USE_WRITE
  USER_write,
#endif  /* _USE_WRITE == 1 */  
#if  _USE_IOCTL == 1
  USER_ioctl,
#endif /* _USE_IOCTL == 1 */
};

/* Private functions ---------------------------------------------------------*/

/**
  * @brief  Initializes a Drive
  * @param  pdrv: Physical drive number (0..)
  * @retval DSTATUS: Operation status
  */
DSTATUS USER_initialize (
	BYTE pdrv           /* Physical drive nmuber to identify the drive */
)
{
  /* USER CODE BEGIN INIT */
  uint16_t i;
	DSTATUS status = STA_NOINIT;	
	switch (pdrv) {   
		case SPI_FLASH:    /* SPI Flash */ 
      /* 初始化SPI Flash */
			SPI_FLASH_Init();
      /* 延时一小段时间 */
      i=500;
	    while(--i);	
      /* 唤醒SPI Flash */
	    SPI_Flash_WAKEUP();
      /* 获取SPI Flash芯片状态 */
      status=USER_status(SPI_FLASH);
			break;
      
		default:
			status = STA_NOINIT;
	}
	return status;
  /* USER CODE END INIT */
}
 
/**
  * @brief  Gets Disk Status 
  * @param  pdrv: Physical drive number (0..)
  * @retval DSTATUS: Operation status
  */
DSTATUS USER_status (
	BYTE pdrv       /* Physical drive number to identify the drive */
)
{
  /* USER CODE BEGIN STATUS */
	DSTATUS status = STA_NOINIT;
	
	switch (pdrv) {
		case SPI_FLASH:      
      /* SPI Flash状态检测：读取SPI Flash 设备ID */
      if(sFLASH_ID == SPI_FLASH_ReadID())
      {
        /* 设备ID读取结果正确 */
        status &= ~STA_NOINIT;
      }
      else
      {
        /* 设备ID读取结果错误 */
        status = STA_NOINIT;;
      }
			break;

		default:
			status = STA_NOINIT;
	}
	return status;
  /* USER CODE END STATUS */
}

/**
  * @brief  Reads Sector(s) 
  * @param  pdrv: Physical drive number (0..)
  * @param  *buff: Data buffer to store read data
  * @param  sector: Sector address (LBA)
  * @param  count: Number of sectors to read (1..128)
  * @retval DRESULT: Operation result
  */
DRESULT USER_read (
	BYTE pdrv,      /* Physical drive nmuber to identify the drive */
	BYTE *buff,     /* Data buffer to store read data */
	DWORD sector,   /* Sector address in LBA */
	UINT count      /* Number of sectors to read */
)
{
  /* USER CODE BEGIN READ */
  DRESULT status = RES_PARERR;
	switch (pdrv) {
		case SPI_FLASH:
      /* 扇区偏移6MB，外部Flash文件系统空间放在SPI Flash后面10MB空间 */
      sector+=1536;      
      SPI_FLASH_BufferRead(buff, sector <<12, count<<12);
      status = RES_OK;
		break;
    
		default:
			status = RES_PARERR;
	}
	return status;
  /* USER CODE END READ */
}

/**
  * @brief  Writes Sector(s)  
  * @param  pdrv: Physical drive number (0..)
  * @param  *buff: Data to be written
  * @param  sector: Sector address (LBA)
  * @param  count: Number of sectors to write (1..128)
  * @retval DRESULT: Operation result
  */
#if _USE_WRITE == 1
DRESULT USER_write (
	BYTE pdrv,          /* Physical drive nmuber to identify the drive */
	const BYTE *buff,   /* Data to be written */
	DWORD sector,       /* Sector address in LBA */
	UINT count          /* Number of sectors to write */
)
{ 
  /* USER CODE BEGIN WRITE */
  /* USER CODE HERE */
  uint32_t write_addr; 
	DRESULT status = RES_PARERR;
	if (!count) {
		return RES_PARERR;		/* Check parameter */
	}

	switch (pdrv) {
		case SPI_FLASH:
      /* 扇区偏移6MB，外部Flash文件系统空间放在SPI Flash后面10MB空间 */
			sector+=1536;
      write_addr = sector<<12;    
      SPI_FLASH_SectorErase(write_addr);
      SPI_FLASH_BufferWrite((uint8_t *)buff,write_addr,count<<12);
      status = RES_OK;
		break;
    
		default:
			status = RES_PARERR;
	}
	return status;
  /* USER CODE END WRITE */
}
#endif /* _USE_WRITE == 1 */

/**
  * @brief  I/O control operation  
  * @param  pdrv: Physical drive number (0..)
  * @param  cmd: Control code
  * @param  *buff: Buffer to send/receive control data
  * @retval DRESULT: Operation result
  */
#if _USE_IOCTL == 1
DRESULT USER_ioctl (
	BYTE pdrv,      /* Physical drive nmuber (0..) */
	BYTE cmd,       /* Control code */
	void *buff      /* Buffer to send/receive control data */
)
{
  /* USER CODE BEGIN IOCTL */
  DRESULT status = RES_PARERR;
	switch (pdrv) {
		case SPI_FLASH:
			switch (cmd) {
        /* 扇区数量：2560*4096/1024/1024=10(MB) */
        case GET_SECTOR_COUNT:
          *(DWORD * )buff = 2560;		
        break;
        /* 扇区大小  */
        case GET_SECTOR_SIZE :
          *(WORD * )buff = 4096;
        break;
        /* 同时擦除扇区个数 */
        case GET_BLOCK_SIZE :
          *(DWORD * )buff = 1;
        break;        
      }
      status = RES_OK;
		break;
    
		default:
			status = RES_PARERR;
	}
	return status;
  /* USER CODE END IOCTL */
}
#endif /* _USE_IOCTL == 1 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238

读这个代码可以发现，我们需要根据实际使用的硬件来填写这几个函数。

USER_initialize,
USER_status,
USER_read, 
USER_write,
USER_ioctl,
1
2
3
4
5

比如写操作，我们需要写入SPI_FLASH的实际操作过程，这也就是驱动。SPI对FLASH的操作一般由驱动工程师或者硬件厂家完成。

DRESULT USER_write (
	BYTE pdrv,          /* Physical drive nmuber to identify the drive */
	const BYTE *buff,   /* Data to be written */
	DWORD sector,       /* Sector address in LBA */
	UINT count          /* Number of sectors to write */
)
{ 
  /* USER CODE BEGIN WRITE */
  /* USER CODE HERE */
  uint32_t write_addr; 
	DRESULT status = RES_PARERR;
	if (!count) {
		return RES_PARERR;		/* Check parameter */
	}

	switch (pdrv) {
		case SPI_FLASH:
      /* 扇区偏移6MB，外部Flash文件系统空间放在SPI Flash后面10MB空间 */
			sector+=1536;
      write_addr = sector<<12;    
      SPI_FLASH_SectorErase(write_addr);
      SPI_FLASH_BufferWrite((uint8_t *)buff,write_addr,count<<12);
      status = RES_OK;
		break;
    
		default:
			status = RES_PARERR;
	}
	return status;
  /* USER CODE END WRITE */
}
#endif /* _USE_WRITE == 1 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

SPI_FLASH的驱动，我直接用的野火的FLASH板级支持包bsp_spi_flash.c，这里吗有FLASH的驱动实现，以及SPI_FLASH_BufferWrite()等函数的实现，到这里我们以及移植好了，可以进行代码编写了。

案例演示

实际使用主要参考http://elm-chan.org/fsw/ff/00index_e.html。全部API都有相应的解释。
在这里插入图片描述
自己的代码写在fatfs.c文件里，在这里贴出一个我用的测试案例。

/**
  ******************************************************************************
  * @file   fatfs.c
  * @brief  Code for fatfs applications
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2022 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under Ultimate Liberty license
  * SLA0044, the "License"; You may not use this file except in compliance with
  * the License. You may obtain a copy of the License at:
  *                             www.st.com/SLA0044
  *
  ******************************************************************************
  */

#include "fatfs.h"

uint8_t retUSER;    /* Return value for USER */
char USERPath[4];   /* USER logical drive path */
FATFS USERFatFS;    /* File system object for USER logical drive */
FIL USERFile;       /* File object for USER */

/* USER CODE BEGIN Variables */
BYTE work[_MAX_SS];
UINT fnum;
BYTE WriteBuffer[] = "hello world  你好!!"; 
/* USER CODE END Variables */    

void MX_FATFS_Init(void) 
{
  /*## FatFS: Link the USER driver ###########################*/
  retUSER = FATFS_LinkDriver(&USER_Driver, USERPath);

  /* USER CODE BEGIN Init */
  retUSER = f_mount(&USERFatFS,"",1);
	

	if(retUSER == FR_NO_FILESYSTEM)
	{
		printf("FLASH is not formatted\r\n");
   
		retUSER=f_mkfs("", FM_ANY, 0, work, sizeof work);							
		
		if(retUSER == FR_OK)
		{
			printf("The FLASH formats the file system successfully\r\n");
   
			retUSER = f_mount(NULL,"",1);			
 			
			retUSER = f_mount(&USERFatFS,"",1);
		}
		else
		{
			printf("Formatting failure\r\n");
			while(1);
		}
	}
  else if(retUSER!=FR_OK)
  {
    printf("The external Flash failed to mount the file system. Procedure (%d)\r\n",retUSER);
    printf("Possible cause: The SPI Flash initialization fails\r\n");
		while(1);
  }
  else
  {
    printf("The file system is mounted successfully, and you can perform read/write tests\r\n");
  }
/*----------------------- 文件系统测试：写测试 -----------------------------*/
	/* 打开文件，如果文件不存在则创建它 */
	printf("\r\n****** 即将进行文件写入测试... ******\r\n");
	retUSER = f_open(&USERFile, "0:FatUSERFatFS读写测试文件.txt",FA_CREATE_ALWAYS | FA_WRITE );
	if (retUSER == FR_OK)
	{
		printf("》打开/创建FatUSERFatFS读写测试文件.txt文件成功，向文件写入数据。\r\n");
    /* 将指定存储区内容写入到文件内 */
		retUSER=f_write(&USERFile,WriteBuffer,sizeof(WriteBuffer),&fnum);
    if(retUSER==FR_OK)
    {
      printf("》文件写入成功，写入字节数据：%d\n",fnum);
      printf("》向文件写入的数据为：\r\n%s\r\n",WriteBuffer);
    }
    else
    {
      printf("！！文件写入失败：(%d)\n",retUSER);
    }
		/* 不再读写，关闭文件 */
    f_close(&USERFile);
	}
	else
	{
		printf("！！打开/创建文件失败。\r\n");
	}

  printf("****** 即将进行文件读取测试... ******\r\n");
	retUSER = f_open(&USERFile, "FatUSERFatFS读写测试文件.txt", FA_OPEN_EXISTING | FA_READ);
	if(retUSER == FR_OK)
	{
		printf("》打开文件成功。\r\n");
		retUSER = f_read(&USERFile, work, sizeof(work), &fnum);
    if(retUSER==FR_OK)
    {
      printf("》文件读取成功,读到字节数据：%d\r\n",fnum);
      printf("》读取得的文件数据为：\r\n%s \r\n", work);
    }
    else
    {
      printf("！！文件读取失败：(%d)\n",retUSER);
    }
	}
	else
	{
		printf("！！打开文件失败。\r\n");
	}
	/* 不再读写，关闭文件 */
	f_close(&USERFile);
  /* additional user code for init */     
  /* USER CODE END Init */
}

/**
  * @brief  Gets Time from RTC 
  * @param  None
  * @retval Time in DWORD
  */
DWORD get_fattime(void)
{
  /* USER CODE BEGIN get_fattime */
  return 0;
  /* USER CODE END get_fattime */  
}

/* USER CODE BEGIN Application */
     
/* USER CODE END Application */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

案例其实没有什么讲的，移植FatFs后的文件，操作就与win下的一样了，都是f_open打开，f_write写一类的操作，不同的地方就是使用前需要挂载一下。实验结果如下所示：
在这里插入图片描述
到此FatFs移植成功，并能正常使用。

代码解析

代码野火课程P63讲的比较详细，在这里我简要叙述一下。

Diskio_drvTypeDef  USER_Driver =
{
  USER_initialize,
  USER_status,
  USER_read, 
#if  _USE_WRITE
  USER_write,
#endif  /* _USE_WRITE == 1 */  
#if  _USE_IOCTL == 1
  USER_ioctl,
#endif /* _USE_IOCTL == 1 */
};
1
2
3
4
5
6
7
8
9
10
11
12

这几个函数，也就是我们需要写的实现函数，在这个结构体中被赋值给了函数指针（也可以认为是回调函数），声明是这个样子的。

typedef struct
{
  DSTATUS (*disk_initialize) (BYTE);                     /*!< Initialize Disk Drive                     */
  DSTATUS (*disk_status)     (BYTE);                     /*!< Get Disk Status                           */
  DRESULT (*disk_read)       (BYTE, BYTE*, DWORD, UINT);       /*!< Read Sector(s)                            */
#if _USE_WRITE == 1
  DRESULT (*disk_write)      (BYTE, const BYTE*, DWORD, UINT); /*!< Write Sector(s) when _USE_WRITE = 0       */
#endif /* _USE_WRITE == 1 */
#if _USE_IOCTL == 1
  DRESULT (*disk_ioctl)      (BYTE, BYTE, void*);              /*!< I/O control operation when _USE_IOCTL = 1 */
#endif /* _USE_IOCTL == 1 */

}Diskio_drvTypeDef;
1
2
3
4
5
6
7
8
9
10
11
12
13

定义好后，通过这个函数，将驱动进行链接。

retUSER = FATFS_LinkDriver(&USER_Driver, USERPath);
1

结构体指针在这个函数中被赋值

uint8_t FATFS_LinkDriverEx(const Diskio_drvTypeDef *drv, char *path, uint8_t lun)
{
  uint8_t ret = 1;
  uint8_t DiskNum = 0;

  if(disk.nbr < _VOLUMES)
  {
    disk.is_initialized[disk.nbr] = 0;
    disk.drv[disk.nbr] = drv;  //这个就是自己的驱动函数
    disk.lun[disk.nbr] = lun;
    DiskNum = disk.nbr++;
    path[0] = DiskNum + '0';
    path[1] = ':';
    path[2] = '/';
    path[3] = 0;
    ret = 0;
  }

  return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

到这里已经链接上了。

DRESULT disk_read (
	BYTE pdrv,		/* Physical drive nmuber to identify the drive */
	BYTE *buff,		/* Data buffer to store read data */
	DWORD sector,	        /* Sector address in LBA */
	UINT count		/* Number of sectors to read */
)
{
  DRESULT res;

  res = disk.drv[pdrv]->disk_read(disk.lun[pdrv], buff, sector, count);
  return res;
}
1
2
3
4
5
6
7
8
9
10
11
12

这里看一个上层的读函数，f_read调用了disk_read函数，自己写的驱动函数，也就是控制SPI_FLASH的读操作已经赋值给了disk.drv。这样一切就耦合起来了。

总结

这次遇到的问题是开始不知道驱动怎么写，因为自己主要做的是网络通信方面，虽然知道驱动，但是一直不知道如何将软件以及硬件耦合起来，经过这次的项目，终于知道软件层以及硬件层是如何耦合到一起的，也将之前学的IIC,SPI等应用了起来。
下一步我继续网络方面，使用FTP远程连接，向文件系统中写入文件。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/464055?site