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

已于 2023-05-06 09:36:55 修改
阅读量1.1k 收藏 15
点赞数 2
分类专栏： # SD Nand 与 SD卡 文章标签： stm32 单片机 SDIO SD nand SD卡
于 2023-04-29 00:09:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43332314/article/details/130437000
版权

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

文章目录

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. 选择芯片，ACCESS TO MCU SELECTOR
    在这里插入图片描述

  2. 搜索对应的芯片型号，在对应列表下方选择对应芯片
    在这里插入图片描述

  3. 配置时钟方案，采用外部高速时钟，无源晶振方案
    在这里插入图片描述

  4. 配置调试器，由于我采用SWD调试接口，因此选择 Serial Wrie 串行总线
    在这里插入图片描述

  5. 配置SDIO外设，由于我们所使用的SD nand支持4线传输，因此此处选择4线宽度；如果你所使用的SD nand或SD卡不支持4线传输，此处应选择1线宽度；支持4线宽度的SD卡肯定可以使用1线宽度，因此如果你实在不知道你的SD卡支持几线宽度，你可以直接选择1线宽度！4线和1线宽度的差别也就在于速度上相差了4倍！
    (注意这里暂时不需要对SDIO的参数进行配置，后面我们再回来配置！)
    在这里插入图片描述

  6. 完成时钟树配置：

    • 配置外部晶振频率
    • 调整时钟选择，SYSCLK由PLL产生，PLL由外部时钟倍频产生
    • 配置SDIO外设时钟，注意此处SDIO外设比较特殊，有两个时钟！具体原因见后文！
      在这里插入图片描述

  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. 使能 MicroLIB 微库，否则调用 printf 函数会卡住
    在这里插入图片描述

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

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

#include <stdio.h>
int fputc(int ch, FILE *f)
{
	HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1,0xffff);
	return (ch);
}
  1. 添加 sdcard 信息打印函数，查看卡片信息
HAL_SD_CardInfoTypeDef  SDCardInfo;    
void printf_sdcard_info(void)
{
	uint64_t CardCap;                       //SD卡容量
	HAL_SD_CardCIDTypeDef SDCard_CID; 

	HAL_SD_GetCardCID(&hsd,&SDCard_CID);	//获取CID
	HAL_SD_GetCardInfo(&hsd,&SDCardInfo);   //获取SD卡信息
	CardCap=(uint64_t)(SDCardInfo.LogBlockNbr)*(uint64_t)(SDCardInfo.LogBlockSize);	//计算SD卡容量
	switch(SDCardInfo.CardType)
	{
		case CARD_SDSC:
		{
			if(SDCardInfo.CardVersion == CARD_V1_X)
				printf("Card Type:SDSC V1\r\n");
			else if(SDCardInfo.CardVersion == CARD_V2_X)
				printf("Card Type:SDSC V2\r\n");
		}
		break;
		case CARD_SDHC_SDXC:printf("Card Type:SDHC\r\n");break;
		default:break;
	}	
		
    printf("Card ManufacturerID: %d \r\n",SDCard_CID.ManufacturerID);				//制造商ID	
 	printf("CardVersion:         %d \r\n",(uint32_t)(SDCardInfo.CardVersion));		//卡版本号
	printf("Class:               %d \r\n",(uint32_t)(SDCardInfo.Class));		    //SD卡类别
 	printf("Card RCA(RelCardAdd):%d \r\n",SDCardInfo.RelCardAdd);					//卡相对地址
	printf("Card BlockNbr:       %d \r\n",SDCardInfo.BlockNbr);						//块数量
 	printf("Card BlockSize:      %d \r\n",SDCardInfo.BlockSize);					//块大小
	printf("LogBlockNbr:         %d \r\n",(uint32_t)(SDCardInfo.LogBlockNbr));		//逻辑块数量
	printf("LogBlockSize:        %d \r\n",(uint32_t)(SDCardInfo.LogBlockSize));		//逻辑块大小
	printf("Card Capacity:       %d MB\r\n",(uint32_t)(CardCap>>20));				//卡容量
}
  1. 添加初始化及读写测试代码，注意此处我们没有直接使用FATFS的读写接口，我们先测试生成的SD驱动函数接口
int main(void)
{
  /* USER CODE BEGIN 1 */
  BYTE send_buf[512];
  DRESULT ret;
  /* USER CODE END 1 */

  /* ...省略若干自动生成代码... */
  
  /* USER CODE BEGIN 2 */

  SD_Driver.disk_initialize(0);
  printf_sdcard_info();

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

  ret = SD_Driver.disk_write(0,
(BYTE *)"Life is too short to spend time with people who suck the happiness out of you. \
If someone wants you in their life, they’ll make room for you. You shouldn’t have to fight for a spot. Never, ever\
 insist yourself to someone who continuously overlooks your worth. And remember, it’s not the people that stand by \
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\
 friends",20,2);
  printf("sd write result:%d\r\n", ret);
  ret = SD_Driver.disk_read(0, send_buf, 20, 2);
  printf("sd reak result:%d\r\n", ret);
  printf("sd read content:\r\n%s\r\n", send_buf);
  
  printf("\r\n\r\n********** 中文读写测试 **********\r\n");

  ret = SD_Driver.disk_write(0,
(BYTE *)"开发者社区的明天需要大家一同开源共创，期待下一次你的分享，让我们一同携手共进，推动人类科技的发展！！！\r\n\
创作不易，转载请注明出处~\r\n\
更多文章敬请关注：爱出名的狗腿子\r\n", 22, 2);
  printf("sd write result:%d\r\n", ret);
  ret = SD_Driver.disk_read(0, send_buf, 22, 2);
  printf("sd reak result:%d\r\n", ret);
  printf("sd read content:\r\n%s\r\n", send_buf);
  /* USER CODE END 2 */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}
  1. 修改烧录器配置，配置为烧录后自动运行
  2. 下载测试，这里由于我们采用UTF-8编码，所以使用的串口上位机也需要支持UTF-8解析，我们这里使用Mobaxterm上位机，测试结果如下:
    在这里插入图片描述
  3. main.c 文件全部代码如下，供大家参考：
/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "fatfs.h"
#include "sdio.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

#include <stdio.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

HAL_SD_CardInfoTypeDef  SDCardInfo;    
void printf_sdcard_info(void)
{
	uint64_t CardCap;                       //SD卡容量
	HAL_SD_CardCIDTypeDef SDCard_CID; 

	HAL_SD_GetCardCID(&hsd,&SDCard_CID);	//获取CID
	HAL_SD_GetCardInfo(&hsd,&SDCardInfo);   //获取SD卡信息
	CardCap=(uint64_t)(SDCardInfo.LogBlockNbr)*(uint64_t)(SDCardInfo.LogBlockSize);	//计算SD卡容量
	switch(SDCardInfo.CardType)
	{
		case CARD_SDSC:
		{
			if(SDCardInfo.CardVersion == CARD_V1_X)
				printf("Card Type:SDSC V1\r\n");
			else if(SDCardInfo.CardVersion == CARD_V2_X)
				printf("Card Type:SDSC V2\r\n");
		}
		break;
		case CARD_SDHC_SDXC:printf("Card Type:SDHC\r\n");break;
		default:break;
	}	
		
    printf("Card ManufacturerID: %d \r\n",SDCard_CID.ManufacturerID);				//制造商ID	
 	printf("CardVersion:         %d \r\n",(uint32_t)(SDCardInfo.CardVersion));		//卡版本号
	printf("Class:               %d \r\n",(uint32_t)(SDCardInfo.Class));		    //SD卡类别
 	printf("Card RCA(RelCardAdd):%d \r\n",SDCardInfo.RelCardAdd);					//卡相对地址
	printf("Card BlockNbr:       %d \r\n",SDCardInfo.BlockNbr);						//块数量
 	printf("Card BlockSize:      %d \r\n",SDCardInfo.BlockSize);					//块大小
	printf("LogBlockNbr:         %d \r\n",(uint32_t)(SDCardInfo.LogBlockNbr));		//逻辑块数量
	printf("LogBlockSize:        %d \r\n",(uint32_t)(SDCardInfo.LogBlockSize));		//逻辑块大小
	printf("Card Capacity:       %d MB\r\n",(uint32_t)(CardCap>>20));				//卡容量
}

int fputc(int ch, FILE *f)
{
	HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1,0xffff);
	return (ch);
}
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */
  BYTE send_buf[512];
  DRESULT ret;
  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_SDIO_SD_Init();
  MX_USART1_UART_Init();
  MX_FATFS_Init();
  /* USER CODE BEGIN 2 */
  
  SD_Driver.disk_initialize(0);
  printf_sdcard_info();

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

  ret = SD_Driver.disk_write(0,
(BYTE *)"Life is too short to spend time with people who suck the happiness out of you. \
If someone wants you in their life, they’ll make room for you. You shouldn’t have to fight for a spot. Never, ever\
 insist yourself to someone who continuously overlooks your worth. And remember, it’s not the people that stand by \
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\
 friends",20,2);
  printf("sd write result:%d\r\n", ret);
  ret = SD_Driver.disk_read(0, send_buf, 20, 2);
  printf("sd reak result:%d\r\n", ret);
  printf("sd read content:\r\n%s\r\n", send_buf);
  
  printf("\r\n\r\n********** 中文读写测试 **********\r\n");

  ret = SD_Driver.disk_write(0,
(BYTE *)"开发者社区的明天需要大家一同开源共创，期待下一次你的分享，让我们一同携手共进，推动人类科技的发展！！！\r\n\
创作不易，转载请注明出处~\r\n\
更多文章敬请关注：爱出名的狗腿子\r\n", 22, 2);
  printf("sd write result:%d\r\n", ret);
  ret = SD_Driver.disk_read(0, send_buf, 22, 2);
  printf("sd reak result:%d\r\n", ret);
  printf("sd read content:\r\n%s\r\n", send_buf);
  
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

3.3 FATFS文件操作

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

FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode);				/* Open or create a file */
FRESULT f_close (FIL* fp);											/* Close an open file object */
FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br);			/* Read data from a file */
FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw);	/* Write data to a file */
FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf);	/* Forward data to the stream */
FRESULT f_lseek (FIL* fp, DWORD ofs);								/* Move file pointer of a file object */
FRESULT f_truncate (FIL* fp);										/* Truncate file */
FRESULT f_sync (FIL* fp);											/* Flush cached data of a writing file */
FRESULT f_opendir (DIR* dp, const TCHAR* path);						/* Open a directory */
FRESULT f_closedir (DIR* dp);										/* Close an open directory */
FRESULT f_readdir (DIR* dp, FILINFO* fno);							/* Read a directory item */
FRESULT f_findfirst (DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern);	/* Find first file */
FRESULT f_findnext (DIR* dp, FILINFO* fno);							/* Find next file */
FRESULT f_mkdir (const TCHAR* path);								/* Create a sub directory */
FRESULT f_unlink (const TCHAR* path);								/* Delete an existing file or directory */
FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new);	/* Rename/Move a file or directory */
FRESULT f_stat (const TCHAR* path, FILINFO* fno);					/* Get file status */
FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask);			/* Change attribute of the file/dir */
FRESULT f_utime (const TCHAR* path, const FILINFO* fno);			/* Change times-tamp of the file/dir */
FRESULT f_chdir (const TCHAR* path);								/* Change current directory */
FRESULT f_chdrive (const TCHAR* path);								/* Change current drive */
FRESULT f_getcwd (TCHAR* buff, UINT len);							/* Get current directory */
FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs);	/* Get number of free clusters on the drive */
FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* vsn);	/* Get volume label */
FRESULT f_setlabel (const TCHAR* label);							/* Set volume label */
FRESULT f_mount (FATFS* fs, const TCHAR* path, BYTE opt);			/* Mount/Unmount a logical drive */
FRESULT f_mkfs (const TCHAR* path, BYTE sfd, UINT au);				/* Create a file system on the volume */
FRESULT f_fdisk (BYTE pdrv, const DWORD szt[], void* work);			/* Divide a physical drive into some partitions */
int f_putc (TCHAR c, FIL* fp);										/* Put a character to the file */
int f_puts (const TCHAR* str, FIL* cp);								/* Put a string to the file */
int f_printf (FIL* fp, const TCHAR* str, ...);						/* Put a formatted string to the file */
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头文件！

#include "fatfs.h"
int main()
{
  /* USER CODE BEGIN 1 */
#define USERPath "0:/"
  
  BYTE write_buf[] = "\r\n\r\n\
hello world!\r\n\
开发者社区的明天需要大家一同开源共创，期待下一次你的分享，让我们一同携手共进，推动人类科技的发展！！！\r\n\
创作不易，转载请注明出处~\r\n\
更多文章敬请关注：爱出名的狗腿子\r\n\r\n\
";
  BYTE read_buf[1024] = {0};
  UINT num;
  FRESULT ret;
  /* USER CODE END 1 */
  
  /* ... 省略初始化代码... */
  
  /* USER CODE BEGIN 2 */
  
  /* 挂载文件系统，挂载的时候会完成对应硬件设备（SD卡/SDnand）初始化 */
  ret = f_mount(&SDFatFS, USERPath, 1);
  if (ret != FR_OK) {
    printf("f_mount error!\r\n");
    goto mount_error;
  } else if(ret == FR_NO_FILESYSTEM) {         /* 检测是否存在文件系统，如果没有则进行格式化 */
    printf("未检测到FATFS文件系统，执行格式化...\r\n");
    ret = f_mkfs(USERPath, 0, 0);
    if(ret == FR_OK) {
      printf("格式化成功！\r\n");
      f_mount(NULL, USERPath, 1); /* 先取消挂载，后重新挂载 */
      ret = f_mount(&SDFatFS, USERPath, 1);
    } else {
      printf("格式化失败！\r\n");
      goto mount_error;
    }
  } else {
    printf("f_mount success!\r\n");
  }
  
  /* 读写测试 */
  printf("\r\n ========== write test ==========\r\n");
  ret = f_open(&SDFile, "hello.txt", FA_CREATE_ALWAYS | FA_WRITE);
  if(ret == FR_OK) {
    printf("open file sucess!\r\n");
    ret = f_write(&SDFile, write_buf, sizeof(write_buf), &num);
    if(ret == FR_OK) {
      printf("write \"%s\" success!\r\nwrite len：%d\r\n", write_buf, num);
    } else {
      printf("write error! ret:%d \r\n", ret);
      goto rw_error;
    }
    f_close(&SDFile);
  } else {
    printf("open file error!\r\n");
    goto rw_error;
  }
	
  printf("\r\n ========== read test ==========\r\n");
  ret = f_open(&SDFile, "hello.txt",FA_OPEN_EXISTING | FA_READ); 	 
  if(ret == FR_OK) {
    printf("open file sucess!\r\n");
	ret = f_read(&SDFile, read_buf, sizeof(read_buf), &num); 
    if(ret == FR_OK) {
      printf("read data:\"%s\"!\r\nread len：%d\r\n", read_buf, num);
    } else {
      printf("read error! ret:%d \r\n", ret);
      goto rw_error;
  }
} else {
   printf("open file error!\r\n");
   goto rw_error;
}

rw_error:
  f_close(&SDFile);	
  
mount_error:
  f_mount(NULL, USERPath, 1);
  /* USER CODE END 2 */
  while (1) {
  
  }
}

#define USERPath "0:/" 表示挂载的位置，这是由于FATFS初始化的时候链接的根目录为 0:/ ，所以挂载的文件系统需要在此目录下，当然也可以是此目录下的路径，如0:/hello，但不能是其他目录，如 1:/
在这里插入图片描述
测试结果如下：
在这里插入图片描述
main.c完整内容如下：

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "fatfs.h"
#include "sdio.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

#include <stdio.h>
#include "fatfs.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

HAL_SD_CardInfoTypeDef  SDCardInfo;    
void printf_sdcard_info(void)
{
	uint64_t CardCap;                       //SD卡容釿
	HAL_SD_CardCIDTypeDef SDCard_CID; 

	HAL_SD_GetCardCID(&hsd,&SDCard_CID);	//获取CID
	HAL_SD_GetCardInfo(&hsd,&SDCardInfo);   //获取SD卡信恿
	CardCap=(uint64_t)(SDCardInfo.LogBlockNbr)*(uint64_t)(SDCardInfo.LogBlockSize);	//计算SD卡容釿
	switch(SDCardInfo.CardType)
	{
		case CARD_SDSC:
		{
			if(SDCardInfo.CardVersion == CARD_V1_X)
				printf("Card Type:SDSC V1\r\n");
			else if(SDCardInfo.CardVersion == CARD_V2_X)
				printf("Card Type:SDSC V2\r\n");
		}
		break;
		case CARD_SDHC_SDXC:printf("Card Type:SDHC\r\n");break;
		default:break;
	}	
		
    printf("Card ManufacturerID: %d \r\n",SDCard_CID.ManufacturerID);				//制鿠商ID	
 	printf("CardVersion:         %d \r\n",(uint32_t)(SDCardInfo.CardVersion));		//卡版本号
	printf("Class:               %d \r\n",(uint32_t)(SDCardInfo.Class));		    //SD卡类刿
 	printf("Card RCA(RelCardAdd):%d \r\n",SDCardInfo.RelCardAdd);					//卡相对地坿
	printf("Card BlockNbr:       %d \r\n",SDCardInfo.BlockNbr);						//块数釿
 	printf("Card BlockSize:      %d \r\n",SDCardInfo.BlockSize);					//块大尿
	printf("LogBlockNbr:         %d \r\n",(uint32_t)(SDCardInfo.LogBlockNbr));		//逻辑块数釿
	printf("LogBlockSize:        %d \r\n",(uint32_t)(SDCardInfo.LogBlockSize));		//逻辑块大尿
	printf("Card Capacity:       %d MB\r\n",(uint32_t)(CardCap>>20));				//卡容釿
}

int fputc(int ch, FILE *f)
{
	HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1,0xffff);
	return (ch);
}

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */
#define USERPath "0:/"
  
  BYTE write_buf[] = "\r\n\r\n\
hello world!\r\n\
开发者社区的明天需要大家一同开源共创，期待下一次你的分享，让我们一同携手共进，推动人类科技的发展！！！\r\n\
创作不易，转载请注明出处~\r\n\
更多文章敬请关注：爱出名的狗腿子\r\n\r\n\
";
  BYTE read_buf[1024] = {0};
  UINT num;
  FRESULT ret;
  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_SDIO_SD_Init();
  MX_USART1_UART_Init();
  MX_FATFS_Init();
  /* USER CODE BEGIN 2 */
  
  /* 挂载文件系统，挂载的时候会完成对应硬件设备（SD卡/SDnand）初始化 */
  ret = f_mount(&SDFatFS, USERPath, 1);
  if (ret != FR_OK) {
    printf("f_mount error!\r\n");
    goto mount_error;
  } else if(ret == FR_NO_FILESYSTEM) {         /* 检测是否存在文件系统，如果没有则进行格式化 */
    printf("未检测到FATFS文件系统，执行格式化...\r\n");
    ret = f_mkfs(USERPath, 0, 0);
    if(ret == FR_OK) {
      printf("格式化成功！\r\n");
      f_mount(NULL, USERPath, 1); /* 先取消挂载，后重新挂载 */
      ret = f_mount(&SDFatFS, USERPath, 1);
    } else {
      printf("格式化失败！\r\n");
      goto mount_error;
    }
  } else {
    printf("f_mount success!\r\n");
  }
  
  /* 读写测试 */
  printf("\r\n ========== write test ==========\r\n");
  ret = f_open(&SDFile, "hello.txt", FA_CREATE_ALWAYS | FA_WRITE);
  if(ret == FR_OK) {
    printf("open file sucess!\r\n");
    ret = f_write(&SDFile, write_buf, sizeof(write_buf), &num);
    if(ret == FR_OK) {
      printf("write \"%s\" success!\r\nwrite len：%d\r\n", write_buf, num);
    } else {
      printf("write error! ret:%d \r\n", ret);
      goto rw_error;
    }
    f_close(&SDFile);
  } else {
    printf("open file error!\r\n");
    goto rw_error;
  }
	
  printf("\r\n ========== read test ==========\r\n");
	ret = f_open(&SDFile, "hello.txt",FA_OPEN_EXISTING | FA_READ); 	 
	if(ret == FR_OK) {
    printf("open file sucess!\r\n");
		ret = f_read(&SDFile, read_buf, sizeof(read_buf), &num); 
    if(ret == FR_OK) {
      printf("read data:\"%s\"!\r\nread len：%d\r\n", read_buf, num);
    } else {
      printf("read error! ret:%d \r\n", ret);
      goto rw_error;
    }
	} else {
    printf("open file error!\r\n");
    goto rw_error;
	}

rw_error:
	f_close(&SDFile);	
  
mount_error:
	f_mount(NULL, USERPath, 1);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#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. 结束语

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

创作不易，转载请注明出处~

更多文章敬请关注：爱出名的狗腿子（点击跳转!!!）

爱出名的狗腿子
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
电子-使用STM32CUBEMX生成FatFS代码操作SPIFLASHmengfei314的博客博客频道CSDN.pdf
09-05
电子-使用STM32CUBEMX生成FatFS代码操作SPIFLASHmengfei314的博客博客频道CSDN.pdf,单片机/嵌入式STM32-F0/F1/F2
cubemx配置freertos+lvgl+fatfs，基于stm32f103zet6
08-25
FATFS是一个文件系统模块，允许STM32与存储设备（如SD卡）进行文件操作。在CubeMX中，你首先需要配置SPI或SDIO接口来连接SD卡。然后，你需要包含FATFS库，并根据需求设置文件系统的配置，如分区大小、簇大小等。这将...
STM32CubeMX学习笔记（27）——FatFs文件系统使用（操作SD卡）
热门推荐
Leung的博客
12-07 1万+
一、FatFs简介 FatFs 是面向小型嵌入式系统的一种通用的 FAT 文件系统。它完全是由 ANSI C 语言编写并且完全独立于底层的 I/O 介质。因此它可以很容易地不加修改地移植到其他的处理器当中，如 8051、PIC、AVR、SH、Z80、H8、ARM 等。FatFs 支持 FAT12、FAT16、FAT32 等格式，所以我们利用前面写好的 SPI Flash 芯片驱动，把 FatFs 文件系统代码移植到工程之中，就可以利用文件系统的各种函数，对 SPI Flash 芯片以“文件”格式进行读写操
STM32CubeMX学习笔记（27）——FatFs文件系统使用（操作SD卡
最新发布
2401_85013339的博客
05-17 702
SDIO 外设支持生成 DMA 请求，使用 DMA 传输可以提高数据传输效率，因此在 SDIO 的控制代码中，可以把它设置为 DMA 传输模式或轮询模式，ST 标准库提供 SDIO 示例中针对这两个模式做了区分处理。主时钟 SDIOCLK 产生 CLK 引脚时钟有效沿选择，可选上升沿或下降沿，它设定 SDIO 时钟控制寄存器(SDIO_CLKCR)的 NEGEDGE 位的值，一般选择设置为。硬件流控制选择，可选使能或禁用，它设定 SDIO_CLKCR 寄存器的 HWFC_EN 位的值。
STM32CubeMX学习笔记（27）——FatFs文件系统使用（操作SD卡(1)
2401_85013339的博客
05-17 598
FA_CREATE_ALWAYS | 创建一个新文件。如果文件已存在，则它将被截断并覆盖。
STM32CubeMX系列|FATFS文件系统
安迪西_嵌入式攻城狮
10-16 8563
FATFS文件系统 1.FATFS文件系统简介 2. 硬件设计 3. 软件设计 3.1 STM32CubeMX设置 3.2 MDK-ARM编程 4. 下载验证
STM32CubeMX学习笔记20——SD卡FATFS文件系统
H2z1220的博客
03-11 2855
文件系统是操作系统用于明确存储设备或分区上的文件的方法和数据结构（即在存储设备上组织文件的方法）。操作系统中负责管理和存储文件信息的软件机构称为文件管理系统，简称文件系统；不带文件系统的SD卡仅能实现简单的读写扇区操作，要真正应用SD卡必须要使用文件系统FATFS文件存储原理（以FAT32为例），下图为FAT32文件系统布局：分区空间大小簇空间大小每个簇包含的扇区数< 8GB4KB88KB1616KB32>= 32GB32KB64。
雷龙SD NAND FLASH Stm32例程
02-23
1. **SD卡接口**：SD卡接口是STM32与SD NAND Flash通信的桥梁。STM32通过SPI或SDIO接口与SD卡进行数据传输。SPI（Serial Peripheral Interface）是一种简单、高速的串行通信协议，而SDIO（Secure Digital Input/...
STM32SD卡读取
08-13
总的来说，STM32利用FATFS库读取SD卡，是嵌入式系统中实现数据持久化存储的一种常见方法。理解FATFS的工作原理和接口使用，以及如何编写对应的驱动代码，是掌握这一技术的关键。通过实践和参考提供的示例代码，...
基于stm32F103vct6的SD卡FATFS文件系统移植
11-29
FATFS库则是用于实现文件系统操作的软件框架，尤其适合在资源有限的嵌入式系统中读写SD卡等存储设备。本文将详细介绍如何在基于STM32F103VCT6的系统中移植并使用FATFS文件系统。 首先，了解STM32F103VCT6。这是一款...
运行于STM32F1O3 FATFS移植到SPIFlash
02-27
FATFS是一个通用的文件系统模块，它允许用户在微控制器上实现FAT16或FAT32文件系统，以读写存储设备，如SD卡、USB驱动器或在这个案例中的SPI Flash。 移植FATFS到STM32F103的SPI Flash意味着你需要将FATFS的接口与...
STM32CubeMX配置STM32F407的SDCard-DMA-FatFs
05-09
STM32CubeMX配置STM32F407的SDCard-DMA-FatFs
STM32CubeMX配置SD+DMA+Fatfs（正点原子F767开发板）
05-27
使用STM32CubeMX配置SD卡，Fatfs对SD卡文件进行读写测试，代码适配正点原子F767开发板。
基于CubeMX配置 FreeRTOS + SD + Fatfs 进行SD卡的读写操作
08-27
基于CubeMX配置 FreeRTOS + SD + Fatfs 进行SD卡的读写操作 基于keil编辑器
STM32CubeMX配置SD卡+DMA+Fatfs文件系统
dxc8865de2的博客
08-10 8317
STM32CubeMX配置SD卡+DMA+Fatfs文件系统 一、设备及软件 1、keil 2、STM32CubeMX 3、正点原子STM32F407探索者开发板 二、配置步骤 1、配置RCC外部晶振和SYS为SW模式（看之前配置方式） 2、配置USART1（调试使用） 3、时钟树配置，SDIO模块输入时钟为48MHZ 4,、SDIO配置 SDIO时钟SDIO_CK = 48MHz/(CLKDIV+2)。即12MHZ 打开SDIO中断 添加DMA 5、配置Fatfs文件系统 支持中文及长文件
9.2CubeMx配置SD卡FATFS系统_stm32H7系列 SD卡 FR_NO_FILESYSTEM 找不到FatFs系统的问题
qq_36561846的博客
10-13 3112
/挂载盘符A】会出现f_mount挂载SD卡返回没有文件系统FR_NO_FILESYSTEM，但是SD卡是有文件系统的，即使接着格式化SD卡你会出现问题（retSD = f_mkfs(SDPath,0,0,work,sizeof(work));这时,就需要手动打开两个宏定义ENABLE_SD_DMA_CACHE_MAINTENANCE 、ENABLE_SCRATCH_BUFFER。开启宏ENABLE_SD_DMA_CACHE_MAINTENANCE、ENABLE_SCRATCH_BUFFER。
STM32CubeMX通过FatFS读写U盘
ASWaterbenben的博客
11-06 8247
最近出现了使用STM32读写U盘的需求，本着自己也出了好多良心博客的份上就像偷懒抄一篇CSDN，但是鉴于某些博主这点小东西都要收费、还不公开源码，一气之下准备自己写一篇博客来谴责某些不良心的博主；（上述气话，接下来上干货） 大致思路 STM32读写U盘主要分为以下几个方面： 1、文件系统（抽象层，以统一方式对不同外设进行读写） 2、USB_Host（USB硬件驱动，维持USB的正常工作） 3、FreeRTOS（操作系统，鉴于各位可能右用到操作系统的需求加上，也可以裸机跑） 具体思想如下：(是不是很简单，就搞
STM32CubeMX教程26 FatFs 文件系统 - W25Q128读写
lc_guo的博客
01-23 2143
使用STM32CubeMX软件配置STM32F407开发板使用FatFs中间件通过SPI通信协议对W25Q128芯片进行读写等操作
使用stm32cubemx快速生成fatfs例程
jian3214的博客
03-05 7262
使用stm32cubemx快速生成fatfs例程前言1. cubemx生成过程1.1 sdio相关配置1.2 系统时钟树配置1.3 fatfs配置1.4 修改工程的栈空间2. 修改工程代码2.1 fatfs sd卡读写文件的流程2.2 具体代码的实现3.实验现象 前言 本文将介绍如何使用stm32cubemx快速生成一个stm32 sdio 接口的fatfs例程，并实现对sd卡读写，本文的cube...
cubemx 读卡器_STM32CubeMX基于SD卡的FATFS文件系统测试
05-24
在使用STM32CubeMX基于SD卡的FATFS文件系统测试时，需要按照以下步骤进行操作： 1. 首先，在STM32CubeMX中配置SD卡接口。选择相应的SDIO接口、时钟频率等参数，并将其配置为FATFS文件系统。 2. 在代码中添加相关头文件和宏定义，如下所示： ``` #include "ff.h" #include "sdio.h" #include "stm32f4xx_hal.h" #define FILENAME "test.txt" //定义文件名 ``` 3. 初始化SD卡接口，包括初始化SDIO接口和卡片检测引脚： ``` MX_SDIO_SD_Init(); MX_SDIO_SDIO1_SD_DETECT_Init(); ``` 4. 挂载文件系统并打开文件： ``` FATFS fs; FIL fil; if(f_mount(&fs, "", 0) != FR_OK) { //挂载文件系统 printf("Failed to mount file system\n"); return; } if(f_open(&fil, FILENAME, FA_CREATE_ALWAYS | FA_WRITE) != FR_OK) { //打开文件 printf("Failed to open file\n"); f_mount(NULL, "", 0); return; } ``` 5. 向文件中写入数据： ``` char message[] = "Hello, world!\r\n"; UINT bytesWritten; if(f_write(&fil, message, strlen(message), &bytesWritten) != FR_OK) { //写入数据 printf("Failed to write data\n"); f_close(&fil); f_mount(NULL, "", 0); return; } ``` 6. 关闭文件并卸载文件系统： ``` f_close(&fil); f_mount(NULL, "", 0); ``` 以上就是使用STM32CubeMX基于SD卡的FATFS文件系统测试的基本步骤。需要注意的是，具体实现可能会因为不同的芯片和开发环境而有所不同，需要根据实际情况进行调整。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱出名的狗腿子

你的鼓励就是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值