21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 基于STM32的SD卡+STM32CubeMx+FatFS文件系统创建Excel表 ...
返回列表 发新帖我要提问

[其他ST产品] 基于STM32的SD卡+STM32CubeMx+FatFS文件系统创建Excel表保存数据

[复制链接]
2548|18
 楼主| 怎么总是重复啊 发表于 2023-9-22 10:23 | 显示全部楼层 |阅读模式
CubeMX, FATFS, SD卡, ST, STM
简介
通过STM32控制SD卡创建text文件或Excel文件来保存传感器采集到的数据，并且当文件大小超过规定时，自动重新新建文件继续保存数据。
单片机型号：STM32F103VCT6
✨2 SD卡工作原理
47341650cfaa6c922e.png
回复

收藏 举报

相关帖子
 楼主| 怎么总是重复啊 发表于 2023-9-22 10:23 | 显示全部楼层
2.2 SPI模式介绍
简要说明：主机首先进行片选，选中从机，同时产生通讯时钟，每到来一个时钟周期，按照配置的SPI通信模式，主机移出一位数据发送到从机，同时从机发送一位数据到主机，完成一位数据交换，重复多次，即可完成一个字节数据，若此次传输完成，取消片选。
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:24 | 显示全部楼层
接线：SI主收从发 SO主发从收 SCK 时钟线（主设备产生） SD_CS片选（主设备控制，一主多从时刻控制从机的选择）
24652650cfaccb7933.png
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:24 | 显示全部楼层
19781650cfadd441f6.png
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:25 | 显示全部楼层
STM32CubeMx配置
常规配置在此不进行展示，相比其他就多一个SPI配置和一个FatFS文件配置，其他都是常见的引脚配置。
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:25 | 显示全部楼层
15264650cfb28754ec.png
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:26 | 显示全部楼层
3454650cfb374ce1c.png
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:26 | 显示全部楼层
FatFS文件系统
简要概括：FATFS是一个为小型嵌入式系统设计的通用FAT(File Allocation Table)文件系统模块。FatFs 的编写遵循ANSI C，并且完全与磁盘I/O层分开。因此，它独立(不依赖)于硬件架构。它可以被嵌入到低成本的微控制器中，如AVR, 8051, PIC, ARM, Z80, 68K 等等，而不需要做任何修改。 我们直接调用就OK了。
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:26 | 显示全部楼层
本次主要用到了以下函数，后面代码有详细使用
✔f_open：创建 / 打开一个用于访问文件的文件对象
✔f_close ：关闭一个打开的文件
✔f_lseek：移动一个打开的文件对象的文件读 / 写指针。也可以被用来扩展文件大小 ( 簇预分配 ) 。
✔f_read ：从一个文件读取数据
✔f_write：写入数据到一个文件
✔f_mkfs：在驱动器上创建一个文件系统
✔f_mount：在 FatFs 模块上注册 / 注销一个工作区 ( 文件系统对象 )
✔f_printf：f_printf 函数向文件中写入一个格式化字符串。
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:26 | 显示全部楼层
具体代码（直接上干货）
SPI协议：[color=rgba(0, 0, 0, 0.75)]spi.c 除了STM32CubeMx自动生成的，需要添加以下代码：
[color=rgba(0, 0, 0, 0.75)]
//SPI速度设置函数
//SPI速度=fAPB1/分频系数
//fAPB1时钟一般为42Mhz：
void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
{
    assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
    __HAL_SPI_DISABLE(&hspi1);            //关闭SPI
    hspi1.Instance->CR1&=0XFFC7;          //位3-5清零，用来设置波特率
    hspi1.Instance->CR1|=SPI_BaudRatePrescaler;//设置SPI速度
    __HAL_SPI_ENABLE(&hspi1);             //使能SPI  
}
//SPI1 读写一个字节
//TxData:要写入的字节
//返回值:读取到的字节
u8 SPI1_ReadWriteByte(u8 TxData)
{
    u8 Rxdata;
    HAL_SPI_TransmitReceive(&hspi1,&TxData,&Rxdata,1, 1000);      
    return Rxdata;                      //返回收到的数据        
}



回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:27 | 显示全部楼层
复制
  1. u8 SPI1_ReadWriteByte(u8 TxData);
    

  2. void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler);
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:27 | 显示全部楼层
SD卡的配置程序：m_sd.c 和 m_sd.h
复制
  1. #include "main.h"
    

  2. #include "spi.h"
    

  3. #include "usart.h"                               
    

  4. u8  SD_Type=0;//SD卡的类型 
    

  5. //移植时候的接口
    

  6. //data:要写入的数据
    

  7. //返回值:读到的数据
    

  8. u8 SD_SPI_ReadWriteByte(u8 data)
    

  9. {
    

  10.     return SPI1_ReadWriteByte(data);
    

  11. }
    

  12.  
    

  13. //SD卡初始化的时候,需要低速
    

  14. void SD_SPI_SpeedLow(void)
    

  15. {
    

  16.      SPI1_SetSpeed(SPI_BAUDRATEPRESCALER_256);//设置到低速模式    
    

  17. }
    

  18.  
    

  19. //SD卡正常工作的时候,可以高速了
    

  20. void SD_SPI_SpeedHigh(void)
    

  21. {
    

  22.      SPI1_SetSpeed(SPI_BAUDRATEPRESCALER_2);//设置到高速模式    
    

  23. }
    

  24.  
    

  25. //SPI硬件层初始化
    

  26. void SD_SPI_Init(void)
    

  27. {
    

  28.     //设置硬件上与SD卡相关联的控制引脚输出
    

  29.     GPIO_InitTypeDef GPIO_Initure;
    

  30.     __HAL_RCC_GPIOA_CLK_ENABLE();               //开启GPIOA时钟
    

  31.     //PA12
    

  32.     GPIO_Initure.Pin=GPIO_PIN_12
    

  33.     GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;      //推挽输出
    

  34.     GPIO_Initure.Pull=GPIO_PULLUP;              //上拉
    

  35.     GPIO_Initure.Speed=GPIO_SPEED_HIGH;             //高速
    

  36.     HAL_GPIO_Init(GPIOA,&GPIO_Initure);
    

  37.    
    

  38.     HAL_GPIO_WritePin(GPIOA,GPIO_PIN_3,GPIO_PIN_SET);
    

  39.     MX_SPI1_Init();
    

  40.     SD_CS_1;
    

  41. }
    

  42. ///
    

  43. //取消选择,释放SPI总线
    

  44. void SD_DisSelect(void)
    

  45. {
    

  46.     SD_CS_1;
    

  47.     SD_SPI_ReadWriteByte(0xff);//提供额外的8个时钟
    

  48. }
    

  49.  
    

  50. //选择sd卡,并且等待卡准备OK
    

  51. //返回值:0,成功;1,失败;
    

  52. u8 SD_Select(void)
    

  53. {
    

  54.     SD_CS_0;
    

  55.     if(SD_WaitReady()==0)return 0;//等待成功
    

  56.     SD_DisSelect();
    

  57.     return 1;//等待失败
    

  58. }
    

  59.  
    

  60. //等待卡准备好
    

  61. //返回值:0,准备好了;其他,错误代码
    

  62. u8 SD_WaitReady(void)
    

  63. {
    

  64.     u32 t=0;
    

  65.     do
    

  66.     {
    

  67.         if(SD_SPI_ReadWriteByte(0XFF)==0XFF)return 0;//OK
    

  68.         t++;              
    

  69.     }while(t<0XFFFFFF);//等待 
    

  70.     return 1;
    

  71. }
    

  72.  
    

  73. //等待SD卡回应
    

  74. //Response:要得到的回应值
    

  75. //返回值:0,成功得到了该回应值
    

  76. //    其他,得到回应值失败
    

  77. u8 SD_GetResponse(u8 Response)
    

  78. {
    

  79.     u16 Count=0xFFFF;//等待次数                                 
    

  80.     while ((SD_SPI_ReadWriteByte(0XFF)!=Response)&&Count)Count--;//等待得到准确的回应        
    

  81.     if (Count==0)return MSD_RESPONSE_FAILURE;//得到回应失败   
    

  82.     else return MSD_RESPONSE_NO_ERROR;//正确回应
    

  83. }
    

  84.  
    

  85. //从sd卡读取一个数据包的内容
    

  86. //buf:数据缓存区
    

  87. //len:要读取的数据长度.
    

  88. //返回值:0,成功;其他,失败;    
    

  89. u8 SD_RecvData(u8*buf,u16 len)
    

  90. {                    
    

  91.     if(SD_GetResponse(0xFE))return 1;//等待SD卡发回数据起始令牌0xFE
    

  92.     while(len--)//开始接收数据
    

  93.     {
    

  94.         *buf=SPI1_ReadWriteByte(0xFF);
    

  95.         buf++;
    

  96.     }
    

  97.     //下面是2个伪CRC（dummy CRC）
    

  98.     SD_SPI_ReadWriteByte(0xFF);
    

  99.     SD_SPI_ReadWriteByte(0xFF);                                                              
    

  100.     return 0;//读取成功
    

  101. }
    

  102.  
    

  103. //向sd卡写入一个数据包的内容 512字节
    

  104. //buf:数据缓存区
    

  105. //cmd:指令
    

  106. //返回值:0,成功;其他,失败;    
    

  107. u8 SD_SendBlock(u8*buf,u8 cmd)
    

  108. {    
    

  109.     u16 t;                
    

  110.     if(SD_WaitReady())return 1;//等待准备失效
    

  111.     SD_SPI_ReadWriteByte(cmd);
    

  112.     if(cmd!=0XFD)//不是结束指令
    

  113.     {
    

  114.         for(t=0;t<512;t++)SPI1_ReadWriteByte(buf[t]);//提高速度,减少函数传参时间
    

  115.         SD_SPI_ReadWriteByte(0xFF);//忽略crc
    

  116.         SD_SPI_ReadWriteByte(0xFF);
    

  117.         t=SD_SPI_ReadWriteByte(0xFF);//接收响应
    

  118.         if((t&0x1F)!=0x05)return 2;//响应错误                                                              
    

  119.     }                                                                                       
    

  120.     return 0;//写入成功
    

  121. }
    

  122.  
    

  123. //向SD卡发送一个命令
    

  124. //输入: u8 cmd   命令 
    

  125. //      u32 arg  命令参数
    

  126. //      u8 crc   crc校验值       
    

  127. //返回值:SD卡返回的响应                                                              
    

  128. u8 SD_SendCmd(u8 cmd, u32 arg, u8 crc)
    

  129. {
    

  130.     u8 r1;    
    

  131.     u8 Retry=0; 
    

  132.     SD_DisSelect();//取消上次片选
    

  133.     if(SD_Select())return 0XFF;//片选失效 
    

  134.     //发送
    

  135.     SD_SPI_ReadWriteByte(cmd | 0x40);//分别写入命令
    

  136.     SD_SPI_ReadWriteByte(arg >> 24);
    

  137.     SD_SPI_ReadWriteByte(arg >> 16);
    

  138.     SD_SPI_ReadWriteByte(arg >> 8);
    

  139.     SD_SPI_ReadWriteByte(arg);      
    

  140.     SD_SPI_ReadWriteByte(crc); 
    

  141.     if(cmd==CMD12)SD_SPI_ReadWriteByte(0xff);//Skip a stuff byte when stop reading
    

  142.     //等待响应，或超时退出
    

  143.     Retry=0X1F;
    

  144.     do
    

  145.     {
    

  146.         r1=SD_SPI_ReadWriteByte(0xFF);
    

  147.     }while((r1&0X80) && Retry--);     
    

  148.     //返回状态值
    

  149.     return r1;
    

  150. }                                                                                          
    

  151. //获取SD卡的CID信息，包括制造商信息
    

  152. //输入: u8 *cid_data(存放CID的内存，至少16Byte）      
    

  153. //返回值:0：NO_ERR
    

  154. //         1：错误                                                           
    

  155. u8 SD_GetCID(u8 *cid_data)
    

  156. {
    

  157.     u8 r1;       
    

  158.     //发CMD10命令，读CID
    

  159.     r1=SD_SendCmd(CMD10,0,0x01);
    

  160.     if(r1==0x00)
    

  161.     {
    

  162.         r1=SD_RecvData(cid_data,16);//接收16个字节的数据     
    

  163.     }
    

  164.     SD_DisSelect();//取消片选
    

  165.     if(r1)return 1;
    

  166.     else return 0;
    

  167. }                                                                                  
    

  168. //获取SD卡的CSD信息，包括容量和速度信息
    

  169. //输入:u8 *cid_data(存放CID的内存，至少16Byte）        
    

  170. //返回值:0：NO_ERR
    

  171. //         1：错误                                                           
    

  172. u8 SD_GetCSD(u8 *csd_data)
    

  173. {
    

  174.     u8 r1;     
    

  175.     r1=SD_SendCmd(CMD9,0,0x01);//发CMD9命令，读CSD
    

  176.     if(r1==0)
    

  177.     {
    

  178.         r1=SD_RecvData(csd_data, 16);//接收16个字节的数据 
    

  179.     }
    

  180.     SD_DisSelect();//取消片选
    

  181.     if(r1)return 1;
    

  182.     else return 0;
    

  183. }  
    

  184. //获取SD卡的总扇区数（扇区数）   
    

  185. //返回值:0： 取容量出错 
    

  186. //       其他:SD卡的容量(扇区数/512字节)
    

  187. //每扇区的字节数必为512，因为如果不是512，则初始化不能通过.                                                          
    

  188. u32 SD_GetSectorCount(void)
    

  189. {
    

  190.     u8 csd[16];
    

  191.     u32 Capacity;  
    

  192.     u8 n;
    

  193.     u16 csize;                          
    

  194.     //取CSD信息，如果期间出错，返回0
    

  195.     if(SD_GetCSD(csd)!=0) return 0;        
    

  196.     //如果为SDHC卡，按照下面方式计算
    

  197.     if((csd[0]&0xC0)==0x40)     //V2.00的卡
    

  198.     {    
    

  199.         csize = csd[9] + ((u16)csd[8] << 8) + 1;
    

  200.         Capacity = (u32)csize << 10;//得到扇区数                
    

  201.     }else//V1.XX的卡
    

  202.     {    
    

  203.         n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
    

  204.         csize = (csd[8] >> 6) + ((u16)csd[7] << 2) + ((u16)(csd[6] & 3) << 10) + 1;
    

  205.         Capacity= (u32)csize << (n - 9);//得到扇区数   
    

  206.     }
    

  207.     return Capacity;
    

  208. }
    

  209. //初始化SD卡
    

  210. u8 SD_Init(void)
    

  211. {
    

  212.     u8 r1;      // 存放SD卡的返回值
    

  213.     u16 retry;  // 用来进行超时计数
    

  214.     u8 buf[4];  
    

  215.     u16 i;
    

  216.  
    

  217.     SD_SPI_Init();        //初始化IO
    

  218.      SD_SPI_SpeedLow();    //设置到低速模式 
    

  219.      for(i=0;i<10;i++)SD_SPI_ReadWriteByte(0XFF);//发送最少74个脉冲
    

  220.     retry=20;
    

  221.     do
    

  222.     {
    

  223.         r1=SD_SendCmd(CMD0,0,0x95);//进入IDLE状态
    

  224.     }while((r1!=0X01) && retry--);
    

  225.      SD_Type=0;//默认无卡
    

  226.     if(r1==0X01)
    

  227.     {
    

  228.         if(SD_SendCmd(CMD8,0x1AA,0x87)==1)//SD V2.0
    

  229.         {
    

  230.             for(i=0;i<4;i++)buf[i]=SD_SPI_ReadWriteByte(0XFF);    //Get trailing return value of R7 resp
    

  231.             if(buf[2]==0X01&&buf[3]==0XAA)//卡是否支持2.7~3.6V
    

  232.             {
    

  233.                 retry=0XFFFE;
    

  234.                 do
    

  235.                 {
    

  236.                     SD_SendCmd(CMD55,0,0X01);    //发送CMD55
    

  237.                     r1=SD_SendCmd(CMD41,0x40000000,0X01);//发送CMD41
    

  238.                 }while(r1&&retry--);
    

  239.                 if(retry&&SD_SendCmd(CMD58,0,0X01)==0)//鉴别SD2.0卡版本开始
    

  240.                 {
    

  241.                     for(i=0;i<4;i++)buf[i]=SD_SPI_ReadWriteByte(0XFF);//得到OCR值
    

  242.                     if(buf[0]&0x40)SD_Type=SD_TYPE_V2HC;    //检查CCS
    

  243.                     else SD_Type=SD_TYPE_V2;   
    

  244.                 }
    

  245.             }
    

  246.         }else//SD V1.x/ MMC    V3
    

  247.         {
    

  248.             SD_SendCmd(CMD55,0,0X01);        //发送CMD55
    

  249.             r1=SD_SendCmd(CMD41,0,0X01);    //发送CMD41
    

  250.             if(r1<=1)
    

  251.             {        
    

  252.                 SD_Type=SD_TYPE_V1;
    

  253.                 retry=0XFFFE;
    

  254.                 do //等待退出IDLE模式
    

  255.                 {
    

  256.                     SD_SendCmd(CMD55,0,0X01);    //发送CMD55
    

  257.                     r1=SD_SendCmd(CMD41,0,0X01);//发送CMD41
    

  258.                 }while(r1&&retry--);
    

  259.             }else//MMC卡不支持CMD55+CMD41识别
    

  260.             {
    

  261.                 SD_Type=SD_TYPE_MMC;//MMC V3
    

  262.                 retry=0XFFFE;
    

  263.                 do //等待退出IDLE模式
    

  264.                 {                                                
    

  265.                     r1=SD_SendCmd(CMD1,0,0X01);//发送CMD1
    

  266.                 }while(r1&&retry--);  
    

  267.             }
    

  268.             if(retry==0||SD_SendCmd(CMD16,512,0X01)!=0)SD_Type=SD_TYPE_ERR;//错误的卡
    

  269.         }
    

  270.     }
    

  271.     SD_DisSelect();//取消片选
    

  272.     SD_SPI_SpeedHigh();//高速
    

  273.     if(SD_Type)return 0;
    

  274.     else if(r1)return r1;        
    

  275.     return 0xaa;//其他错误
    

  276. }
    

  277.  
    

  278. //读SD卡
    

  279. //buf:数据缓存区
    

  280. //sector:扇区
    

  281. //cnt:扇区数
    

  282. //返回值:0,ok;其他,失败.
    

  283. u8 SD_ReadDisk(u8*buf,u32 sector,u8 cnt)
    

  284. {
    

  285.     u8 r1;
    

  286.     if(SD_Type!=SD_TYPE_V2HC)sector <<= 9;//转换为字节地址
    

  287.     if(cnt==1)
    

  288.     {
    

  289.         r1=SD_SendCmd(CMD17,sector,0X01);//读命令
    

  290.         if(r1==0)//指令发送成功
    

  291.         {
    

  292.             r1=SD_RecvData(buf,512);//接收512个字节       
    

  293.         }
    

  294.     }else
    

  295.     {
    

  296.         r1=SD_SendCmd(CMD18,sector,0X01);//连续读命令
    

  297.         do
    

  298.         {
    

  299.             r1=SD_RecvData(buf,512);//接收512个字节     
    

  300.             buf+=512;  
    

  301.         }while(--cnt && r1==0);     
    

  302.         SD_SendCmd(CMD12,0,0X01);    //发送停止命令
    

  303.     }   
    

  304.     SD_DisSelect();//取消片选
    

  305.     return r1;//
    

  306. }
    

  307.  
    

  308. //写SD卡
    

  309. //buf:数据缓存区
    

  310. //sector:起始扇区
    

  311. //cnt:扇区数
    

  312. //返回值:0,ok;其他,失败.
    

  313. u8 SD_WriteDisk(u8*buf,u32 sector,u8 cnt)
    

  314. {
    

  315.     u8 r1;
    

  316.     if(SD_Type!=SD_TYPE_V2HC)sector *= 512;//转换为字节地址
    

  317.     if(cnt==1)
    

  318.     {
    

  319.         r1=SD_SendCmd(CMD24,sector,0X01);//读命令
    

  320.         if(r1==0)//指令发送成功
    

  321.         {
    

  322.             r1=SD_SendBlock(buf,0xFE);//写512个字节       
    

  323.         }
    

  324.     }else
    

  325.     {
    

  326.         if(SD_Type!=SD_TYPE_MMC)
    

  327.         {
    

  328.             SD_SendCmd(CMD55,0,0X01);    
    

  329.             SD_SendCmd(CMD23,cnt,0X01);//发送指令    
    

  330.         }
    

  331.          r1=SD_SendCmd(CMD25,sector,0X01);//连续读命令
    

  332.         if(r1==0)
    

  333.         {
    

  334.             do
    

  335.             {
    

  336.                 r1=SD_SendBlock(buf,0xFC);//接收512个字节     
    

  337.                 buf+=512;  
    

  338.             }while(--cnt && r1==0);
    

  339.             r1=SD_SendBlock(0,0xFD);//接收512个字节 
    

  340.         }
    

  341.     }   
    

  342.     SD_DisSelect();//取消片选
    

  343.     return r1;
    

  344. }    
    


  345. 


  346.


回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:28 | 显示全部楼层
m_sd.h

复制
  1. #ifndef __M_SD_H__
    

  2. #define __M_SD_H__
    


  3. 

  4. #include "type.h"  
    

  5. #include "stm32f1xx_hal.h"    
    

  6.  
    

  7.  
    

  8. #define SD_CS_1  HAL_GPIO_WritePin(GPIOA,GPIO_PIN_12,GPIO_PIN_SET)
    

  9. #define SD_CS_0  HAL_GPIO_WritePin(GPIOA,GPIO_PIN_12,GPIO_PIN_RESET)
    

  10.  
    

  11. // SD卡类型定义  
    

  12. #define SD_TYPE_ERR     0X00
    

  13. #define SD_TYPE_MMC     0X01
    

  14. #define SD_TYPE_V1      0X02
    

  15. #define SD_TYPE_V2      0X04
    

  16. #define SD_TYPE_V2HC    0X06
    

  17.  
    

  18. // SD卡指令表         
    

  19. #define CMD0    0       //卡复位
    

  20. #define CMD1    1
    

  21. #define CMD8    8       //命令8 ，SEND_IF_COND
    

  22. #define CMD9    9       //命令9 ，读CSD数据
    

  23. #define CMD10   10      //命令10，读CID数据
    

  24. #define CMD12   12      //命令12，停止数据传输
    

  25. #define CMD16   16      //命令16，设置SectorSize 应返回0x00
    

  26. #define CMD17   17      //命令17，读sector
    

  27. #define CMD18   18      //命令18，读Multi sector
    

  28. #define CMD23   23      //命令23，设置多sector写入前预先擦除N个block
    

  29. #define CMD24   24      //命令24，写sector
    

  30. #define CMD25   25      //命令25，写Multi sector
    

  31. #define CMD41   41      //命令41，应返回0x00
    

  32. #define CMD55   55      //命令55，应返回0x01
    

  33. #define CMD58   58      //命令58，读OCR信息
    

  34. #define CMD59   59      //命令59，使能/禁止CRC，应返回0x00
    

  35. //数据写入回应字意义
    

  36. #define MSD_DATA_OK                0x05
    

  37. #define MSD_DATA_CRC_ERROR         0x0B
    

  38. #define MSD_DATA_WRITE_ERROR       0x0D
    

  39. #define MSD_DATA_OTHER_ERROR       0xFF
    

  40. //SD卡回应标记字
    

  41. #define MSD_RESPONSE_NO_ERROR      0x00
    

  42. #define MSD_IN_IDLE_STATE          0x01
    

  43. #define MSD_ERASE_RESET            0x02
    

  44. #define MSD_ILLEGAL_COMMAND        0x04
    

  45. #define MSD_COM_CRC_ERROR          0x08
    

  46. #define MSD_ERASE_SEQUENCE_ERROR   0x10
    

  47. #define MSD_ADDRESS_ERROR          0x20
    

  48. #define MSD_PARAMETER_ERROR        0x40
    

  49. #define MSD_RESPONSE_FAILURE       0xFF
    

  50.                                                              
    

  51. extern u8  SD_Type;            //SD卡的类型
    

  52. //函数申明区 
    

  53. u8 SD_SPI_ReadWriteByte(u8 data);
    

  54. void SD_SPI_SpeedLow(void);
    

  55. void SD_SPI_SpeedHigh(void);
    

  56. u8 SD_WaitReady(void);                            //等待SD卡准备
    

  57. u8 SD_GetResponse(u8 Response);                    //获得相应
    

  58. u8 SD_Init(void);                                //初始化
    

  59. u8 SD_ReadDisk(u8*buf,u32 sector,u8 cnt);        //读块
    

  60. u8 SD_WriteDisk(u8*buf,u32 sector,u8 cnt);        //写块
    

  61. u32 SD_GetSectorCount(void);                       //读扇区数
    

  62. u8 SD_GetCID(u8 *cid_data);                     //读SD卡CID
    

  63. u8 SD_GetCSD(u8 *csd_data);                     //读SD卡CSD
    

  64.  
    

  65. #endif
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:29 | 显示全部楼层
实现FATFS读写SD卡的主要代码：
user_diskio.c

复制
  1. #ifdef USE_OBSOLETE_USER_CODE_SECTION_0
    

  2. /*
    

  3.  * Warning: the user section 0 is no more in use (starting from CubeMx version 4.16.0)
    

  4.  * To be suppressed in the future.
    

  5.  * Kept to ensure backward compatibility with previous CubeMx versions when
    

  6.  * migrating projects.
    

  7.  * User code previously added there should be copied in the new user sections before
    

  8.  * the section contents can be deleted.
    

  9.  */
    

  10. /* USER CODE BEGIN 0 */
    

  11. /* USER CODE END 0 */
    

  12. #endif
    


  13. 

  14. /* USER CODE BEGIN DECL */
    

  15. /* Includes ------------------------------------------------------------------*/
    

  16. #include <string.h>
    

  17. #include "ff_gen_drv.h"
    


  18. 

  19. /* Private typedef -----------------------------------------------------------*/
    

  20. /* Private define ------------------------------------------------------------*/
    

  21. #include "m_sd.h"
    

  22. #define SD_CARD  0
    

  23. /* Private variables ---------------------------------------------------------*/
    

  24. /* Disk status */
    

  25. static volatile DSTATUS Stat = STA_NOINIT;
    


  26. 

  27. /* USER CODE END DECL */
    

  28. /* Private function prototypes -----------------------------------------------*/
    

  29. DSTATUS USER_initialize (BYTE pdrv);
    

  30. DSTATUS USER_status (BYTE pdrv);
    

  31. DRESULT USER_read (BYTE pdrv, BYTE *buff, DWORD sector, UINT count);
    

  32. #if _USE_WRITE == 1
    

  33.   DRESULT USER_write (BYTE pdrv, const BYTE *buff, DWORD sector, UINT count);
    

  34. #endif /* _USE_WRITE == 1 */
    

  35. #if _USE_IOCTL == 1
    

  36.   DRESULT USER_ioctl (BYTE pdrv, BYTE cmd, void *buff);
    

  37. #endif /* _USE_IOCTL == 1 */
    


  38. 

  39. Diskio_drvTypeDef  USER_Driver =
    

  40. {
    

  41.   USER_initialize,
    

  42.   USER_status,
    

  43.   USER_read,
    

  44. #if  _USE_WRITE
    

  45.   USER_write,
    

  46. #endif  /* _USE_WRITE == 1 */
    

  47. #if  _USE_IOCTL == 1
    

  48.   USER_ioctl,
    

  49. #endif /* _USE_IOCTL == 1 */
    

  50. };
    


  51. 

  52. /* Private functions ---------------------------------------------------------*/
    


  53. 

  54. /**
    

  55.   * [url=home.php?mod=space&uid=247401]@brief[/url]  Initializes a Drive
    

  56.   * @param  pdrv: Physical drive number (0..)
    

  57.   * @retval DSTATUS: Operation status
    

  58.   */
    

  59. DSTATUS USER_initialize (
    

  60.         BYTE pdrv           /* Physical drive nmuber to identify the drive */
    

  61. )
    

  62. {
    

  63.   /* USER CODE BEGIN INIT */
    

  64.     Stat = RES_OK;
    

  65.     return Stat;
    

  66.   /* USER CODE END INIT */
    

  67. }
    


  68. 

  69. /**
    

  70.   * @brief  Gets Disk Status
    

  71.   * @param  pdrv: Physical drive number (0..)
    

  72.   * @retval DSTATUS: Operation status
    

  73.   */
    

  74. DSTATUS USER_status (
    

  75.         BYTE pdrv       /* Physical drive number to identify the drive */
    

  76. )
    

  77. {
    

  78.   /* USER CODE BEGIN STATUS */
    

  79.    u8 res=0;        
    

  80.     switch(pdrv)
    

  81.     {
    

  82.         case SD_CARD:        //SD卡
    

  83.             res=SD_Init();    //SD卡初始化 
    

  84.               break;
    

  85.         
    

  86.         default:
    

  87.             res=1; 
    

  88.     }         
    

  89.     if(res)return  STA_NOINIT;
    

  90.     else return 0; //初始化成功 
    

  91.   /* USER CODE END STATUS */
    

  92. }
    


  93. 

  94. /**
    

  95.   * @brief  Reads Sector(s)
    

  96.   * @param  pdrv: Physical drive number (0..)
    

  97.   * @param  *buff: Data buffer to store read data
    

  98.   * @param  sector: Sector address (LBA)
    

  99.   * @param  count: Number of sectors to read (1..128)
    

  100.   * @retval DRESULT: Operation result
    

  101.   */
    

  102. DRESULT USER_read (
    

  103.         BYTE pdrv,      /* Physical drive nmuber to identify the drive */
    

  104.         BYTE *buff,     /* Data buffer to store read data */
    

  105.         DWORD sector,   /* Sector address in LBA */
    

  106.         UINT count      /* Number of sectors to read */
    

  107. )
    

  108. {
    

  109.   /* USER CODE BEGIN READ */
    

  110.    u8 res=0; 
    

  111.     if (!count)return RES_PARERR;//count不能等于0，否则返回参数错误              
    

  112.     switch(pdrv)
    

  113.     {
    

  114.         case SD_CARD://SD卡
    

  115.             res=SD_ReadDisk(buff,sector,count);     
    

  116.             while(res)//读出错
    

  117.             {
    

  118.                 SD_Init();    //重新初始化SD卡
    

  119.                 res=SD_ReadDisk(buff,sector,count);    
    

  120.             }
    

  121.             break;
    

  122.         default:
    

  123.             res=1; 
    

  124.     }
    

  125.    //处理返回值，将SPI_SD_driver.c的返回值转成ff.c的返回值
    

  126.     if(res==0x00)return RES_OK;     
    

  127.     else return RES_ERROR;  
    

  128.   /* USER CODE END READ */
    

  129. }
    


  130. 

  131. /**
    

  132.   * @brief  Writes Sector(s)
    

  133.   * @param  pdrv: Physical drive number (0..)
    

  134.   * @param  *buff: Data to be written
    

  135.   * @param  sector: Sector address (LBA)
    

  136.   * @param  count: Number of sectors to write (1..128)
    

  137.   * @retval DRESULT: Operation result
    

  138.   */
    

  139. #if _USE_WRITE == 1
    

  140. DRESULT USER_write (
    

  141.         BYTE pdrv,          /* Physical drive nmuber to identify the drive */
    

  142.         const BYTE *buff,   /* Data to be written */
    

  143.         DWORD sector,       /* Sector address in LBA */
    

  144.         UINT count          /* Number of sectors to write */
    

  145. )
    

  146. {
    

  147.   /* USER CODE BEGIN WRITE */
    

  148.   /* USER CODE HERE */
    

  149.    u8 res=0;  
    

  150.     if (!count)return RES_PARERR;//count不能等于0，否则返回参数错误              
    

  151.     switch(pdrv)
    

  152.     {
    

  153.         case SD_CARD://SD卡
    

  154.             res=SD_WriteDisk((u8*)buff,sector,count);
    

  155.             while(res)//写出错
    

  156.             {
    

  157.                 SD_Init();    //重新初始化SD卡
    

  158.                 res=SD_WriteDisk((u8*)buff,sector,count);    
    

  159.             }
    

  160.             break;
    

  161.         default:
    

  162.             res=1; 
    

  163.     }
    

  164.     //处理返回值，将SPI_SD_driver.c的返回值转成ff.c的返回值
    

  165.     if(res == 0x00)return RES_OK;     
    

  166.     else return RES_ERROR; 
    

  167.   /* USER CODE END WRITE */
    

  168. }
    

  169. #endif /* _USE_WRITE == 1 */
    


  170. 

  171. /**
    

  172.   * @brief  I/O control operation
    

  173.   * @param  pdrv: Physical drive number (0..)
    

  174.   * @param  cmd: Control code
    

  175.   * @param  *buff: Buffer to send/receive control data
    

  176.   * @retval DRESULT: Operation result
    

  177.   */
    

  178. #if _USE_IOCTL == 1
    

  179. DRESULT USER_ioctl (
    

  180.         BYTE pdrv,      /* Physical drive nmuber (0..) */
    

  181.         BYTE cmd,       /* Control code */
    

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

  183. )
    

  184. {
    

  185.   /* USER CODE BEGIN IOCTL */
    

  186.     DRESULT res;                                           
    

  187.     if(pdrv==SD_CARD)//SD卡
    

  188.     {
    

  189.         switch(cmd)
    

  190.         {
    

  191.             case CTRL_SYNC:
    

  192.                 res = RES_OK; 
    

  193.                 break;     
    

  194.             case GET_SECTOR_SIZE:
    

  195.                 *(DWORD*)buff = 512; 
    

  196.                 res = RES_OK;
    

  197.                 break;     
    

  198.             case GET_BLOCK_SIZE:
    

  199.                 *(WORD*)buff = 8;
    

  200.                 res = RES_OK;
    

  201.                 break;     
    

  202.             case GET_SECTOR_COUNT:
    

  203.                 *(DWORD*)buff = SD_GetSectorCount();
    

  204.                 res = RES_OK;
    

  205.                 break;
    

  206.             default:
    

  207.                 res = RES_PARERR;
    

  208.                 break;
    

  209.         }
    

  210.     }
    

  211.  
    

  212. else res=RES_ERROR;//其他的不支持
    

  213.     return res;
    

  214.   /* USER CODE END IOCTL */
    

  215. }
    

  216. #endif /* _USE_IOCTL == 1 */
    


  217. 

  218. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
    


  219.
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:29 | 显示全部楼层
main.c 调用函数具体实现Excel文件的实现
复制
  1. u8 excle_head=0;   //控制Excel表头
    

  2. u16 num_text[]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,,16,17};   //模拟传感器收到的数据
    

  3. u32 SD_number=0; //写入数据进行计数
    

  4. //sd卡
    

  5. char SD_FileName[]="data1.csv";   
    

  6. int SD_FileName_number=1;   //默认为1，超过大小后自动++
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:29 | 显示全部楼层
//文件超过大小后，新建文件
void SD_FileName_creat(void)
{
        SD_FileName_number++;
    sprintf(SD_FileName,"data%d.csv",SD_FileName_number);
        excle_head=0;
}
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:30 | 显示全部楼层
//控制Excel表头的写入
void WritetoSD(char write_buff[],uint8_t bufSize)
{
        FATFS fs;
        FIL file;
        uint8_t res=0;
        UINT Bw;       
       
        res = SD_init();                //SD卡初始化
       
        if(res == 1)
        {
                printf("SD卡初始化失败! \r\n");               
        }
        else
        {
                printf("SD卡初始化成功！ \r\n");               
        }
       
        res=f_mount(&fs,"0:",1);                //挂载
       
        if(res == FR_NO_FILESYSTEM)                //没有文件系统，格式化
        {
                printf("没有文件系统! \r\n");               
                res = f_mkfs("", 0, 0);                //格式化sd卡
                if(res == FR_OK)
                {
                        printf("格式化成功! \r\n");               
                        res = f_mount(NULL,"0:",1);                 //格式化后先取消挂载
                        res = f_mount(&fs,"0:",1);                        //重新挂载       
                        if(res == FR_OK)
                        {
                                printf("SD卡已经成功挂载，可以进进行文件写入测试!\r\n");
                        }       
                }
                else
                {
                        printf("格式化失败! \r\n");               
                }
        }
        else if(res == FR_OK)
        {
                printf("挂载成功! \r\n");               
        }
        else
        {
                printf("挂载失败! \r\n");
        }       
       
        res = f_open(&file,SD_FileName,FA_OPEN_ALWAYS |FA_WRITE);
        if((res & FR_DENIED) == FR_DENIED)
        {
                printf("卡存储已满，写入失败!\r\n");               
        }
       
        f_lseek(&file, f_size(&file));//确保写词写入不会覆盖之前的数据
        if(res == FR_OK)
        {
                printf("打开成功/创建文件成功！ \r\n");               
                res = f_write(&file,write_buff,bufSize,&Bw);                //写数据到SD卡
                if(res == FR_OK)
                {
                        printf("文件写入成功！ \r\n");                       
                }
                else
                {
                        printf("文件写入失败！ \r\n");
                }               
        }
        else
        {
                printf("打开文件失败!\r\n");
        }       
       
        f_close(&file);                                                //关闭文件               
        f_mount(NULL,"0:",1);                        //取消挂载
       
}

//控制具体数据的写入
void WritetoSD_data(void)
{
        FATFS fs;
        FIL file;
        uint8_t res=0;
        int8_t ress;
       
        res = SD_init();                //SD卡初始化
       
        if(res == 1)
        {
                printf("SD卡初始化失败! \r\n");               
        }
        else
        {
                printf("SD卡初始化成功！ \r\n");               
        }
       
        res=f_mount(&fs,"0:",1);                //挂载
       
        if(res == FR_NO_FILESYSTEM)                //没有文件系统，格式化
        {
                printf("没有文件系统! \r\n");               
                res = f_mkfs("", 0, 0);                //格式化sd卡
                if(res == FR_OK)
                {
                        printf("格式化成功! \r\n");               
                        res = f_mount(NULL,"0:",1);                 //格式化后先取消挂载
                        res = f_mount(&fs,"0:",1);                        //重新挂载       
                        if(res == FR_OK)
                        {
                                printf("SD卡已经成功挂载，可以进进行文件写入测试!\r\n");
                        }       
                }
                else
                {
                        printf("格式化失败! \r\n");               
                }
        }
        else if(res == FR_OK)
        {
                printf("挂载成功! \r\n");               
        }
        else
        {
                printf("挂载失败! \r\n");
        }       
       
        res = f_open(&file,SD_FileName,FA_OPEN_ALWAYS |FA_WRITE);
        if((res & FR_DENIED) == FR_DENIED)
        {
                printf("卡存储已满，写入失败!\r\n");               
        }
       
        f_lseek(&file, f_size(&file));//确保写词写入不会覆盖之前的数据
        if(res == FR_OK)
        {
                printf("打开成功/创建文件成功！ \r\n");               
                //res = f_write(&file,write_buff,bufSize,&Bw);                //写数据到SD卡
                ress = f_printf(&file,"%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n"
                ,num_text[0],num_text[1],num_text[2],num_text[3],num_text[4],num_text[5],num_text[6],num_text[7],num_text[8]
                ,num_text[9],num_text[10],num_text[11],num_text[12],num_text[13],num_text[14],num_text[15],num_text[16],num_text[17]);
                SD_number++;
                if(ress == (-1))
                {
                        //printf("文件写入成功！ \r\n");       
            printf("文件写入失败！ \r\n");                       
                }
                else
                {
                        printf("文件写入成功！ \r\n");       
                        //printf("文件写入失败！ \r\n");
                }               
        }
        else
        {
                printf("打开文件失败!\r\n");
        }       
       
        f_close(&file);                                                //关闭文件               
        f_mount(NULL,"0:",1);                        //取消挂载
       
}
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:30 | 显示全部楼层
while(1)里实现：
复制
  1.                 if(SD_number>=36)   //判断文件大小，重新创建        1M 约= 18000   根据自己每次写入的数据大小进行修改
    

  2.                                 {
    

  3.                                  SD_FileName_creat();
    

  4.                                  SD_number=0;
    

  5.                                 }
    

  6.                                 if(excle_head==0)
    

  7.                 {
    

  8.                                 excle_head=1; 
    

  9.                                 WritetoSD("空气湿度%RH,空气温度℃,噪声值dB,二氧化碳PPM,大气压Kpa,光照高Lux,光照低Lux,ETCH土壤含水率%,ETCH土壤温度℃,ETCH土壤电导率us/cm,ETCH盐度,ETCHTDS,氮mg/kg,磷mg/kg,磷mg/kg,土壤PH值PH,WS土壤含水率%,WS土壤温度℃\r\n",
    

  10.                                 sizeof("空气湿度%RH,空气温度℃,噪声值dB,二氧化碳PPM,大气压Kpa,光照Lux,光照低Lux,ETCH土壤含水率%,ETCH土壤温度℃,ETCH土壤电导率us/cm,ETCH盐度,ETCHTDS,氮mg/kg,磷mg/kg,磷mg/kg,土壤PH值PH,WS土壤含水率%,WS土壤温度℃\r\n"));    //Excel表头
    

  11.                                 }else
    

  12.                                 {
    

  13.                                  WritetoSD_data();          //具体数据
    

  14.                                 }
回复

收藏 举报

 楼主| 怎么总是重复啊 发表于 2023-9-22 10:31 | 显示全部楼层
结果：
93740650cfc5a1e931.png

82394650cfc6c3303a.png
回复

收藏 举报

公羊子丹 发表于 2024-8-11 07:25 | 显示全部楼层

一般PCB是V-CUT，
回复

收藏 举报

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

本版积分规则

怎么总是重复啊

29

主题

262

帖子

1

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