STM32F1与STM32CubeIDE快速入门-USB+SDIO+FatFs实现U盘

USB+SDIO+FatFs实现U盘

STM32F1 USB外设实现了USB2.0全速总线和APB1总线间的接口。USB 提供的串行接口，具有以下特点：1）简单性和灵活性（即插即用）；2）双向性；3）提高速度；4）低成本。

STM32F103自带的USB符合USB2.0规范。但是STM32F1的USB只支持作为设备，不能作为主机。

本文将详细介绍如何使用STM32CubeIDE中如何配置通过USB的Mass Storage Class功能挂载SD卡。

1、SDIO配置

STM32CubeIDE创建工程、系统配置、调试配置，在这里不再做介绍，请参考：

SDIO的配置如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8aKuKHup-1652595379926)(images/28-1.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ru0oKtAx-1652595379928)(images/28-2.png)]

前面的文章，对SDIO的配置作了详细的描述，请参考：

2、FatFs配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-By9vc63F-1652595379928)(images/29-3.png)]

注意：本实例使用自定义的FatFs。因为在测试过程中，选择SD Car选项，导致SD卡挂载不成功。在后面将详细实现相关接口。

3、USB配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ikvr3AGZ-1652595379929)(images/28-4.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JRcLpQtg-1652595379930)(images/28-5.png)]

基本使用默认配置。

4、SDIO与FatFs接口实现

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
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
// stm32\_sd\_my\_bsp.h
#ifndef \_\_STM3210E\_MY\_BSP\_H\_\_
#define \_\_STM3210E\_MY\_BSP\_H\_\_

#ifdef \_\_cplusplus
 extern "C" {
#endif 

#include "stm32f1xx\_hal.h"

/\*\* 
 \* @brief SD Card信息结构
 \*/
#define BSP\_SD\_CardInfo HAL\_SD\_CardInfoTypeDef


#define MSD\_OK ((uint8\_t)0x00)
#define MSD\_ERROR ((uint8\_t)0x01)

/\*\* 
 \* @brief SD 传输状态定义
 \*/     
#define SD\_TRANSFER\_OK ((uint8\_t)0x00)
#define SD\_TRANSFER\_BUSY ((uint8\_t)0x01)

#define SD\_DETECT\_PIN GPIO\_PIN\_6
#define SD\_DETECT\_GPIO\_PORT GPIOC
#define \_\_SD\_DETECT\_GPIO\_CLK\_ENABLE() \_\_HAL\_RCC\_GPIOF\_CLK\_ENABLE()
#define SD\_DETECT\_IRQn EXTI15\_10\_IRQn
   
#define SD\_DATATIMEOUT 100000000U

#define SD\_PRESENT ((uint8\_t)0x01)
#define SD\_NOT\_PRESENT ((uint8\_t)0x00)

/\* DMA definitions for SD DMA transfer \*/
#define \_\_DMAx\_TxRx\_CLK\_ENABLE \_\_HAL\_RCC\_DMA2\_CLK\_ENABLE
#define SD\_DMAx\_Tx\_INSTANCE DMA2\_Channel4
#define SD\_DMAx\_Rx\_INSTANCE DMA2\_Channel4
#define SD\_DMAx\_Tx\_IRQn DMA2\_Channel4\_5\_IRQn
#define SD\_DMAx\_Rx\_IRQn DMA2\_Channel4\_5\_IRQn
#define BSP\_SD\_IRQHandler SDIO\_IRQHandler
#define SD\_DMAx\_Tx\_IRQHandler DMA2\_Channel4\_5\_IRQHandler
#define SD\_DMAx\_Rx\_IRQHandler DMA2\_Channel4\_5\_IRQHandler

uint8\_t BSP\_SD\_Init(void);
uint8\_t BSP\_SD\_ITConfig(void);
void    BSP\_SD\_DetectIT(void);
void    BSP\_SD\_DetectCallback(void);
uint8\_t BSP\_SD\_ReadBlocks(uint32\_t \*pData, uint32\_t ReadAddr, uint32\_t NumOfBlocks, uint32\_t Timeout);
uint8\_t BSP\_SD\_WriteBlocks(uint32\_t \*pData, uint32\_t WriteAddr, uint32\_t NumOfBlocks, uint32\_t Timeout);
uint8\_t BSP\_SD\_ReadBlocks\_DMA(uint32\_t \*pData, uint32\_t ReadAddr, uint32\_t NumOfBlocks);
uint8\_t BSP\_SD\_WriteBlocks\_DMA(uint32\_t \*pData, uint32\_t WriteAddr, uint32\_t NumOfBlocks);
uint8\_t BSP\_SD\_Erase(uint32\_t StartAddr, uint32\_t EndAddr);
uint8\_t BSP\_SD\_GetCardState(void);
void    BSP\_SD\_GetCardInfo(HAL_SD_CardInfoTypeDef \*CardInfo);
uint8\_t BSP\_SD\_IsDetected(void);
   

void    BSP\_SD\_MspInit(void \*Params);
void    BSP\_SD\_AbortCallback(void);
void    BSP\_SD\_WriteCpltCallback(void);
void    BSP\_SD\_ReadCpltCallback(void); 


#ifdef \_\_cplusplus
}
#endif

#endif /\* \_\_STM3210E\_MY\_BSP\_H\_\_ \*/


2）接口实现

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
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
// stm32\_sd\_my\_bsp.c

#include "stm32\_sd\_my\_bsp.h"

// SD卡定义句柄
extern SD_HandleTypeDef hsd;

// DMA传输相关
uint8\_t SD\_DMAConfigRx(SD_HandleTypeDef \*hsd);
uint8\_t SD\_DMAConfigTx(SD_HandleTypeDef \*hsd);


uint8\_t BSP\_SD\_Init(void) {
	uint8\_t state = MSD_OK;

	/\* SD卡设备配置 \*/
	hsd.Instance = SDIO;

	hsd.Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
	hsd.Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
	hsd.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
	hsd.Init.BusWide = SDIO_BUS_WIDE_1B;
	hsd.Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
	hsd.Init.ClockDiv = SDIO_TRANSFER_CLK_DIV;

	/\* Msp SD 初始化 \*/
	BSP\_SD\_MspInit(NULL);

	if (HAL\_SD\_Init(&hsd) != HAL_OK) {
		state = MSD_ERROR;
	}

	/\* 配置SD卡总线模式 \*/
	if (state == MSD_OK) {
		if (HAL\_SD\_ConfigWideBusOperation(&hsd, SDIO_BUS_WIDE_4B) != HAL_OK) {
			state = MSD_ERROR;
		} else {
			state = MSD_OK;
		}
	}

	return state;
}

/\*\*
 \* @brief SD中断检测
 \*/
void BSP\_SD\_DetectIT(void) {
	/\* SD detect IT callback \*/
	BSP\_SD\_DetectCallback();

}

/\*\*
 \* @brief SD 中断检测回调
 \*/
__weak void BSP\_SD\_DetectCallback(void) {
	/\* NOTE: This function Should not be modified, when the callback is needed,
 the BSP\_SD\_DetectCallback could be implemented in the user file
 \*/
}

/\*\*
 \* @brief 以轮询模式从 SD 卡中的指定地址读取块。
 \* @param pData: 指向将包含要传输的数据的缓冲区的指针
 \* @param ReadAddr: 读取数据的地址
 \* @param NumOfBlocks:要读取的 SD 块数
 \* @param Timeout: 读操作超时
 \* @retval SD 状态
 \*/
uint8\_t BSP\_SD\_ReadBlocks(uint32\_t \*pData, uint32\_t ReadAddr,
		uint32\_t NumOfBlocks, uint32\_t Timeout) {
	if (HAL\_SD\_ReadBlocks(&hsd, (uint8\_t\*) pData, ReadAddr, NumOfBlocks,
			Timeout) != HAL_OK) {
		return MSD_ERROR;
	} else {
		return MSD_OK;
	}
}

/\*\*
 \* @brief 以轮询模式将块写入 SD 卡中的指定地址。
 \* @param pData: 指向将包含要传输的数据的缓冲区的指针
 \* @param WriteAddr: 写入数据的地址
 \* @param NumOfBlocks: 要写入的 SD 块数
 \* @param Timeout: 写操作超时
 \* @retval SD 状态
 \*/
uint8\_t BSP\_SD\_WriteBlocks(uint32\_t \*pData, uint32\_t WriteAddr,
		uint32\_t NumOfBlocks, uint32\_t Timeout) {
	if (HAL\_SD\_WriteBlocks(&hsd, (uint8\_t\*) pData, WriteAddr, NumOfBlocks,
			Timeout) != HAL_OK) {
		return MSD_ERROR;
	} else {
		return MSD_OK;
	}
}

/\*\*
 \* @brief 在 DMA 模式下从 SD 卡中的指定地址读取块。
 \* @param pData: 指向将包含要传输的数据的缓冲区的指针
 \* @param ReadAddr: 读取数据的地址
 \* @param NumOfBlocks: 要读取的 SD 块数
 \* @retval SD 状态
 \*/
uint8\_t BSP\_SD\_ReadBlocks\_DMA(uint32\_t \*pData, uint32\_t ReadAddr,
		uint32\_t NumOfBlocks) {
	uint8\_t state = MSD_OK;

	/\* 使 dma tx 句柄无效\*/
	hsd.hdmatx = NULL;

	/\* 为读取操作准备 dma 通道 \*/
	state = ((SD\_DMAConfigRx(&hsd) == MSD_OK) ? MSD_OK : MSD_ERROR);

	if (state == MSD_OK) {
		/\* 在 DMA 传输模式下读取块 \*/
		state = (
				(HAL\_SD\_ReadBlocks\_DMA(&hsd, (uint8\_t\*) pData, ReadAddr,
						NumOfBlocks) == HAL_OK) ? MSD_OK : MSD_ERROR);
	}

	return state;
}

/\*\*
 \* @brief 在 DMA 模式下，将块写入 SD 卡中的指定地址。
 \* @param pData: 指向将包含要传输的数据的缓冲区的指针
 \* @param WriteAddr: 写入数据的地址
 \* @param NumOfBlocks: 要写入的 SD 块数
 \* @retval SD 状态
 \*/
uint8\_t BSP\_SD\_WriteBlocks\_DMA(uint32\_t \*pData, uint32\_t WriteAddr,
		uint32\_t NumOfBlocks) {
	uint8\_t state = MSD_OK;

	/\* 使 dma tx 句柄无效\*/
	hsd.hdmarx = NULL;

	/\* 为写入操作准备 dma 通道 \*/
	state = ((SD\_DMAConfigTx(&hsd) == MSD_OK) ? MSD_OK : MSD_ERROR);

	if (state == MSD_OK) {
		/\* 在 DMA 传输模式下写入块 \*/
		state = (
				(HAL\_SD\_WriteBlocks\_DMA(&hsd, (uint8\_t\*) pData, WriteAddr,
						NumOfBlocks) == HAL_OK) ? MSD_OK : MSD_ERROR);
	}

	return state;
}

/\*\*
 \* @brief 擦除给定 SD 卡的指定内存区域
 \* @param StartAddr:起始字节地址
 \* @param EndAddr: 结束字节地址
 \* @retval SD 状态
 \*/
uint8\_t BSP\_SD\_Erase(uint32\_t StartAddr, uint32\_t EndAddr) {
	if (HAL\_SD\_Erase(&hsd, StartAddr, EndAddr) != HAL_OK) {
		return MSD_ERROR;
	} else {
		return MSD_OK;
	}
}

/\*\*
 \* @brief 获取当前 SD 卡数据状态
 \* @retval 数据传输状态
 \* 此值可以是以下值之一:
 \* @arg SD\_TRANSFER\_OK: 没有数据传输
 \* @arg SD\_TRANSFER\_BUSY: 正在数据传输
 \*/
uint8\_t BSP\_SD\_GetCardState(void) {
	return ((HAL\_SD\_GetCardState(&hsd) == HAL_SD_CARD_TRANSFER) ?
			SD_TRANSFER_OK : SD_TRANSFER_BUSY);
}

/\*\*
 \* @brief 获取有关特定 SD 卡的 SD 信息。
 \* @param CardInfo: 指向 HAL\_SD\_CardInfoTypedef 结构的指针
 \* @retval None
 \*/
void BSP\_SD\_GetCardInfo(HAL_SD_CardInfoTypeDef \*CardInfo) {
	/\*查询SD卡信息 \*/
	HAL\_SD\_GetCardInfo(&hsd, CardInfo);
}

/\*\*
 \* @brief 初始化SD卡MSP.
 \* @param Params : 附加配置参数的指针，可以为 NULL。
 \*/
__weak void BSP\_SD\_MspInit(void \*Params) {
	GPIO_InitTypeDef gpioinitstruct = { 0 };

	/\*启用 SDIO 时钟 \*/
	\_\_HAL\_RCC\_SDIO\_CLK\_ENABLE();

	/\*启用 DMA2 时钟 \*/
	\_\_DMAx\_TxRx\_CLK\_ENABLE()
	;

	/\* 启用 GPIO 时钟 \*/
	\_\_HAL\_RCC\_GPIOC\_CLK\_ENABLE();
	\_\_HAL\_RCC\_GPIOD\_CLK\_ENABLE();
	\_\_SD\_DETECT\_GPIO\_CLK\_ENABLE();

	/\* 通用 GPIO 配置 \*/
	gpioinitstruct.Mode = GPIO_MODE_AF_PP;
	gpioinitstruct.Pull = GPIO_PULLUP;
	gpioinitstruct.Speed = GPIO_SPEED_FREQ_HIGH;

	/\* GPIOC 配置 \*/
	gpioinitstruct.Pin = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11
			| GPIO_PIN_12;

	HAL\_GPIO\_Init(GPIOC, &gpioinitstruct);

	/\* GPIOD 配置 \*/
	gpioinitstruct.Pin = GPIO_PIN_2;
	HAL\_GPIO\_Init(GPIOD, &gpioinitstruct);

	/\* SD卡检测引脚配置 \*/
	gpioinitstruct.Mode = GPIO_MODE_INPUT;
	gpioinitstruct.Pull = GPIO_PULLUP;
	gpioinitstruct.Speed = GPIO_SPEED_FREQ_HIGH;
	gpioinitstruct.Pin = SD_DETECT_PIN;
	HAL\_GPIO\_Init(SD_DETECT_GPIO_PORT, &gpioinitstruct);

	/\* SDIO 中断的 NVIC 配置 \*/
	HAL\_NVIC\_SetPriority(SDIO_IRQn, 0xC, 0);
	HAL\_NVIC\_EnableIRQ(SDIO_IRQn);

	/\* DMA 初始化应该在这里完成，但是，因为只有一个通道用于 RX 和 TX，它在需要时直接配置和完成\*/
}

/\*\*
 \* @brief 配置DMA从SD卡接收数据
 \* @retval
 \* SD\_ERROR or SD\_OK
 \*/
uint8\_t SD\_DMAConfigRx(SD_HandleTypeDef \*hsd) {
	static DMA_HandleTypeDef hdma_rx;
	HAL_StatusTypeDef status = HAL_ERROR;

	if (hsd->hdmarx == NULL) {
		/\* 配置 DMA Rx 参数 \*/
		hdma_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
		hdma_rx.Init.PeriphInc = DMA_PINC_DISABLE;
		hdma_rx.Init.MemInc = DMA_MINC_ENABLE;
		hdma_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
		hdma_rx.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
		hdma_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH;

		hdma_rx.Instance = SD_DMAx_Rx_INSTANCE;

		/\* 关联 DMA 句柄 \*/
		\_\_HAL\_LINKDMA(hsd, hdmarx, hdma_rx);

		/\* 停止任何正在进行的传输并重置状态\*/
		HAL\_DMA\_Abort(&hdma_rx);

		/\* 取消初始化通道以进行新传输 \*/
		HAL\_DMA\_DeInit(&hdma_rx);

		/\* 配置 DMA 通道 \*/
		status = HAL\_DMA\_Init(&hdma_rx);

		/\* MA 传输完成中断的 NVIC 配置 \*/
		HAL\_NVIC\_SetPriority(SD_DMAx_Rx_IRQn, 0xD, 0);
		HAL\_NVIC\_EnableIRQ(SD_DMAx_Rx_IRQn);
	} else {
		status = HAL_OK;
	}

	return (status != HAL_OK ? MSD_ERROR : MSD_OK);
}

/\*\*
 \* @brief 该函数配置 DMA 将数据传输到 SD 卡
 \* @retval
 \* SD\_ERROR or SD\_OK
 \*/
uint8\_t SD\_DMAConfigTx(SD_HandleTypeDef \*hsd) {
	static DMA_HandleTypeDef hdma_tx;
	HAL_StatusTypeDef status;

	if (hsd->hdmatx == NULL) {
		/\* 配置 DMA Tx 参数s \*/
		hdma_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
		hdma_tx.Init.PeriphInc = DMA_PINC_DISABLE;
		hdma_tx.Init.MemInc = DMA_MINC_ENABLE;
		hdma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
		hdma_tx.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
		hdma_tx.Init.Priority = DMA_PRIORITY_VERY_HIGH;

		hdma_tx.Instance = SD_DMAx_Tx_INSTANCE;

		/\* 关联 DMA 句柄 \*/
		\_\_HAL\_LINKDMA(hsd, hdmatx, hdma_tx);

		/\*停止任何正在进行的传输并重置状态\*/
		HAL\_DMA\_Abort(&hdma_tx);

		/\* 取消初始化通道以进行新传输 \*/
		HAL\_DMA\_DeInit(&hdma_tx);

		/\* 配置 DMA 通道 \*/
		status = HAL\_DMA\_Init(&hdma_tx);

		/\* DMA 传输完成中断的 NVIC 配置 \*/
		HAL\_NVIC\_SetPriority(SD_DMAx_Tx_IRQn, 0xD, 0);
		HAL\_NVIC\_EnableIRQ(SD_DMAx_Tx_IRQn);
	} else {
		status = HAL_OK;
	}

	return (status != HAL_OK ? MSD_ERROR : MSD_OK);
}

/\*\*
 \* @brief SD 中止回调
 \* @param hsd: SD handle
 \* @retval None
 \*/
void HAL\_SD\_AbortCallback(SD_HandleTypeDef \*hsd) {
	BSP\_SD\_AbortCallback();
}

/\*\*
 \* @brief Tx 传输完成的回调
 \* @param hsd: SD handle
 \* @retval None
 \*/
void HAL\_SD\_TxCpltCallback(SD_HandleTypeDef \*hsd) {
	BSP\_SD\_WriteCpltCallback();
}

/\*\*
 \* @brief Rx 传输完成的回调
 \* @param hsd: SD handle
 \* @retval None
 \*/
void HAL\_SD\_RxCpltCallback(SD_HandleTypeDef \*hsd) {
	BSP\_SD\_ReadCpltCallback();
}

/\*\*
 \* @brief BSP SD 中止回调
 \* @retval None
 \*/
__weak void BSP\_SD\_AbortCallback(void) {

}

/\*\*
 \* @brief BSP Tx 传输完成回调
 \* @retval None
 \*/
__weak void BSP\_SD\_WriteCpltCallback(void) {

}

/\*\*
 \* @brief BSP Rx 传输完成回调
 \* @retval None
 \*/
__weak void BSP\_SD\_ReadCpltCallback(void) {

}


最后编译下载程序。

程序运行结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V2Jjone5-1652595379931)(images/28-6.png)]

(https://blog.csdn.net/wujuxKkoolerter/article/details/123176631)

5、STM32F1与STM32CubeIDE系列文章

5.1 STM32F1与STM32CubeIDE快速入门

5.2 STM32F1与STM32CubeIDE编程实例

文章来源: https://iotsmart.blog.csdn.net/article/details/124781784