STM32F407单片机通过FATFS文件系统写SD卡正确率只有98%，但是偶而出错，该如何彻底根治

霸王猫 · 发表于 2021-4-8 11:32:28

我的单片机每隔10分钟自动重启（有重启电路，每次大概运行2分钟，运行完毕，自动关闭电源，下个整点到时，自动重启）。

   每次运行时，先采集三路模拟量数据，然后将采集的模拟量数据写到SD卡，每个模拟量数据写一行，3个模拟量数据写三行。
经过长期运行观察，正确写SD卡的成功率达到98%，但是始终有2%的错误，发现偶而出现如下四种错误现象。

   1、有时候SD卡的文件中会漏写三行。（注：共采集三路模拟量数据，每路模拟量数据写一行，3路模拟量数据写三行）
            即：该次的数据没有被写到SD卡的文件中。
   2、有时候SD卡的文件中会漏写二行。（注：共采集三路模拟量数据，每路模拟量数据写一行，3路模拟量数据写三行）
            即：该次的数据只有一路模拟量被写到SD卡的文件中，另外二路没有被写到SD卡的文件中。
   3、有时候SD卡的文件中会漏写一行。（注：共采集三路模拟量数据，每路模拟量数据写一行，3路模拟量数据写三行）
            即：该次的数据只有二路模拟量被写到SD卡的文件中，另外一路没有被写到SD卡的文件中。
   4、有时候创建的文件不能写入数据到文件中，该文件是个空文件，拨掉SD卡，插入电脑插口，只要拷贝该空文件到电脑上，就报错。

/*********************************************************************************************************
* 说明 : 本例程移植FatFS文件系统（版本 R0.09b）
*********************************************************************************************************/
void PRINT_FileFatFS(void)
{
FRESULT result;
FATFS fs;
FIL file;
DIR DirInf;
uint32_t bw;
uint32_t fil_size;
char FileName[50];
if (!GPIO_SD_READY())
{
//printf("插槽中没有插入SD卡\r\n");
return ;
}
/* 挂载文件系统 */
result = f_mount(FS_SD, &fs); /* Mount a logical drive */
if (result != FR_OK)
{
//printf("挂载文件系统失败 (%d)\r\n", result);
return ;
}
/* 打开根文件夹 */
result = f_opendir(&DirInf, "/"); /* 如果不带参数，则从当前目录开始 */
if (result != FR_OK)
{
//printf("打开根目录失败 (%d)\r\n");
/* 卸载文件系统 */
f_mount(FS_SD, NULL);
return ;
}
/* 打开文件 */
strcpy(FileName ,"TEST.csv");
result = f_open(&file, FileName, FA_OPEN_ALWAYS | FA_WRITE);
if (result == FR_OK)
{
fil_size = f_size(&file);
result = f_lseek(&file,fil_size);
if (result == FR_OK)
{
Printf_FATFS_COM_Buffer(enum_COM1_CHANNEL_NO); //生成第一路模拟量数据
result = f_write(&file, FATFS_COM_Buffer , strlen(FATFS_COM_Buffer), &bw); //往SD卡写第一路模拟量数据
Printf_FATFS_COM_Buffer(enum_COM2_CHANNEL_NO); //生成第二路模拟量数据
result = f_write(&file, FATFS_COM_Buffer , strlen(FATFS_COM_Buffer), &bw); //往SD卡写第二路模拟量数据
Printf_FATFS_COM_Buffer(enum_COM3_CHANNEL_NO); //生成第三路模拟量数据
result = f_write(&file, FATFS_COM_Buffer , strlen(FATFS_COM_Buffer), &bw); //往SD卡写第三路模拟量数据
}//if (result == FR_OK)
}//if (result == FR_OK)
/* 关闭文件*/
f_close(&file);
/* 卸载文件系统 */
f_mount(FS_SD, NULL);
}

复制代码

下面是SD卡底层移植函数

/**************************************************************************************/
//SD卡SPI驱动程序
/**************************************************************************************/
#include "MMC_SD.h"
#include "BSP_SPI.h"
u8 SD_Type=0;//SD卡的类型
//SD卡初始化的时候,需要低速
void SD_SPI_SpeedLow(void)
{
//SPI2_SetSpeed(SPI_BaudRatePrescaler_256);//设置到低速模式
SPI1_SetSpeed(enum_SPI_SPEED_LOW);
}
//SD卡正常工作的时候,可以配置为高速
void SD_SPI_SpeedHigh(void)
{
//SPI1_SetSpeed(SPI_BaudRatePrescaler_8);//设置到高速模式
SPI1_SetSpeed(enum_SPI_SPEED_HIGH);
}
//取消选择,释放SPI总线
void SD_DisSelect(void)
{
GPIO_SetBits(GPIOA,GPIO_Pin_4);
SPI_WriteByte(0xff);//提供额外的8个时钟
}
//选择sd卡,并且等待卡准备OK
//返回值:0,成功;1,失败;
u8 SD_Select(void)
{
GPIO_ResetBits(GPIOA,GPIO_Pin_4);
if(SD_WaitReady()==0)return 0;//等待成功
SD_DisSelect();
return 1;//等待失败
}
//等待卡准备好
//返回值:0,准备好了;其他,错误代码
u8 SD_WaitReady(void)
{
u32 t=0;
do
{
if (SPI_ReadByte()==0XFF)return 0;//OK
t++;
}while(t<0XFFF);//等待
return 1;
}
//等待SD卡回应
//Response:要得到的回应值
//返回值:0,成功得到了该回应值
// 其他,得到回应值失败
u8 SD_GetResponse(u8 Response)
{
u16 Count=0xFFFF;//等待次数
while ((SPI_ReadByte()!=Response) && Count) Count--;//等待得到准确的回应(等待得到读取数据令牌0xfe)
if (Count==0)
return MSD_RESPONSE_FAILURE; //得到回应失败
else
return MSD_RESPONSE_NO_ERROR; //正确回应
}
//从sd卡读取一个数据包的内容
//buf:数据缓存区
//len:要读取的数据长度.
//返回值:0,成功;其他,失败;
u8 SD_RecvData(u8*buf,u16 len)
{
if (SD_GetResponse(0xFE)) return 1;//等待SD卡发回数据起始令牌0xFE
while(len--)//开始接收数据
{
*buf=SPI_ReadByte();
buf++;
}
//下面是2个伪CRC（dummy CRC）
SPI_WriteByte(0xFF);
SPI_WriteByte(0xFF);
return 0;//读取成功
}
//向sd卡写入一个数据包的内容 512字节
//buf:数据缓存区
//cmd:指令
//返回值:0,成功;其他,失败;
u8 SD_SendBlock(u8*buf,u8 cmd)
{
u16 t;
if(SD_WaitReady())return 1;//等待准备失效
SPI_WriteByte(cmd);
if(cmd!=0XFD)//不是结束指令
{
for(t=0; t<512; t++)SPI_WriteByte(buf[t]); //提高速度,减少函数传参时间
SPI_WriteByte(0xFF);//忽略crc
SPI_WriteByte(0xFF);
t=SPI_ReadByte();//接收响应
if((t&0x1F)!=0x05)return 2;//响应错误
}
return 0;//写入成功
}
//向SD卡发送一个命令
//输入: u8 cmd 命令
// u32 arg 命令参数
// u8 crc crc校验值
//返回值:SD卡返回的响应
u8 SD_SendCmd(u8 cmd, u32 arg, u8 crc)
{
u8 r1;
u8 Retry=0;
SD_DisSelect();//取消上次片选
if(SD_Select())return 0XFF;//片选失效
//发送
SPI_WriteByte(cmd | 0x40);//分别写入命令
SPI_WriteByte(arg >> 24);
SPI_WriteByte(arg >> 16);
SPI_WriteByte(arg >> 8);
SPI_WriteByte(arg);
SPI_WriteByte(crc);
if(cmd==CMD12)SPI_WriteByte(0xff);//Skip a stuff byte when stop reading
//等待响应，或超时退出
Retry=0X1F;
do
{
r1=SPI_ReadByte();
}
while((r1&0X80) && Retry--);
//返回状态值
return r1;
}
//获取SD卡的CID信息，包括制造商信息
//输入: u8 *cid_data(存放CID的内存，至少16Byte）
//返回值:0：NO_ERR
// 1：错误
u8 SD_GetCID(u8 *cid_data)
{
u8 r1;
//发CMD10命令，读CID
r1=SD_SendCmd(CMD10,0,0x01);
if(r1==0x00)
{
r1=SD_RecvData(cid_data,16);//接收16个字节的数据
}
SD_DisSelect();//取消片选
if(r1)return 1;
else return 0;
}
//获取SD卡的CSD信息，包括容量和速度信息
//输入:u8 *cid_data(存放CID的内存，至少16Byte）
//返回值:0：NO_ERR
// 1：错误
u8 SD_GetCSD(u8 *csd_data)
{
u8 r1;
r1=SD_SendCmd(CMD9,0,0x01);//发CMD9命令，读CSD
if(r1==0)
{
r1=SD_RecvData(csd_data, 16);//接收16个字节的数据
}
SD_DisSelect();//取消片选
if(r1)return 1;
else return 0;
}
//获取SD卡的总扇区数（扇区数）
//返回值:0：取容量出错
// 其他:SD卡的容量(扇区数/512字节)
//每扇区的字节数必为512，因为如果不是512，则初始化不能通过.
u32 SD_GetSectorCount(void)
{
u8 csd[16];
u32 Capacity;
u8 n;
u16 csize;
//取CSD信息，如果期间出错，返回0
if(SD_GetCSD(csd)!=0) return 0;
//如果为SDHC卡，按照下面方式计算
if((csd[0]&0xC0)==0x40) //V2.00的卡
{
csize = csd[9] + ((u16)csd[8] << 8) + 1;
Capacity = (u32)csize << 10;//得到扇区数
}
else //V1.XX的卡
{
n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
csize = (csd[8] >> 6) + ((u16)csd[7] << 2) + ((u16)(csd[6] & 3) << 10) + 1;
Capacity= (u32)csize << (n - 9);//得到扇区数
}
return Capacity;
}
//初始化SD卡
u8 SD_Initialize(void)
{
u8 r1; // 存放SD卡的返回值
u16 retry; // 用来进行超时计数
u8 buf[4];
u16 i;
SPI1_Configuration();
SD_SPI_SpeedLow(); //设置到低速模式
for(i=0; i<15; i++)SPI_WriteByte(0XFF); //发送最少74个脉冲
retry=2000;
do
{
r1=SD_SendCmd(CMD0,0,0x95);//进入IDLE状态
}
while((r1!=0X01) && retry--);
SD_Type=0;//默认无卡
if(r1==0X01)
{
if(SD_SendCmd(CMD8,0x1AA,0x87)==1)//SD V2.0
{
for(i=0; i<4; i++)buf[i] = SPI_ReadWriteByte(0XFF); //Get trailing return value of R7 resp
if(buf[2]==0X01&&buf[3]==0XAA)//卡是否支持2.7~3.6V
{
retry=0XFFFE;
do
{
SD_SendCmd(CMD55,0,0X01); //发送CMD55
r1=SD_SendCmd(CMD41,0x40000000,0X01);//发送CMD41
}
while(r1&&retry--);
if(retry&&SD_SendCmd(CMD58,0,0X01)==0)//鉴别SD2.0卡版本开始
{
for(i=0; i<4; i++)buf[i] = SPI_ReadWriteByte(0XFF); //得到OCR值
if(buf[0]&0x40)SD_Type=SD_TYPE_V2HC; //检查CCS
else SD_Type=SD_TYPE_V2;
}
}
}
else //SD V1.x/ MMC V3
{
SD_SendCmd(CMD55,0,0X01); //发送CMD55
r1=SD_SendCmd(CMD41,0,0X01); //发送CMD41
if(r1<=1)
{
SD_Type=SD_TYPE_V1;
retry=0XFFFE;
do //等待退出IDLE模式
{
SD_SendCmd(CMD55,0,0X01); //发送CMD55
r1=SD_SendCmd(CMD41,0,0X01);//发送CMD41
}
while(r1&&retry--);
}
else
{
SD_Type=SD_TYPE_MMC;//MMC V3
retry=0XFFFE;
do //等待退出IDLE模式
{
r1=SD_SendCmd(CMD1,0,0X01);//发送CMD1
}
while(r1&&retry--);
}
if(retry==0||SD_SendCmd(CMD16,512,0X01)!=0)SD_Type=SD_TYPE_ERR;//错误的卡
}
}
SD_DisSelect();//取消片选
SD_SPI_SpeedHigh();//SPI配置为高速模式
if (SD_Type)
return 0;
else if(r1)
return r1;
return (0xaa);//其他错误
}
//读SD卡
//buf:数据缓存区
//sector:扇区
//cnt:扇区数
//返回值:0,ok;其他,失败.
u8 SD_ReadDisk(u8*buf,u32 sector,u8 cnt)
{
u8 r1;
if(SD_Type!=SD_TYPE_V2HC)sector <<= 9;//转换为字节地址
if(cnt==1)
{
r1=SD_SendCmd(CMD17,sector,0X01);//读命令
if(r1==0)//指令发送成功
{
r1=SD_RecvData(buf,512);//接收512个字节
}
}
else
{
r1=SD_SendCmd(CMD18,sector,0X01);//连续读命令
do
{
r1=SD_RecvData(buf,512);//接收512个字节
buf+=512;
}
while(--cnt && r1==0);
SD_SendCmd(CMD12,0,0X01); //发送停止命令
}
SD_DisSelect();//取消片选
return r1;//
}
//写SD卡
//buf:数据缓存区
//sector:起始扇区
//cnt:扇区数
//返回值:0,ok;其他,失败.
u8 SD_WriteDisk(u8*buf,u32 sector,u8 cnt)
{
u8 r1;
if(SD_Type!=SD_TYPE_V2HC)sector *= 512;//转换为字节地址
if(cnt==1)
{
r1=SD_SendCmd(CMD24,sector,0X01);//读命令
if(r1==0)//指令发送成功
{
r1=SD_SendBlock(buf,0xFE);//写512个字节
}
}
else
{
if(SD_Type!=SD_TYPE_MMC)
{
SD_SendCmd(CMD55,0,0X01);
SD_SendCmd(CMD23,cnt,0X01);//发送指令
}
r1=SD_SendCmd(CMD25,sector,0X01);//连续读命令
if(r1==0)
{
do
{
r1=SD_SendBlock(buf,0xFC);//接收512个字节
buf+=512;
}
while(--cnt && r1==0);
r1=SD_SendBlock(0,0xFD);//接收512个字节
}
}
SD_DisSelect();//取消片选
return r1;//
}

复制代码

下面是SPI硬件中断配置

void SPI1_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_SPI1);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_SPI1);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_SPI1);
//Configure SPI1 Pins: SCK, MISO and MOSI
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//Configure NSS Pin
//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4; //CS/NSS
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_SetBits(GPIOA, GPIO_Pin_4);//不选中（关闭片选）--->低电平选通SD卡
SPI_I2S_DeInit(SPI1);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,ENABLE); //复位SPI1
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,DISABLE);//停止复位SPI1
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; //双线双向全双工
SPI_InitStructure.SPI_Mode = SPI_Mode_Master; //主器件
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; //8位数据长度
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High; //这里要注意，一定要配置为上升沿数据有效，因为SD卡为上升沿数据有效
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge; //这里要注意，一定要配置为SPI_CPHA_2Edge（数据捕获于第2个时钟沿），参见SD卡协议要求
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; //NSS信号由外部管脚管理
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;//SPI速度为低速
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; //数据传输的第一个字节为MSB
SPI_InitStructure.SPI_CRCPolynomial = 7; //CRC的多项式
SPI_Init(SPI1,&SPI_InitStructure);
SPI_Cmd(SPI1,DISABLE);
SPI_Cmd(SPI1,ENABLE);
}
//SPI 速度设置函数
//SpeedSet:
//SPI_BaudRatePrescaler_2 2分频 (SPI 36M[url=home.php?mod=space&uid=19210]@sys[/url] 72M)
//SPI_BaudRatePrescaler_8 8分频 (SPI 9M@sys 72M)
//SPI_BaudRatePrescaler_16 16分频 (SPI 4.5M@sys 72M)
//SPI_BaudRatePrescaler_256 256分频 (SPI 281.25K@sys 72M)
void SPI1_SetSpeed(uint8_t SpeedSet)
{
SPI_InitTypeDef SPI_InitStructure;
SPI_I2S_DeInit(SPI1);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,ENABLE); //复位SPI1
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,DISABLE);//停止复位SPI1
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; //双线双向全双工
SPI_InitStructure.SPI_Mode = SPI_Mode_Master; //主器件
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; //8位数据长度
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High; //这里要注意，一定要配置为上升沿数据有效，因为SD卡为上升沿数据有效
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge; //这里要注意，一定要配置为SPI_CPHA_2Edge（数据捕获于第2个时钟沿），参见SD卡协议要求
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; //NSS信号由外部管脚管理
switch (SpeedSet)
{
case enum_SPI_SPEED_LOW:
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;//设置到低速模式
break;
case enum_SPI_SPEED_HIGH:
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16; //设置到高速模式
break;
default:
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;//设置到低速模式
break;
}
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; //数据传输的第一个字节为MSB
SPI_InitStructure.SPI_CRCPolynomial = 7; //CRC的多项式
SPI_Init(SPI1,&SPI_InitStructure);
SPI_Cmd(SPI1 , DISABLE);
SPI_Cmd(SPI1 , ENABLE);
}
void SPI_WriteByte(uint8_t _ucByte)
{
while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_TXE )==RESET); //等待数据发送寄存器清空
SPI_I2S_SendData(SPI1 , _ucByte); //通过SPI发送出去一个字节数据
while(SPI_I2S_GetFlagStatus(SPI1 , SPI_I2S_FLAG_RXNE )==RESET); //等待接收到一个数据（接收到一个数据就相当于发送一个数据完毕）
SPI_I2S_ReceiveData(SPI1); //返回接收到的数据
}
uint8_t SPI_ReadByte(void)
{
uint8_t ch;
while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_TXE )==RESET);
SPI_I2S_SendData(SPI1 , 0xFF);
while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_RXNE )==RESET);
ch = SPI_I2S_ReceiveData(SPI1);
return (ch);
}
uint8_t SPI_ReadWriteByte(uint8_t _ucByte)
{
uint8_t ch;
while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET); // 等待发送缓冲区空
SPI_I2S_SendData(SPI1, _ucByte);
while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET); // 等待数据接收完毕
ch = SPI_I2S_ReceiveData(SPI1);
return (ch);
}

复制代码

霸王猫 · 发表于 2021-4-8 11:32:29

解决方法: 对程序进行如下改造：
   1、第一步：
      挂载文件系统
   2、第二步：
         打开根目录
   3、第三步：
         打开文件
   4、第四步
         移动文件指针到文件尾
   5、第五步：
         写第一行数据，延时一段时间
   6、第六步：
         写第二行数据，延时一段时间
   7、第七步：
         写第三行数据

经过上述处理，没有再出现之前的情况，搞不懂，为什么打开文件写完第一行332字节之后，必须要延时一点时间才能写第二行332个字节呢？

void PRINT_TemperatureFatFS(uint8_t mode)
{
      char FileName[50];


      /* 挂载文件系统 */
      result = f_mount(FS_SD, &fs);             /* Mount a logical drive */
      if (result != FR_OK)
      {
            //printf("挂载文件系统失败 (%d)\r\n", result);

            I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE1-1]++;       //记录FATFS 挂载文件系统失败次数到I2C芯片中存储
            AT24C512_Write_configuration_PARAMETERS();
            return ;
      }

      /* 打开根文件夹 */
      result = f_opendir(&DirInf, "/");       /* 如果不带参数，则从当前目录开始 */
      if (result != FR_OK)
      {
            //printf("打开根目录失败 (%d)\r\n");
            /* 卸载文件系统 */
            I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE2-1]++;       //记录FATFS 打开根文件夹失败次数到I2C芯片中存储
            AT24C512_Write_configuration_PARAMETERS();
            /* 卸载文件系统 */
            f_mount(FS_SD, NULL);
            return ;
      }


      /* 打开文件 */
      sprintf(FileName ,"B082-%02X%02X%02X%02X%02X%02X.csv"             ,MAC_ADDRESS_Buffer[0] , MAC_ADDRESS_Buffer[1] , MAC_ADDRESS_Buffer[2] , MAC_ADDRESS_Buffer[3] , MAC_ADDRESS_Buffer[4] , MAC_ADDRESS_Buffer[5]);
      result = f_open(&file, FileName, FA_OPEN_ALWAYS | FA_WRITE);



      if (result != FR_OK)
      {
            I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE3-1]++;       //记录FATFS 打开文件失败次数到I2C芯片中存储
            AT24C512_Write_configuration_PARAMETERS();
            /* 卸载文件系统 */
            f_mount(FS_SD, NULL);
            return ;
      }

      fil_size = f_size(&file);
      result = f_lseek(&file,fil_size);
      if (result != FR_OK)
      {
            I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE4-1]++;       //记录FATFS 移动文件指针到文件尾失败次数到I2C芯片中存储
            AT24C512_Write_configuration_PARAMETERS();
            /* 关闭文件*/
            f_close(&file);
            /* 卸载文件系统 */
            f_mount(FS_SD, NULL);
            return ;
      }


      result = f_write(&file, FATFS_COM_Buffer , strlen(FATFS_COM_Buffer), &bw);
      if (result != FR_OK)
      {
            I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE5-1]++;       //记录FATFS 写第一行数据时出错次数到I2C芯片中存储
            AT24C512_Write_configuration_PARAMETERS();
            /* 关闭文件*/
            f_close(&file);
            /* 卸载文件系统 */
            f_mount(FS_SD, NULL);
            return ;
      }

      WatchDog_Delay(50000); //必须要增加延时

      result = f_write(&file, FATFS_COM_Buffer , strlen(FATFS_COM_Buffer), &bw);
      if (result != FR_OK)
      {
            I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE6-1]++;       //记录FATFS 写第二行数据时出错次数到I2C芯片中存储
            AT24C512_Write_configuration_PARAMETERS();
            /* 关闭文件*/
            f_close(&file);
            /* 卸载文件系统 */
            f_mount(FS_SD, NULL);
            return ;
      }

WatchDog_Delay(50000); //必须要增加延时

      result = f_write(&file, FATFS_COM_Buffer , strlen(FATFS_COM_Buffer), &bw);
      if (result != FR_OK)
      {
            I2C_SUN_BATTERY_Buffer[I2C_SUN_SPARE1-1]++;       //记录FATFS 写第三行数据时出错次数到I2C芯片中存储
            AT24C512_Write_SUN_BATTERY_PARAMETERS();
            /* 关闭文件*/
            f_close(&file);
            /* 卸载文件系统 */
            f_mount(FS_SD, NULL);
            return ;
      }


      /* 关闭文件*/
      f_close(&file);
      /* 卸载文件系统 */
      f_mount(FS_SD, NULL);

}

LcwSwust · 发表于 2021-4-8 13:16:44

result = f_write 这里监测一下result看看，再看看文件字节数是否能对上，会不会写入的数据中有0导致读出时有遗漏。

霸王猫 · 发表于 2021-4-8 15:24:16

本帖最后由霸王猫于 2021-4-8 15:26 编辑

我怀疑是由于单片机堆栈空间分配不足造成的，原因是FATFS文件系统太占用空间啦.

                           不应该把 FATFS fs; FIL file; 定义成局部变量，而应该定义成全局变量。

1、我的单片机工程项目堆栈分配了800个WORD，参见下图。

2、FATFS的FIL结构体太占用空间啦！我有2个写SD卡的函数，每个函数都在内部定义了局部变量 FIL file;


3、FATFS的FATFS结构体太占用空间啦！我有2个写SD卡的函数，每个函数都在内部定义了局部变量 FATFS fs;

4、函数1

5、函数2

  6、MAX_SS分配了512字节

霸王猫 · 发表于 2021-4-8 15:29:00

本帖最后由霸王猫于 2021-4-8 15:30 编辑

我怀疑是由于单片机堆栈空间分配不足造成的，原因是FATFS文件系统太占用空间啦.

不应该把 FATFS fs; FIL file; 定义成局部变量，而应该定义成全局变量。

1、我的单片机工程项目堆栈分配了800个WORD，参见下图。

2、FATFS的FIL结构体太占用空间啦！我有2个写SD卡的函数，每个函数都在内部定义了局部变量 FIL file;

3、FATFS的FATFS结构体太占用空间啦！我有2个写SD卡的函数，每个函数都在内部定义了局部变量 FATFS fs;

4、函数1

5、函数2

6、MAX_SS分配了512字节

霸王猫 · 发表于 2021-4-8 15:56:52

我把 FATFS fs; FIL file; 该定义成全局变量观察一个星期试试，同时我把SD卡读写的每个环节都进行监视，如果某个环节出现错误，我会把错误次数记录到I2C芯片中，一个星期后，我通过读I2C芯片的读数就可以知道是否彻底根治了没有。

正点原子 · 发表于 2021-4-9 02:06:10

不间隔休眠，会不会出错，感觉出错可能是因为你的10分钟重启导致的

霸王猫 · 发表于 2021-4-9 08:49:57

正点原子发表于 2021-4-9 02:06
不间隔休眠，会不会出错，感觉出错可能是因为你的10分钟重启导致的

版主，你理解错啦！不是不间隔休眠，是单片机和外围设备全断电，只是板子上外挂的一块RTC实时时钟有电，当倒计时时间到时，RTC实时时钟触发低电平，让单片机重新上电。

正点原子 · 发表于 2021-4-10 01:56:40

霸王猫发表于 2021-4-9 08:49
版主，你理解错啦！不是不间隔休眠，是单片机和外围设备全断电，只是板子上外挂的一块RTC实时时钟有电， ...

我是说你断电的时候，可能文件存储没处理好。
导致数据丢失，你不断电看看还丢失不？

霸王猫 · 发表于 2021-4-10 10:19:04

正点原子发表于 2021-4-10 01:56
我是说你断电的时候，可能文件存储没处理好。
导致数据丢失，你不断电看看还丢失不？

我写完文件后，还要将数据发送到服务器（如果服务器无应答，还要等待30秒），然后再等待25秒（目的是等待GPS信号稳定，GPS信号稳定后，用GPS的的年月日时分秒来校准RTC时钟芯片的时间），最后单片机才断电。
所以不存在【我是说你断电的时候，可能文件存储没处理好。导致数据丢失】

霸王猫 · 发表于 2021-4-12 14:03:30

本帖最后由霸王猫于 2021-4-12 14:39 编辑

经过3天的运行，发现不是堆栈的原因。

我对写SD卡的所有文件系统操作相关部分都添加追踪记录方面的代码，只有发现操作失败（result != FR_OK）一次就记录一次到I2C芯片（AT24C02）中。

我对文件系统以下操作部分添加了追踪代码，发现这部分代码错误一次，就记录一次到I2C芯片（AT24C02）中。

1、 /* 挂载文件系统 */
result = f_mount(FS_SD, &fs); /* Mount a logical drive */
2、 /* 打开根文件夹 */
result = f_opendir(&DirInf, "/"); /* 如果不带参数，则从当前目录开始 */
3、 /* 打开文件 */
result = f_open(&file, FileName, FA_OPEN_ALWAYS | FA_WRITE);
4、/*移动文件指针*/
fil_size = f_size(&file);
result = f_lseek(&file,fil_size);
5、/*写数据到文件*/
result = f_write(&file, FATFS_COM_Buffer , strlen(FATFS_COM_Buffer), &bw);

复制代码

结果连续运行3天（每小时写6次，1天写144次，3天写432次），结果发现如下规律，总共错误11次，错误都发生在FATFS文件系统【5./*写数据到文件(/】这一步，其它4种情况从来都没有出过错。

      也就是说， 1、 /* 挂载文件系统 */
                        2、/* 打开根文件夹 */
                     3、 /* 打开文件 */
                     4、/*移动文件指针*/
            从来都不会发生错误
                  错误只出现在  5、/*写数据到文件*/

         我就搞不懂了，我每次只写332个字节，没有超出FATFS的缺省长度（512）呀？怎么会单单错在5、/*写数据到文件*/ 这一步呢？

以下是SD卡文件中缺失的数据（注：单片机每次向SD卡文件中写三行数据）
2021.04.08 21：50  SD卡文件中缺失第二行数据
                              SD卡文件中缺失第三行数据

2021.04.09 00：20  SD卡文件中缺失第三行数据
2021.04.09 03：00 SD卡文件中缺失第三行数据
2021.04.09 06：40 SD卡文件中缺失第三行数据

2021.04.09 08：00 SD卡文件中缺失第一行数据
2021.04.09 08：00 SD卡文件中缺失第二行数据
2021.04.09 08：00 SD卡文件中缺失第三行数据

2021.04.09 10：30 SD卡文件中缺失第三行数据

2021.04.12 10：30 SD卡文件中缺失第二行数据
2021.04.12 10：30 SD卡文件中缺失第三行数据

zhxzhx · 发表于 2021-4-13 17:44:11

本帖最后由 zhxzhx 于 2021-4-13 17:48 编辑

你写完的文件关闭了吗？不关闭数据还在缓冲区里。
最好挂载的系统也注销了

霸王猫 · 发表于 2021-4-13 19:05:37

zhxzhx 发表于 2021-4-13 17:44
你写完的文件关闭了吗？不关闭数据还在缓冲区里。
最好挂载的系统也注销了

我写完文件关闭了，同时还注销了挂载的系统。

/* 关闭文件*/
f_close(&file);
/* 卸载文件系统 */
f_mount(FS_SD, NULL);

复制代码

nashui_sx · 发表于 2021-4-13 20:55:44

本帖最后由 nashui_sx 于 2021-4-13 20:58 编辑

霸王猫发表于 2021-4-13 19:05
我写完文件关闭了，同时还注销了挂载的系统。

假如你板子上有外部flash 写到flash的文件系统试试，排除下sd的问题写flash的txt也有问题那就是你代码问题了，没问题那就是sd卡硬件及电路问题了
还有就是写sd卡的数据处理成字符串的代码会不会有bug,把写sd卡的三行数据用个固定的字符串数组试试

正点原子 · 发表于 2021-4-14 01:46:22

霸王猫发表于 2021-4-12 14:03
经过3天的运行，发现不是堆栈的原因。

我对写SD卡的所有文件系统操作相关部分都添加追踪记录方面的 ...

建议一次写512字节，或者其整数倍。。。

霸王猫 · 发表于 2021-4-15 09:57:47

nashui_sx 发表于 2021-4-13 20:55
假如你板子上有外部flash 写到flash的文件系统试试，排除下sd的问题写flash的txt也有问题那就是你代 ...

我现在固定写三行同样的字符串，字符串长度为512，字符串为512个“1”，再运行3天观察。

下面是我改造后的程序，只有有FATFS文件系统返回值的地方都进行了监控，只要发生错误，就将错误次数记录到I2C中保存，便于查看到底是在哪里出错啦。

void PRINT_TemperatureFatFS(uint8_t mode)
{
char FileName[50];
/* 挂载文件系统 */
result = f_mount(FS_SD, &fs); /* Mount a logical drive */
if (result != FR_OK)
{
//printf("挂载文件系统失败 (%d)\r\n", result);
I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE1-1]++; //记录FATFS 挂载文件系统失败次数到I2C芯片中存储
AT24C512_Write_configuration_PARAMETERS();
return ;
}
/* 打开根文件夹 */
result = f_opendir(&DirInf, "/"); /* 如果不带参数，则从当前目录开始 */
if (result != FR_OK)
{
//printf("打开根目录失败 (%d)\r\n");
/* 卸载文件系统 */
I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE2-1]++; //记录FATFS 打开根文件夹失败次数到I2C芯片中存储
AT24C512_Write_configuration_PARAMETERS();
/* 卸载文件系统 */
f_mount(FS_SD, NULL);
return ;
}
/* 打开文件 */
sprintf(FileName ,"B082-%02X%02X%02X%02X%02X%02X.csv" ,MAC_ADDRESS_Buffer[0] , MAC_ADDRESS_Buffer[1] , MAC_ADDRESS_Buffer[2] , MAC_ADDRESS_Buffer[3] , MAC_ADDRESS_Buffer[4] , MAC_ADDRESS_Buffer[5]);
result = f_open(&file, FileName, FA_OPEN_ALWAYS | FA_WRITE);
if (result != FR_OK)
{
I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE3-1]++; //记录FATFS 打开文件失败次数到I2C芯片中存储
AT24C512_Write_configuration_PARAMETERS();
/* 卸载文件系统 */
f_mount(FS_SD, NULL);
return ;
}
fil_size = f_size(&file);
result = f_lseek(&file,fil_size);
if (result != FR_OK)
{
I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE4-1]++; //记录FATFS 移动文件指针到文件尾失败次数到I2C芯片中存储
AT24C512_Write_configuration_PARAMETERS();
/* 关闭文件*/
f_close(&file);
/* 卸载文件系统 */
f_mount(FS_SD, NULL);
return ;
}
result = f_write(&file, FATFS_COM_Buffer , strlen(FATFS_COM_Buffer), &bw);
if (result != FR_OK)
{
I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE5-1]++; //记录FATFS 写第一行数据时出错次数到I2C芯片中存储
AT24C512_Write_configuration_PARAMETERS();
/* 关闭文件*/
f_close(&file);
/* 卸载文件系统 */
f_mount(FS_SD, NULL);
return ;
}
WatchDog_Delay(50000);
result = f_write(&file, FATFS_COM_Buffer , strlen(FATFS_COM_Buffer), &bw);
if (result != FR_OK)
{
I2C_PARAMETERS_Buffer[I2C_PARAMETERS_SPARE6-1]++; //记录FATFS 写第二行数据时出错次数到I2C芯片中存储
AT24C512_Write_configuration_PARAMETERS();
/* 关闭文件*/
f_close(&file);
/* 卸载文件系统 */
f_mount(FS_SD, NULL);
return ;
}
result = f_write(&file, FATFS_COM_Buffer , strlen(FATFS_COM_Buffer), &bw);
if (result != FR_OK)
{
I2C_SUN_BATTERY_Buffer[I2C_SUN_SPARE1-1]++; //记录FATFS 写第三行数据时出错次数到I2C芯片中存储
AT24C512_Write_SUN_BATTERY_PARAMETERS();
/* 关闭文件*/
f_close(&file);
/* 卸载文件系统 */
f_mount(FS_SD, NULL);
return ;
}
/* 关闭文件*/
f_close(&file);
/* 卸载文件系统 */
f_mount(FS_SD, NULL);
}

复制代码

霸王猫 · 发表于 2021-4-20 08:54:04

霸王猫发表于 2021-4-15 09:57
我现在固定写三行同样的字符串，字符串长度为512，字符串为512个“1”，再运行3天观察。

还是会出现错误。

霸王猫 · 发表于 2021-4-20 08:59:13

继续对程序进行如下改造：
   1、第一步：
      挂载文件系统
   2、第二步：
         打开根目录
   3、第三步：
         打开文件
   4、第四步
         移动文件指针到文件尾
   5、第五步：
         写第一行数据，延时一段时间
   6、第六步：
         写第二行数据，延时一段时间
   7、第七步：
         写第三行数据

继续连续运行观察3天

000000ret · 发表于 2021-4-20 13:38:42

关注一下跟进一下

跟紧我 · 发表于 2021-4-20 14:15:37

三天三天又三天呀

熊大 · 发表于 2021-5-6 23:45:43

一个月过去啦，怎么样了楼主

霸王猫 · 发表于 2021-5-10 17:24:37

熊大发表于 2021-5-6 23:45
一个月过去啦，怎么样了楼主

我做了如下改进：

1、写完第一行后，延时一段时间 WatchDog_Delay(50000);
2、写完第二行后，延时一段时间 WatchDog_Delay(50000);
3、写第三行

又连续运行3天，没有发现任何错误。

难道是写完第一行数据时，立即写第二行数据，文件系统反应不过来吗？

霸王猫 · 发表于 2021-5-10 17:25:29

解决方法: 对程序进行如下改造：
   1、第一步：
      挂载文件系统
   2、第二步：
         打开根目录
   3、第三步：
         打开文件
   4、第四步
         移动文件指针到文件尾
   5、第五步：
         写第一行数据，延时一段时间
   6、第六步：
         写第二行数据，延时一段时间
   7、第七步：
         写第三行数据

经过上述处理，连续3天没有再出现之前的情况，搞不懂，为什么打开文件写完第一行332字节之后，必须要延时一点时间才能写第二行332个字节呢？

帐号		自动登录	找回密码
密码			立即注册

STM32F407单片机通过FATFS文件系统写SD卡正确率只有98%，但是偶而出错，该如何彻底根治

最佳答案

原子哥极力推荐 /2