21ic电子技术开发论坛 › 综合技术交流 › RISC-V › 【RISC-V MCU CH32V103测评】+ TF卡目录读取
12下一页
返回列表 发新帖我要提问

[RISC-V MCU 应用开发] 【RISC-V MCU CH32V103测评】+ TF卡目录读取

[复制链接]
6882|27
 楼主| linyu0395 发表于 2020-12-4 16:17 | 显示全部楼层 |阅读模式
MCU, RISC-V, pi, spi, TE
本帖最后由 linyu0395 于 2020-12-4 16:17 编辑

        收到CH32V103开发板有一段时间了，百忙之中突然记起来要交稿了，赶紧搭建环境测试一下开发板（其实偷懒了一段时间…… ）。
        

        第一步打开  https://bbs.21ic.com/icview-3037572-1-1.html   这个链接，里面有关于CH32V103的数据手册、应用手册和官方例程。下载安装MounRiver Stduio后，打开如下图：
         937385fc9e632305c4.png
打开“File”，选择“New”菜单下的“MounRiver Project”选择“CH32V103”，Project Name填写项目名称，直接“Finish”就OK了。

       778415fc9e69b81a10.png

       开发环境比较智能，已经在项目中自动生成了比较完整的可以直接编译的模板。现在很多厂商的IDE环境都是基于Eclipse的框架进行集成定制开发，通用性很强，而且Eclipse很适合做编写代码的工具，插件功能强大、开源免费，还有我们程序员都喜欢的智能提示、跳转等，真的是不可多得的优秀代码开发环境。动手能力强的，都可以直接脱离MDK、IAR等开发环境，直接用Eclipse来编写代码、编译、仿真调试。

       731365fc9e875aac28.png
      这次我主要测试TF卡的目录读取功能，按照原理图，采用的是SPI通讯方式来驱动TF卡。因为CH32V103不支持SDIO硬件接口，所以只能用SPI。从官方例子里我找到了spi Flash的例子修改了一下代码，并且下载了最新的fatfs开源库，版本号是0.14.  然后把SPI_FLASH目录底下的文件直接复制到项目中的User文件夹，覆盖即可。

       894845fc9e95aa8226.png   

然后新建一个文件夹，把fatfs的所有的c文件和头文件都拷贝进去，并在设置中添加头文件的路径
       108025fc9eab097b0a.png

因为fatfs并没有附带TF的驱动，所以要对diskio.c  diskio.h 进行改写

diskio.c:

复制
  1. /*-----------------------------------------------------------------------*/
    

  2. /* MMC/SDC (in SPI mode) control module  (C)ChaN, 2007                   */
    

  3. /*-----------------------------------------------------------------------*/
    

  4. /* Only rcvr_spi(), xmit_spi(), disk_timerproc() and some macros         */
    

  5. /* are platform dependent.                                               */
    

  6. /*-----------------------------------------------------------------------*/
    

  7. #define TRUE  1
    

  8. #define FALSE 0
    

  9. #define bool BYTE
    


  10. 

  11. #include "debug.h"
    

  12. #include "ff.h"
    

  13. #include "diskio.h"
    

  14. #include <stdint.h>
    


  15. 

  16. /* Definitions for MMC/SDC command */
    

  17. #define CMD0    (0x40+0)    /* GO_IDLE_STATE */
    

  18. #define CMD1    (0x40+1)    /* SEND_OP_COND */
    

  19. #define CMD8    (0x40+8)    /* SEND_IF_COND */
    

  20. #define CMD9    (0x40+9)    /* SEND_CSD */
    

  21. #define CMD10    (0x40+10)    /* SEND_CID */
    

  22. #define CMD12    (0x40+12)    /* STOP_TRANSMISSION */
    

  23. #define CMD16    (0x40+16)    /* SET_BLOCKLEN */
    

  24. #define CMD17    (0x40+17)    /* READ_SINGLE_BLOCK */
    

  25. #define CMD18    (0x40+18)    /* READ_MULTIPLE_BLOCK */
    

  26. #define CMD23    (0x40+23)    /* SET_BLOCK_COUNT */
    

  27. #define CMD24    (0x40+24)    /* WRITE_BLOCK */
    

  28. #define CMD25    (0x40+25)    /* WRITE_MULTIPLE_BLOCK */
    

  29. #define CMD41    (0x40+41)    /* SEND_OP_COND (ACMD) */
    

  30. #define CMD55    (0x40+55)    /* APP_CMD */
    

  31. #define CMD58    (0x40+58)    /* READ_OCR */
    


  32. 

  33. /*--------------------------------------------------------------------------
    


  34. 

  35.  Module Private Functions
    


  36. 

  37.  ---------------------------------------------------------------------------*/
    


  38. 

  39. static volatile DSTATUS Stat = STA_NOINIT; /* Disk status */
    


  40. 

  41. static volatile BYTE Timer1, Timer2; /* 100Hz decrement timer */
    


  42. 

  43. static BYTE CardType; /* b0:MMC, b1:SDC, b2:Block addressing */
    


  44. 

  45. static BYTE PowerFlag = 0; /* indicates if "power" is on */
    


  46. 

  47. BYTE SPI1_ReadWriteByte(BYTE TxData)
    

  48. {
    

  49.         BYTE i=0;
    


  50. 

  51.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET)
    

  52.         {
    

  53.                 i++;
    

  54.                 if(i>200)return 0;
    

  55.         }
    


  56. 

  57.         SPI_I2S_SendData(SPI1, TxData);
    

  58.         i=0;
    


  59. 

  60.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET)
    

  61.         {
    

  62.                 i++;
    

  63.                 if(i>200)return 0;
    

  64.         }
    


  65. 

  66.         return SPI_I2S_ReceiveData(SPI1);
    

  67. }
    


  68. 

  69. static
    

  70. void SELECT(void)
    

  71. {
    

  72.         //HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_RESET);
    

  73.         GPIO_ResetBits(GPIOA, GPIO_Pin_3);
    

  74. }
    


  75. 

  76. static
    

  77. void DESELECT(void)
    

  78. {
    

  79.         //HAL_GPIO_WritePin(GPIOB, GPIO_PIN_12, GPIO_PIN_SET);
    

  80.         GPIO_SetBits(GPIOA, GPIO_Pin_3);
    

  81. }
    


  82. 

  83. static
    

  84. void xmit_spi(BYTE Data)
    

  85. {
    

  86.         SPI1_ReadWriteByte(Data);
    

  87. }
    


  88. 

  89. static BYTE rcvr_spi(void)
    

  90. {
    

  91.         unsigned char Data;
    

  92.         Data = SPI1_ReadWriteByte(0xFF);
    

  93.         return Data;
    

  94. }
    


  95. 

  96. static
    

  97. void rcvr_spi_m(BYTE *dst)
    

  98. {
    

  99.         *dst = rcvr_spi();
    

  100. }
    


  101. 

  102. /*-----------------------------------------------------------------------*/
    

  103. /* Wait for card ready                                                   */
    

  104. /*-----------------------------z------------------------------------------*/
    


  105. 

  106. static BYTE wait_ready(void)
    

  107. {
    

  108.         BYTE res;
    


  109. 

  110.         Timer2 = 50;
    

  111.         rcvr_spi();
    

  112.         do
    

  113.                 res = rcvr_spi();
    

  114.         while ((res != 0xFF) && Timer2);
    


  115. 

  116.         return res;
    

  117. }
    


  118. 

  119. /*-----------------------------------------------------------------------*/
    

  120. /* Power Control  (Platform dependent)                                   */
    

  121. /*-----------------------------------------------------------------------*/
    

  122. /* When the target system does not support socket power control, there   */
    

  123. /* is nothing to do in these functions and chk_power always returns 1.   */
    


  124. 

  125. static
    

  126. void power_on(void)
    

  127. {
    

  128.         unsigned char i, cmd_arg[6];
    

  129.         unsigned int Count = 0x1FFF;
    


  130. 

  131.         DESELECT();
    


  132. 

  133.         for (i = 0; i < 10; i++)
    

  134.                 xmit_spi(0xFF);
    


  135. 

  136.         SELECT();
    


  137. 

  138.         cmd_arg[0] = (CMD0 | 0x40);
    

  139.         cmd_arg[1] = 0;
    

  140.         cmd_arg[2] = 0;
    

  141.         cmd_arg[3] = 0;
    

  142.         cmd_arg[4] = 0;
    

  143.         cmd_arg[5] = 0x95;
    


  144. 

  145.         for (i = 0; i < 6; i++)
    

  146.                 xmit_spi(cmd_arg[i]);
    


  147. 

  148.         while ((rcvr_spi() != 0x01) && Count)
    

  149.                 Count--;
    


  150. 

  151.         DESELECT();
    

  152.         xmit_spi(0XFF);
    


  153. 

  154.         PowerFlag = 1;
    

  155. }
    


  156. 

  157. static
    

  158. void power_off(void)
    

  159. {
    

  160.         PowerFlag = 0;
    

  161. }
    


  162. 

  163. static
    

  164. int chk_power(void) /* Socket power state: 0=off, 1=on */
    

  165. {
    

  166.         return PowerFlag;
    

  167. }
    


  168. 

  169. /*-----------------------------------------------------------------------*/
    

  170. /* Receive a data packet from MMC                                        */
    

  171. /*-----------------------------------------------------------------------*/
    


  172. 

  173. static bool rcvr_datablock(BYTE *buff, /* Data buffer to store received data */
    

  174. UINT btr /* Byte count (must be even number) */
    

  175. )
    

  176. {
    

  177.         BYTE token;
    


  178. 

  179.         Timer1 = 10;
    

  180.         do
    

  181.         { /* Wait for data packet in timeout of 100ms */
    

  182.                 token = rcvr_spi();
    

  183.         } while ((token == 0xFF) && Timer1);
    

  184.         if (token != 0xFE)
    

  185.                 return FALSE; /* If not valid data token, retutn with error */
    


  186. 

  187.         do
    

  188.         { /* Receive the data block into buffer */
    

  189.                 rcvr_spi_m(buff++);
    

  190.                 rcvr_spi_m(buff++);
    

  191.         } while (btr -= 2);
    

  192.         rcvr_spi(); /* Discard CRC */
    

  193.         rcvr_spi();
    


  194. 

  195.         return TRUE; /* Return with success */
    

  196. }
    


  197. 

  198. /*-----------------------------------------------------------------------*/
    

  199. /* Send a data packet to MMC                                             */
    

  200. /*-----------------------------------------------------------------------*/
    


  201. 

  202. #if _READONLY == 0
    

  203. static bool xmit_datablock(const BYTE *buff, /* 512 byte data block to be transmitted */
    

  204. BYTE token /* Data/Stop token */
    

  205. )
    

  206. {
    

  207.         BYTE resp, wc;
    

  208.         uint32_t i = 0;
    


  209. 

  210.         if (wait_ready() != 0xFF)
    

  211.                 return FALSE;
    


  212. 

  213.         xmit_spi(token); /* Xmit data token */
    

  214.         if (token != 0xFD)
    

  215.         { /* Is data token */
    

  216.                 wc = 0;
    

  217.                 do
    

  218.                 { /* Xmit the 512 byte data block to MMC */
    

  219.                         xmit_spi(*buff++);
    

  220.                         xmit_spi(*buff++);
    

  221.                 } while (--wc);
    


  222. 

  223.                 rcvr_spi();
    

  224.                 rcvr_spi();
    


  225. 

  226.                 while (i <= 64)
    

  227.                 {
    

  228.                         resp = rcvr_spi(); /* Reveive data response */
    

  229.                         if ((resp & 0x1F) == 0x05) /* If not accepted, return with error */
    

  230.                                 break;
    

  231.                         i++;
    

  232.                 }
    

  233.                 while (rcvr_spi() == 0)
    

  234.                         ;
    

  235.         }
    

  236.         if ((resp & 0x1F) == 0x05)
    

  237.                 return TRUE;
    

  238.         else
    

  239.                 return FALSE;
    

  240. }
    

  241. #endif /* _READONLY */
    


  242. 

  243. /*-----------------------------------------------------------------------*/
    

  244. /* Send a command packet to MMC                                          */
    

  245. /*-----------------------------------------------------------------------*/
    


  246. 

  247. static BYTE send_cmd(BYTE cmd, /* Command byte */
    

  248. DWORD arg /* Argument */
    

  249. )
    

  250. {
    

  251.         BYTE n, res;
    


  252. 

  253.         if (wait_ready() != 0xFF)
    

  254.                 return 0xFF;
    


  255. 

  256.         /* Send command packet */
    

  257.         xmit_spi(cmd); /* Command */
    

  258.         xmit_spi((BYTE) (arg >> 24)); /* Argument[31..24] */
    

  259.         xmit_spi((BYTE) (arg >> 16)); /* Argument[23..16] */
    

  260.         xmit_spi((BYTE) (arg >> 8)); /* Argument[15..8] */
    

  261.         xmit_spi((BYTE) arg); /* Argument[7..0] */
    

  262.         n = 0;
    

  263.         if (cmd == CMD0)
    

  264.                 n = 0x95; /* CRC for CMD0(0) */
    

  265.         if (cmd == CMD8)
    

  266.                 n = 0x87; /* CRC for CMD8(0x1AA) */
    

  267.         xmit_spi(n);
    


  268. 

  269.         /* Receive command response */
    

  270.         if (cmd == CMD12)
    

  271.                 rcvr_spi(); /* Skip a stuff byte when stop reading */
    

  272.         n = 10; /* Wait for a valid response in timeout of 10 attempts */
    

  273.         do
    

  274.                 res = rcvr_spi();
    

  275.         while ((res & 0x80) && --n);
    


  276. 

  277.         return res; /* Return with the response value */
    

  278. }
    


  279. 

  280. /*--------------------------------------------------------------------------
    


  281. 

  282.  Public Functions
    


  283. 

  284.  ---------------------------------------------------------------------------*/
    


  285. 

  286. /*-----------------------------------------------------------------------*/
    

  287. /* Initialize Disk Drive                                                 */
    

  288. /*-----------------------------------------------------------------------*/
    


  289. 

  290. DSTATUS disk_initialize(BYTE drv /* Physical drive nmuber (0) */
    

  291. )
    

  292. {
    

  293.         BYTE n, ty, ocr[4];
    


  294. 

  295.         if (drv)
    

  296.                 return STA_NOINIT; /* Supports only single drive */
    

  297.         if (Stat & STA_NODISK)
    

  298.                 return Stat; /* No card in the socket */
    


  299. 

  300.         power_on(); /* Force socket power on */
    

  301.         //send_initial_clock_train();
    


  302. 

  303.         SELECT(); /* CS = L */
    

  304.         ty = 0;
    

  305.         if (send_cmd(CMD0, 0) == 1)
    

  306.         { /* Enter Idle state */
    

  307.                 Timer1 = 100; /* Initialization timeout of 1000 msec */
    

  308.                 if (send_cmd(CMD8, 0x1AA) == 1)
    

  309.                 { /* SDC Ver2+ */
    

  310.                         for (n = 0; n < 4; n++)
    

  311.                                 ocr[n] = rcvr_spi();
    

  312.                         if (ocr[2] == 0x01 && ocr[3] == 0xAA)
    

  313.                         { /* The card can work at vdd range of 2.7-3.6V */
    

  314.                                 do
    

  315.                                 {
    

  316.                                         if (send_cmd(CMD55, 0) <= 1
    

  317.                                                         && send_cmd(CMD41, 1UL << 30) == 0)
    

  318.                                                 break; /* ACMD41 with HCS bit */
    

  319.                                 } while (Timer1);
    

  320.                                 if (Timer1 && send_cmd(CMD58, 0) == 0)
    

  321.                                 { /* Check CCS bit */
    

  322.                                         for (n = 0; n < 4; n++)
    

  323.                                                 ocr[n] = rcvr_spi();
    

  324.                                         ty = (ocr[0] & 0x40) ? 6 : 2;
    

  325.                                 }
    

  326.                         }
    

  327.                 }
    

  328.                 else
    

  329.                 { /* SDC Ver1 or MMC */
    

  330.                         ty = (send_cmd(CMD55, 0) <= 1 && send_cmd(CMD41, 0) <= 1) ? 2 : 1; /* SDC : MMC */
    

  331.                         do
    

  332.                         {
    

  333.                                 if (ty == 2)
    

  334.                                 {
    

  335.                                         if (send_cmd(CMD55, 0) <= 1 && send_cmd(CMD41, 0) == 0)
    

  336.                                                 break; /* ACMD41 */
    

  337.                                 }
    

  338.                                 else
    

  339.                                 {
    

  340.                                         if (send_cmd(CMD1, 0) == 0)
    

  341.                                                 break; /* CMD1 */
    

  342.                                 }
    

  343.                         } while (Timer1);
    

  344.                         if (!Timer1 || send_cmd(CMD16, 512) != 0) /* Select R/W block length */
    

  345.                                 ty = 0;
    

  346.                 }
    

  347.         }
    

  348.         CardType = ty;
    

  349.         DESELECT(); /* CS = H */
    

  350.         rcvr_spi(); /* Idle (Release DO) */
    


  351. 

  352.         if (ty) /* Initialization succeded */
    

  353.                 Stat &= ~STA_NOINIT; /* Clear STA_NOINIT */
    

  354.         else
    

  355.                 /* Initialization failed */
    

  356.                 power_off();
    


  357. 

  358.         return Stat;
    

  359. }
    


  360. 

  361. /*-----------------------------------------------------------------------*/
    

  362. /* Get Disk Status                                                       */
    

  363. /*-----------------------------------------------------------------------*/
    


  364. 

  365. DSTATUS disk_status(BYTE drv /* Physical drive nmuber (0) */
    

  366. )
    

  367. {
    

  368.         if (drv)
    

  369.                 return STA_NOINIT; /* Supports only single drive */
    

  370.         return Stat;
    

  371. }
    


  372. 

  373. /*-----------------------------------------------------------------------*/
    

  374. /* Read Sector(s)                                                        */
    

  375. /*-----------------------------------------------------------------------*/
    


  376. 

  377. DRESULT disk_read(BYTE pdrv, BYTE* buff, DWORD sector, UINT count)
    

  378. {
    

  379.         if (pdrv || !count)
    

  380.                 return RES_PARERR;
    

  381.         if (Stat & STA_NOINIT)
    

  382.                 return RES_NOTRDY;
    


  383. 

  384.         if (!(CardType & 4))
    

  385.                 sector *= 512; /* Convert to byte address if needed */
    


  386. 

  387.         SELECT(); /* CS = L */
    


  388. 

  389.         if (count == 1)
    

  390.         { /* Single block read */
    

  391.                 if ((send_cmd(CMD17, sector) == 0) /* READ_SINGLE_BLOCK */
    

  392.                 && rcvr_datablock(buff, 512))
    

  393.                         count = 0;
    

  394.         }
    

  395.         else
    

  396.         { /* Multiple block read */
    

  397.                 if (send_cmd(CMD18, sector) == 0)
    

  398.                 { /* READ_MULTIPLE_BLOCK */
    

  399.                         do
    

  400.                         {
    

  401.                                 if (!rcvr_datablock(buff, 512))
    

  402.                                         break;
    

  403.                                 buff += 512;
    

  404.                         } while (--count);
    

  405.                         send_cmd(CMD12, 0); /* STOP_TRANSMISSION */
    

  406.                 }
    

  407.         }
    


  408. 

  409.         DESELECT(); /* CS = H */
    

  410.         rcvr_spi(); /* Idle (Release DO) */
    


  411. 

  412.         return count ? RES_ERROR : RES_OK;
    

  413. }
    


  414. 

  415. /*-----------------------------------------------------------------------*/
    

  416. /* Write Sector(s)                                                       */
    

  417. /*-----------------------------------------------------------------------*/
    


  418. 

  419. #if _READONLY == 0
    

  420. DRESULT disk_write(BYTE pdrv, const BYTE* buff, DWORD sector, UINT count)
    

  421. {
    

  422.         if (pdrv || !count)
    

  423.                 return RES_PARERR;
    

  424.         if (Stat & STA_NOINIT)
    

  425.                 return RES_NOTRDY;
    

  426.         if (Stat & STA_PROTECT)
    

  427.                 return RES_WRPRT;
    


  428. 

  429.         if (!(CardType & 4))
    

  430.                 sector *= 512; /* Convert to byte address if needed */
    


  431. 

  432.         SELECT(); /* CS = L */
    


  433. 

  434.         if (count == 1)
    

  435.         { /* Single block write */
    

  436.                 if ((send_cmd(CMD24, sector) == 0) /* WRITE_BLOCK */
    

  437.                 && xmit_datablock(buff, 0xFE))
    

  438.                         count = 0;
    

  439.         }
    

  440.         else
    

  441.         { /* Multiple block write */
    

  442.                 if (CardType & 2)
    

  443.                 {
    

  444.                         send_cmd(CMD55, 0);
    

  445.                         send_cmd(CMD23, count); /* ACMD23 */
    

  446.                 }
    

  447.                 if (send_cmd(CMD25, sector) == 0)
    

  448.                 { /* WRITE_MULTIPLE_BLOCK */
    

  449.                         do
    

  450.                         {
    

  451.                                 if (!xmit_datablock(buff, 0xFC))
    

  452.                                         break;
    

  453.                                 buff += 512;
    

  454.                         } while (--count);
    

  455.                         if (!xmit_datablock(0, 0xFD)) /* STOP_TRAN token */
    

  456.                                 count = 1;
    

  457.                 }
    

  458.         }
    


  459. 

  460.         DESELECT(); /* CS = H */
    

  461.         rcvr_spi(); /* Idle (Release DO) */
    


  462. 

  463.         return count ? RES_ERROR : RES_OK;
    

  464. }
    

  465. #endif /* _READONLY */
    


  466. 

  467. /*-----------------------------------------------------------------------*/
    

  468. /* Miscellaneous Functions                                               */
    

  469. /*-----------------------------------------------------------------------*/
    


  470. 

  471. DRESULT disk_ioctl(BYTE drv, /* Physical drive nmuber (0) */
    

  472. BYTE ctrl, /* Control code */
    

  473. void *buff /* Buffer to send/receive control data */
    

  474. )
    

  475. {
    

  476.         DRESULT res;
    

  477.         BYTE n, csd[16], *ptr = buff;
    

  478.         WORD csize;
    


  479. 

  480.         if (drv)
    

  481.                 return RES_PARERR;
    


  482. 

  483.         res = RES_ERROR;
    


  484. 

  485.         if (ctrl == CTRL_POWER)
    

  486.         {
    

  487.                 switch (*ptr)
    

  488.                 {
    

  489.                 case 0: /* Sub control code == 0 (POWER_OFF) */
    

  490.                         if (chk_power())
    

  491.                                 power_off(); /* Power off */
    

  492.                         res = RES_OK;
    

  493.                         break;
    

  494.                 case 1: /* Sub control code == 1 (POWER_ON) */
    

  495.                         power_on(); /* Power on */
    

  496.                         res = RES_OK;
    

  497.                         break;
    

  498.                 case 2: /* Sub control code == 2 (POWER_GET) */
    

  499.                         *(ptr + 1) = (BYTE) chk_power();
    

  500.                         res = RES_OK;
    

  501.                         break;
    

  502.                 default:
    

  503.                         res = RES_PARERR;
    

  504.                 }
    

  505.         }
    

  506.         else
    

  507.         {
    

  508.                 if (Stat & STA_NOINIT)
    

  509.                         return RES_NOTRDY;
    


  510. 

  511.                 SELECT(); /* CS = L */
    


  512. 

  513.                 switch (ctrl)
    

  514.                 {
    

  515.                 case GET_SECTOR_COUNT: /* Get number of sectors on the disk (DWORD) */
    

  516.                         if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16))
    

  517.                         {
    

  518.                                 if ((csd[0] >> 6) == 1)
    

  519.                                 { /* SDC ver 2.00 */
    

  520.                                         csize = csd[9] + ((WORD) csd[8] << 8) + 1;
    

  521.                                         *(DWORD*) buff = (DWORD) csize << 10;
    

  522.                                 }
    

  523.                                 else
    

  524.                                 { /* MMC or SDC ver 1.XX */
    

  525.                                         n = (csd[5] & 15) + ((csd[10] & 128) >> 7)
    

  526.                                                         + ((csd[9] & 3) << 1) + 2;
    

  527.                                         csize = (csd[8] >> 6) + ((WORD) csd[7] << 2)
    

  528.                                                         + ((WORD) (csd[6] & 3) << 10) + 1;
    

  529.                                         *(DWORD*) buff = (DWORD) csize << (n - 9);
    

  530.                                 }
    

  531.                                 res = RES_OK;
    

  532.                         }
    

  533.                         break;
    


  534. 

  535.                 case GET_SECTOR_SIZE: /* Get sectors on the disk (WORD) */
    

  536.                         *(WORD*) buff = 512;
    

  537.                         res = RES_OK;
    

  538.                         break;
    


  539. 

  540.                 case CTRL_SYNC: /* Make sure that data has been written */
    

  541.                         if (wait_ready() == 0xFF)
    

  542.                                 res = RES_OK;
    

  543.                         break;
    


  544. 

  545.                 case MMC_GET_CSD: /* Receive CSD as a data block (16 bytes) */
    

  546.                         if (send_cmd(CMD9, 0) == 0 /* READ_CSD */
    

  547.                         && rcvr_datablock(ptr, 16))
    

  548.                                 res = RES_OK;
    

  549.                         break;
    


  550. 

  551.                 case MMC_GET_CID: /* Receive CID as a data block (16 bytes) */
    

  552.                         if (send_cmd(CMD10, 0) == 0 /* READ_CID */
    

  553.                         && rcvr_datablock(ptr, 16))
    

  554.                                 res = RES_OK;
    

  555.                         break;
    


  556. 

  557.                 case MMC_GET_OCR: /* Receive OCR as an R3 resp (4 bytes) */
    

  558.                         if (send_cmd(CMD58, 0) == 0)
    

  559.                         { /* READ_OCR */
    

  560.                                 for (n = 0; n < 4; n++)
    

  561.                                         *ptr++ = rcvr_spi();
    

  562.                                 res = RES_OK;
    

  563.                         }
    


  564. 

  565. //        case MMC_GET_TYPE :    /* Get card type flags (1 byte) */
    

  566. //            *ptr = CardType;
    

  567. //            res = RES_OK;
    

  568. //            break;
    


  569. 

  570.                 default:
    

  571.                         res = RES_PARERR;
    

  572.                 }
    


  573. 

  574.                 DESELECT(); /* CS = H */
    

  575.                 rcvr_spi(); /* Idle (Release DO) */
    

  576.         }
    


  577. 

  578.         return res;
    

  579. }
    


  580. 

  581. /*-----------------------------------------------------------------------*/
    

  582. /* Device Timer Interrupt Procedure  (Platform dependent)                */
    

  583. /*-----------------------------------------------------------------------*/
    

  584. /* This function must be called in period of 10ms                        */
    


  585. 

  586. void disk_timerproc(void)
    

  587. {
    

  588. //    BYTE n, s;
    

  589.         BYTE n;
    


  590. 

  591.         n = Timer1; /* 100Hz decrement timer */
    

  592.         if (n)
    

  593.                 Timer1 = --n;
    

  594.         n = Timer2;
    

  595.         if (n)
    

  596.                 Timer2 = --n;
    


  597. 

  598. }
    


  599. 

  600. volatile unsigned short int sdcard_timer;
    


  601. 

  602. void inline sdcard_systick_timerproc(void)
    

  603. {
    

  604.         ++sdcard_timer;
    

  605.         if (sdcard_timer >= 100)
    

  606.         {
    

  607.                 sdcard_timer = 0;
    

  608.                 disk_timerproc();
    

  609.         }
    

  610. }
    


  611. 

  612. /*---------------------------------------------------------*/
    

  613. /* User Provided Timer Function for FatFs module           */
    

  614. /*---------------------------------------------------------*/
    

  615. /* This is a real time clock service to be called from     */
    

  616. /* FatFs module. Any valid time must be returned even if   */
    

  617. /* the system does not support a real time clock.          */
    


  618. 

  619. DWORD get_fattime(void)
    

  620. {
    


  621. 

  622.         return ((2007UL - 1980) << 25) // Year = 2007
    

  623.         | (6UL << 21) // Month = June
    

  624.                         | (5UL << 16) // Day = 5
    

  625.                         | (11U << 11) // Hour = 11
    

  626.                         | (38U << 5) // Min = 38
    

  627.                         | (0U >> 1) // Sec = 0
    

  628.         ;
    


  629. 

  630. }
    


  631.

diskio.h
复制
  1. /*-----------------------------------------------------------------------/
    

  2. /  Low level disk interface modlue include file   (C)ChaN, 2019          /
    

  3. /-----------------------------------------------------------------------*/
    


  4. 

  5. #ifndef _DISKIO_DEFINED
    

  6. #define _DISKIO_DEFINED
    


  7. 

  8. #ifdef __cplusplus
    

  9. extern "C" {
    

  10. #endif
    


  11. 

  12. /* Status of Disk Functions */
    

  13. typedef BYTE        DSTATUS;
    


  14. 

  15. /* Results of Disk Functions */
    

  16. typedef enum {
    

  17.         RES_OK = 0,                /* 0: Successful */
    

  18.         RES_ERROR,                /* 1: R/W Error */
    

  19.         RES_WRPRT,                /* 2: Write Protected */
    

  20.         RES_NOTRDY,                /* 3: Not Ready */
    

  21.         RES_PARERR                /* 4: Invalid Parameter */
    

  22. } DRESULT;
    


  23. 


  24. 

  25. /*---------------------------------------*/
    

  26. /* Prototypes for disk control functions */
    


  27. 


  28. 

  29. DSTATUS disk_initialize (BYTE pdrv);
    

  30. DSTATUS disk_status (BYTE pdrv);
    

  31. DRESULT disk_read (BYTE pdrv, BYTE* buff, LBA_t sector, UINT count);
    

  32. DRESULT disk_write (BYTE pdrv, const BYTE* buff, LBA_t sector, UINT count);
    

  33. DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff);
    

  34. void sdcard_systick_timerproc(void);
    

  35. void disk_timerproc(void);
    

  36. /* Disk Status Bits (DSTATUS) */
    


  37. 

  38. #define STA_NOINIT                0x01        /* Drive not initialized */
    

  39. #define STA_NODISK                0x02        /* No medium in the drive */
    

  40. #define STA_PROTECT                0x04        /* Write protected */
    


  41. 


  42. 

  43. /* Command code for disk_ioctrl fucntion */
    


  44. 

  45. /* Generic command (Used by FatFs) */
    

  46. #define CTRL_SYNC                        0        /* Complete pending write process (needed at FF_FS_READONLY == 0) */
    

  47. #define GET_SECTOR_COUNT        1        /* Get media size (needed at FF_USE_MKFS == 1) */
    

  48. #define GET_SECTOR_SIZE                2        /* Get sector size (needed at FF_MAX_SS != FF_MIN_SS) */
    

  49. #define GET_BLOCK_SIZE                3        /* Get erase block size (needed at FF_USE_MKFS == 1) */
    

  50. #define CTRL_TRIM                        4        /* Inform device that the data on the block of sectors is no longer used (needed at FF_USE_TRIM == 1) */
    


  51. 

  52. /* Generic command (Not used by FatFs) */
    

  53. #define CTRL_POWER                        5        /* Get/Set power status */
    

  54. #define CTRL_LOCK                        6        /* Lock/Unlock media removal */
    

  55. #define CTRL_EJECT                        7        /* Eject media */
    

  56. #define CTRL_FORMAT                        8        /* Create physical format on the media */
    


  57. 

  58. /* MMC/SDC specific ioctl command */
    

  59. #define MMC_GET_TYPE                10        /* Get card type */
    

  60. #define MMC_GET_CSD                        11        /* Get CSD */
    

  61. #define MMC_GET_CID                        12        /* Get CID */
    

  62. #define MMC_GET_OCR                        13        /* Get OCR */
    

  63. #define MMC_GET_SDSTAT                14        /* Get SD status */
    

  64. #define ISDIO_READ                        55        /* Read data form SD iSDIO register */
    

  65. #define ISDIO_WRITE                        56        /* Write data to SD iSDIO register */
    

  66. #define ISDIO_MRITE                        57        /* Masked write data to SD iSDIO register */
    


  67. 

  68. /* ATA/CF specific ioctl command */
    

  69. #define ATA_GET_REV                        20        /* Get F/W revision */
    

  70. #define ATA_GET_MODEL                21        /* Get model name */
    

  71. #define ATA_GET_SN                        22        /* Get serial number */
    


  72. 

  73. #ifdef __cplusplus
    

  74. }
    

  75. #endif
    


  76. 

  77. #endif

修改了一下spi的初始化函数
复制
  1. /*******************************************************************************
    

  2.  * Function Name  : SPI_FullDuplex_Init
    

  3.  * Description    : Configuring the SPI for full-duplex communication.
    

  4.  * Input          : None
    

  5.  * Return         : None
    

  6.  *******************************************************************************/
    

  7. void SPI_FullDuplex_Init(void)
    

  8. {
    

  9.         GPIO_InitTypeDef GPIO_InitStructure;
    

  10.         SPI_InitTypeDef SPI_InitStructure;
    


  11. 

  12.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA | RCC_APB2Periph_SPI1, ENABLE);
    


  13. 

  14.         //CS
    

  15.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
    

  16.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    

  17.         GPIO_Init( GPIOA, &GPIO_InitStructure);
    

  18.         GPIO_SetBits(GPIOA, GPIO_Pin_3);
    

  19.         //SD_IN
    

  20.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    

  21.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    

  22.         GPIO_Init( GPIOA, &GPIO_InitStructure);
    


  23. 

  24.         //SCLK
    

  25.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    

  26.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  27.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  28.         GPIO_Init( GPIOA, &GPIO_InitStructure);
    


  29. 

  30.         //MISO
    

  31.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    

  32.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    

  33.         GPIO_Init( GPIOA, &GPIO_InitStructure);
    


  34. 

  35.         //MOSI
    

  36.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
    

  37.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    

  38.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    

  39.         GPIO_Init( GPIOA, &GPIO_InitStructure);
    


  40. 

  41.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    

  42.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    

  43.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    

  44.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
    

  45.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
    

  46.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    

  47.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
    

  48.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    

  49.         SPI_InitStructure.SPI_CRCPolynomial = 7;
    

  50.         SPI_Init( SPI1, &SPI_InitStructure);
    

  51.         SPI_SSOutputCmd( SPI1, DISABLE);
    

  52.         SPI_Cmd( SPI1, ENABLE);
    

  53. }
这里大家要注意一下，开发板上的SPI NSS连接的IO口是PA3，但是0欧的电阻并没有焊接上去，我们还需要自行焊接短路一下，我调试的时候因为没认真看原理图，以为TF卡都直接焊接好了，我直接用就可以了，后来查找问题的时候才发现 这个电阻没有焊接。还有SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;这条语句，因为TF的SPI驱动方式是高位在前，例程里的是SPI_FirstBit_LSB低位在前，这个也要改一下。还有一个最重要的一点，TF卡在初始化成SPI驱动的时候，SPI速率切不可太高，不能超过400K，我当时就是设置太高了，也花了好多时间。

       main函数的测试TF卡的文件遍历函数，也是直接一直fatfs的“readdir.html”里的“scan_files”函数
复制
  1. FRESULT scan_files (
    

  2.     char* path        /* Start node to be scanned (***also used as work area***) */
    

  3. )
    

  4. {
    

  5.     FRESULT res;
    

  6.     DIR dir;
    

  7.     UINT i;
    

  8.     static FILINFO fno;
    


  9. 


  10. 

  11.     res = f_opendir(&dir, path);                       /* Open the directory */
    

  12.     if (res == FR_OK) {
    

  13.         for (;;) {
    

  14.             res = f_readdir(&dir, &fno);                   /* Read a directory item */
    

  15.             if (res != FR_OK || fno.fname[0] == 0) break;  /* Break on error or end of dir */
    

  16.             if (fno.fattrib & AM_DIR) {                    /* It is a directory */
    

  17.                 i = strlen(path);
    

  18.                 sprintf(&path[i], "/%s", fno.fname);
    

  19.                 res = scan_files(path);                    /* Enter the directory */
    

  20.                 if (res != FR_OK) break;
    

  21.                 path[i] = 0;
    

  22.             } else {                                       /* It is a file. */
    

  23.                 printf("%s/%s\n", path, fno.fname);
    

  24.             }
    

  25.         }
    

  26.         f_closedir(&dir)
    

  27.     }
    


  28. 

  29.     return res;
    

  30. }
    


  31. 


  32. 

  33. int main (void)
    

  34. {
    

  35.     FATFS fs;
    

  36.     FRESULT res;
    

  37.     char buff[256];
    


  38. 


  39. 

  40.     res = f_mount(&fs, "", 1);
    

  41.     if (res == FR_OK) {
    

  42.         strcpy(buff, "/");
    

  43.         res = scan_files(buff);
    

  44.     }
    


  45. 

  46.     return res;

我在TF卡里预先建立了一些目录和文件，因为测试报告需要至少三级的目录，所以我建立的文件如图所示：
111555fc9edb51c277.png     37885fc9edc0bbfaa.png     571665fc9edcad76d8.png

然后通过串口来打印出文件目录结构，实际运行如下所示：
765455fc9ee138a9b9.png
可以看到和我建立的目录结构是一样的。后续还有很多功能需要研究，比如USB、触摸按键等。
其实USB开发也非常便捷，把例程HOST_Udis和Udisk_Lib的库文件也拷贝到项目文件中，直接编译运行，插入U盘，电脑上就可以找到U盘的磁盘信息了，而且库文件也对USB进行了更高一层的封装，跟fatfs很相似，直接调用也非常方便，参考“CH32V103UFI.c”就可以快速对USB进行开发。


最后附上我的程序供大家参考，在此，也非常感谢二姨平台和各大厂商给了我们程序员这么好的环境来学习和交流，在不知不觉中学到了很多知识，受益匪浅！谢谢！

CH32V103C6T6-TF.zip (1.2 MB, 下载次数: 20)


      


回复

收藏 举报

评论

zhengfish
赞。。。“这里大家要注意一下，开发板上的SPI NSS连接的IO口是PA3，但是0欧的电阻并没有焊接上去，我们还需要自行焊接短路一下，我调试的时候因为没认真看原理图，以为TF卡都直接焊接好了，我直接用就可以了，后来查找问题的时候才发现 这个电阻没有焊接。还有SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;这条语句，因为TF的SPI驱动方式是高位在前，例程里的是SPI_FirstBit_LSB...  发表于 2020-12-4 21:07

相关帖子
1988020566 发表于 2021-2-21 20:29 | 显示全部楼层
FATFS系统吗？      
回复

收藏 举报

xinpian101 发表于 2021-2-22 10:16 | 显示全部楼层
操作真棒。学习学习。
回复

收藏 举报

明天真的好 发表于 2021-2-23 16:13 | 显示全部楼层
这个是SDIO模式吗？还是SPI模式进**的读写操作呢？
回复

收藏 举报

自己造声卡 发表于 2021-2-23 16:32 | 显示全部楼层
SDIO模式吗？还是SPI模式？
回复

收藏 举报

An追求 发表于 2022-8-4 15:12 | 显示全部楼层
请问这个可以移植到RISC-V的CH582m吗
回复

收藏 举报

mollylawrence 发表于 2022-10-9 19:58 | 显示全部楼层
单片机怎样读写TF卡?               
回复

收藏 举报

aspoke 发表于 2022-10-9 20:11 | 显示全部楼层
这个汉字库是怎么输出的？     
回复

收藏 举报

suzhanhua 发表于 2022-10-9 20:31 | 显示全部楼层
单片机 控制 tf卡很容易吗   
回复

收藏 举报

elsaflower 发表于 2022-10-9 21:02 | 显示全部楼层
用CH32V103完成对SD卡的数据读取
回复

收藏 举报

soodesyt 发表于 2022-10-9 21:37 | 显示全部楼层
怎么通过单片机将汉字字库存放到外部的FLASH中
回复

收藏 举报

jonas222 发表于 2022-10-9 22:26 | 显示全部楼层
单片机读取SD(TF)卡速度测试   
回复

收藏 举报

jstgotodo 发表于 2022-10-10 17:45 | 显示全部楼层
TF卡读写模块上的这个IC有什么用?  
回复

收藏 举报

51xlf 发表于 2022-10-10 20:15 | 显示全部楼层
找sd卡的读写资料,大把大把的。  
回复

收藏 举报

suzhanhua 发表于 2022-10-10 21:06 | 显示全部楼层
单片机读写1G以上内存卡吗      
回复

收藏 举报

hearstnorman323 发表于 2022-10-10 21:58 | 显示全部楼层
怎么用单片机读取tf卡(sd卡)数据,播放音乐。
回复

收藏 举报

houjiakai 发表于 2022-12-1 17:57 | 显示全部楼层
fatfs占用多大的内存？              
回复

收藏 举报

jackcat 发表于 2022-12-1 18:05 | 显示全部楼层
使用stm32开发的时候，不是要配置spi的速率吗？
回复

收藏 举报

cashrwood 发表于 2022-12-1 20:50 | 显示全部楼层
记得官方提供了这个参考代码了。              
回复

收藏 举报

mmbs 发表于 2022-12-1 21:29 | 显示全部楼层
diskio使用的硬件驱动的吗？
回复

收藏 举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

linyu0395

22

主题

249

帖子

4

粉丝
快速回复 在线客服 返回列表 返回顶部