m61_sd卡模块的使用

搜了下看 sdk里面有demo但是没文档。

稍微整理了下。
里面默认是一个 读写文件的demo
路径在aithinker_Ai-M6X_SDK\examples\fatfs\main.c
核心头文件

//fatfs
#include "fatfs_diskio_register.h"
#include "ff.h"


board_sdh_gpio_init();
直接抄就行，修改引脚的函数
引脚定义。

1. #include "bflb_mtimer.h"
   
2. #include "board.h"
   
3. #include "fatfs_diskio_register.h"
   
4. #include "ff.h"
   
5. 
   
6. #define DBG_TAG "MAIN"
   
7. #include "log.h"
   
8. 
   
9. FATFS fs;
   
10. __attribute((aligned(8))) static uint32_t workbuf[4096];
    
11. 
    
12. MKFS_PARM fs_para = {
    
13.     .fmt = FM_FAT32,     /* Format option (FM_FAT, FM_FAT32, FM_EXFAT and FM_SFD) */
    
14.     .n_fat = 1,          /* Number of FATs */
    
15.     .align = 0,          /* Data area alignment (sector) */
    
16.     .n_root = 1,         /* Number of root directory entries */
    
17.     .au_size = 512 * 32, /* Cluster size (byte) */
    
18. };
    
19. 
    
20. void filesystem_init(void)
    
21. {
    
22.     FRESULT ret;
    
23. 
    
24.     board_sdh_gpio_init();
    
25. 
    
26.     fatfs_sdh_driver_register();
    
27. 
    
28.     ret = f_mount(&fs, "/sd", 1);
    
29.     // ret = FR_NO_FILESYSTEM;
    
30. 
    
31.     if (ret == FR_NO_FILESYSTEM) {
    
32.         LOG_W("No filesystem yet, try to be formatted...\r\n");
    
33. 
    
34.         ret = f_mkfs("/sd", &fs_para, workbuf, sizeof(workbuf));
    
35. 
    
36.         if (ret != FR_OK) {
    
37.             LOG_F("fail to make filesystem %d\r\n", ret);
    
38.             _CALL_ERROR();
    
39.         }
    
40. 
    
41.         if (ret == FR_OK) {
    
42.             LOG_I("done with formatting.\r\n");
    
43.             LOG_I("first start to unmount.\r\n");
    
44.             ret = f_mount(NULL, "/sd", 1);
    
45.             LOG_I("then start to remount.\r\n");
    
46.         }
    
47.     } else if (ret != FR_OK) {
    
48.         LOG_F("fail to mount filesystem,error= %d\r\n", ret);
    
49.         LOG_F("SD card might fail to initialise.\r\n");
    
50.         _CALL_ERROR();
    
51.     } else {
    
52.         LOG_D("Succeed to mount filesystem\r\n");
    
53.     }
    
54. 
    
55.     if (ret == FR_OK) {
    
56.         LOG_I("FileSystem cluster size:%d-sectors (%d-Byte)\r\n", fs.csize, fs.csize * 512);
    
57.     }
    
58. }
    
59. 
    
60. #define SDU_DATA_CHECK 1
    
61. 
    
62. char test_data[] =
    
63.     "I've been reading books of old \r\n\
    
64.     The legends and the myths \r\n\
    
65.     Achilles and his gold \r\n\
    
66.     Hercules and his gifts \r\n\
    
67.     Spiderman's control \r\n\
    
68.     And Batman with his fists\r\n\
    
69.     And clearly I don't see myself upon that list\r\n\
    
70.     But she said, where'd you wanna go?\r\n\
    
71.     How much you wanna risk?\r\n\
    
72.     I'm not looking for somebody\r\n\
    
73.     With some superhuman gifts\r\n\
    
74.     Some superhero\r\n\
    
75.     Some fairytale bliss\r\n\
    
76.     Just something I can turn to\r\n\
    
77.     Somebody I can kiss\r\n\
    
78.     I want something just like this\r\n\r\n";
    
79. 
    
80. BYTE RW_Buffer[32 * 1024] = { 0 };
    
81. #if SDU_DATA_CHECK
    
82. BYTE Check_Buffer[sizeof(RW_Buffer)] = { 0 };
    
83. #endif
    
84. 
    
85. void fatfs_write_read_test()
    
86. {
    
87.     FRESULT ret;
    
88.     FIL fnew;
    
89.     UINT fnum;
    
90. 
    
91.     uint32_t time_node, i, j;
    
92. 
    
93.     /* full test data to buff */
    
94.     for (uint32_t size = 0; size < (sizeof(RW_Buffer) - sizeof(test_data)); size += sizeof(test_data)) {
    
95.         memcpy(&RW_Buffer[size], test_data, sizeof(test_data));
    
96. #if SDU_DATA_CHECK
    
97.         memcpy(&Check_Buffer[size], test_data, sizeof(test_data));
    
98. #endif
    
99.     }
    
100. 
     
101.     /* write test */
     
102.     LOG_I("\r\n******************** be about to write test... **********************\r\n");
     
103.     ret = f_open(&fnew, "/sd/test_file.txt", FA_CREATE_ALWAYS | FA_WRITE);
     
104.     if (ret == FR_OK) {
     
105.         time_node = (uint32_t)bflb_mtimer_get_time_ms();
     
106.         /*write into file*/
     
107.         ret = f_write(&fnew, RW_Buffer, 1024, &fnum);
     
108.         for (i = 0; i < 1024; i++) {
     
109.             ret = f_write(&fnew, RW_Buffer, sizeof(RW_Buffer), &fnum);
     
110.             if (ret) {
     
111.                 break;
     
112.             }
     
113.         }
     
114. 
     
115.         /* close file */
     
116.         ret |= f_close(&fnew);
     
117.         /* get time */
     
118.         time_node = (uint32_t)bflb_mtimer_get_time_ms() - time_node;
     
119. 
     
120.         if (ret == FR_OK) {
     
121.             LOG_I("Write Test Succeed! \r\n");
     
122.             LOG_I("Single data size:%d Byte, Write the number:%d, Total size:%d KB\r\n", sizeof(RW_Buffer), i, sizeof(RW_Buffer) * i >> 10);
     
123.             LOG_I("Time:%dms, Write Speed:%d KB/s \r\n", time_node, ((sizeof(RW_Buffer) * i) >> 10) * 1000 / time_node);
     
124.         } else {
     
125.             LOG_F("Fail to write files(%d) num:%d\n", ret, i);
     
126.             return;
     
127.         }
     
128.     } else {
     
129.         LOG_F("Fail to open or create files: %d.\r\n", ret);
     
130.         return;
     
131.     }
     
132. 
     
133.     /* read test */
     
134.     LOG_I("\r\n******************** be about to read test... **********************\r\n");
     
135.     ret = f_open(&fnew, "/sd/test_file.txt", FA_OPEN_EXISTING | FA_READ);
     
136.     if (ret == FR_OK) {
     
137.         time_node = (uint32_t)bflb_mtimer_get_time_ms();
     
138. 
     
139.         ret = f_read(&fnew, RW_Buffer, 1024, &fnum);
     
140.         for (i = 0; i < 1024; i++) {
     
141.             ret = f_read(&fnew, RW_Buffer, sizeof(RW_Buffer), &fnum);
     
142.             if (ret) {
     
143.                 break;
     
144.             }
     
145.         }
     
146.         /* close file */
     
147.         ret |= f_close(&fnew);
     
148.         /* get time */
     
149.         time_node = (uint32_t)bflb_mtimer_get_time_ms() - time_node;
     
150. 
     
151.         if (ret == FR_OK) {
     
152.             LOG_I("Read Test Succeed! \r\n");
     
153.             LOG_I("Single data size:%dByte, Read the number:%d, Total size:%d KB\r\n", sizeof(RW_Buffer), i, sizeof(RW_Buffer) * i >> 10);
     
154.             LOG_I("Time:%dms, Read Speed:%d KB/s \r\n", time_node, ((sizeof(RW_Buffer) * i) >> 10) * 1000 / time_node);
     
155.         } else {
     
156.             LOG_F("Fail to read file: (%d), num:%d\n", ret, i);
     
157.             return;
     
158.         }
     
159.     } else {
     
160.         LOG_F("Fail to open files.\r\n");
     
161.         return;
     
162.     }
     
163. 
     
164.     /* check data */
     
165. #if SDU_DATA_CHECK
     
166.     LOG_I("\r\n******************** be about to check test... **********************\r\n");
     
167.     ret = f_open(&fnew, "/sd/test_file.txt", FA_OPEN_EXISTING | FA_READ);
     
168.     if (ret == FR_OK) {
     
169.         ret = f_read(&fnew, RW_Buffer, 1024, &fnum);
     
170.         for (i = 0; i < 1024; i++) {
     
171.             ret = f_read(&fnew, RW_Buffer, sizeof(RW_Buffer), &fnum);
     
172.             if (ret) {
     
173.                 break;
     
174.             }
     
175.             for (j = 0; j < sizeof(RW_Buffer); j++) {
     
176.                 if (RW_Buffer[j] != Check_Buffer[j]) {
     
177.                     break;
     
178.                 }
     
179.             }
     
180.             if (j < sizeof(RW_Buffer)) {
     
181.                 break;
     
182.             }
     
183.         }
     
184.         /* close file */
     
185.         ret |= f_close(&fnew);
     
186. 
     
187.         if (ret == FR_OK) {
     
188.             if (i < 1024 || j < sizeof(RW_Buffer)) {
     
189.                 LOG_I("Check Test Error! \r\n");
     
190.                 LOG_I("Data Error!  Num:%d/1024, Byte:%d/%d", i, j, sizeof(RW_Buffer));
     
191.             } else {
     
192.                 LOG_I("Check Test Succeed! \r\n");
     
193.                 LOG_I("All Data Is Good! \r\n");
     
194.             }
     
195. 
     
196.         } else {
     
197.             LOG_F("Fail to read file: (%d), num:%d\n", ret, i);
     
198.             return;
     
199.         }
     
200.     } else {
     
201.         LOG_F("Fail to open files.\r\n");
     
202.         return;
     
203.     }
     
204. #endif
     
205. }
     
206. 
     
207. int main(void)
     
208. {
     
209.     board_init();
     
210. 
     
211.     filesystem_init();
     
212. 
     
213.     fatfs_write_read_test();
     
214. 
     
215. #if defined(CONFIG_NEWLIB) && CONFIG_NEWLIB && defined(CONFIG_NEWLIB_FATFS) && CONFIG_NEWLIB_FATFS
     
216.     FILE *fp;
     
217.     fp = fopen("/sd/hellotest.txt", "w+");
     
218.     fprintf(fp, "hello world\r\n");
     
219.     fclose(fp);
     
220. #endif
     
221. 
     
222.     while (1) {
     
223.         bflb_mtimer_delay_ms(200);
     
224.     }
     
225. }
     

复制代码

赞

赞👍

赞

赞

更详细的操作可以参考小安派 cam 那个里面操作sd卡的逻辑比较多一些

赞

赞

赞