【STM32】SD卡讀寫（五）-STM32CubeMX HAL庫SPI操作 SD卡帶FATFS

1、添加SD卡SPI模式驅動

1. /**
2. * @brief SPI1 Initialization Function
3. * @param None
4. * @retval None
5. */
6. static void MX_SPI1_Init(void)
7. {
9. /* USER CODE BEGIN SPI1_Init 0 */
10. /* USER CODE END SPI1_Init 0 */
12. /* USER CODE BEGIN SPI1_Init 1 */
14. /* USER CODE END SPI1_Init 1 */
15. /* SPI1 parameter configuration*/
16. hspi1.Instance = SPI1;
17. hspi1.Init.Mode = SPI_MODE_MASTER;
18. hspi1.Init.Direction = SPI_DIRECTION_2LINES;
19. hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
20. hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
21. hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
22. hspi1.Init.NSS = SPI_NSS_HARD_OUTPUT;
23. hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
24. hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
25. hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
26. hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
27. hspi1.Init.CRCPolynomial = 10;
28. if (HAL_SPI_Init(&hspi1) != HAL_OK)
29. {
30. Error_Handler();
31. }
32. /* USER CODE BEGIN SPI1_Init 2 */
33. /* USER CODE END SPI1_Init 2 */
35. }

編寫SD卡SPI驅動 SDCard.c

1. #include "main.h"
2. #include "SDCard.h"
6. /* USER CODE BEGIN 0 */
8. /* USER CODE END 0 */
10. /* USART1 init function */
11. /**************************************************************************/
12. #define Dummy_Byte 0xFF
14. /* 私有變量 ------------------------------------------------------------------*/
15. SPI_HandleTypeDef hspiflash;
18. extern SPI_HandleTypeDef hspi1;
19. u8 SD_Type=0;
20. /* function ------------------------------------------------------------------*/
21. /**
22. * 函數功能: 從串行Flash讀取一個字節數據
23. * 輸入參數: 無
24. * 返 回 值: uint8_t：讀取到的數據
25. * 說 明：This function must be used only if the Start_Read_Sequence
26. * function has been previously called.
27. */
28. uint8_t SPI_FLASH_ReadByte(void)
29. {
30. uint8_t d_read,d_send=Dummy_Byte;
31. if(HAL_SPI_TransmitReceive(&hspiflash,&d_send,&d_read,1,0xFFFFFF)!=HAL_OK)
32. d_read=Dummy_Byte;
34. return d_read;
35. }
39. void SPI_I2S_SendData(SPI_TypeDef* SPIx, u16 Data)
40. {
41. /* Check the parameters */
42. assert_param(IS_SPI_ALL_PERIPH(SPIx));
44. /* Write in the DR register the data to be sent */
45. SPIx->DR = Data;
46. }
48. u16 SPI_I2S_ReceiveData(SPI_TypeDef* SPIx)
49. {
50. /* Check the parameters */
51. assert_param(IS_SPI_ALL_PERIPH(SPIx));
53. //assert_param(IS_SPI_DIRECTION_2LINES_OR_1LINE(hspi->Init.Direction));
54. /* Return the data in the DR register */
55. return SPIx->DR;
56. }
58. /**
59. * 函數功能: 往串行Flash讀取寫入一個字節數據並接收一個字節數據
60. * 輸入參數: byte：待發送數據
61. * 返 回 值: uint8_t：接收到的數據
62. * 說 明：無
63. */
64. uint8_t SPI_FLASH_SendByte(uint8_t byte)
65. {
66. uint8_t d_read,d_send=byte;
67. // if(HAL_SPI_TransmitReceive(&hspiflash,&d_send,&d_read,1,0xFFFFFF)!=HAL_OK)
68. //{
69. //d_read=Dummy_Byte;
70. //}
71. //等待發送緩衝區空
72. // while(__HAL_SPI_GET_FLAG(&hspi1, SPI_FLAG_TXE));
73. //發一個字節
74. // SPI_I2S_SendData(SPI1, d_send);
75. HAL_SPI_Transmit(&hspi1,&d_send,1,1000);
76. //HAL_SPI_Receive(&hspi1,&d_read,1,1000);
77. //等待數據接收
78. while(__HAL_SPI_GET_FLAG(&hspi1, SPI_FLAG_RXNE));
79. //取數據
80. d_read = SPI_I2S_ReceiveData(SPI1);
82. return d_read;
83. }
85. /*******************************************************************************
86. * Function Name : SD_WaitReady
87. * Description : 等待SD卡Ready
88. * Input : None
89. * Output : None
90. * Return : u8
91. * 0： 成功
92. * other：失敗
93. *******************************************************************************/
94. u8 SD_WaitReady(void)
95. {
96. u8 r1;
97. u16 retry;
98. retry = 0;
99. do
100. {
101. r1 = SPI_FLASH_SendByte(0xFF);
102. if(retry==0xfffe)
103. {
104. return 1;
105. }
106. }while(r1!=0xFF);
108. return 0;
109. }
113. /*******************************************************************************
114. * Function Name : SD_SendCommand
115. * Description : 向SD卡發送一個命令
116. * Input : u8 cmd 命令
117. * u32 arg 命令參數
118. * u8 crc crc校驗值
119. * Output : None
120. * Return : u8 r1 SD卡返回的響應
121. *******************************************************************************/
122. u8 SD_SendCommand(u8 cmd, u32 arg, u8 crc)
123. {
124. unsigned char r1;
125. unsigned char Retry = 0;
127. //????????
128. SPI_FLASH_SendByte(0xff);
129. //片選端置低，選中SD卡
130. FLASH_SPI_CS_ENABLE();
132. //發送
133. SPI_FLASH_SendByte(cmd | 0x40); //分別寫入命令
134. SPI_FLASH_SendByte(arg >> 24);
135. SPI_FLASH_SendByte(arg >> 16);
136. SPI_FLASH_SendByte(arg >> 8);
137. SPI_FLASH_SendByte(arg);
138. SPI_FLASH_SendByte(crc);
140. //等待響應，或超時退出
141. while((r1 = SPI_FLASH_SendByte(0xFF))==0xFF)
142. {
143. Retry++;
144. if(Retry > 200)
145. {
146. break;
147. }
148. }
151. //關閉片選
152. FLASH_SPI_CS_DISABLE();
153. //在總線上額外增加8個時鐘，讓SD卡完成剩下的工作
154. SPI_FLASH_SendByte(0xFF);
156. //返回狀態值
157. return r1;
158. }
161. /*******************************************************************************
162. * Function Name : SD_SendCommand_NoDeassert
163. * Description : 向SD卡發送一個命令(結束是不失能片選，還有後續數據傳來）
164. * Input : u8 cmd 命令
165. * u32 arg 命令參數
166. * u8 crc crc校驗值
167. * Output : None
168. * Return : u8 r1 SD卡返回的響應
169. *******************************************************************************/
170. u8 SD_SendCommand_NoDeassert(u8 cmd, u32 arg, u8 crc)
171. {
172. unsigned char r1;
173. unsigned char Retry = 0;
175. //????????
176. SPI_FLASH_SendByte(0xff);
177. //片選端置低，選中SD卡
178. FLASH_SPI_CS_ENABLE();
180. //發送
181. SPI_FLASH_SendByte(cmd | 0x40); //分別寫入命令
182. SPI_FLASH_SendByte(arg >> 24);
183. SPI_FLASH_SendByte(arg >> 16);
184. SPI_FLASH_SendByte(arg >> 8);
185. SPI_FLASH_SendByte(arg);
186. SPI_FLASH_SendByte(crc);
188. //等待響應，或超時退出
189. while((r1 = SPI_FLASH_SendByte(0xFF))==0xFF)
190. {
191. Retry++;
192. if(Retry > 200)
193. {
194. break;
195. }
196. }
197. //返回響應值
198. return r1;
199. }
200. void SPI_SetSpeed(u8 SpeedSet)
201. {
202. hspi1.Instance = SPI1;
203. hspi1.Init.Mode = SPI_MODE_MASTER;
204. hspi1.Init.Direction = SPI_DIRECTION_2LINES;
205. hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
206. hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
207. hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
208. hspi1.Init.NSS = SPI_NSS_HARD_OUTPUT;
209. //如果速度設置輸入0，則低速模式，非0則高速模式
210. if(SpeedSet==SPI_SPEED_LOW)
211. {
212. hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
213. }
214. else
215. {
216. hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
217. }
218. hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
219. hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
220. hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
221. hspi1.Init.CRCPolynomial = 10;
222. if (HAL_SPI_Init(&hspi1) != HAL_OK)
223. {
224. Error_Handler();
225. }
227. // if(SpeedSet==SPI_SPEED_LOW)
228. //{
229. // hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
230. //}
231. //else
232. //{
233. //hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
234. //}
235. //HAL_SPI_Init(&hspi1);
238. //moon.mp3: 4707774 Byte size 目標文件 設為buffer[512]
239. //speed:實驗測試數據，最大速度 392314 Byte/S，
240. //Prescaler_128, 59592 Byte/S
241. //Prescaler_64, 104617 Byte/S
242. //Prescaler_32, 168134 Byte/S 162337 Byte/S
243. //Prescaler_16, 261543 Byte/S 247777 Byte/S
244. //Prescaler_8, 313851 Byte/S 336269 Byte/S
245. //Prescaler_4, 392314 Byte/S 392314 Byte/S
246. //Prescaler_2, 392314 Byte/S
247. }
248. /*******************************************************************************
249. * Function Name : SD_Init
250. * Description : 初始化SD卡
251. * Input : None
252. * Output : None
253. * Return : u8
254. * 0：NO_ERR
255. * 1：TIME_OUT
256. * 99：NO_CARD
257. *******************************************************************************/
258. u8 SD_Init(void)
259. {
260. u16 i; // 用來循環計數
261. u8 r1; // 存放SD卡的返回值
262. u16 retry; // 用來進行超時計數
263. u8 buff[6];
265. //如果沒有檢測到卡插入，直接退出，返回錯誤標誌
266. // if(!SD_DET())
267. // {
268. // //return 99;
269. // return STA_NODISK; // FatFS錯誤標誌：沒有插入磁盤
270. // }
272. //SD卡上電
273. //SD_PWR_ON();
274. // 純延時，等待SD卡上電完成
275. //for(i=0;i<0xf00;i++);
277. /*******************************************************
278. //這個地方要加一句,設置SPI速度為低速。
279. //為什麼有的卡可以呢？因為SPI初始化時是低速的，SD卡初始化
280. //完成後設置為高速，有的卡只要初始化一次就行，程序就ok；
281. //但有的卡需要多次復位，呵呵，這個地方差這一句，
282. //這種卡就用不成咯！
283. *******************************************************/
284. SPI_SetSpeed(0); //設置SPI速度為低速
286. //先產生>74個脈衝，讓SD卡自己初始化完成
287. for(i=0;i<100;i++)
288. {
289. SPI_FLASH_SendByte(0xFF);
290. }
292. //-----------------SD卡復位到idle開始-----------------
293. //循環連續發送CMD0，直到SD卡返回0x01,進入IDLE狀態
294. //超時則直接退出
295. retry = 0;
296. do
297. {
298. //發送CMD0，讓SD卡進入IDLE狀態
299. r1 = SD_SendCommand(CMD0, 0, 0x95);
300. retry++;
301. }while((r1 != 0x01) && (retry<200));
302. //跳出循環後，檢查原因：初始化成功？or 重試超時？
303. if(retry==200)
304. {
305. return 1; //超時返回1
306. }
307. //-----------------SD卡復位到idle結束-----------------
311. //獲取卡片的SD版本信息
312. r1 = SD_SendCommand_NoDeassert(8, 0x1aa, 0x87);
313. //如果卡片版本信息是v1.0版本的，即r1=0x05，則進行以下初始化
314. if(r1 == 0x05)
315. {
316. printf("\\r\\n SD卡版本信息:V1.0 \\r\\n");
317. //設置卡類型為SDV1.0，如果後面檢測到為MMC卡，再修改為MMC
318. SD_Type = SD_TYPE_V1;
320. //如果是V1.0卡，CMD8指令後沒有後續數據
321. //片選置高，結束本次命令
322. FLASH_SPI_CS_DISABLE();
323. //多發8個CLK，讓SD結束後續操作
324. SPI_FLASH_SendByte(0xFF);
326. //-----------------SD卡、MMC卡初始化開始-----------------
328. //髮卡初始化指令CMD55+ACMD41
329. // 如果有應答，說明是SD卡，且初始化完成
330. // 沒有回應，說明是MMC卡，額外進行相應初始化
331. retry = 0;
332. do
333. {
334. //先發CMD55，應返回0x01；否則出錯
335. r1 = SD_SendCommand(CMD55, 0, 0);
336. if(r1 != 0x01)
337. {
338. return r1;
339. }
340. //得到正確響應後，發ACMD41，應得到返回值0x00，否則重試200次
341. r1 = SD_SendCommand(ACMD41, 0, 0);
342. retry++;
343. }while((r1!=0x00) && (retry<400));
344. // 判斷是超時還是得到正確回應
345. // 若有回應：是SD卡；沒有回應：是MMC卡
347. //----------MMC卡額外初始化操作開始------------
348. if(retry==400)
349. {
350. printf("\\r\\n SD卡信息: MMC卡 \\r\\n");
351. retry = 0;
352. //發送MMC卡初始化命令（沒有測試）
353. do
354. {
355. r1 = SD_SendCommand(1, 0, 0);
356. retry++;
357. }while((r1!=0x00)&& (retry<400));
358. if(retry==400)
359. {
360. return 1; //MMC卡初始化超時
361. }
362. //寫入卡類型
363. SD_Type = SD_TYPE_MMC;
364. }
365. else
366. {
367. printf("\\r\\n SD卡信息: SD卡 \\r\\n");
368. }
369. //----------MMC卡額外初始化操作結束------------
371. //設置SPI為高速模式
372. SPI_SetSpeed(1);
374. SPI_FLASH_SendByte(0xFF);
376. //禁止CRC校驗
377. /*
378. r1 = SD_SendCommand(CMD59, 0, 0x01);
379. if(r1 != 0x00)
380. {
381. return r1; //命令錯誤，返回r1
382. }
383. */
384. //設置Sector Size
385. r1 = SD_SendCommand(CMD16, 512, 0xff);
386. if(r1 != 0x00)
387. {
388. return r1; //命令錯誤，返回r1
389. }
390. //-----------------SD卡、MMC卡初始化結束-----------------
392. }//SD卡為V1.0版本的初始化結束
395. //下面是V2.0卡的初始化
396. //其中需要讀取OCR數據，判斷是SD2.0還是SD2.0HC卡
397. else if(r1 == 0x01)
398. {
399. printf("\\r\\n SD卡版本信息:V2.0 \\r\\n");
400. //V2.0的卡，CMD8命令後會傳回4字節的數據，要跳過再結束本命令
401. buff[0] = SPI_FLASH_SendByte(0xFF); //should be 0x00
402. buff[1] = SPI_FLASH_SendByte(0xFF); //should be 0x00
403. buff[2] = SPI_FLASH_SendByte(0xFF); //should be 0x01
404. buff[3] = SPI_FLASH_SendByte(0xFF); //should be 0xAA
406. FLASH_SPI_CS_DISABLE();
407. //the next 8 clocks
408. SPI_FLASH_SendByte(0xFF);
410. //判斷該卡是否支持2.7V-3.6V的電壓範圍
411. if(buff[2]==0x01 && buff[3]==0xAA)
412. {
413. //支持電壓範圍，可以操作
414. retry = 0;
415. //髮卡初始化指令CMD55+ACMD41
416. do
417. {
418. r1 = SD_SendCommand(CMD55, 0, 0);
419. if(r1!=0x01)
420. {
421. return r1;
422. }
423. r1 = SD_SendCommand(ACMD41, 0x40000000, 0);
424. if(retry>200)
425. {
426. return r1; //超時則返回r1狀態
427. }
428. }while(r1!=0);
430. //初始化指令發送完成，接下來獲取OCR信息
432. //-----------鑑別SD2.0卡版本開始-----------
433. r1 = SD_SendCommand_NoDeassert(CMD58, 0, 0);
434. if(r1!=0x00)
435. {
436. return r1; //如果命令沒有返回正確應答，直接退出，返回應答
437. }
438. //讀OCR指令發出後，緊接著是4字節的OCR信息
439. buff[0] = SPI_FLASH_SendByte(0xFF);
440. buff[1] = SPI_FLASH_SendByte(0xFF);
441. buff[2] = SPI_FLASH_SendByte(0xFF);
442. buff[3] = SPI_FLASH_SendByte(0xFF);
444. //OCR接收完成，片選置高
445. FLASH_SPI_CS_DISABLE();
446. SPI_FLASH_SendByte(0xFF);
448. //檢查接收到的OCR中的bit30位（CCS），確定其為SD2.0還是SDHC
449. //如果CCS=1：SDHC CCS=0：SD2.0
450. if(buff[0]&0x40) //檢查CCS
451. {
452. SD_Type = SD_TYPE_V2HC;
453. printf("\\r\\n SD卡信息: SDHC \\r\\n");
454. }
455. else
456. {
457. SD_Type = SD_TYPE_V2;
458. printf("\\r\\n SD卡信息: SD2.0 \\r\\n");
459. }
460. //-----------鑑別SD2.0卡版本結束-----------
463. //設置SPI為高速模式
464. SPI_SetSpeed(1);
465. }
467. }
468. return r1;
469. }
473. /*******************************************************************************
474. * Function Name : SD_ReceiveData
475. * Description : 從SD卡中讀回指定長度的數據，放置在給定位置
476. * Input : u8 *data(存放讀回數據的內存>len)
477. * u16 len(數據長度）
478. * u8 release(傳輸完成後是否釋放總線CS置高 0：不釋放 1：釋放）
479. * Output : None
480. * Return : u8
481. * 0：NO_ERR
482. * other：錯誤信息
483. *******************************************************************************/
484. u8 SD_ReceiveData(u8 *data, u16 len, u8 release)
485. {
486. u16 retry;
487. u8 r1;
489. // 啟動一次傳輸
490. FLASH_SPI_CS_ENABLE();
491. //等待SD卡發回數據起始令牌0xFE
492. retry = 0;
493. do
494. {
495. r1 = SPI_FLASH_SendByte(0xFF);
496. retry++;
497. if(retry>2000) //2000次等待後沒有應答，退出報錯
498. {
499. FLASH_SPI_CS_DISABLE();
500. return 1;
501. }
502. }while(r1 != 0xFE);
503. //開始接收數據
504. while(len--)
505. {
506. *data = SPI_FLASH_SendByte(0xFF);
507. data++;
508. }
509. //下面是2個偽CRC（dummy CRC）
510. SPI_FLASH_SendByte(0xFF);
511. SPI_FLASH_SendByte(0xFF);
512. //按需釋放總線，將CS置高
513. if(release == RELEASE)
514. {
515. //傳輸結束
516. FLASH_SPI_CS_DISABLE();
517. SPI_FLASH_SendByte(0xFF);
518. }
520. return 0;
521. }
524. /*******************************************************************************
525. * Function Name : SD_GetCID
526. * Description : 獲取SD卡的CID信息，包括製造商信息
527. * Input : u8 *cid_data(存放CID的內存，至少16Byte）
528. * Output : None
529. * Return : u8
530. * 0：NO_ERR
531. * 1：TIME_OUT
532. * other：錯誤信息
533. *******************************************************************************/
534. u8 SD_GetCID(u8 *cid_data)
535. {
536. u8 r1;
538. //發CMD10命令，讀CID
539. r1 = SD_SendCommand(CMD10, 0, 0xFF);
540. if(r1 != 0x00)
541. {
542. return r1; //沒返回正確應答，則退出，報錯
543. }
544. //接收16個字節的數據
545. SD_ReceiveData(cid_data, 16, RELEASE);
547. return 0;
548. }
551. /*******************************************************************************
552. * Function Name : SD_GetCSD
553. * Description : 獲取SD卡的CSD信息，包括容量和速度信息
554. * Input : u8 *cid_data(存放CID的內存，至少16Byte）
555. * Output : None
556. * Return : u8
557. * 0：NO_ERR
558. * 1：TIME_OUT
559. * other：錯誤信息
560. *******************************************************************************/
561. u8 SD_GetCSD(u8 *csd_data)
562. {
563. u8 r1;
565. //發CMD9命令，讀CSD
566. r1 = SD_SendCommand(CMD9, 0, 0xFF);
567. if(r1 != 0x00)
568. {
569. return r1; //沒返回正確應答，則退出，報錯
570. }
571. //接收16個字節的數據
572. SD_ReceiveData(csd_data, 16, RELEASE);
574. return 0;
575. }
578. /*******************************************************************************
579. * Function Name : SD_GetCapacity
580. * Description : 獲取SD卡的容量
581. * Input : None
582. * Output : None
583. * Return : u32 capacity
584. * 0： 取容量出錯
585. *******************************************************************************/
586. u32 SD_GetCapacity(void)
587. {
588. u8 csd[16];
589. u32 Capacity;
590. u8 r1;
591. u16 i;
592. u16 temp;
594. //取CSD信息，如果期間出錯，返回0
595. if(SD_GetCSD(csd)!=0)
596. {
597. return 0;
598. }
600. //如果為SDHC卡，按照下面方式計算
601. if((csd[0]&0xC0)==0x40)
602. {
603. Capacity = ((((u32)csd[8])<<8) + (u32)csd[9] + 1)*(u32)1024;
604. }
605. else
606. {
607. //下面代碼為網上版本
608. ////////////formula of the capacity///////////////
609. //
610. // memory capacity = BLOCKNR * BLOCK_LEN
611. //
612. //BLOCKNR = (C_SIZE + 1)* MULT
613. //
614. // C_SIZE_MULT+2
615. //MULT = 2
616. //
617. // READ_BL_LEN
618. //BLOCK_LEN = 2
619. /**********************************************/
620. //C_SIZE
621. i = csd[6]&0x03;
622. i<<=8;
623. i += csd[7];
624. i<<=2;
625. i += ((csd[8]&0xc0)>>6);
627. //C_SIZE_MULT
628. r1 = csd[9]&0x03;
629. r1<<=1;
630. r1 += ((csd[10]&0x80)>>7);
632. //BLOCKNR
633. r1+=2;
634. temp = 1;
635. while(r1)
636. {
637. temp*=2;
638. r1--;
639. }
640. Capacity = ((u32)(i+1))*((u32)temp);
642. // READ_BL_LEN
643. i = csd[5]&0x0f;
644. //BLOCK_LEN
645. temp = 1;
646. while(i)
647. {
648. temp*=2;
649. i--;
650. }
651. //The final result
652. Capacity *= (u32)temp;
653. //Capacity /= 512;
654. }
655. return (u32)Capacity;
656. }
659. /*******************************************************************************
660. * Function Name : SD_ReadSingleBlock
661. * Description : 讀SD卡的一個block
662. * Input : u32 sector 取地址（sector值，非物理地址）
663. * u8 *buffer 數據存儲地址（大小至少512byte）
664. * Output : None
665. * Return : u8 r1
666. * 0： 成功
667. * other：失敗
668. *******************************************************************************/
669. u8 SD_ReadSingleBlock(u32 sector, u8 *buffer)
670. {
671. u8 r1;
673. //設置為高速模式
674. SPI_SetSpeed(SPI_SPEED_HIGH);
676. //如果不是SDHC，將sector地址轉成byte地址
677. //sector = sector<<9;
679. r1 = SD_SendCommand(CMD17, sector, 0);//讀命令
681. if(r1 != 0x00)
682. {
683. return r1;
684. }
686. r1 = SD_ReceiveData(buffer, 512, RELEASE);
687. if(r1 != 0)
688. {
689. return r1; //讀數據出錯！
690. }
691. else
692. {
693. return 0;
694. }
695. }
697. /*******************************************************************************
698. * Function Name : SD_WriteSingleBlock
699. * Description : 寫入SD卡的一個block
700. * Input : u32 sector 扇區地址（sector值，非物理地址）
701. * u8 *buffer 數據存儲地址（大小至少512byte）
702. * Output : None
703. * Return : u8 r1
704. * 0： 成功
705. * other：失敗
706. *******************************************************************************/
707. u8 SD_WriteSingleBlock(u32 sector, const u8 *data)
708. {
709. u8 r1;
710. u16 i;
711. u16 retry;
713. //設置為高速模式
714. SPI_SetSpeed(SPI_SPEED_HIGH);
716. //如果不是SDHC，給定的是sector地址，將其轉換成byte地址
717. // if(SD_Type!=SD_TYPE_V2HC)
718. // {
719. // sector = sector<<9;
720. // }
722. r1 = SD_SendCommand(CMD24, sector, 0x00);
723. if(r1 != 0x00)
724. {
725. return r1; //應答不正確，直接返回
726. }
728. //開始準備數據傳輸
729. FLASH_SPI_CS_ENABLE();
730. //先放3個空數據，等待SD卡準備好
731. SPI_FLASH_SendByte(0xff);
732. SPI_FLASH_SendByte(0xff);
733. SPI_FLASH_SendByte(0xff);
734. //放起始令牌0xFE
735. SPI_FLASH_SendByte(0xFE);
737. //放一個sector的數據
738. for(i=0;i<512;i++)
739. {
740. SPI_FLASH_SendByte(*data++);
741. }
742. //發2個Byte的dummy CRC
743. SPI_FLASH_SendByte(0xff);
744. SPI_FLASH_SendByte(0xff);
746. //等待SD卡應答
747. r1 = SPI_FLASH_SendByte(0xff);
748. if((r1&0x1F)!=0x05)
749. {
750. FLASH_SPI_CS_DISABLE();
751. return r1;
752. }
754. //等待操作完成
755. retry = 0;
756. while(!SPI_FLASH_SendByte(0xff))
757. {
758. retry++;
759. if(retry>0xfffe) //如果長時間寫入沒有完成，報錯退出
760. {
761. FLASH_SPI_CS_DISABLE();
762. return 1; //寫入超時返回1
763. }
764. }
766. //寫入完成，片選置1
767. FLASH_SPI_CS_DISABLE();
768. SPI_FLASH_SendByte(0xff);
770. return 0;
771. }
774. /*******************************************************************************
775. * Function Name : SD_ReadMultiBlock
776. * Description : 讀SD卡的多個block
777. * Input : u32 sector 取地址（sector值，非物理地址）
778. * u8 *buffer 數據存儲地址（大小至少512byte）
779. * u8 count 連續讀count個block
780. * Output : None
781. * Return : u8 r1
782. * 0： 成功
783. * other：失敗
784. *******************************************************************************/
785. u8 SD_ReadMultiBlock(u32 sector, u8 *buffer, u8 count)
786. {
787. u8 r1;
789. //設置為高速模式
790. SPI_SetSpeed(SPI_SPEED_HIGH);
792. //如果不是SDHC，將sector地址轉成byte地址
793. // sector = sector<<9;
794. //SD_WaitReady();
795. //發讀多塊命令
796. r1 = SD_SendCommand(CMD18, sector, 0);//讀命令
797. if(r1 != 0x00)
798. {
799. return r1;
800. }
801. //開始接收數據
802. do
803. {
804. if(SD_ReceiveData(buffer, 512, NO_RELEASE) != 0x00)
805. {
806. break;
807. }
808. buffer += 512;
809. } while(--count);
811. //全部傳輸完畢，發送停止命令
812. SD_SendCommand(CMD12, 0, 0);
813. //釋放總線
814. FLASH_SPI_CS_DISABLE();
815. SPI_FLASH_SendByte(0xFF);
817. if(count != 0)
818. {
819. return count; //如果沒有傳完，返回剩餘個數
820. }
821. else
822. {
823. return 0;
824. }
825. }
828. /*******************************************************************************
829. * Function Name : SD_WriteMultiBlock
830. * Description : 寫入SD卡的N個block
831. * Input : u32 sector 扇區地址（sector值，非物理地址）
832. * u8 *buffer 數據存儲地址（大小至少512byte）
833. * u8 count 寫入的block數目
834. * Output : None
835. * Return : u8 r1
836. * 0： 成功
837. * other：失敗
838. *******************************************************************************/
839. u8 SD_WriteMultiBlock(u32 sector, const u8 *data, u8 count)
840. {
841. u8 r1;
842. u16 i;
844. //設置為高速模式
845. SPI_SetSpeed(SPI_SPEED_HIGH);
847. //如果不是SDHC，給定的是sector地址，將其轉換成byte地址
848. // if(SD_Type != SD_TYPE_V2HC)
849. // {
850. // sector = sector<<9;
851. // }
852. //如果目標卡不是MMC卡，啟用ACMD23指令使能預擦除
853. if(SD_Type != SD_TYPE_MMC)
854. {
855. r1 = SD_SendCommand(ACMD23, count, 0x00);
856. }
857. //發多塊寫入指令
858. r1 = SD_SendCommand(CMD25, sector, 0x00);
859. if(r1 != 0x00)
860. {
861. return r1; //應答不正確，直接返回
862. }
864. //開始準備數據傳輸
865. FLASH_SPI_CS_ENABLE();
866. //先放3個空數據，等待SD卡準備好
867. SPI_FLASH_SendByte(0xff);
868. SPI_FLASH_SendByte(0xff);
870. //--------下面是N個sector寫入的循環部分
871. do
872. {
873. //放起始令牌0xFC 表明是多塊寫入
874. SPI_FLASH_SendByte(0xFC);
876. //放一個sector的數據
877. for(i=0;i<512;i++)
878. {
879. SPI_FLASH_SendByte(*data++);
880. }
881. //發2個Byte的dummy CRC
882. SPI_FLASH_SendByte(0xff);
883. SPI_FLASH_SendByte(0xff);
885. //等待SD卡應答
886. r1 = SPI_FLASH_SendByte(0xff);
887. if((r1&0x1F)!=0x05)
888. {
889. FLASH_SPI_CS_DISABLE(); //如果應答為報錯，則帶錯誤代碼直接退出
890. return r1;
891. }
893. //等待SD卡寫入完成
894. if(SD_WaitReady()==1)
895. {
896. FLASH_SPI_CS_DISABLE(); //等待SD卡寫入完成超時，直接退出報錯
897. return 1;
898. }
900. //本sector數據傳輸完成
901. }while(--count);
903. //髮結束傳輸令牌0xFD
904. r1 = SPI_FLASH_SendByte(0xFD);
905. if(r1==0x00)
906. {
907. count = 0xfe;
908. }
910. if(SD_WaitReady())
911. {
912. while(1)
913. {
914. }
915. }
917. //寫入完成，片選置1
918. FLASH_SPI_CS_DISABLE();
919. SPI_FLASH_SendByte(0xff);
921. return count; //返回count值，如果寫完則count=0，否則count=1
922. }
926. /* USER CODE END 1 */

SDCard.h 根據YS-F1Pro SPI Flash 改寫 SD

1. /* Define to prevent recursive inclusion -------------------------------------*/
2. #ifndef __SDCard_H
3. #define __SDCard_H
4. #ifdef __cplusplus
5. extern "C" {
6. #endif
8. /* Includes ------------------------------------------------------------------*/
9. #include "main.h"
11. /* USER CODE BEGIN Includes */
12. /* 包含頭文件 ----------------------------------------------------------------*/
13. #include "stm32f1xx_hal.h"
14. /* USER CODE END Includes */
17. /* 類型定義 ------------------------------------------------------------------*/
18. /* 宏定義 --------------------------------------------------------------------*/
19. //#define SPI_FLASH_ID 0xEF3015 //W25X16 2MB
20. //#define SPI_FLASH_ID 0xEF4015 //W25Q16 4MB
21. //#define SPI_FLASH_ID 0XEF4017 //W25Q64 8MB
22. #define SPI_FLASH_ID 0XEF4018 //W25Q128 16MB YS-F1Pro開發默認使用
24. #define FLASH_SPIx SPI1
25. #define FLASH_SPIx_RCC_CLK_ENABLE() __HAL_RCC_SPI1_CLK_ENABLE()
26. #define FLASH_SPIx_RCC_CLK_DISABLE() __HAL_RCC_SPI1_CLK_DISABLE()
28. #define FLASH_SPI_GPIO_ClK_ENABLE() __HAL_RCC_GPIOA_CLK_ENABLE()
29. #define FLASH_SPI_GPIO_PORT GPIOA
30. #define FLASH_SPI_SCK_PIN GPIO_PIN_5
31. #define FLASH_SPI_MISO_PIN GPIO_PIN_6
32. #define FLASH_SPI_MOSI_PIN GPIO_PIN_7
34. #define FLASH_SPI_CS_CLK_ENABLE() __HAL_RCC_GPIOA_CLK_ENABLE()
35. #define FLASH_SPI_CS_PORT GPIOA
36. #define FLASH_SPI_CS_PIN GPIO_PIN_4
38. #define FLASH_SPI_CS_ENABLE() HAL_GPIO_WritePin(FLASH_SPI_CS_PORT, FLASH_SPI_CS_PIN, GPIO_PIN_RESET)
39. #define FLASH_SPI_CS_DISABLE() HAL_GPIO_WritePin(FLASH_SPI_CS_PORT, FLASH_SPI_CS_PIN, GPIO_PIN_SET)
41. /* 擴展變量 ------------------------------------------------------------------*/
42. extern SPI_HandleTypeDef hspiflash;
44. /* 函數聲明 ------------------------------------------------------------------*/
47. /* USER CODE BEGIN Private defines */
49. /* USER CODE END Private defines */
50. #define u8 uint8_t
51. #define u16 uint16_t
52. #define u32 uint32_t
55. /* Private define ------------------------------------------------------------*/
56. /* SD卡類型定義 */
57. #define SD_TYPE_MMC 0
58. #define SD_TYPE_V1 1
59. #define SD_TYPE_V2 2
60. #define SD_TYPE_V2HC 4
62. /* SPI總線速度設置*/
63. #define SPI_SPEED_LOW 0
64. #define SPI_SPEED_HIGH 1
66. /* SD傳輸數據結束後是否釋放總線宏定義 */
67. #define NO_RELEASE 0
68. #define RELEASE 1
70. /* SD卡指令表 */
71. #define CMD0 0 //卡復位
72. #define CMD9 9 //命令9 ，讀CSD數據
73. #define CMD10 10 //命令10，讀CID數據
74. #define CMD12 12 //命令12，停止數據傳輸
75. #define CMD16 16 //命令16，設置SectorSize 應返回0x00
76. #define CMD17 17 //命令17，讀sector
77. #define CMD18 18 //命令18，讀Multi sector
78. #define ACMD23 23 //命令23，設置多sector寫入前預先擦除N個block
79. #define CMD24 24 //命令24，寫sector
80. #define CMD25 25 //命令25，寫Multi sector
81. #define ACMD41 41 //命令41，應返回0x00
82. #define CMD55 55 //命令55，應返回0x01
83. #define CMD58 58 //命令58，讀OCR信息
84. #define CMD59 59 //命令59，使能/禁止CRC，應返回0x00
89. /* Private macro -------------------------------------------------------------*/
90. //SD卡CS片選使能端操作：
91. #define SD_CS_ENABLE() GPIO_ResetBits(GPIOA,GPIO_PIN_4) //選中SD卡
92. #define SD_CS_DISABLE() GPIO_SetBits(GPIOA,GPIO_PIN_4) //不選中SD卡
93. //#define SD_PWR_ON() GPIO_ResetBits(GPIOD,GPIO_Pin_10) //SD卡上電
94. //#define SD_PWR_OFF() GPIO_SetBits(GPIOD,GPIO_Pin_10) //SD卡斷電
95. //#define SD_DET() !GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_2) //檢測有卡
96. //1-有 0-無
98. /* Private function prototypes -----------------------------------------------*/
99. void SPI_Configuration(void);
100. void SPI_SetSpeed(u8 SpeedSet);
102. u8 SPI_ReadWriteByte(u8 TxData); //SPI總線讀寫一個字節
103. u8 SD_WaitReady(void); //等待SD卡就緒
104. u8 SD_SendCommand(u8 cmd, u32 arg, u8 crc); //SD卡發送一個命令
105. u8 SD_SendCommand_NoDeassert(u8 cmd, u32 arg, u8 crc);
106. u8 SD_Init(void); //SD卡初始化
107. //
108. u8 SD_ReceiveData(u8 *data, u16 len, u8 release);//SD卡讀數據
109. u8 SD_GetCID(u8 *cid_data); //讀SD卡CID
110. u8 SD_GetCSD(u8 *csd_data); //讀SD卡CSD
111. u32 SD_GetCapacity(void); //取SD卡容量
113. u8 SD_ReadSingleBlock(u32 sector, u8 *buffer); //讀一個sector
114. u8 SD_WriteSingleBlock(u32 sector, const u8 *buffer); //寫一個sector
115. u8 SD_ReadMultiBlock(u32 sector, u8 *buffer, u8 count); //讀多個sector
116. u8 SD_WriteMultiBlock(u32 sector, const u8 *data, u8 count); //寫多個sector
117. /* USER CODE BEGIN Prototypes */
119. extern u8 SD_Init(void);
121. /* USER CODE END Prototypes */
123. #ifdef __cplusplus
124. }
125. #endif
126. #endif /*__ usart_H */

2、添加FATFS文件系統

3、修改FATFS文件系統SD卡驅動部分sdcard_diskio.c

1. /* 包含頭文件 ----------------------------------------------------------------*/
2. #include "main.h"
3. #include <string.h>
4. #include "SDCard.h"
5. #include "ff_gen_drv.h"
7. /* 私有類型定義 --------------------------------------------------------------*/
8. /* 私有宏定義 ----------------------------------------------------------------*/
9. #define BLOCK_SIZE 512
11. /* 私有變量 ------------------------------------------------------------------*/
12. static volatile DSTATUS Stat = STA_NOINIT;
15. /* 擴展變量 ------------------------------------------------------------------*/
16. /* 私有函數原形 --------------------------------------------------------------*/
17. DSTATUS SD_initialize (BYTE);
18. DSTATUS SD_status (BYTE);
19. DRESULT SD_read (BYTE, BYTE*, DWORD, UINT);
21. #if _USE_WRITE == 1 // 如果允許寫操作
22. DRESULT SD_write (BYTE, const BYTE*, DWORD, UINT);
23. #endif /* _USE_WRITE == 1 */
25. #if _USE_IOCTL == 1 // 如果輸入輸出操作控制
26. DRESULT SD_ioctl (BYTE, BYTE, void*);
27. #endif /* _USE_IOCTL == 1 */
29. /* 定義SD卡接口函數 */
30. const Diskio_drvTypeDef SD_Driver =
31. {
32. SD_initialize, // SD卡初始化
33. SD_status, // SD卡狀態獲取
34. SD_read, // SD卡讀數據
35. #if _USE_WRITE == 1
36. SD_write, // SD卡寫數據
37. #endif /* _USE_WRITE == 1 */
39. #if _USE_IOCTL == 1
40. SD_ioctl, // 獲取SD卡信息
41. #endif /* _USE_IOCTL == 1 */
42. };
45. /* 函數體 --------------------------------------------------------------------*/
46. /**
47. * 函數功能: SD卡初始化配置
48. * 輸入參數: 無
49. * 返 回 值: 無
50. * 說 明: 無
51. */
53. //extern void MX_SPI1_Init(void);
54. DSTATUS SD_initialize(BYTE lun)
55. {
56. Stat = STA_NOINIT;
57. /* 初始化SDIO外設 */
58. // MX_SPI1_Init();
59. /* 獲取SD卡狀態 */
60. int result;
61. result = SD_Init();
62. // if(HAL_SD_GetStatus(&hsdcard)==SD_TRANSFER_OK)
63. // {
64. // Stat &= ~STA_NOINIT;
65. // }
67. if (result == 0)
68. {
69. Stat = RES_OK;
70. }
71. else
72. {
73. Stat = RES_ERROR;
74. }
76. return Stat;
77. }
79. /**
80. * 函數功能: SD卡狀態獲取
81. * 輸入參數: lun : 不用
82. * 返 回 值: DSTATUS：SD卡狀態返回值
83. * 說 明: 無
84. */
85. DSTATUS SD_status(BYTE lun)
86. {
87. Stat = STA_NOINIT;
89. // if(HAL_SD_GetStatus(&hsdcard) == SD_TRANSFER_OK)
90. // {
91. // Stat &= ~STA_NOINIT;
92. // }
93. Stat = RES_OK;
94. return Stat;
95. }
97. /**
98. * 函數功能: 從SD卡讀取數據到緩衝區
99. * 輸入參數: lun : 不用
100. * buff：存放讀取到數據緩衝區指針
101. * sector：扇區地址(LBA)
102. * count：扇區數目
103. * 返 回 值: DSTATUS：操作結果
104. * 說 明: SD卡讀操作使用DMA傳輸
105. */
106. DRESULT SD_read(BYTE lun, BYTE *buff, DWORD sector, UINT count)
107. {
108. DRESULT res = RES_OK;
109. // if((DWORD)buff&3)
110. // {
111. // DWORD scratch[BLOCK_SIZE/4];
112. // while (count--)
113. // {
114. // res = SD_read(lun,(void *)scratch, sector++, 1);
115. // if (res != RES_OK)
116. // {
117. // break;
118. // }
119. // memcpy(buff, scratch, BLOCK_SIZE);
120. // buff += BLOCK_SIZE;
121. // }
122. // return res;
123. // }
124. //
125. // if(HAL_SD_ReadBlocks_DMA(&hsdcard,(uint32_t*)buff,(uint64_t)(sector * BLOCK_SIZE),BLOCK_SIZE,count) != SD_OK)
126. // {
127. // res = RES_ERROR;
128. // }
129. // if(res==RES_OK)
130. // {
131. // if(HAL_SD_CheckReadOperation(&hsdcard, 0xFFFFFFFF) != SD_OK)
132. // {
133. // res = RES_ERROR;
134. // }
135. // }
136. int result;
137. if(count==1)
138. {
139. result=SD_ReadSingleBlock(sector,buff);
140. }
141. else
142. {
143. result = SD_ReadMultiBlock(sector, buff, count);
144. }
145. if (result == 0)
146. {
147. res = RES_OK;
148. }
149. else
150. {
151. res = RES_ERROR;
152. }
153. return res;
154. }
156. /**
157. * 函數功能: 將緩衝區數據寫入到SD卡內
158. * 輸入參數: lun : 不用
159. * buff：存放待寫入數據的緩衝區指針
160. * sector：扇區地址(LBA)
161. * count：扇區數目
162. * 返 回 值: DSTATUS：操作結果
163. * 說 明: SD卡寫操作沒有使用DMA傳輸
164. */
165. #if _USE_WRITE == 1
166. DRESULT SD_write(BYTE lun, const BYTE *buff, DWORD sector, UINT count)
167. {
168. DRESULT res = RES_OK;
169. // if((DWORD)buff&3)
170. // {
171. // DRESULT res = RES_OK;
172. // DWORD scratch[BLOCK_SIZE / 4];
174. // while (count--)
175. // {
176. // memcpy( scratch,buff,BLOCK_SIZE);
177. // res = SD_write(lun,(void *)scratch, sector++, 1);
178. // if (res != RES_OK)
179. // {
180. // break;
181. // }
182. // buff += BLOCK_SIZE;
183. // }
184. // return res;
185. // }
186. //
187. // if(HAL_SD_WriteBlocks(&hsdcard,(uint32_t*)buff,(uint64_t)(sector * BLOCK_SIZE),BLOCK_SIZE, count) != SD_OK)
188. // {
189. // res = RES_ERROR;
190. // }
191. int result;
192. if(count==1)
193. {
194. result=SD_WriteSingleBlock(sector, buff);
195. }
196. else
197. {
198. result = SD_WriteMultiBlock(sector, buff, count);
199. }
200. if (result == 0)
201. {
202. res = RES_OK;
203. }
204. else
205. {
206. res = RES_ERROR;
207. }
208. return res;
209. }
210. #endif /* _USE_WRITE == 1 */
212. /**
213. * 函數功能: 輸入輸出控制操作(I/O control operation)
214. * 輸入參數: lun : 不用
215. * cmd：控制命令
216. * buff：存放待寫入或者讀取數據的緩衝區指針
217. * 返 回 值: DSTATUS：操作結果
218. * 說 明: 無
219. */
220. #if _USE_IOCTL == 1
221. DRESULT SD_ioctl(BYTE lun, BYTE cmd, void *buff)
222. {
223. DRESULT res = RES_ERROR;
225. // if (Stat & STA_NOINIT) return RES_NOTRDY;
226. //
227. // switch (cmd)
228. // {
229. // /* Make sure that no pending write process */
230. // case CTRL_SYNC :
231. //FLASH_SPI_CS_ENABLE();
232. //if(SD_WaitReady()==0)
233. //{
234. //res = RES_OK;
235. //}
236. //else
237. //{
238. //res = RES_ERROR;
239. //}
240. ////FLASH_SPI_CSDISABLE();
241. // break;
242. //
243. // /* 獲取SD卡總扇區數目(DWORD) */
244. // case GET_SECTOR_COUNT :
245. //*(WORD*)buff = 512;
246. //res = RES_OK;
247. // break;
248. //
249. // /* 獲取讀寫扇區大小(WORD) */
250. // case GET_SECTOR_SIZE :
251. //*(DWORD*)buff = SD_GetCapacity();
252. //res = RES_OK;
253. // break;
254. //
255. // /* 獲取擦除塊大小(DWORD) */
256. // case GET_BLOCK_SIZE :
257. // *(DWORD*)buff = BLOCK_SIZE;
258. // break;
259. //
260. // default:
261. // res = RES_PARERR;
262. // }
264. uint8_t CSD[16] = {0};
265. uint8_t csddata[16] = {0};
266. uint32_t csize;
267. uint32_t Capacity;
268. switch (cmd)
269. {
270. case CTRL_SYNC:
271. res = RES_OK;
272. break;
273. case GET_SECTOR_COUNT:
274. SD_GetCID(CSD);
275. SD_GetCSD(csddata);
276. //SDGetCIDCSD(CSD, csddata);
277. csize = csddata[9] + ((uint32_t)csddata[8] << 8) + ((uint32_t)(csddata[7] & 0x3f) << 16) + 1;
278. Capacity = csize << 9;
279. *((DWORD *)buff) = Capacity;
280. res = RES_OK;
281. break;
282. case GET_SECTOR_SIZE:
283. *(WORD *)buff = 512; //spi flash的扇區大小是 512 Bytes
284. return RES_OK;
285. case GET_BLOCK_SIZE:
286. *((DWORD *)buff) = 4096;
287. res = RES_OK;
288. break;
289. default:
290. res = RES_PARERR;
291. break;
292. }
293. return res;
294. }
296. #endif /* _USE_IOCTL == 1 */

4、在Main.c文件中添加 測試應用程序

1. char SPIFLASHPath[4]; /* 串行Flash邏輯設備路徑 */
2. char SDPath[4]; /* SD卡邏輯設備路徑 */
4. FATFS fs;/* FatFs文件系統對象 */
5. FIL file;/* 文件對象 */
6. FRESULT f_res; /* 文件操作結果 */
7. UINT fnum; /* 文件成功讀寫數量 */
8. BYTE ReadBuffer[1024]={0}; /* 讀緩衝區 */
9. BYTE WriteBuffer[]= "歡迎使用硬石STM32開發板 今天是個好日子，新建文件系統測試文件\\n";/* 寫緩衝區*/
11. extern Diskio_drvTypeDef SD_Driver;

添加文件系統操作結果處理

1. /**
2. * 函數功能: FatFS文件系統操作結果信息處理.
3. * 輸入參數: FatFS文件系統操作結果：FRESULT
4. * 返 回 值: 無
5. * 說 明: 無
6. */
7. static void printf_fatfs_error(FRESULT fresult)
8. {
9. switch(fresult)
10. {
11. case FR_OK: //(0)
12. printf("》操作成功。\\n");
13. break;
14. case FR_DISK_ERR: //(1)
15. printf("！！硬件輸入輸出驅動出錯。\\n");
16. break;
17. case FR_INT_ERR: //(2)
18. printf("！！斷言錯誤。\\n");
19. break;
20. case FR_NOT_READY: //(3)
21. printf("！！物理設備無法工作。\\n");
22. break;
23. case FR_NO_FILE: //(4)
24. printf("！！無法找到文件。\\n");
25. break;
26. case FR_NO_PATH: //(5)
27. printf("！！無法找到路徑。\\n");
28. break;
29. case FR_INVALID_NAME: //(6)
30. printf("！！無效的路徑名。\\n");
31. break;
32. case FR_DENIED: //(7)
33. case FR_EXIST: //(8)
34. printf("！！拒絕訪問。\\n");
35. break;
36. case FR_INVALID_OBJECT: //(9)
37. printf("！！無效的文件或路徑。\\n");
38. break;
39. case FR_WRITE_PROTECTED: //(10)
40. printf("！！邏輯設備寫保護。\\n");
41. break;
42. case FR_INVALID_DRIVE: //(11)
43. printf("！！無效的邏輯設備。\\n");
44. break;
45. case FR_NOT_ENABLED: //(12)
46. printf("！！無效的工作區。\\n");
47. break;
48. case FR_NO_FILESYSTEM: //(13)
49. printf("！！無效的文件系統。\\n");
50. break;
51. case FR_MKFS_ABORTED: //(14)
52. printf("！！因函數參數問題導致f_mkfs函數操作失敗。\\n");
53. break;
54. case FR_TIMEOUT: //(15)
55. printf("！！操作超時。\\n");
56. break;
57. case FR_LOCKED: //(16)
58. printf("！！文件被保護。\\n");
59. break;
60. case FR_NOT_ENOUGH_CORE: //(17)
61. printf("！！長文件名支持獲取堆空間失敗。\\n");
62. break;
63. case FR_TOO_MANY_OPEN_FILES: //(18)
64. printf("！！打開太多文件。\\n");
65. break;
66. case FR_INVALID_PARAMETER: // (19)
67. printf("！！參數無效。\\n");
68. break;
69. }
70. }

添加測試程序：

1. /* 註冊一個FatFS設備：SD卡 */
2. if(FATFS_LinkDriver(&SD_Driver, SDPath) == 0)
3. {
4. //在SD卡掛載文件系統，文件系統掛載時會對SD卡初始化
5. f_res = f_mount(&fs,(TCHAR const*)SDPath,1);
6. printf_fatfs_error(f_res);
7. /*----------------------- 格式化測試 ---------------------------*/
8. /* 如果沒有文件系統就格式化創建創建文件系統 */
9. if(f_res == FR_NO_FILESYSTEM)
10. {
11. printf("》SD卡還沒有文件系統，即將進行格式化...\\n");
12. /* 格式化 */
13. f_res=f_mkfs((TCHAR const*)SDPath,0,0);
15. if(f_res == FR_OK)
16. {
17. printf("》SD卡已成功格式化文件系統。\\n");
18. /* 格式化後，先取消掛載 */
19. f_res = f_mount(NULL,(TCHAR const*)SDPath,1);
20. /* 重新掛載*/
21. f_res = f_mount(&fs,(TCHAR const*)SDPath,1);
22. }
23. else
24. {
25. printf("《《格式化失敗。》》\\n");
26. while(1);
27. }
28. }
29. else if(f_res!=FR_OK)
30. {
31. printf("！！SD卡掛載文件系統失敗。(%d)\\n",f_res);
32. printf_fatfs_error(f_res);
33. while(1);
34. }
35. else
36. {
37. printf("》文件系統掛載成功，可以進行讀寫測試\\n");
38. }
40. /*----------------------- 文件系統測試：寫測試 -----------------------------*/
41. /* 打開文件，如果文件不存在則創建它 */
42. printf("****** 即將進行文件寫入測試... ******\\n");
43. f_res = f_open(&file, "FatFs讀寫測試文件.txt",FA_CREATE_ALWAYS | FA_WRITE );
44. if ( f_res == FR_OK )
45. {
46. printf("》打開/創建FatFs讀寫測試文件.txt文件成功，向文件寫入數據。\\n");
47. /* 將指定存儲區內容寫入到文件內 */
48. f_res=f_write(&file,WriteBuffer,sizeof(WriteBuffer),&fnum);
49. if(f_res==FR_OK)
50. {
51. printf("》文件寫入成功，寫入字節數據：%d\\n",fnum);
52. printf("》向文件寫入的數據為：\\n%s\\n",WriteBuffer);
53. }
54. else
55. {
56. printf("！！文件寫入失敗：(%d)\\n",f_res);
57. }
58. /* 不再讀寫，關閉文件 */
59. f_close(&file);
60. }
61. else
62. {
63. printf("！！打開/創建文件失敗。\\n");
64. }
66. /*------------------- 文件系統測試：讀測試 ------------------------------------*/
67. printf("****** 即將進行文件讀取測試... ******\\n");
68. f_res = f_open(&file, "FatFs讀寫測試文件.txt", FA_OPEN_EXISTING | FA_READ);
69. if(f_res == FR_OK)
70. {
71. printf("》打開文件成功。\\n");
72. f_res = f_read(&file, ReadBuffer, sizeof(ReadBuffer), &fnum);
73. if(f_res==FR_OK)
74. {
75. printf("》文件讀取成功,讀到字節數據：%d\\n",fnum);
76. printf("》讀取得的文件數據為：\\n%s \\n", ReadBuffer);
77. }
78. else
79. {
80. printf("！！文件讀取失敗：(%d)\\n",f_res);
81. }
82. }
83. else
84. {
85. printf("！！打開文件失敗。\\n");
86. }
87. /* 不再讀寫，關閉文件 */
88. f_close(&file);
90. /* 不再使用，取消掛載 */
91. f_res = f_mount(NULL,(TCHAR const*)SDPath,1);
92. }
94. /* 註銷一個FatFS設備：SD卡 */
95. FATFS_UnLinkDriver(SDPath);

3、使用串口查看測試結果

閱讀更多 愛碼廝小妖 的文章

關鍵字: 讀寫 Flash 卡帶