旗点科技星空派（GD32）
直播中

qjp1988113

12年用户 343经验值
擅长:测量仪表 嵌入式技术 处理器/DSP 控制/MCU EDA/IC设计
私信 关注
[GD32F303]

【星空派GD32F303开发板试用体验】+FATFS移植

今天我们移植下FATFS，让他显示SD卡当前容量~
先下载FATFS包，这里途径很多可用其他工程上的，直接拿来修改下就能用了。
我们先配置好SD卡，板上的SPI FLASH太小512K字节，就不使用了。
SD卡采用的SDIO接口，我们直接用给出的例程(gd32-f303-master3 例程Project16_SDIO_SDCardTest)。
编译下载，正常~(2.0的卡正常。这了用3.0新卡试验过。能读不能写，可能配置的速度不够，未去深究)
MM1.png
好，我们就在这个例子的基础上，移植FATFS，我们把包添加进工程：
ZZ1.png
并把头文件路径，包含进工程：
ZZ2.png
配置好后，我们对代码的一些初始化、读写等改成我们之前配置的SD的底层操作函数。我们主要对"sd_diskio.c"进行修改~
  1. /**
  2.   ******************************************************************************
  3.   * [url=home.php?mod=space&uid=1455510]@file[/url]    sd_diskio.c
  4.   * [url=home.php?mod=space&uid=40524]@author[/url]  MCD Application Team
  5.   * [url=home.php?mod=space&uid=644434]@version[/url] V1.3.0
  6.   * @date    08-May-2015
  7.   * [url=home.php?mod=space&uid=2666770]@Brief[/url]   SD Disk I/O driver
  8.   ******************************************************************************
  9.   * @attention
  10.   *
  11.   *

    © COPYRIGHT 2015 STMicroelectronics


  12.   *
  13.   * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
  14.   * You may not use this file except in compliance with the License.
  15.   * You may obtain a copy of the License at:
  16.   *
  17.   *        http://www.st.com/software_license_agreement_liberty_v2
  18.   *
  19.   * Unless required by applicable law or agreed to in writing, software
  20.   * distributed under the License is distributed on an "AS IS" BASIS,
  21.   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  22.   * See the License for the specific language governing permissions and
  23.   * limitations under the License.
  24.   *
  25.   ******************************************************************************
  26.   */

  28. /* Includes ------------------------------------------------------------------*/
  29. #include
  30. #include "ff_gen_drv.h"
  31. #include "sdio_sdcard.h"
  32. #include "sdcard_user.h"

  34. /* Private typedef -----------------------------------------------------------*/
  35. /* Private define ------------------------------------------------------------*/
  36. /* Block Size in Bytes */
  37. #define BLOCK_SIZE                512

  39. /* Private variables ---------------------------------------------------------*/
  40. /* Disk status */
  41. static volatile DSTATUS Stat = STA_NOINIT;

  43. /* Private function prototypes -----------------------------------------------*/
  44. DSTATUS SD_initialize (BYTE);
  45. DSTATUS SD_status (BYTE);
  46. DRESULT SD_read (BYTE, BYTE*, DWORD, UINT);
  47. #if _USE_WRITE == 1
  48.   DRESULT SD_write (BYTE, const BYTE*, DWORD, UINT);
  49. #endif /* _USE_WRITE == 1 */
  50. #if _USE_IOCTL == 1
  51.   DRESULT SD_ioctl (BYTE, BYTE, void*);
  52. #endif  /* _USE_IOCTL == 1 */
  53.   
  54. const Diskio_drvTypeDef  SD_Driver =
  55. {
  56.   SD_initialize,
  57.   SD_status,
  58.   SD_read,
  59. #if  _USE_WRITE == 1
  60.   SD_write,
  61. #endif /* _USE_WRITE == 1 */
  62.   
  63. #if  _USE_IOCTL == 1
  64.   SD_ioctl,
  65. #endif /* _USE_IOCTL == 1 */
  66. };

  68. /* Private functions ---------------------------------------------------------*/

  70. /**
  71.   * @brief  Initializes a Drive
  72.   * [url=home.php?mod=space&uid=3142012]@param[/url]  lun : not used
  73.   * @retval DSTATUS: Operation status
  74.   */
  75. DSTATUS SD_initialize(BYTE lun)
  76. {
  77.   Stat = STA_NOINIT;
  78.   
  79.   /* Configure the uSD device */
  80.   if(sd_io_init() == SD_OK)
  81.   {
  82.     Stat &= ~STA_NOINIT;
  83.   }

  85.   return Stat;
  86. }

  88. /**
  89.   * @brief  Gets Disk Status
  90.   * @param  lun : not used
  91.   * @retval DSTATUS: Operation status
  92.   */
  93. DSTATUS SD_status(BYTE lun)
  94. {
  95.   Stat = STA_NOINIT;

  97.   if(sd_transfer_state_get() == SD_NO_TRANSFER)
  98.   {
  99.     Stat &= ~STA_NOINIT;
  100.   }
  101.   
  102.   return Stat;
  103. }

  105. /**
  106.   * @brief  Reads Sector(s)
  107.   * @param  lun : not used
  108.   * @param  *buff: Data buffer to store read data
  109.   * @param  sector: Sector address (LBA)
  110.   * @param  count: Number of sectors to read (1..128)
  111.   * @retval DRESULT: Operation result
  112.   */
  113. DRESULT SD_read(BYTE lun, BYTE *buff, DWORD sector, UINT count)
  114. {
  115.   DRESULT res = RES_OK;
  116.   
  117.   if(sd_multiblocks_read((uint32_t*)buff,
  118.                        (uint64_t) (sector * BLOCK_SIZE),
  119.                        BLOCK_SIZE,
  120.                        count) != SD_OK)
  121.   {
  122.     res = RES_ERROR;
  123.   }
  124.   
  125.   return res;
  126. }

  128. /**
  129.   * @brief  Writes Sector(s)
  130.   * @param  lun : not used
  131.   * @param  *buff: Data to be written
  132.   * @param  sector: Sector address (LBA)
  133.   * @param  count: Number of sectors to write (1..128)
  134.   * @retval DRESULT: Operation result
  135.   */
  136. #if _USE_WRITE == 1
  137. DRESULT SD_write(BYTE lun, const BYTE *buff, DWORD sector, UINT count)
  138. {
  139.   DRESULT res = RES_OK;
  140.   
  141.   if(sd_multiblocks_write((uint32_t*)buff,
  142.                         (uint64_t)(sector * BLOCK_SIZE),
  143.                         BLOCK_SIZE, count) != SD_OK)
  144.   {
  145.     res = RES_ERROR;
  146.   }
  147.   
  148.   return res;
  149. }
  150. #endif /* _USE_WRITE == 1 */

  152. /**
  153.   * @brief  I/O control operation
  154.   * @param  lun : not used
  155.   * @param  cmd: Control code
  156.   * @param  *buff: Buffer to send/receive control data
  157.   * @retval DRESULT: Operation result
  158.   */
  159. #if _USE_IOCTL == 1
  160. DRESULT SD_ioctl(BYTE lun, BYTE cmd, void *buff)
  161. {
  162.   DRESULT res = RES_ERROR;
  163. // SD_CardInfo CardInfo;
  164.   
  165.   if (Stat & STA_NOINIT) return RES_NOTRDY;
  166.   
  167.   switch (cmd)
  168.   {
  169.   /* Make sure that no pending write process */
  170.   case CTRL_SYNC :
  171.     res = RES_OK;
  172.     break;
  173.   
  174.   /* Get number of sectors on the disk (DWORD) */
  175.   case GET_SECTOR_COUNT :
  176.     card_info_get();
  177.     *(DWORD*)buff = sd_cardinfo.card_capacity / BLOCK_SIZE;
  178.     res = RES_OK;
  179.     break;
  180.   
  181.   /* Get R/W sector size (WORD) */
  182.   case GET_SECTOR_SIZE :
  183.     *(WORD*)buff = BLOCK_SIZE;
  184.     res = RES_OK;
  185.     break;
  186.   
  187.   /* Get erase block size in unit of sector (DWORD) */
  188.   case GET_BLOCK_SIZE :
  189.     *(DWORD*)buff = BLOCK_SIZE;
  190.     break;
  191.   
  192.   default:
  193.     res = RES_PARERR;
  194.   }
  195.   
  196.   return res;
  197. }
  198. #endif /* _USE_IOCTL == 1 */
  199.   
  200. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/




我们再创建一个文件用来写自己的一些FATFS的应用的函数：
fatfs_user.h
  1. #ifndef __FATFS_H
  2. #define __FATFS_H
  3. #include "gd32f30x.h"
  4. #include "ff.h"
  5. #include "ff_gen_drv.h"
  6. #include "sd_diskio.h" /* defines SD_Driver as external */

  8. enum{
  9.     USBDisk = 0,
  10.     SDCard
  11. };


  14. extern FIL openfile;
  15. extern uint32_t totalsize;
  16. extern uint32_t freesize;

  18. uint8_t Fatfs_init(uint8_t driver);
  19. uint8_t Fatfs_getfree(uint8_t driver);
  20. uint8_t Fatfs_open(uint8_t driver,uint8_t*path,uint8_t mode);
  21. uint8_t Fatfs_close(void);
  22. uint8_t Fatfs_read(uint8_t *data,uint32_t len);
  23. uint8_t Fatfs_write(uint8_t *data,uint32_t len);
  24. #endif //__FATFS_H
fatfs_user.c
  1. #include "fatfs_user.h"
  2. #include "usart.h"
  3. #include "stdbool.h"
  4. #include "string.h"
  5. uint32_t totalsize = 0;
  6. uint32_t freesize = 0;

  8. FIL openfile;
  9. FATFS SDFatFs = {0};
  10. char SD_Path[4]={0,0,0,0};

  12. FATFS USBfatfs;
  13. char UDisk_Path[4]={0,0,0,0};
  14. extern Diskio_drvTypeDef  USBH_Driver;
  15. uint8_t retSD; /* Return value for SD */

  17. const char* DriverString[2]={
  18.         {"USBDisk"},
  19.   {"SDCard"}
  20. };

  22. //return 0:no sd card find
  23. //return 1: find sd card
  24. uint8_t Fatfs_init(uint8_t driver)
  25. {
  26.         uint8_t res;
  27.   FATFS *Fatfs;
  28.   char *Path;
  29.   Diskio_drvTypeDef *Driver;

  31.   if(driver == SDCard)
  32.   {
  33.     Fatfs = &SDFatFs;
  34.     Path = (char*)&SD_Path;
  35.     Driver = &SD_Driver;
  36.   }else if(driver == USBDisk)
  37.   {
  38.   //  Fatfs = &USBfatfs;
  39. //   Path = (char*)&UDisk_Path;
  40.   //  Driver = &USBH_Driver;
  41.   }
  42.   /*## FatFS: Link the SD driver ###########################*/
  43.   res = FATFS_LinkDriver(Driver, Path);
  44.   if(res != FR_OK)
  45.   {
  46.     printf("rn%s FATFS LinkDriver errorrn",DriverString[driver]);
  47.     return 0;
  48.   }
  49.   else{
  50.     printf("rn%s FATFS LinkDriver OK,Drive path is %srn",DriverString[driver],Path);
  51.   }
  52.     /*##-2- Register the file system object to the FatFs module ##############*/
  53.     printf("%s FATFS mountrn",DriverString[driver]);
  54.     res = f_mount(Fatfs, (TCHAR const*)Path, 0);
  55.     if(res != FR_OK)
  56.     {
  57.       printf("%s FATFS mount Errorrn",DriverString[driver]);
  58.       FATFS_UnLinkDriver(Path);
  59.       return 0;
  60.     }
  61.     else{
  62.       printf("%s FATFS mount OK,Fatfs init donern",DriverString[driver]);
  63.     }
  64.   res =  Fatfs_getfree(driver);//计算当时SD的容量跟剩余大小
  65.   if(res != FR_OK)
  66.   {
  67.     printf("%s FATFS get size Errorrn",DriverString[driver]);
  68.     return 0;
  69.   }
  70.   else{
  71.     printf("%s FATFS  total size is %d,free size is %d.rn",DriverString[driver],totalsize,freesize);
  72.     return 1;
  73.   }
  74. }

  76. uint8_t Fatfs_getfree(uint8_t driver)
  77. {
  78.     uint8_t res;
  79.     FATFS *fs1;
  80.     uint32_t fre_clust=0, fre_sect=0, tot_sect=0;

  82.    char *Path;

  84.   if(driver == SDCard)
  85.   {
  86.     Path = (char*)&SD_Path;
  87.   }else if(driver == USBDisk)
  88.   {
  89.     Path = (char*)&UDisk_Path;
  90.   }

  92.     //得到磁盘信息及空闲簇数量
  93.     res =(uint32_t)f_getfree((const TCHAR*)Path, (DWORD*)&fre_clust, &fs1);
  94.     if(res==0)
  95.         {                                                                                          
  96.             tot_sect=(fs1->n_fatent-2)*fs1->csize;        //得到总扇区数
  97.             fre_sect=fre_clust*fs1->csize;                        //得到空闲扇区数          
  98. #if _MAX_SS!=512                                                                  //扇区大小不是512字节,则转换为512字节
  99.                 tot_sect*=fs1->ssize/512;
  100.                 fre_sect*=fs1->ssize/512;
  101. #endif          
  102.     totalsize=tot_sect>>1;        //单位为KB
  103.                 freesize=fre_sect>>1;        //单位为KB
  104.    }
  105.    return res;
  106. }

  108. uint8_t Fatfs_open(uint8_t driver,uint8_t*path,uint8_t mode)
  109. {
  110.   char  filepath[50];
  111.         memset(filepath,0,20);
  112.   if(driver == SDCard)
  113.   {
  114.       strcat(filepath,SD_Path);
  115.   }else if(driver == USBDisk)
  116.   {
  117.       strcat(filepath,UDisk_Path);
  118.   }
  119.   strcat((char*)filepath,(const char*)path);
  120.   retSD=f_open(&openfile,(const TCHAR*)filepath,mode);//打开文件夹
  121.   if(retSD != FR_OK)
  122.     {
  123.       printf("FATFS open Error:%drn",retSD);
  124.     }
  125.     else printf("FATFS open file[%s] ok!rn",filepath);
  126.   return retSD;
  127. }

  129. uint8_t Fatfs_close(void)
  130. {
  131.   retSD=f_close(&openfile);
  132.         return retSD;
  133. }

  135. //读出数据
  136. //len:读出的长度
  137. //返回值:执行结果
  138. uint8_t Fatfs_read(uint8_t *data,uint32_t len)
  139. {
  140.   uint16_t i;
  141.   uint32_t tlen=0;
  142.   uint32_t bytesread;
  143.   uint8_t *pdata = data;
  144.         for(i=0;i
  145.         {
  146.                 retSD=f_read(&openfile,pdata,512,&bytesread);
  147.                 if(retSD)
  148.                 {
  149.                         printf("Read Error:%drn",retSD);
  150.                         break;
  151.                 }else
  152.                 {
  153.                         tlen+=bytesread;
  154.       pdata += bytesread;
  155.                 }
  156.         }
  157.         if(len%512)
  158.         {
  159.                 retSD=f_read(&openfile,pdata,len%512,&bytesread);
  160.                 if(retSD)        //读数据出错了
  161.                 {
  162.                         printf("rnRead Error:%drn",retSD);   
  163.                 }else
  164.                 {
  165.                         tlen+=bytesread;
  166.                 }         
  167.         }
  168.         if(tlen)printf("rnReaded data len:%drn",tlen);//读到的数据长度
  169.         printf("Read data overrn");         
  170.         return retSD;
  171. }

  173. //写入数据
  174. //data:数据缓存区
  175. //len:写入长度
  176. //返回值:执行结果
  177. uint8_t Fatfs_write(uint8_t *data,uint32_t len)
  178. {
  179.   uint32_t byteswrite;                                            
  180.   printf("rnBegin Write file...rn");
  181.   printf("Write data len:%drn",len);         
  182.     retSD=f_write(&openfile,data,len,&byteswrite);
  183.     if(retSD)
  184.     {
  185.       printf("Write Error:%drn",retSD);   
  186.     }else printf("Writed data len:%drn",byteswrite);
  187.     printf("Write data over.rn");
  188.     return retSD;
  189. }
好，到这我们就移植好了，我们开始在main函数里面，初始化，并挂载SD卡~
  1.   while(Fatfs_init(SDCard)!=1)
  2.   {
  3.     printf("FATTS INI fail!rn");
  4.   }
  5.   printf("FATTS INI OK!rn");
  6.   
其中Fatfs_init(SDCard)里面会挂载，并打印一些SD卡的信息：
  1. //return 0:no sd card find
  2. //return 1: find sd card
  3. uint8_t Fatfs_init(uint8_t driver)
  4. {
  5.         uint8_t res;
  6.   FATFS *Fatfs;
  7.   char *Path;
  8.   Diskio_drvTypeDef *Driver;

  10.   if(driver == SDCard)
  11.   {
  12.     Fatfs = &SDFatFs;
  13.     Path = (char*)&SD_Path;
  14.     Driver = &SD_Driver;
  15.   }else if(driver == USBDisk)
  16.   {
  17.   //  Fatfs = &USBfatfs;
  18. //   Path = (char*)&UDisk_Path;
  19.   //  Driver = &USBH_Driver;
  20.   }
  21.   /*## FatFS: Link the SD driver ###########################*/
  22.   res = FATFS_LinkDriver(Driver, Path);
  23.   if(res != FR_OK)
  24.   {
  25.     printf("rn%s FATFS LinkDriver errorrn",DriverString[driver]);
  26.     return 0;
  27.   }
  28.   else{
  29.     printf("rn%s FATFS LinkDriver OK,Drive path is %srn",DriverString[driver],Path);
  30.   }
  31.     /*##-2- Register the file system object to the FatFs module ##############*/
  32.     printf("%s FATFS mountrn",DriverString[driver]);
  33.     res = f_mount(Fatfs, (TCHAR const*)Path, 0);
  34.     if(res != FR_OK)
  35.     {
  36.       printf("%s FATFS mount Errorrn",DriverString[driver]);
  37.       FATFS_UnLinkDriver(Path);
  38.       return 0;
  39.     }
  40.     else{
  41.       printf("%s FATFS mount OK,Fatfs init donern",DriverString[driver]);
  42.     }
  43.   res =  Fatfs_getfree(driver);//计算当时SD的容量跟剩余大小
  44.   if(res != FR_OK)
  45.   {
  46.     printf("%s FATFS get size Errorrn",DriverString[driver]);
  47.     return 0;
  48.   }
  49.   else{
  50.     printf("%s FATFS  total size is %d,free size is %d.rn",DriverString[driver],totalsize,freesize);
  51.     return 1;
  52.   }
  53. }
我们编译，下载程序~并插好SD卡~
查看串口输出：
ZZ3.png
好了，FATFS移植就到这儿了~
FATFS包：
FatFs.rar (502.57 KB)
(下载次数: 27, 2021-10-24 09:35 上传)

使用的配置文件：
FATFS_User.rar (7.27 KB)
(下载次数: 24, 2021-10-24 09:35 上传)



回帖（3）

jinglixixi

2021-10-31 15:23:06
在编译时报错，提示缺少“sys.h”，注释掉后又提示缺少“sdio_sdcard.h”，能否把这些文件也上传一下。
1 举报
  • qjp1988113: 好，这个其实一个就是数据类型的头文件定义，一个就是SD卡的底层驱动。

qjp1988113

2021-11-1 08:26:02
这个工程上传了~
举报

jinglixixi

2021-11-1 08:28:54
好的多谢了！                 
举报

更多回帖

3 0 1

相关帖子

开发板
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分