stm32 CubeMx 实现SD卡/sd nand FATFS读写测试

文章目录

stm32 CubeMx 实现SD卡/SD nand FATFS读写测试

1. 前言

2. 环境介绍

2.1 软硬件说明

2.2 外设原理图

3. 工程搭建

3.1 CubeMx 配置

3.2 SDIO时钟配置说明

3.2 读写测试

3.2.1 添加读写测试代码

3.3 FATFS文件操作

3.3.1 修改读写测试代码

3.4 配置问题记录

3.4.1 CubeMx生成代码bug

3.4.2 SD插入检测引脚配置

4. 结束语

1. 前言

SD卡/SD nand是嵌入式开发中常为使用的大容量存储设备，SD nand虽然当前价格比SD卡高，但胜在价格、封装以及稳定性上有优势，实际操作和SD卡没什么区别。

关于 SD卡/SDnand 的驱动，有了CubeMx之后其实基本上都自动生成了对应的驱动了，基本上把驱动配置一下之后，自己写一些应用就可以完成基本的读写了，同时关于FATFS文件系统，也可以直接采用CubeMx配置，也不用自己移植，因此使用STM32开发这些还是比较爽的！不过使用过程中也有一些坑，自动生成的驱动有时候也还是有一些bug，因此还是需要大家对对应驱动有一定的了解。

本文将主要分享关于使用 CubeMx 配置 stm32 的工程，通过SDIO总线完成 SD卡/SD nand 的读写，并配置FATFS，采用文件操作实现对 SD卡/SD nand 的读写操作；此外还将分享博主在调试过程中遇到的一些问题，比如CubeMx自动生成的驱动存在的bug等，以及分享关于驱动部分的代码分析！

2. 环境介绍

2.1 软硬件说明

硬件环境：

主控：stm32f103vet6

SD nand： CSNPGCR01-AOW

软件环境：

CubeMx版本：Version 6.6.1

注意：当前最新版本 V6.8.0，生成的工程配置存在bug，具体细节在后文描述

2.2 外设原理图

SD卡槽原理图部分如下：

3. 工程搭建

3.1 CubeMx 配置

1. 1.选择芯片，ACCESS TO MCU SELECTOR 

2. 

3. 2.搜索对应的芯片型号，在对应列表下方选择对应芯片

4. 

5. 3.配置时钟方案，采用外部高速时钟，无源晶振方案

6. 

7. 4.配置调试器，由于我采用SWD调试接口，因此选择 Serial Wrie 串行总线

8. 

9. 5.配置SDIO外设，由于我们所使用的SD nand支持4线传输，因此此处选择4线宽度；如果你所使用的SD nand或SD卡不支持4线传输，此处应选择1线宽度；支持4线宽度的SD卡肯定可以使用1线宽度，因此如果你实在不知道你的SD卡支持几线宽度，你可以直接选择1线宽度！4线和1线宽度的差别也就在于速度上相差了4倍！

10. (注意这里暂时不需要对SDIO的参数进行配置，后面我们再回来配置！)

11. 

12. 6.完成时钟树配置：

• 配置外部晶振频率

• 调整时钟选择，SYSCLK由PLL产生，PLL由外部时钟倍频产生

• 配置SDIO外设时钟，注意此处SDIO外设比较特殊，有两个时钟！具体原因见后文！

1. 7.

修改SDIO参数配置，主要是修改SDIOCLK的分频

• 由于我们上述配置的SDIO时钟为 72M，而SD卡支持的通讯速率在0MHz至25MHz之间，因此我们需要分频，配置 SDIO Clock divider bypass 为 Disable

• 此处设置 SDIOCLK clock divide factor CLKDIV分频系数为 8，这个受限于具体的SD卡支持的最大速度。如果设置值较小，可能由于SDIO_CK速度过高，SD卡/SDnand不支持，导致通讯失败，因此建议先将此值设大点（或查看SD卡/SDnand手册，或先设一个较大值，软件完成SD信息读取后再配置）

• 注意这个配置的时钟是用于SD读写通讯时候的时钟，而不是SD卡信息识别过程时的速度！

  

8.勾选 FATFS 配置，选择 SD Card

9.配置SD卡检测引脚，有以下两种方案

• 方案一：选择一个输入IO，作为触发引脚

• 方案二：不配置输入IO，最后生成代码的时候无视警报即可，生成的代码会自动取消输入检测判断

10.配置调试串口，用来打印信息，此处我选择USART1，大家可根据自己硬件环境自行选择

11.配置工程信息

• 配置工程名

• 选择工程路径

• 配置应用程序结构，我习惯选择 Basic 结构

• 选择IDE工具及版本

• 修改堆栈大小，适当改大一点，怕不够用
  

12.勾选将外设初始化放置在独立的.c和.h文件，这样每个外设的初始化是独立的，方便阅读移植！

13.生成代码

3.2 SDIO时钟配置说明

在上述CubeMx时钟配置中，外设的时钟一般都是只有一路过去，但是在此处我们会发现SDIO的时钟在时钟树中有两个！没弄清楚还会以为这是CubeMx出现bug了！

其实这是SDIO外设的特殊点，我们查看数据手册上的时钟树，便可以发现，实际上是真的有两路时钟，分别是：1）SDIOCLK；2）至SDIO的AHB接口；

之后，我们看到数据手册的SDIO章节，我们可以看到SDIO外设分为：1）AHB总线接口 和 2）SDIO适配器两大块，且使用不同的时钟，这也就是我们在时钟树配置中可以看到有两路时钟配置的原因了！

从下图我们可以知道，SDIO外设不同于其他外设，其外设模块部分与中断、DMA是分开的，并采用不同的时钟！

关于AHB总线接口及SDIO适配器更多细节，大家可自行阅读参考手册部分章节内容，此处不做赘述。

此外，关于时钟配置有一个特别需要注意的，也就是SDIO_CK时钟信号。SDIO_CK时钟，也就是我们SDIO外设与SD卡/SD nand通讯的CLK时钟，从上图我们可知，SDIO_CK时钟来自SDIO适配器，也就是来自SDIOCLK，对应CubeMX时钟配置中的：

3.2 读写测试

3.2.1 添加读写测试代码

1. 1.使能 MicroLIB 微库，否则调用 printf 函数会卡住

2.修改编码规则为 UTF-8，这是由于我们CubeMx中配置的FATFS的编码格式为 UTF-8导致，如果不修改为 UTF-8 则部分中文会乱码！ //TODO:确认是由FATFS配置导致

3.添加 printf 重映射 （位置可根据自行决定）

1. #include <stdio.h>

2. int fputc(int ch, FILE *f)

3. {

4. HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1,0xffff);

5. return (ch);

6. }

4.添加 sdcard 信息打印函数，查看卡片信息

1. HAL_SD_CardInfoTypeDef  SDCardInfo;    

2. void printf_sdcard_info(void)

3. {

4. uint64_t CardCap;                       //SD卡容量

5. HAL_SD_CardCIDTypeDef SDCard_CID; 

6. 
   

7. HAL_SD_GetCardCID(&hsd,&SDCard_CID); //获取CID

8. HAL_SD_GetCardInfo(&hsd,&SDCardInfo);   //获取SD卡信息

9. CardCap=(uint64_t)(SDCardInfo.LogBlockNbr)*(uint64_t)(SDCardInfo.LogBlockSize); //计算SD卡容量

10. switch(SDCardInfo.CardType)

11. {

12. case CARD_SDSC:

13. {

14. if(SDCardInfo.CardVersion == CARD_V1_X)

15. printf("Card Type:SDSC V1\r\n");

16. else if(SDCardInfo.CardVersion == CARD_V2_X)

17. printf("Card Type:SDSC V2\r\n");

18. }

19. break;

20. case CARD_SDHC_SDXC:printf("Card Type:SDHC\r\n");break;

21. default:break;

22. }

24.     printf("Card ManufacturerID: %d \r\n",SDCard_CID.ManufacturerID); //制造商ID

25.   printf("CardVersion:         %d \r\n",(uint32_t)(SDCardInfo.CardVersion)); //卡版本号

26. printf("Class:               %d \r\n",(uint32_t)(SDCardInfo.Class));     //SD卡类别

27.   printf("Card RCA(RelCardAdd):%d \r\n",SDCardInfo.RelCardAdd); //卡相对地址

28. printf("Card BlockNbr:       %d \r\n",SDCardInfo.BlockNbr); //块数量

29.   printf("Card BlockSize:      %d \r\n",SDCardInfo.BlockSize); //块大小

30. printf("LogBlockNbr:         %d \r\n",(uint32_t)(SDCardInfo.LogBlockNbr)); //逻辑块数量

31. printf("LogBlockSize:        %d \r\n",(uint32_t)(SDCardInfo.LogBlockSize)); //逻辑块大小

32. printf("Card Capacity:       %d MB\r\n",(uint32_t)(CardCap>>20)); //卡容量

33. }

5.添加初始化及读写测试代码，注意此处我们没有直接使用FATFS的读写接口，我们先测试生成的SD驱动函数接口

1. int main(void)

2. {

3.   /* USER CODE BEGIN 1 */

4.   BYTE send_buf[512];

5.   DRESULT ret;

6.   /* USER CODE END 1 */

7. 
   

8.   /* ...省略若干自动生成代码... */

9.   

10.   /* USER CODE BEGIN 2 */

11. 
    

12.   SD_Driver.disk_initialize(0);

13.   printf_sdcard_info();

14. 
    

15.   printf("\r\n\r\n********** 英文读写测试 **********\r\n");

16. 
    

17.   ret = SD_Driver.disk_write(0,

18. (BYTE *)"Life is too short to spend time with people who suck the happiness out of you. \

19. If someone wants you in their life, they’ll make room for you. You shouldn’t have to fight for a spot. Never, ever\

20.  insist yourself to someone who continuously overlooks your worth. And remember, it’s not the people that stand by \

21. your side when you’re at your best, but the ones who stand beside you when you’re at your worst that are your true\

22.  friends",20,2);

23.   printf("sd write result:%d\r\n", ret);

24.   ret = SD_Driver.disk_read(0, send_buf, 20, 2);

25.   printf("sd reak result:%d\r\n", ret);

26.   printf("sd read content:\r\n%s\r\n", send_buf);

27.   

28.   printf("\r\n\r\n********** 中文读写测试 **********\r\n");

29. 
    

30.   ret = SD_Driver.disk_write(0,

31. (BYTE *)"开发者社区的明天需要大家一同开源共创，期待下一次你的分享，让我们一同携手共进，推动人类科技的发展！！！\r\n\

32. 创作不易，转载请注明出处~\r\n\

33. 更多文章敬请关注：爱出名的狗腿子\r\n", 22, 2);

34.   printf("sd write result:%d\r\n", ret);

35.   ret = SD_Driver.disk_read(0, send_buf, 22, 2);

36.   printf("sd reak result:%d\r\n", ret);

37.   printf("sd read content:\r\n%s\r\n", send_buf);

38.   /* USER CODE END 2 */

39.   while (1)

40.   {

41.     /* USER CODE END WHILE */

42. 
    

43.     /* USER CODE BEGIN 3 */

44.   }

45.   /* USER CODE END 3 */

46. }

6.修改烧录器配置，配置为烧录后自动运行

7.下载测试，这里由于我们采用UTF-8编码，所以使用的串口上位机也需要支持UTF-8解析，我们这里使用Mobaxterm上位机，测试结果如下:

8.main.c 文件全部代码如下，供大家参考：

1. /* USER CODE BEGIN Header */

2. /**

3.   ******************************************************************************

4.   * @file           : main.c

5.   * @brief          : Main program body

6.   ******************************************************************************

7.   * @attention

8.   *

9.   * Copyright (c) 2023 STMicroelectronics.

10.   * All rights reserved.

11.   *

12.   * This software is licensed under terms that can be found in the LICENSE file

13.   * in the root directory of this software component.

14.   * If no LICENSE file comes with this software, it is provided AS-IS.

15.   *

16.   ******************************************************************************

17.   */

18. /* USER CODE END Header */

19. /* Includes ------------------------------------------------------------------*/

20. #include "main.h"

21. #include "fatfs.h"

22. #include "sdio.h"

23. #include "usart.h"

24. #include "gpio.h"

25. 
    

26. /* Private includes ----------------------------------------------------------*/

27. /* USER CODE BEGIN Includes */

28. 
    

29. #include <stdio.h>

30. /* USER CODE END Includes */

31. 
    

32. /* Private typedef -----------------------------------------------------------*/

33. /* USER CODE BEGIN PTD */

34. 
    

35. /* USER CODE END PTD */

36. 
    

37. /* Private define ------------------------------------------------------------*/

38. /* USER CODE BEGIN PD */

39. /* USER CODE END PD */

40. 
    

41. /* Private macro -------------------------------------------------------------*/

42. /* USER CODE BEGIN PM */

43. 
    

44. /* USER CODE END PM */

45. 
    

46. /* Private variables ---------------------------------------------------------*/

47. 
    

48. /* USER CODE BEGIN PV */

49. 
    

50. /* USER CODE END PV */

51. 
    

52. /* Private function prototypes -----------------------------------------------*/

53. void SystemClock_Config(void);

54. /* USER CODE BEGIN PFP */

55. 
    

56. /* USER CODE END PFP */

57. 
    

58. /* Private user code ---------------------------------------------------------*/

59. /* USER CODE BEGIN 0 */

60. 
    

61. HAL_SD_CardInfoTypeDef  SDCardInfo;    

62. void printf_sdcard_info(void)

63. {

64. uint64_t CardCap;                       //SD卡容量

65. HAL_SD_CardCIDTypeDef SDCard_CID; 

66. 
    

67. HAL_SD_GetCardCID(&hsd,&SDCard_CID); //获取CID

68. HAL_SD_GetCardInfo(&hsd,&SDCardInfo);   //获取SD卡信息

69. CardCap=(uint64_t)(SDCardInfo.LogBlockNbr)*(uint64_t)(SDCardInfo.LogBlockSize); //计算SD卡容量

70. switch(SDCardInfo.CardType)

71. {

72. case CARD_SDSC:

73. {

74. if(SDCardInfo.CardVersion == CARD_V1_X)

75. printf("Card Type:SDSC V1\r\n");

76. else if(SDCardInfo.CardVersion == CARD_V2_X)

77. printf("Card Type:SDSC V2\r\n");

78. }

79. break;

80. case CARD_SDHC_SDXC:printf("Card Type:SDHC\r\n");break;

81. default:break;

82. }

84.     printf("Card ManufacturerID: %d \r\n",SDCard_CID.ManufacturerID); //制造商ID

85.   printf("CardVersion:         %d \r\n",(uint32_t)(SDCardInfo.CardVersion)); //卡版本号

86. printf("Class:               %d \r\n",(uint32_t)(SDCardInfo.Class));     //SD卡类别

87.   printf("Card RCA(RelCardAdd):%d \r\n",SDCardInfo.RelCardAdd); //卡相对地址

88. printf("Card BlockNbr:       %d \r\n",SDCardInfo.BlockNbr); //块数量

89.   printf("Card BlockSize:      %d \r\n",SDCardInfo.BlockSize); //块大小

90. printf("LogBlockNbr:         %d \r\n",(uint32_t)(SDCardInfo.LogBlockNbr)); //逻辑块数量

91. printf("LogBlockSize:        %d \r\n",(uint32_t)(SDCardInfo.LogBlockSize)); //逻辑块大小

92. printf("Card Capacity:       %d MB\r\n",(uint32_t)(CardCap>>20)); //卡容量

93. }

94. 
    

95. int fputc(int ch, FILE *f)

96. {

97. HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1,0xffff);

98. return (ch);

99. }

100. /* USER CODE END 0 */

101. 
     

102. /**

103.   * @brief  The application entry point.

104.   * @retval int

105.   */

106. int main(void)

107. {

108.   /* USER CODE BEGIN 1 */

109.   BYTE send_buf[512];

110.   DRESULT ret;

111.   /* USER CODE END 1 */

112. 
     

113.   /* MCU Configuration--------------------------------------------------------*/

114. 
     

115.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */

116.   HAL_Init();

117. 
     

118.   /* USER CODE BEGIN Init */

119. 
     

120.   /* USER CODE END Init */

121. 
     

122.   /* Configure the system clock */

123.   SystemClock_Config();

124. 
     

125.   /* USER CODE BEGIN SysInit */

126. 
     

127.   /* USER CODE END SysInit */

128. 
     

129.   /* Initialize all configured peripherals */

130.   MX_GPIO_Init();

131.   MX_SDIO_SD_Init();

132.   MX_USART1_UART_Init();

133.   MX_FATFS_Init();

134.   /* USER CODE BEGIN 2 */

135.   

136.   SD_Driver.disk_initialize(0);

137.   printf_sdcard_info();

138. 
     

139.   printf("\r\n\r\n********** 英文读写测试 **********\r\n");

140. 
     

141.   ret = SD_Driver.disk_write(0,

142. (BYTE *)"Life is too short to spend time with people who suck the happiness out of you. \

143. If someone wants you in their life, they’ll make room for you. You shouldn’t have to fight for a spot. Never, ever\

144.  insist yourself to someone who continuously overlooks your worth. And remember, it’s not the people that stand by \

145. your side when you’re at your best, but the ones who stand beside you when you’re at your worst that are your true\

146.  friends",20,2);

147.   printf("sd write result:%d\r\n", ret);

148.   ret = SD_Driver.disk_read(0, send_buf, 20, 2);

149.   printf("sd reak result:%d\r\n", ret);

150.   printf("sd read content:\r\n%s\r\n", send_buf);

151.   

152.   printf("\r\n\r\n********** 中文读写测试 **********\r\n");

153. 
     

154.   ret = SD_Driver.disk_write(0,

155. (BYTE *)"开发者社区的明天需要大家一同开源共创，期待下一次你的分享，让我们一同携手共进，推动人类科技的发展！！！\r\n\

156. 创作不易，转载请注明出处~\r\n\

157. 更多文章敬请关注：爱出名的狗腿子\r\n", 22, 2);

158.   printf("sd write result:%d\r\n", ret);

159.   ret = SD_Driver.disk_read(0, send_buf, 22, 2);

160.   printf("sd reak result:%d\r\n", ret);

161.   printf("sd read content:\r\n%s\r\n", send_buf);

162.   

163.   /* USER CODE END 2 */

164. 
     

165.   /* Infinite loop */

166.   /* USER CODE BEGIN WHILE */

167.   while (1)

168.   {

169.     /* USER CODE END WHILE */

170. 
     

171.     /* USER CODE BEGIN 3 */

172.   }

173.   /* USER CODE END 3 */

174. }

175. 
     

176. /**

177.   * @brief System Clock Configuration

178.   * @retval None

179.   */

180. void SystemClock_Config(void)

181. {

182.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};

183.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

184. 
     

185.   /** Initializes the RCC Oscillators according to the specified parameters

186.   * in the RCC_OscInitTypeDef structure.

187.   */

188.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;

189.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;

190.   RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;

191.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;

192.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;

193.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;

194.   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;

195.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)

196.   {

197.     Error_Handler();

198.   }

199. 
     

200.   /** Initializes the CPU, AHB and APB buses clocks

201.   */

202.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK

203.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;

204.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

205.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

206.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;

207.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

208. 
     

209.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)

210.   {

211.     Error_Handler();

212.   }

213. }

214. 
     

215. /* USER CODE BEGIN 4 */

216. 
     

217. /* USER CODE END 4 */

218. 
     

219. /**

220.   * @brief  This function is executed in case of error occurrence.

221.   * @retval None

222.   */

223. void Error_Handler(void)

224. {

225.   /* USER CODE BEGIN Error_Handler_Debug */

226.   /* User can add his own implementation to report the HAL error return state */

227.   __disable_irq();

228.   while (1)

229.   {

230.   }

231.   /* USER CODE END Error_Handler_Debug */

232. }

233. 
     

234. #ifdef  USE_FULL_ASSERT

235. /**

236.   * @brief  Reports the name of the source file and the source line number

237.   *         where the assert_param error has occurred.

238.   * @param  file: pointer to the source file name

239.   * @param  line: assert_param error line source number

240.   * @retval None

241.   */

242. void assert_failed(uint8_t *file, uint32_t line)

243. {

244.   /* USER CODE BEGIN 6 */

245.   /* User can add his own implementation to report the file name and line number,

246.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

247.   /* USER CODE END 6 */

248. }

249. #endif /* USE_FULL_ASSERT */

3.3 FATFS文件操作

移植了FATFS，当然也就可以只用通用的文件系统操作函数完成文件的读写，通用的文件系统操作API 在 ff.c 文件内，声明在 ff.h 文件内，主要使用的API接口如下：

1. FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode); /* Open or create a file */

2. FRESULT f_close (FIL* fp); /* Close an open file object */

3. FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br); /* Read data from a file */

4. FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw); /* Write data to a file */

5. FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf); /* Forward data to the stream */

6. FRESULT f_lseek (FIL* fp, DWORD ofs); /* Move file pointer of a file object */

7. FRESULT f_truncate (FIL* fp); /* Truncate file */

8. FRESULT f_sync (FIL* fp); /* Flush cached data of a writing file */

9. FRESULT f_opendir (DIR* dp, const TCHAR* path); /* Open a directory */

10. FRESULT f_closedir (DIR* dp); /* Close an open directory */

11. FRESULT f_readdir (DIR* dp, FILINFO* fno); /* Read a directory item */

12. FRESULT f_findfirst (DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern); /* Find first file */

13. FRESULT f_findnext (DIR* dp, FILINFO* fno); /* Find next file */

14. FRESULT f_mkdir (const TCHAR* path); /* Create a sub directory */

15. FRESULT f_unlink (const TCHAR* path); /* Delete an existing file or directory */

16. FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new); /* Rename/Move a file or directory */

17. FRESULT f_stat (const TCHAR* path, FILINFO* fno); /* Get file status */

18. FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask); /* Change attribute of the file/dir */

19. FRESULT f_utime (const TCHAR* path, const FILINFO* fno); /* Change times-tamp of the file/dir */

20. FRESULT f_chdir (const TCHAR* path); /* Change current directory */

21. FRESULT f_chdrive (const TCHAR* path); /* Change current drive */

22. FRESULT f_getcwd (TCHAR* buff, UINT len); /* Get current directory */

23. FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs); /* Get number of free clusters on the drive */

24. FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* vsn); /* Get volume label */

25. FRESULT f_setlabel (const TCHAR* label); /* Set volume label */

26. FRESULT f_mount (FATFS* fs, const TCHAR* path, BYTE opt); /* Mount/Unmount a logical drive */

27. FRESULT f_mkfs (const TCHAR* path, BYTE sfd, UINT au); /* Create a file system on the volume */

28. FRESULT f_fdisk (BYTE pdrv, const DWORD szt[], void* work); /* Divide a physical drive into some partitions */

29. int f_putc (TCHAR c, FIL* fp); /* Put a character to the file */

30. int f_puts (const TCHAR* str, FIL* cp); /* Put a string to the file */

31. int f_printf (FIL* fp, const TCHAR* str, ...); /* Put a formatted string to the file */

32. TCHAR* f_gets (TCHAR* buff, int len, FIL* fp); /* Get a string from the file */

关于API的使用此处不做过多赘述，大家可以自行上官网查阅 FATFS官网，或者网上搜索，或直接看下述示例亦可。

3.3.1 修改读写测试代码

修改3.2.1章节所使用的读写测试代码，此处我们直接使用FATFS文件系统的读写函数接口，修改主函数如下，注意需要包含fatfs.h头文件！

1. #include "fatfs.h"

2. int main()

3. {

4.   /* USER CODE BEGIN 1 */

5. #define USERPath "0:/"

6.   

7.   BYTE write_buf[] = "\r\n\r\n\

8. hello world!\r\n\

9. 开发者社区的明天需要大家一同开源共创，期待下一次你的分享，让我们一同携手共进，推动人类科技的发展！！！\r\n\

10. 创作不易，转载请注明出处~\r\n\

11. 更多文章敬请关注：爱出名的狗腿子\r\n\r\n\

12. ";

13.   BYTE read_buf[1024] = {0};

14.   UINT num;

15.   FRESULT ret;

16.   /* USER CODE END 1 */

17.   

18.   /* ... 省略初始化代码... */

19.   

20.   /* USER CODE BEGIN 2 */

21.   

22.   /* 挂载文件系统，挂载的时候会完成对应硬件设备（SD卡/SDnand）初始化 */

23.   ret = f_mount(&SDFatFS, USERPath, 1);

24.   if (ret != FR_OK) {

25.     printf("f_mount error!\r\n");

26.     goto mount_error;

27.   } else if(ret == FR_NO_FILESYSTEM) {         /* 检测是否存在文件系统，如果没有则进行格式化 */

28.     printf("未检测到FATFS文件系统，执行格式化...\r\n");

29.     ret = f_mkfs(USERPath, 0, 0);

30.     if(ret == FR_OK) {

31.       printf("格式化成功！\r\n");

32.       f_mount(NULL, USERPath, 1); /* 先取消挂载，后重新挂载 */

33.       ret = f_mount(&SDFatFS, USERPath, 1);

34.     } else {

35.       printf("格式化失败！\r\n");

36.       goto mount_error;

37.     }

38.   } else {

39.     printf("f_mount success!\r\n");

40.   }

41.   

42.   /* 读写测试 */

43.   printf("\r\n ========== write test ==========\r\n");

44.   ret = f_open(&SDFile, "hello.txt", FA_CREATE_ALWAYS | FA_WRITE);

45.   if(ret == FR_OK) {

46.     printf("open file sucess!\r\n");

47.     ret = f_write(&SDFile, write_buf, sizeof(write_buf), &num);

48.     if(ret == FR_OK) {

49.       printf("write \"%s\" success!\r\nwrite len：%d\r\n", write_buf, num);

50.     } else {

51.       printf("write error! ret:%d \r\n", ret);

52.       goto rw_error;

53.     }

54.     f_close(&SDFile);

55.   } else {

56.     printf("open file error!\r\n");

57.     goto rw_error;

58.   }

60.   printf("\r\n ========== read test ==========\r\n");

61.   ret = f_open(&SDFile, "hello.txt",FA_OPEN_EXISTING | FA_READ);  

62.   if(ret == FR_OK) {

63.     printf("open file sucess!\r\n");

64. ret = f_read(&SDFile, read_buf, sizeof(read_buf), &num); 

65.     if(ret == FR_OK) {

66.       printf("read data:\"%s\"!\r\nread len：%d\r\n", read_buf, num);

67.     } else {

68.       printf("read error! ret:%d \r\n", ret);

69.       goto rw_error;

70.   }

71. } else {

72.    printf("open file error!\r\n");

73.    goto rw_error;

74. }

75. 
    

76. rw_error:

77.   f_close(&SDFile);

78.   

79. mount_error:

80.   f_mount(NULL, USERPath, 1);

81.   /* USER CODE END 2 */

82.   while (1) {

83.   

84.   }

85. }

#define USERPath "0:/" 表示挂载的位置，这是由于FATFS初始化的时候链接的根目录为 0:/ ，所以挂载的文件系统需要在此目录下，当然也可以是此目录下的路径，如0:/hello，但不能是其他目录，如 1:/

测试结果如下：

main.c完整内容如下：

1. /* USER CODE BEGIN Header */

2. /**

3.   ******************************************************************************

4.   * @file           : main.c

5.   * @brief          : Main program body

6.   ******************************************************************************

7.   * @attention

8.   *

9.   * Copyright (c) 2023 STMicroelectronics.

10.   * All rights reserved.

11.   *

12.   * This software is licensed under terms that can be found in the LICENSE file

13.   * in the root directory of this software component.

14.   * If no LICENSE file comes with this software, it is provided AS-IS.

15.   *

16.   ******************************************************************************

17.   */

18. /* USER CODE END Header */

19. /* Includes ------------------------------------------------------------------*/

20. #include "main.h"

21. #include "fatfs.h"

22. #include "sdio.h"

23. #include "usart.h"

24. #include "gpio.h"

25. 
    

26. /* Private includes ----------------------------------------------------------*/

27. /* USER CODE BEGIN Includes */

28. 
    

29. #include <stdio.h>

30. #include "fatfs.h"

31. /* USER CODE END Includes */

32. 
    

33. /* Private typedef -----------------------------------------------------------*/

34. /* USER CODE BEGIN PTD */

35. 
    

36. /* USER CODE END PTD */

37. 
    

38. /* Private define ------------------------------------------------------------*/

39. /* USER CODE BEGIN PD */

40. /* USER CODE END PD */

41. 
    

42. /* Private macro -------------------------------------------------------------*/

43. /* USER CODE BEGIN PM */

44. 
    

45. /* USER CODE END PM */

46. 
    

47. /* Private variables ---------------------------------------------------------*/

48. 
    

49. /* USER CODE BEGIN PV */

50. 
    

51. /* USER CODE END PV */

52. 
    

53. /* Private function prototypes -----------------------------------------------*/

54. void SystemClock_Config(void);

55. /* USER CODE BEGIN PFP */

56. 
    

57. /* USER CODE END PFP */

58. 
    

59. /* Private user code ---------------------------------------------------------*/

60. /* USER CODE BEGIN 0 */

61. 
    

62. HAL_SD_CardInfoTypeDef  SDCardInfo;    

63. void printf_sdcard_info(void)

64. {

65. uint64_t CardCap;                       //SD卡容釿

66. HAL_SD_CardCIDTypeDef SDCard_CID; 

67. 
    

68. HAL_SD_GetCardCID(&hsd,&SDCard_CID); //获取CID

69. HAL_SD_GetCardInfo(&hsd,&SDCardInfo);   //获取SD卡信恿

70. CardCap=(uint64_t)(SDCardInfo.LogBlockNbr)*(uint64_t)(SDCardInfo.LogBlockSize); //计算SD卡容釿

71. switch(SDCardInfo.CardType)

72. {

73. case CARD_SDSC:

74. {

75. if(SDCardInfo.CardVersion == CARD_V1_X)

76. printf("Card Type:SDSC V1\r\n");

77. else if(SDCardInfo.CardVersion == CARD_V2_X)

78. printf("Card Type:SDSC V2\r\n");

79. }

80. break;

81. case CARD_SDHC_SDXC:printf("Card Type:SDHC\r\n");break;

82. default:break;

83. }

85.     printf("Card ManufacturerID: %d \r\n",SDCard_CID.ManufacturerID); //制鿠商ID

86.   printf("CardVersion:         %d \r\n",(uint32_t)(SDCardInfo.CardVersion)); //卡版本号

87. printf("Class:               %d \r\n",(uint32_t)(SDCardInfo.Class));     //SD卡类刿

88.   printf("Card RCA(RelCardAdd):%d \r\n",SDCardInfo.RelCardAdd); //卡相对地坿

89. printf("Card BlockNbr:       %d \r\n",SDCardInfo.BlockNbr); //块数釿

90.   printf("Card BlockSize:      %d \r\n",SDCardInfo.BlockSize); //块大尿

91. printf("LogBlockNbr:         %d \r\n",(uint32_t)(SDCardInfo.LogBlockNbr)); //逻辑块数釿

92. printf("LogBlockSize:        %d \r\n",(uint32_t)(SDCardInfo.LogBlockSize)); //逻辑块大尿

93. printf("Card Capacity:       %d MB\r\n",(uint32_t)(CardCap>>20)); //卡容釿

94. }

95. 
    

96. int fputc(int ch, FILE *f)

97. {

98. HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1,0xffff);

99. return (ch);

100. }

101. 
     

102. /* USER CODE END 0 */

103. 
     

104. /**

105.   * @brief  The application entry point.

106.   * @retval int

107.   */

108. int main(void)

109. {

110.   /* USER CODE BEGIN 1 */

111. #define USERPath "0:/"

112.   

113.   BYTE write_buf[] = "\r\n\r\n\

114. hello world!\r\n\

115. 开发者社区的明天需要大家一同开源共创，期待下一次你的分享，让我们一同携手共进，推动人类科技的发展！！！\r\n\

116. 创作不易，转载请注明出处~\r\n\

117. 更多文章敬请关注：爱出名的狗腿子\r\n\r\n\

118. ";

119.   BYTE read_buf[1024] = {0};

120.   UINT num;

121.   FRESULT ret;

122.   /* USER CODE END 1 */

123. 
     

124.   /* MCU Configuration--------------------------------------------------------*/

125. 
     

126.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */

127.   HAL_Init();

128. 
     

129.   /* USER CODE BEGIN Init */

130. 
     

131.   /* USER CODE END Init */

132. 
     

133.   /* Configure the system clock */

134.   SystemClock_Config();

135. 
     

136.   /* USER CODE BEGIN SysInit */

137. 
     

138.   /* USER CODE END SysInit */

139. 
     

140.   /* Initialize all configured peripherals */

141.   MX_GPIO_Init();

142.   MX_SDIO_SD_Init();

143.   MX_USART1_UART_Init();

144.   MX_FATFS_Init();

145.   /* USER CODE BEGIN 2 */

146.   

147.   /* 挂载文件系统，挂载的时候会完成对应硬件设备（SD卡/SDnand）初始化 */

148.   ret = f_mount(&SDFatFS, USERPath, 1);

149.   if (ret != FR_OK) {

150.     printf("f_mount error!\r\n");

151.     goto mount_error;

152.   } else if(ret == FR_NO_FILESYSTEM) {         /* 检测是否存在文件系统，如果没有则进行格式化 */

153.     printf("未检测到FATFS文件系统，执行格式化...\r\n");

154.     ret = f_mkfs(USERPath, 0, 0);

155.     if(ret == FR_OK) {

156.       printf("格式化成功！\r\n");

157.       f_mount(NULL, USERPath, 1); /* 先取消挂载，后重新挂载 */

158.       ret = f_mount(&SDFatFS, USERPath, 1);

159.     } else {

160.       printf("格式化失败！\r\n");

161.       goto mount_error;

162.     }

163.   } else {

164.     printf("f_mount success!\r\n");

165.   }

166.   

167.   /* 读写测试 */

168.   printf("\r\n ========== write test ==========\r\n");

169.   ret = f_open(&SDFile, "hello.txt", FA_CREATE_ALWAYS | FA_WRITE);

170.   if(ret == FR_OK) {

171.     printf("open file sucess!\r\n");

172.     ret = f_write(&SDFile, write_buf, sizeof(write_buf), &num);

173.     if(ret == FR_OK) {

174.       printf("write \"%s\" success!\r\nwrite len：%d\r\n", write_buf, num);

175.     } else {

176.       printf("write error! ret:%d \r\n", ret);

177.       goto rw_error;

178.     }

179.     f_close(&SDFile);

180.   } else {

181.     printf("open file error!\r\n");

182.     goto rw_error;

183.   }

185.   printf("\r\n ========== read test ==========\r\n");

186. ret = f_open(&SDFile, "hello.txt",FA_OPEN_EXISTING | FA_READ);  

187. if(ret == FR_OK) {

188.     printf("open file sucess!\r\n");

189. ret = f_read(&SDFile, read_buf, sizeof(read_buf), &num); 

190.     if(ret == FR_OK) {

191.       printf("read data:\"%s\"!\r\nread len：%d\r\n", read_buf, num);

192.     } else {

193.       printf("read error! ret:%d \r\n", ret);

194.       goto rw_error;

195.     }

196. } else {

197.     printf("open file error!\r\n");

198.     goto rw_error;

199. }

200. 
     

201. rw_error:

202. f_close(&SDFile);

203.   

204. mount_error:

205. f_mount(NULL, USERPath, 1);

206.   /* USER CODE END 2 */

207. 
     

208.   /* Infinite loop */

209.   /* USER CODE BEGIN WHILE */

210.   while (1)

211.   {

212.     /* USER CODE END WHILE */

213. 
     

214.     /* USER CODE BEGIN 3 */

215.   }

216.   /* USER CODE END 3 */

217. }

218. 
     

219. /**

220.   * @brief System Clock Configuration

221.   * @retval None

222.   */

223. void SystemClock_Config(void)

224. {

225.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};

226.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

227. 
     

228.   /** Initializes the RCC Oscillators according to the specified parameters

229.   * in the RCC_OscInitTypeDef structure.

230.   */

231.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;

232.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;

233.   RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;

234.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;

235.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;

236.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;

237.   RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;

238.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)

239.   {

240.     Error_Handler();

241.   }

242. 
     

243.   /** Initializes the CPU, AHB and APB buses clocks

244.   */

245.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK

246.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;

247.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;

248.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;

249.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;

250.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

251. 
     

252.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)

253.   {

254.     Error_Handler();

255.   }

256. }

257. 
     

258. /* USER CODE BEGIN 4 */

259. 
     

260. /* USER CODE END 4 */

261. 
     

262. /**

263.   * @brief  This function is executed in case of error occurrence.

264.   * @retval None

265.   */

266. void Error_Handler(void)

267. {

268.   /* USER CODE BEGIN Error_Handler_Debug */

269.   /* User can add his own implementation to report the HAL error return state */

270.   __disable_irq();

271.   while (1)

272.   {

273.   }

274.   /* USER CODE END Error_Handler_Debug */

275. }

276. 
     

277. #ifdef  USE_FULL_ASSERT

278. /**

279.   * @brief  Reports the name of the source file and the source line number

280.   *         where the assert_param error has occurred.

281.   * @param  file: pointer to the source file name

282.   * @param  line: assert_param error line source number

283.   * @retval None

284.   */

285. void assert_failed(uint8_t *file, uint32_t line)

286. {

287.   /* USER CODE BEGIN 6 */

288.   /* User can add his own implementation to report the file name and line number,

289.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

290.   /* USER CODE END 6 */

291. }

292. #endif /* USE_FULL_ASSERT */

3.4 配置问题记录

3.4.1 CubeMx生成代码bug

测试发现，使用CubeMx当前最新版本：V6.8.0版本，生成代码会存在以下问题：

• SD卡/SDnand 卡片信息读取成功，但是读写测试失败

经过仔细分析代码后发现，出现的问题在 MX_SDIO_SD_Init() 此初始化函数内的配置项错误导致，具体分析如下：

1. 我们在CubeMx里面配置的时候选择的是4线宽度模式 SD 4bit Wide bus

   
   

2. v6.8.0版本CubeMx生成的 MX_SDIO_SD_Init() SD初始化函数内，hsd.Init.BusWide = SDIO_BUS_WIDE_4B;

   
   

3. 看上去没有什么问题，配置4线模式，对应的初始化项也使用4线模式，但是不然，我们继续分析 MX_SDIO_SD_Init() 此初始配置的调用

   
   

4. MX_SDIO_SD_Init() 此函数在main函数内初始化的时候调用，此函数只配置了 hsd 结构体，并未配置给SDIO硬件寄存器

   
   

5. 之后调用 SD_Driver.disk_initialize(0); 函数的时候才真正开始进行SDIO外设配置

BSP_SD_Init()

  ->HAL_SD_Init()

    ->HAL_SD_InitCard()

在 HAL_SD_InitCard() 函数内使用Init结构体配置SDIO外设，总线宽度1bit，时钟速度<400k，以进行卡片的初始化识别。

      -> SD_InitCard()

        -> SDIO_Init(hsd->Instance, hsd->Init)

      -> SDMMC_CmdBlockLength(hsd->Instance, BLOCKSIZE)

· 在 SD_InitCard() 函数内实现SD卡的初始化识别，之后调用 SDIO_Init() 将 MX_SDIO_SD_Init() 内对 hsd 的配置配置给SDIO外设，此处的作用主要是提升SDIO外设时钟速率为我们配置的速率；

· v6.8.0版本的代码此时hsd.Init.BusWide = SDIO_BUS_WIDE_4B; ，因此v6.8.0版本代码后续SDIO外设使用4线通讯；

· 之后调用 SDMMC_CmdBlockLength() 设置块大小，由于SDIO外设已切换到4线模式，而SD卡/SDnand此时仍然处于1线模式，因此配置会出错

   -> HAL_SD_ConfigWideBusOperation(&hsd, SDIO_BUS_WIDE_4B)

根据前面获取到的SD卡SCR寄存器值，判断是否支持4线模式，如果支持则发送配置命令通知SD卡/SDnand进入4线模式，之后修改SDIO外设总线宽度为4线模式

      6.通过以上分析可知，MX_SDIO_SD_Init() 函数内对 hsd.Init.BusWide = SDIO_BUS_WIDE_4B; 的配置会导致对SD卡块大小的配置失败，从而导致后续读写时失败，报错为块大小设置失败！

      7.综上，针对当前最新版本 V6.8.0 版本CubeMx的处理方法是：手动修改此 hsd.Init.BusWide 配置为 SDIO_BUS_WIDE_1B 或更换低版本CubeMx，本人更换V6.6.1版本后无此bug。

3.4.2 SD插入检测引脚配置

使用CubeMx配置FATFS 选择 SD Card 之后，有一个配置参数，用来配置SD Card的输入检测引脚。如果我们在硬件上有设计SD卡的卡槽插入检测引脚插入连接到了MCU的IO，则可配置对应IO为输入模式，并设置对应IO为输入检测引脚，比如，我们设置PD12为输入检测引脚，则配置如下：

对应代码如下，输入检测 IO 低电平有效！

如果硬件上，没有此插入检测引脚，则可以在CubeMx内不进行配置，只是在生成代码的时候会提示警报而已，可以不用关心，生成的代码项会自动屏蔽插入检测！

4. 结束语

• 以上便是本文的全部内容了，欢迎大家评论区留言讨论！

• 使用CubeMx虽然能帮助我们快速生成驱动，但是对于SD卡/SD nand的驱动流程，我们还是需要有清晰的认识，推荐阅读： SD Nand 与 SD卡 SDIO模式应用流程

————————————————

【本文转载自CSDN，作者： 爱出名的狗腿子】

　　亲爱的卡友们，欢迎光临雷龙官网，如果看完文章之后还是有疑惑或不懂的地方，请联系我们，自己去理解或猜答案是件很累的事，请把最麻烦的事情交给我们来处理，术业有专攻，闻道有先后，深圳市雷龙发展专注存储行业13年，专业提供小容量存储解决方案。