第047例： SPI-基于串行Flash的FatFS文件系统

【HAL库每天一例】系列例程从今天开始持续更新。
我们将坚持每天至少发布一个基于YS-F1Pro开发板的HAL库例程，
该系列例程将带领大家从零开始使用HAL库，后面会持续添加模块应用例程。
同样的，我们还程序发布基于HAL库的指导文档和视频教程，欢迎持续关注，并提出改进意见。
例程下载：
资料包括程序、相关说明资料以及软件使用截图
链接：http://pan.baidu.com/s/1i574oPv
密码：r3s3
（硬石YS-F1Pro开发板HAL库例程持续更新\1. 软件设计之基本裸机例程(HAL库版本)\YSF1_HAL-047. SPI-基于串行Flash的FatFS文件系统）
/**
  ******************************************************************************
  *                           硬石YS-F1Pro开发板例程功能说明
  *
  *  例程名称: YSF1_HAL-047. SPI-基于串行Flash的FatFS文件系统
  *   
  ******************************************************************************
  * 说明：
  * 本例程配套硬石stm32开发板YS-F1Pro使用。
  *
  * 淘宝：
  * 论坛：http://www.ing10bbs.com
  * 版权归硬石嵌入式开发团队所有，请勿商用。
  ******************************************************************************
  */
【1】例程简介
  串行Flash用于存储数据。YS-F1Pro开发板集成了一个16M字节的W25Q128串行Flash芯片，可以
用于存放数据。该芯片使用SPI1通信接口。
  FatFS是一个专门为嵌入式开发的开源小型文件系统。FatFS可以提供丰富的文件操作函数，方便
文件操作，我们可以在串行Flash空间上移植FatFS文件系统。
【2】跳线帽情况
******* 为保证例程正常运行，必须插入以下跳线帽 **********
丝印编号     IO端口      目标功能引脚        出厂默认设置
  JP1        PA10        TXD(CH340G)          已接入
  JP2        PA9         RXD(CH340G)          已接入
  
【3】操作及现象
使用开发板配套的MINI USB线连接到开发板标示“调试串口”字样的MIMI USB接口（需要安装驱
动），在电脑端打开串口调试助手工具，设置参数为115200 8-N-1。下载完程序之后，在串口调试
助手窗口可接收到信息。
/******************* (C) COPYRIGHT 2015-2020 硬石嵌入式开发团队 *****END OF FILE****/

spiflash_diskio.c文件内容

1. /**
   
2.   ******************************************************************************
   
3.   * 文件名程: spiflash_diskio.c
   
4.   * 作    者: 硬石嵌入式开发团队
   
5.   * 版    本: V1.0
   
6.   * 编写日期: 2015-10-04
   
7.   * 功    能: 串行FLASH与FatFS文件系统桥接函数实现
   
8.   ******************************************************************************
   
9.   * 说明：
   
10.   * 本例程配套硬石stm32开发板YS-F1Pro使用。
    
11.   *
    
12.   * 淘宝：
    
13.   * 论坛：http://www.ing10bbs.com
    
14.   * 版权归硬石嵌入式开发团队所有，请勿商用。
    
15.   ******************************************************************************
    
16.   */
    
17. 
    
18. /* 包含头文件 ----------------------------------------------------------------*/
    
19. #include <string.h>
    
20. #include "ff_gen_drv.h"
    
21. #include "spiflash/bsp_spiflash.h"
    
22. 
    
23. /* 私有类型定义 --------------------------------------------------------------*/
    
24. /* 私有宏定义 ----------------------------------------------------------------*/
    
25. #define SPI_FLASH_REBUILD           1    // 1:使能格式化串行Flash，0：禁用格式化串行Flash
    
26. #define SPI_FLASH_SECTOR_SIZE    4096    // 串行Flash扇区大小
    
27. #define SPI_FLASH_START_SECTOR   1792    // 串行Flash文件系统FatFS偏移量
    
28. #define SPI_FLASH_SECTOR_COUNT   2304    // 串行Flash文件系统FatFS占用扇区个数   
    
29. 
    
30. 
    
31. 
    
32. /* 私有变量 ------------------------------------------------------------------*/
    
33. static __IO DSTATUS Stat = STA_NOINIT;
    
34. 
    
35. /* 扩展变量 ------------------------------------------------------------------*/
    
36. /* 私有函数原形 --------------------------------------------------------------*/
    
37. DSTATUS SPIFLASH_initialize(BYTE);
    
38. DSTATUS SPIFLASH_status(BYTE);
    
39. DRESULT SPIFLASH_read(BYTE, BYTE*, DWORD, UINT);
    
40. 
    
41. #if _USE_WRITE == 1   // 如果允许写操作
    
42.   DRESULT SPIFLASH_write (BYTE, const BYTE*, DWORD, UINT);
    
43. #endif /* _USE_WRITE == 1 */
    
44. 
    
45. #if _USE_IOCTL == 1   // 如果输入输出操作控制
    
46.   DRESULT SPIFLASH_ioctl (BYTE, BYTE, void*);
    
47. #endif  /* _USE_IOCTL == 1 */
    
48. 
    
49. /* 定义串行FLASH接口函数 */
    
50. const Diskio_drvTypeDef  SPIFLASH_Driver =
    
51. {
    
52.   SPIFLASH_initialize,                   // 串行FLASH初始化
    
53.   SPIFLASH_status,                       // 串行FLASH状态获取
    
54.   SPIFLASH_read,                         // 串行FLASH读数据
    
55. #if  _USE_WRITE == 1
    
56.   SPIFLASH_write,                        // 串行FLASH写数据
    
57. #endif /* _USE_WRITE == 1 */
    
58.   
    
59. #if  _USE_IOCTL == 1
    
60.   SPIFLASH_ioctl,                         // 获取串行FLASH信息
    
61. #endif /* _USE_IOCTL == 1 */
    
62. };
    
63. 
    
64. /* 函数体 --------------------------------------------------------------------*/
    
65. /**
    
66.   * 函数功能: 串行FLASH初始化配置
    
67.   * 输入参数: 无
    
68.   * 返 回 值: 无
    
69.   * 说    明: 无
    
70.   */
    
71. DSTATUS SPIFLASH_initialize(BYTE lun)
    
72. {
    
73. #if SPI_FLASH_REBUILD == 1
    
74.   static uint8_t startflag=1;
    
75. #endif
    
76.   Stat = STA_NOINIT;
    
77.   /* 初始化SPIFLASHIO外设 */
    
78.   MX_SPIFlash_Init();
    
79.   /* 获取串行FLASH状态 */
    
80.   if(SPI_FLASH_ReadID()==SPI_FLASH_ID)
    
81.   {
    
82. #if SPI_FLASH_REBUILD == 1
    
83.       if(startflag)
    
84.       {
    
85.         SPI_FLASH_SectorErase(SPI_FLASH_START_SECTOR*SPI_FLASH_SECTOR_SIZE);
    
86.                           startflag=0;
    
87.       }
    
88. #endif
    
89.     Stat &=~STA_NOINIT;
    
90.   }
    
91.   return Stat;
    
92. }
    
93. 
    
94. /**
    
95.   * 函数功能: 串行FLASH状态获取
    
96.   * 输入参数: lun : 不用
    
97.   * 返 回 值: DSTATUS：串行FLASH状态返回值
    
98.   * 说    明: 无
    
99.   */
    
100. DSTATUS SPIFLASH_status(BYTE lun)
     
101. {
     
102.   Stat = STA_NOINIT;
     
103. 
     
104.   if(SPI_FLASH_ReadID()==SPI_FLASH_ID)
     
105.   {
     
106.     Stat &= ~STA_NOINIT;
     
107.   }
     
108.   return Stat;
     
109. }
     
110. 
     
111. /**
     
112.   * 函数功能: 从串行FLASH读取数据到缓冲区
     
113.   * 输入参数: lun : 不用
     
114.   *           buff：存放读取到数据缓冲区指针
     
115.   *           sector：扇区地址(LBA)
     
116.   *           count：扇区数目
     
117.   * 返 回 值: DSTATUS：操作结果
     
118.   * 说    明: 无
     
119.   */
     
120. DRESULT SPIFLASH_read(BYTE lun, BYTE *buff, DWORD sector, UINT count)
     
121. {
     
122.   sector+=SPI_FLASH_START_SECTOR;      
     
123.   SPI_FLASH_BufferRead(buff, sector*SPI_FLASH_SECTOR_SIZE, count*SPI_FLASH_SECTOR_SIZE);
     
124.   return RES_OK;
     
125. }
     
126. 
     
127. /**
     
128.   * 函数功能: 将缓冲区数据写入到串行FLASH内
     
129.   * 输入参数: lun : 不用
     
130.   *           buff：存放待写入数据的缓冲区指针
     
131.   *           sector：扇区地址(LBA)
     
132.   *           count：扇区数目
     
133.   * 返 回 值: DSTATUS：操作结果
     
134.   * 说    明: 无
     
135.   */
     
136. #if _USE_WRITE == 1
     
137. DRESULT SPIFLASH_write(BYTE lun, const BYTE *buff, DWORD sector, UINT count)
     
138. {
     
139.   uint32_t write_addr;
     
140.   /* 扇区偏移7MB，外部Flash文件系统空间放在SPI Flash后面9MB空间 */
     
141.   sector+=SPI_FLASH_START_SECTOR;
     
142.   write_addr = sector*SPI_FLASH_SECTOR_SIZE;   
     
143.   SPI_FLASH_SectorErase(write_addr);
     
144.   SPI_FLASH_BufferWrite((uint8_t *)buff,write_addr,count*SPI_FLASH_SECTOR_SIZE);
     
145.   return RES_OK;
     
146. }
     
147. #endif /* _USE_WRITE == 1 */
     
148. 
     
149. /**
     
150.   * 函数功能: 输入输出控制操作(I/O control operation)
     
151.   * 输入参数: lun : 不用
     
152.   *           cmd：控制命令
     
153.   *           buff：存放待写入或者读取数据的缓冲区指针
     
154.   * 返 回 值: DSTATUS：操作结果
     
155.   * 说    明: 无
     
156.   */
     
157. #if _USE_IOCTL == 1
     
158. DRESULT SPIFLASH_ioctl(BYTE lun, BYTE cmd, void *buff)
     
159. {
     
160.   DRESULT res = RES_ERROR;
     
161.   
     
162.   if (Stat & STA_NOINIT) return RES_NOTRDY;
     
163.   
     
164.   switch (cmd)
     
165.   {
     
166.   /* Make sure that no pending write process */
     
167.   case CTRL_SYNC :
     
168.     res = RES_OK;
     
169.     break;
     
170.   
     
171.   /* 获取串行FLASH总扇区数目(DWORD) */
     
172.   case GET_SECTOR_COUNT :
     
173.     *(DWORD * )buff = SPI_FLASH_SECTOR_COUNT;       
     
174.     res = RES_OK;
     
175.     break;
     
176.   
     
177.   /* 获取读写扇区大小(WORD) */
     
178.   case GET_SECTOR_SIZE :
     
179.     *(WORD * )buff = SPI_FLASH_SECTOR_SIZE;
     
180.     res = RES_OK;
     
181.     break;
     
182.   
     
183.   /* 获取擦除块大小(DWORD) */
     
184.   case GET_BLOCK_SIZE :
     
185.     *(DWORD * )buff = 1;
     
186.     res = RES_OK;
     
187.     break;
     
188.   
     
189.   default:
     
190.     res = RES_PARERR;
     
191.   }
     
192.   
     
193.   return res;
     
194. }
     
195. #endif /* _USE_IOCTL == 1 */
     
196. 
     
197. /******************* (C) COPYRIGHT 2015-2020 硬石嵌入式开发团队 *****END OF FILE****/
     

复制代码

diskio.c文件内容

1. /*-----------------------------------------------------------------------*/
   
2. /* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2014        */
   
3. /*                                                                       */
   
4. /*   Portions COPYRIGHT 2015 STMicroelectronics                          */
   
5. /*   Portions Copyright (C) 2014, ChaN, all right reserved               */
   
6. /*-----------------------------------------------------------------------*/
   
7. /* If a working storage control module is available, it should be        */
   
8. /* attached to the FatFs via a glue function rather than modifying it.   */
   
9. /* This is an example of glue functions to attach various exsisting      */
   
10. /* storage control modules to the FatFs module with a defined API.       */
    
11. /*-----------------------------------------------------------------------*/
    
12. /**
    
13.   ******************************************************************************
    
14.   * 文件名程: diskio.c
    
15.   * 作    者: 硬石嵌入式开发团队
    
16.   * 版    本: V1.0
    
17.   * 编写日期: 2015-10-04
    
18.   * 功    能: FatFS文件系统存储设备输入输出接口实现
    
19.   ******************************************************************************
    
20.   * 说明：
    
21.   * 本例程配套硬石stm32开发板YS-F1Pro使用。
    
22.   *
    
23.   * 淘宝：
    
24.   * 论坛：http://www.ing10bbs.com
    
25.   * 版权归硬石嵌入式开发团队所有，请勿商用。
    
26.   ******************************************************************************
    
27.   */
    
28. 
    
29. /* 包含头文件 ----------------------------------------------------------------*/
    
30. #include "diskio.h"
    
31. #include "ff_gen_drv.h"
    
32. #include "ff.h"
    
33. 
    
34. #if _USE_LFN ！= 0   // 如果使能长文件名，添加相关解码文件
    
35. 
    
36. #if _CODE_PAGE == 936        /* 简体中文：GBK */
    
37. #include "option\cc936.c"
    
38. #elif _CODE_PAGE == 950        /* 繁体中文：Big5 */
    
39. #include "option\cc950.c"
    
40. #else                                        /* Single Byte Character-Set */
    
41. #include "option\ccsbcs.c"
    
42. #endif
    
43. 
    
44. #endif
    
45. 
    
46. /* 私有类型定义 --------------------------------------------------------------*/
    
47. /* 私有宏定义 ----------------------------------------------------------------*/
    
48. /* 私有变量 ------------------------------------------------------------------*/
    
49. /* 扩展变量 ------------------------------------------------------------------*/
    
50. extern Disk_drvTypeDef  disk;
    
51. 
    
52. /* 私有函数原形 --------------------------------------------------------------*/
    
53. /* 函数体 --------------------------------------------------------------------*/
    
54. /**
    
55.   * 函数功能: 获取物理设备状态
    
56.   * 输入参数: pdrv：物理设备编号
    
57.   * 返 回 值: DSTATUS：操作结果
    
58.   * 说    明: 无
    
59.   */
    
60. DSTATUS disk_status (
    
61.         BYTE pdrv                /* Physical drive nmuber to identify the drive */
    
62. )
    
63. {
    
64.   DSTATUS stat;
    
65.   
    
66.   stat = disk.drv[pdrv]->disk_status(disk.lun[pdrv]);
    
67.   return stat;
    
68. }
    
69. 
    
70. /**
    
71.   * 函数功能: 初始化物理设备
    
72.   * 输入参数: pdrv：物理设备编号
    
73.   * 返 回 值: DSTATUS：操作结果
    
74.   * 说    明: 无
    
75.   */
    
76. DSTATUS disk_initialize (
    
77.         BYTE pdrv                                /* Physical drive nmuber to identify the drive */
    
78. )
    
79. {
    
80.   DSTATUS stat = RES_OK;
    
81.   
    
82.   if(disk.is_initialized[pdrv] == 0)
    
83.   {
    
84.     disk.is_initialized[pdrv] = 1;
    
85.     stat = disk.drv[pdrv]->disk_initialize(disk.lun[pdrv]);
    
86.   }
    
87.   return stat;
    
88. }
    
89. 
    
90. /**
    
91.   * 函数功能: 从物理设备读取数据到缓冲区
    
92.   * 输入参数: pdrv：物理设备编号
    
93.   *           buff：存放待写入数据的缓冲区指针
    
94.   *           sector：扇区地址(LBA)
    
95.   *           count：扇区数目(1..128)
    
96.   * 返 回 值: DSTATUS：操作结果
    
97.   * 说    明: 无
    
98.   */
    
99. DRESULT disk_read (
    
100.         BYTE pdrv,                /* Physical drive nmuber to identify the drive */
     
101.         BYTE *buff,                /* Data buffer to store read data */
     
102.         DWORD sector, /* Sector address in LBA */
     
103.         UINT count                /* Number of sectors to read */
     
104. )
     
105. {
     
106.   DRESULT res;
     
107. 
     
108.   res = disk.drv[pdrv]->disk_read(disk.lun[pdrv], buff, sector, count);
     
109.   return res;
     
110. }
     
111. 
     
112. /**
     
113.   * 函数功能: 将缓冲区数据写入到物理设备内
     
114.   * 输入参数: pdrv：物理设备编号
     
115.   *           buff：存放待写入数据的缓冲区指针
     
116.   *           sector：扇区地址(LBA)
     
117.   *           count：扇区数目
     
118.   * 返 回 值: DSTATUS：操作结果
     
119.   * 说    明: SD卡写操作没有使用DMA传输
     
120.   */
     
121. #if _USE_WRITE == 1
     
122. DRESULT disk_write (
     
123.         BYTE pdrv,                /* Physical drive nmuber to identify the drive */
     
124.         const BYTE *buff,        /* Data to be written */
     
125.         DWORD sector,                /* Sector address in LBA */
     
126.         UINT count                /* Number of sectors to write */
     
127. )
     
128. {
     
129.   DRESULT res;
     
130.   
     
131.   res = disk.drv[pdrv]->disk_write(disk.lun[pdrv], buff, sector, count);
     
132.   return res;
     
133. }
     
134. #endif /* _USE_WRITE == 1 */
     
135. 
     
136. /**
     
137.   * 函数功能: 输入输出控制操作(I/O control operation)
     
138.   * 输入参数: pdrv：物理设备编号
     
139.   *           cmd：控制命令
     
140.   *           buff：存放待写入或者读取数据的缓冲区指针
     
141.   * 返 回 值: DSTATUS：操作结果
     
142.   * 说    明: 无
     
143.   */
     
144. #if _USE_IOCTL == 1
     
145. DRESULT disk_ioctl (
     
146.         BYTE pdrv,                /* Physical drive nmuber (0..) */
     
147.         BYTE cmd,                /* Control code */
     
148.         void *buff                /* Buffer to send/receive control data */
     
149. )
     
150. {
     
151.   DRESULT res;
     
152. 
     
153.   res = disk.drv[pdrv]->disk_ioctl(disk.lun[pdrv], cmd, buff);
     
154.   return res;
     
155. }
     
156. #endif /* _USE_IOCTL == 1 */
     
157. 
     
158. /**
     
159.   * 函数功能: 获取实时时钟
     
160.   * 输入参数: 无
     
161.   * 返 回 值: 实时时钟(DWORD)
     
162.   * 说    明: 无
     
163.   */
     
164. __weak DWORD get_fattime (void)
     
165. {
     
166.           /* 返回当前时间戳 */
     
167.         return          ((DWORD)(2015 - 1980) << 25)        /* Year 2015 */
     
168.                         | ((DWORD)10 << 21)                                /* Month 10 */
     
169.                         | ((DWORD)4  << 16)                                /* Mday 4 */
     
170.                         | ((DWORD)10 << 11)                                /* Hour 10 */
     
171.                         | ((DWORD)15 << 5)                                /* Min 15 */
     
172.                         | ((DWORD)46 >> 1);                                /* Sec 46 */
     
173. }
     
174. 
     
175. /******************* (C) COPYRIGHT 2015-2020 硬石嵌入式开发团队 *****END OF FILE****/
     

复制代码