FATFS功能中fopen函数运行异常

feiyinglala

背景：STM32F429，使用SDIO端口驱动SD卡问题和现象：
1.在main函数中SD卡初始化、往里边写TXT都是正常的
2.在我自己的数据记录函数初始化中，同样的语句，就运行不下去了，用仿真跟踪发现在f_open()函数跑飞的，仿真进去参数对比如下图



主函数代码如下

1. while(SD_Init())        //检测不到SD卡
   
2.         {//SD_Init 中后续若需要，添加DMA代码
   
3.     printf("SD Card Error!\r\n");
   
4.         }
   
5.         show_sdcard_info();        //打印SD卡相关信息
   
6. 
   
7.         usmart_dev.init(84);                //初始化USMART【FAT用】初始化串口控制器84MHz
   
8.         exfuns_init();                                                        //【要】为fatfs相关变量申请内存(为每个磁盘、FILE/FTEMP/FATBUF各申请一块内存)
   
9.           f_mount(fs[0],"0:",1);                                         //【要】挂载SD卡                         来自ff.c
   
10.          FAT_res=f_mount(fs[1],"1:",1);                         //挂载FLASH.                 来自ff.c
    
11.         if(FAT_res==0X0D)//FLASH磁盘,FAT文件系统错误,重新格式化FLASH
    
12.         {
    
13.                 FAT_res=f_mkfs("1:",1,4096);//格式化FLASH,1,盘符;1,不需要引导区,8个扇区为1个簇
    
14.                 if(FAT_res==0)
    
15.                 {
    
16.                         f_setlabel((const TCHAR *)"1:ALIENTEK");        //设置Flash磁盘的名字为：ALIENTEK
    
17. }else
    
18.                 Delay_ms(1000);
    
19.         }                                                                                                            
    
20. <blockquote>res=f_open(&fil,"0:/message20250524.txt",FA_CREATE_ALWAYS|FA_WRITE);

复制代码

数据记录函数初始化

1. // 初始化SD卡日志系统
   
2. void SDLogger_Init(void) {
   
3.     FRESULT res;
   
4.         FIL fil_CSV;
   
5.     char filename[32];
   
6.     uint32_t counter = 0;
   
7.    
   
8.         res=f_open(&fil_CSV,"0:/message20250526.txt",FA_CREATE_ALWAYS|FA_WRITE);
   
9.         f_write(&fil_CSV,"Hello Fatfs!Welcome to your UAV trip! CSV\r\n",41,&bw);        //文件指针、写入数据指针、字符数、
   
10.         f_close(&fil_CSV);
    
11.         }

复制代码

fopen函数代码如下

1. FRESULT f_open (
   
2.         FIL* fp,                        /* Pointer to the blank file object */
   
3.         const TCHAR* path,        /* Pointer to the file name */
   
4.         BYTE mode                        /* Access mode and file open mode flags */
   
5. )
   
6. {
   
7.         FRESULT res;
   
8.         DIR dj;
   
9.         BYTE *dir;
   
10.         DEF_NAMEBUF;
    
11. 
    
12. 
    
13.         if (!fp) return FR_INVALID_OBJECT;
    
14.         fp->fs = 0;                        /* Clear file object */
    
15. 
    
16.         /* Get logical drive number */
    
17. #if !_FS_READONLY
    
18.         mode &= FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW;
    
19.         res = find_volume(&dj.fs, &path, (BYTE)(mode & ~FA_READ));
    
20. #else
    
21.         mode &= FA_READ;
    
22.         res = find_volume(&dj.fs, &path, 0);
    
23. #endif
    
24.         if (res == FR_OK) {
    
25.                 INIT_BUF(dj);
    
26.                 res = follow_path(&dj, path);        /* Follow the file path */
    
27.                 dir = dj.dir;
    
28. #if !_FS_READONLY        /* R/W configuration */
    
29.                 if (res == FR_OK) {
    
30.                         if (!dir)        /* Default directory itself */
    
31.                                 res = FR_INVALID_NAME;
    
32. #if _FS_LOCK
    
33.                         else
    
34.                                 res = chk_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
    
35. #endif
    
36.                 }
    
37.                 /* Create or Open a file */
    
38.                 if (mode & (FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)) {
    
39.                         DWORD dw, cl;
    
40. 
    
41.                         if (res != FR_OK) {                                        /* No file, create new */
    
42.                                 if (res == FR_NO_FILE)                        /* There is no file to open, create a new entry */
    
43. #if _FS_LOCK
    
44.                                         res = enq_lock() ? dir_register(&dj) : FR_TOO_MANY_OPEN_FILES;
    
45. #else
    
46.                                         res = dir_register(&dj);
    
47. #endif
    
48.                                 mode |= FA_CREATE_ALWAYS;                /* File is created */
    
49.                                 dir = dj.dir;                                        /* New entry */
    
50.                         }
    
51.                         else {                                                                /* Any object is already existing */
    
52.                                 if (dir[DIR_Attr] & (AM_RDO | AM_DIR)) {        /* Cannot overwrite it (R/O or DIR) */
    
53.                                         res = FR_DENIED;
    
54.                                 } else {
    
55.                                         if (mode & FA_CREATE_NEW)        /* Cannot create as new file */
    
56.                                                 res = FR_EXIST;
    
57.                                 }
    
58.                         }
    
59.                         if (res == FR_OK && (mode & FA_CREATE_ALWAYS)) {        /* Truncate it if overwrite mode */
    
60.                                 dw = get_fattime();                                /* Created time */
    
61.                                 ST_DWORD(dir+DIR_CrtTime, dw);
    
62.                                 dir[DIR_Attr] = 0;                                /* Reset attribute */
    
63.                                 ST_DWORD(dir+DIR_FileSize, 0);        /* size = 0 */
    
64.                                 cl = ld_clust(dj.fs, dir);                /* Get start cluster */
    
65.                                 st_clust(dir, 0);                                /* cluster = 0 */
    
66.                                 dj.fs->wflag = 1;
    
67.                                 if (cl) {                                                /* Remove the cluster chain if exist */
    
68.                                         dw = dj.fs->winsect;
    
69.                                         res = remove_chain(dj.fs, cl);
    
70.                                         if (res == FR_OK) {
    
71.                                                 dj.fs->last_clust = cl - 1;        /* Reuse the cluster hole */
    
72.                                                 res = move_window(dj.fs, dw);
    
73.                                         }
    
74.                                 }
    
75.                         }
    
76.                 }
    
77.                 else {        /* Open an existing file */
    
78.                         if (res == FR_OK) {                                        /* Follow succeeded */
    
79.                                 if (dir[DIR_Attr] & AM_DIR) {        /* It is a directory */
    
80.                                         res = FR_NO_FILE;
    
81.                                 } else {
    
82.                                         if ((mode & FA_WRITE) && (dir[DIR_Attr] & AM_RDO)) /* R/O violation */
    
83.                                                 res = FR_DENIED;
    
84.                                 }
    
85.                         }
    
86.                 }
    
87.                 if (res == FR_OK) {
    
88.                         if (mode & FA_CREATE_ALWAYS)                /* Set file change flag if created or overwritten */
    
89.                                 mode |= FA__WRITTEN;
    
90.                         fp->dir_sect = dj.fs->winsect;                /* Pointer to the directory entry */
    
91.                         fp->dir_ptr = dir;
    
92. #if _FS_LOCK
    
93.                         fp->lockid = inc_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
    
94.                         if (!fp->lockid) res = FR_INT_ERR;
    
95. #endif
    
96.                 }
    
97. 
    
98. #else                                /* R/O configuration */
    
99.                 if (res == FR_OK) {                                        /* Follow succeeded */
    
100.                         dir = dj.dir;
     
101.                         if (!dir) {                                                /* Current directory itself */
     
102.                                 res = FR_INVALID_NAME;
     
103.                         } else {
     
104.                                 if (dir[DIR_Attr] & AM_DIR)        /* It is a directory */
     
105.                                         res = FR_NO_FILE;
     
106.                         }
     
107.                 }
     
108. #endif
     
109.                 FREE_BUF();
     
110. 
     
111.                 if (res == FR_OK) {
     
112.                         fp->flag = mode;                                        /* File access mode */
     
113.                         fp->err = 0;                                                /* Clear error flag */
     
114.                         fp->sclust = ld_clust(dj.fs, dir);        /* File start cluster */
     
115.                         fp->fsize = LD_DWORD(dir+DIR_FileSize);        /* File size */
     
116.                         fp->fptr = 0;                                                /* File pointer */
     
117.                         fp->dsect = 0;
     
118. #if _USE_FASTSEEK
     
119.                         fp->cltbl = 0;                                                /* Normal seek mode */
     
120. #endif
     
121.                         fp->fs = dj.fs;                                                 /* Validate file object */
     
122.                         fp->id = fp->fs->id;
     
123.                 }
     
124.         }
     
125. 
     
126.         LEAVE_FF(dj.fs, res);
     
127. }
     

复制代码

feiyinglala

我应该重点排查哪块，仿真跟踪了半天，还是没抓住重点

正点原子

局部变量太多？

feiyinglala

正点原子 发表于 2025-6-8 18:55
局部变量太多？

原子哥，谢谢指点。我试试在主函数中操作。

正点原子

feiyinglala 发表于 2025-6-10 21:35
原子哥，谢谢指点。我试试在主函数中操作。

定义成全局数组

feiyinglala

正点原子 发表于 2025-6-15 20:46
定义成全局数组

之前仿照https://blog.csdn.net/qq_39538698/article/details/147270657
将stack_size变为100，还是没解决我的问题

刚发现点眉目，原因是我自己定义的一个任务调度定时器初始化干扰了fopen的函数运行。
之前情况：这个定时器调度函数是在第一个fopen和第二个fopen之间，现象就是第一个可以运行，第二个就跑飞
刚刚调试：这个定时器调度函数放在第二个fopen之后，现象就是第一个 第二个fopen函数就都可以运行通过了。第二次的文件操作，也在SD卡上看到了数据落盘了