Appearance
Fatfs
为了有效的进行文件的管理
特点: 会建立一些引导结构, 需要先对存储介质进行格式化
存储的时候可能会将一个应用存储在不连续的地址空间里面, 会使得内存的空间利用率增加
Fatfs是一个脱离底层的文件操作系统, 可以容易的移植到其他的存储器里面
文件组成
- doucuments 帮助文档
- source 源代码
- ff.c 文件系统的模块, 核心文件
- ffconf.c配置文件
- ff.h 使用时候包含的文件
- diskio.h
- diskio.c 包含底层的存储介质的操作函数, 函数需要用户自己进行添加
- ffunicode.c 简体中文包需要的文件
- ffsystem.c支持RTOS, 提供Fatfs功能的线程安全保护功能
- ff.c 文件系统的模块, 核心文件
底层设备的输入输出需要进行读写函数, 存储信息获取函数等
可以使用CubeMX进行添加以及源码进行移植, CubeMX是通过ST工程师修改的, 支持多设更好
自己移植
将几个文件添加到项目, 之后把初始化的几个实例删掉, 添加一个函数, get_fattime()返回一个32位的时间
实现对应的接口
- 获取SPI_FLASH的状态, 使用ID状态进行判断
- 初始化函数
- 读取一个扇区, 读取的时候传入的数据是扇区, 一个扇区是4096个字节, 需要进行转化
- 写的操作和读的操作类似
- 在写之前需要进行擦除
- 获取存储相关信息的函数, 比如存在的扇区的数量
配置对应的文件ff_conf.h
- 进行裁剪
c
#define FF_FS_MINIMIZE 0
/* This option defines minimization level to remove some basic API functions.
/
/ 0: Basic functions are fully enabled.
/ 1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_truncate() and f_rename()
/ are removed.
/ 2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
/ 3: f_lseek() function is removed in addition to 2. */- 格式化
c
#define FF_USE_MKFS 0
/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */- 文件权限
c
#define FF_USE_CHMOD 0
/* This option switches attribute manipulation functions, f_chmod() and f_utime().
/ (0:Disable or 1:Enable) Also FF_FS_READONLY needs to be 0 to enable this option. */- 文件名是否支持中文等
c
#define FF_CODE_PAGE 932
/* This option specifies the OEM code page to be used on the target system.
/ Incorrect code page setting can cause a file open failure.- 长文件名
c
#define FF_USE_LFN 0
#define FF_MAX_LFN 255- 字符编码
C
#define FF_LFN_UNICODE 0- 挂载的设备
c
#define FF_VOLUMES 1
/* Number of volumes (logical drives) to be used. (1-10) */- 扇区大小
c
#define FF_MIN_SS 512
#define FF_MAX_SS 512
/* This set of options configures the range of sector size to be supported. (512,
/ 1024, 2048 or 4096) Always set both 512 for most systems, generic memory card and
/ harddisk, but a larger value may be required for on-board flash memory and some
/ type of optical media. When FF_MAX_SS is larger than FF_MIN_SS, FatFs is configured
/ for variable sector size mode and disk_ioctl() function needs to implement
/ GET_SECTOR_SIZE command. */当使用不同的扇区大小的时候会使用信息获取函数从而获取扇区的大小
- 其他
还有进行分盘的, 进行和操作系统相互协调的, 修改使用的分盘的名字的宏定义等
主要修改使用格式化, 修改编码页支持中文, 使用长文件名, 一个扇区的大小
实际的使用
- 挂载文件系统ff_mount(文件系统句柄, 文件系统挂载的路径, 操作模式(1马上挂载, 0不立即挂载))
- 创建文件系统f_mkfs()
- 打开文件
- 对文件进行修改
- 关闭文件
在使用的时候需要注意文件指针的位置
使用CubeMX进行添加
对应之前宏定义对应的各个选项
stc公司对设备进行封装了一层结构体, 用来简化代码, 以及优化操作
添加了一个文件ff_gen_drv.c用于链接驱动文件
user_diskio.c这是一个具体的驱动的实现
fatfs.c具体的使用, 这是一个上层文件
使用流程上的不同
主要在于对驱动的连接上不同, STC对这个文件做了一层封装, 使用ff_gen_drv.c管理注册的驱动
- MX_FATFS_Init函数调用
- 会进行FATFS_LinkDriver函数, 参数是一个结构体包含驱动是否初始化以及一个驱动的实现, 记录当前的驱动数量等, 还有一个路径变量, 初始化全局变量disk用来记录已经初始化的设备
这个是记录所有设备的结构体,
c
uint8_t FATFS_LinkDriverEx(Diskio_drvTypeDef *drv, char *path, uint8_t lun)
{
uint8_t ret = 1;
uint8_t DiskNum = 0;
if(disk.nbr <= _VOLUMES)
{
disk.is_initialized[disk.nbr] = 0;
disk.drv[disk.nbr] = drv;
disk.lun[disk.nbr] = lun;
DiskNum = disk.nbr++;
path[0] = DiskNum + '0';
path[1] = ':';
path[2] = '/';
path[3] = 0;
ret = 0;
}
return ret;
}问题修正
STM32CubeMX学习笔记（25）——FatFs文件系统使用（操作SPI Flash） - 掘金 (juejin.cn)
c
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file user_diskio.c
* @brief This file includes a diskio driver skeleton to be completed by the user.
******************************************************************************
* @attention
*
* Copyright (c) 2023 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
#ifdef USE_OBSOLETE_USER_CODE_SECTION_0
/*
* Warning: the user section 0 is no more in use (starting from CubeMx version 4.16.0)
* To be suppressed in the future.
* Kept to ensure backward compatibility with previous CubeMx versions when
* migrating projects.
* User code previously added there should be copied in the new user sections before
* the section contents can be deleted.
*/
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
#endif
/* USER CODE BEGIN DECL */
/* Includes ------------------------------------------------------------------*/
#include <string.h>
#include "ff_gen_drv.h"
#include <stdio.h>
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define SPI_FLASH_PageSize 256
#define SPI_FLASH_PerWritePageSize 256
#define ManufactDeviceID_CMD 0x90
#define READ_STATU_REGISTER_1 0x05
#define READ_STATU_REGISTER_2 0x35
#define READ_DATA_CMD 0x03
#define WRITE_ENABLE_CMD 0x06
#define WRITE_DISABLE_CMD 0x04
#define SECTOR_ERASE_CMD 0x20
#define CHIP_ERASE_CMD 0xc7
#define PAGE_PROGRAM_CMD 0x02
#define SPI_FLASH_CS_LOW() HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_RESET);
#define SPI_FLASH_CS_HIGH() HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET);
extern SPI_HandleTypeDef hspi1;
/**
* @brief SPI发送指定长度的数据
* @param buf —— 发送数据缓冲区首地址
* @param size —— 要发送数据的字节数
* @retval 成功返回HAL_OK
*/
static HAL_StatusTypeDef SPI_Transmit(uint8_t* send_buf, uint16_t size)
{
return HAL_SPI_Transmit(&hspi1, send_buf, size, 200);
}
/**
* @brief SPI接收指定长度的数据
* @param buf —— 接收数据缓冲区首地址
* @param size —— 要接收数据的字节数
* @retval 成功返回HAL_OK
*/
static HAL_StatusTypeDef SPI_Receive(uint8_t* recv_buf, uint16_t size)
{
return HAL_SPI_Receive(&hspi1, recv_buf, size, 200);
}
/**
* @brief SPI在发送数据的同时接收指定长度的数据
* @param send_buf —— 接收数据缓冲区首地址
* @param recv_buf —— 接收数据缓冲区首地址
* @param size —— 要发送/接收数据的字节数
* @retval 成功返回HAL_OK
*/
HAL_StatusTypeDef SPI_TransmitReceive(uint8_t* send_buf, uint8_t* recv_buf, uint16_t size)
{
return HAL_SPI_TransmitReceive(&hspi1, send_buf, recv_buf, size, 200);
}
/*等待超时时间*/
#define SPIT_FLAG_TIMEOUT ((uint32_t)0x1000)
#define SPIT_LONG_TIMEOUT ((uint32_t)(10 * SPIT_FLAG_TIMEOUT))
static __IO uint32_t SPITimeout = SPIT_LONG_TIMEOUT;
/**
* @brief 等待超时回调函数
* @param None.
* @retval None.
*/
static uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode)
{
/* 等待超时后的处理,输出错误信息 */
printf("SPI 等待超时!errorCode = %d",errorCode);
return 0;
}
/**
* @brief 使用SPI发送一个字节的数据
* @param byte：要发送的数据
* @retval 返回接收到的数据
*/
uint8_t SPI_FLASH_SendByte(uint8_t byte)
{
SPITimeout = SPIT_FLAG_TIMEOUT;
/* 等待发送缓冲区为空，TXE事件 */
while (__HAL_SPI_GET_FLAG( &hspi1, SPI_FLAG_TXE ) == RESET)
{
if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(0);
}
/* 写入数据寄存器，把要写入的数据写入发送缓冲区 */
WRITE_REG(hspi1.Instance->DR, byte);
SPITimeout = SPIT_FLAG_TIMEOUT;
/* 等待接收缓冲区非空，RXNE事件 */
while (__HAL_SPI_GET_FLAG( &hspi1, SPI_FLAG_RXNE ) == RESET)
{
if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(1);
}
/* 读取数据寄存器，获取接收缓冲区数据 */
return READ_REG(hspi1.Instance->DR);
}
/**
* @brief 读取Flash内部的ID
* @param none
* @retval 成功返回device_id
*/
uint16_t W25QXX_ReadID(void)
{
uint8_t recv_buf[2] = {0}; //recv_buf[0]存放Manufacture ID, recv_buf[1]存放Device ID
uint16_t device_id = 0;
uint8_t send_data[4] = {ManufactDeviceID_CMD,0x00,0x00,0x00}; //待发送数据，命令+地址
/* 使能片选 */
SPI_FLASH_CS_LOW();
/* 发送并读取数据 */
if (HAL_OK == SPI_Transmit(send_data, 4))
{
if (HAL_OK == SPI_Receive(recv_buf, 2))
{
device_id = (recv_buf[0] << 8) | recv_buf[1];
}
}
/* 取消片选 */
SPI_FLASH_CS_HIGH();
return device_id;
}
/**
* @brief 读取W25QXX的状态寄存器，W25Q64一共有2个状态寄存器
* @param reg —— 状态寄存器编号(1~2)
* @retval 状态寄存器的值
*/
static uint8_t W25QXX_ReadSR(uint8_t reg)
{
uint8_t result = 0;
uint8_t send_buf[4] = {0x00,0x00,0x00,0x00};
switch(reg)
{
case 1:
send_buf[0] = READ_STATU_REGISTER_1;
case 2:
send_buf[0] = READ_STATU_REGISTER_2;
case 0:
default:
send_buf[0] = READ_STATU_REGISTER_1;
}
/* 使能片选 */
SPI_FLASH_CS_LOW();
if (HAL_OK == SPI_Transmit(send_buf, 4))
{
if (HAL_OK == SPI_Receive(&result, 1))
{
/* 取消片选 */
SPI_FLASH_CS_HIGH();
return result;
}
}
/* 取消片选 */
SPI_FLASH_CS_HIGH();
return 0;
}
/**
* @brief 阻塞等待Flash处于空闲状态
* @param none
* @retval none
*/
static void W25QXX_Wait_Busy(void)
{
while((W25QXX_ReadSR(1) & 0x01) == 0x01); // 等待BUSY位清空
}
/**
* @brief W25QXX写使能,将S1寄存器的WEL置位
* @param none
* @retval
*/
void W25QXX_Write_Enable(void)
{
uint8_t cmd= WRITE_ENABLE_CMD;
SPI_FLASH_CS_LOW();
SPI_Transmit(&cmd, 1);
SPI_FLASH_CS_HIGH();
W25QXX_Wait_Busy();
}
/**
* @brief W25QXX写禁止,将WEL清零
* @param none
* @retval none
*/
void W25QXX_Write_Disable(void)
{
uint8_t cmd = WRITE_DISABLE_CMD;
SPI_FLASH_CS_LOW();
SPI_Transmit(&cmd, 1);
SPI_FLASH_CS_HIGH();
W25QXX_Wait_Busy();
}
/**
* @brief W25QXX擦除一个扇区
* @param sector_addr —— 扇区地址 根据实际容量设置
* @retval none
* @note 阻塞操作
*/
void W25QXX_Erase_Sector(uint32_t sector_addr)
{
W25QXX_Write_Enable(); //擦除操作即写入0xFF，需要开启写使能
W25QXX_Wait_Busy(); //等待写使能完成
/* 使能片选 */
SPI_FLASH_CS_LOW();
/* 发送扇区擦除指令*/
SPI_FLASH_SendByte(SECTOR_ERASE_CMD);
/*发送擦除扇区地址的高位*/
SPI_FLASH_SendByte((sector_addr & 0xFF0000) >> 16);
/* 发送擦除扇区地址的中位 */
SPI_FLASH_SendByte((sector_addr & 0xFF00) >> 8);
/* 发送擦除扇区地址的低位 */
SPI_FLASH_SendByte(sector_addr & 0xFF);
/* 取消片选 */
SPI_FLASH_CS_HIGH();
W25QXX_Wait_Busy(); //等待扇区擦除完成
}
/**
* @brief 页写入操作
* @param dat —— 要写入的数据缓冲区首地址
* @param WriteAddr —— 要写入的地址
* @param byte_to_write —— 要写入的字节数（0-256）
* @retval none
*/
void W25QXX_PageProgram(uint8_t* dat, uint32_t WriteAddr, uint16_t nbytes)
{
uint8_t cmd = PAGE_PROGRAM_CMD;
// WriteAddr <<= 8;
W25QXX_Write_Enable();
/* 使能片选 */
SPI_FLASH_CS_LOW();
//发送指令
SPI_Transmit(&cmd, 1);
// SPI_Transmit((uint8_t*)&WriteAddr, 3);
uint8_t addr;
/* 发送 读 地址高位 */
addr = (WriteAddr & 0xFF0000) >> 16;
SPI_Transmit(&addr, 1);
/* 发送 读 地址中位 */
addr = (WriteAddr & 0xFF00) >> 8;
SPI_Transmit(&addr, 1);
/* 发送 读 地址低位 */
addr = WriteAddr & 0xFF;
SPI_Transmit(&addr, 1);
SPI_Transmit(dat, nbytes);
/* 取消片选 */
SPI_FLASH_CS_HIGH();
W25QXX_Wait_Busy();
}
/**
* @brief 对FLASH写入数据，调用本函数写入数据前需要先擦除扇区
* @param pBuffer，要写入数据的指针
* @param WriteAddr，写入地址
* @param NumByteToWrite，写入数据长度
* @retval 无
*/
void W25QXX_BufferWrite(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
uint8_t NumOfPage = 0;
uint8_t NumOfSingle = 0;
uint8_t Addr = 0;
uint8_t count = 0;
uint8_t temp = 0;
/*mod运算求余，若writeAddr是SPI_FLASH_PageSize整数倍，运算结果Addr值为0*/
Addr = WriteAddr % SPI_FLASH_PageSize;
/*差count个数据值，刚好可以对齐到页地址*/
count = SPI_FLASH_PageSize - Addr;
/*计算出要写多少整数页*/
NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
/*mod运算求余，计算出剩余不满一页的字节数*/
NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
/* Addr=0,则WriteAddr 刚好按页对齐 aligned */
if(Addr == 0)
{
/* NumByteToWrite < SPI_FLASH_PageSize */
if(NumOfPage == 0)
{
W25QXX_PageProgram(pBuffer, WriteAddr, NumByteToWrite);
}
/* NumByteToWrite > SPI_FLASH_PageSize */
else
{
/*先把整数页都写了*/
while(NumOfPage--)
{
W25QXX_PageProgram(pBuffer, WriteAddr, SPI_FLASH_PageSize);
WriteAddr += SPI_FLASH_PageSize;
pBuffer += SPI_FLASH_PageSize;
}
/*若有多余的不满一页的数据，把它写完*/
W25QXX_PageProgram(pBuffer, WriteAddr, NumOfSingle);
}
}
/* 若地址与 SPI_FLASH_PageSize 不对齐 */
else
{
/* NumByteToWrite < SPI_FLASH_PageSize */
if(NumOfPage == 0)
{
/*当前页剩余的count个位置比NumOfSingle小，写不完*/
if(NumOfSingle > count)
{
temp = NumOfSingle - count;
/*先写满当前页*/
W25QXX_PageProgram(pBuffer, WriteAddr, count);
WriteAddr += count;
pBuffer += count;
/*再写剩余的数据*/
W25QXX_PageProgram(pBuffer, WriteAddr, temp);
}
/*当前页剩余的count个位置能写完NumOfSingle个数据*/
else
{
W25QXX_PageProgram(pBuffer, WriteAddr, NumByteToWrite);
}
}
/* NumByteToWrite > SPI_FLASH_PageSize */
else
{
/*地址不对齐多出的count分开处理，不加入这个运算*/
NumByteToWrite -= count;
NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
W25QXX_PageProgram(pBuffer, WriteAddr, count);
WriteAddr += count;
pBuffer += count;
/*把整数页都写了*/
while(NumOfPage--)
{
W25QXX_PageProgram(pBuffer, WriteAddr, SPI_FLASH_PageSize);
WriteAddr += SPI_FLASH_PageSize;
pBuffer += SPI_FLASH_PageSize;
}
/*若有多余的不满一页的数据，把它写完*/
if(NumOfSingle != 0)
{
W25QXX_PageProgram(pBuffer, WriteAddr, NumOfSingle);
}
}
}
}
/**
* @brief 读取FLASH数据
* @param pBuffer，存储读出数据的指针
* @param ReadAddr，读取地址
* @param NumByteToRead，读取数据长度
* @retval 无
*/
void W25QXX_BufferRead(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
{
W25QXX_Wait_Busy();
/* 选择FLASH: CS低电平 */
SPI_FLASH_CS_LOW();
/* 发送 读 指令 */
uint8_t cmd = READ_DATA_CMD;
SPI_Transmit(&cmd, 1);
// 不知道为什么连起来发不行
// ReadAddr = ReadAddr << 8;
// SPI_Transmit((uint8_t*)&ReadAddr, 3);
uint8_t addr;
HAL_StatusTypeDef status;
/* 发送 读 地址高位 */
addr = (ReadAddr & 0xFF0000) >> 16;
status = SPI_Transmit(&addr, 1);
/* 发送 读 地址中位 */
addr = (ReadAddr& 0xFF00) >> 8;
status = SPI_Transmit(&addr, 1);
/* 发送 读 地址低位 */
addr = ReadAddr & 0xFF;
status = SPI_Transmit(&addr, 1);
if(HAL_OK == status)
{
SPI_Receive(pBuffer, NumByteToRead);
}
/* 停止信号 FLASH: CS 高电平 */
SPI_FLASH_CS_HIGH();
}
/* Private variables ---------------------------------------------------------*/
/* Disk status */
static volatile DSTATUS Stat = STA_NOINIT;
/* USER CODE END DECL */
/* Private function prototypes -----------------------------------------------*/
DSTATUS USER_initialize (BYTE pdrv);
DSTATUS USER_status (BYTE pdrv);
DRESULT USER_read (BYTE pdrv, BYTE *buff, DWORD sector, UINT count);
#if _USE_WRITE == 1
DRESULT USER_write (BYTE pdrv, const BYTE *buff, DWORD sector, UINT count);
#endif /* _USE_WRITE == 1 */
#if _USE_IOCTL == 1
DRESULT USER_ioctl (BYTE pdrv, BYTE cmd, void *buff);
#endif /* _USE_IOCTL == 1 */
Diskio_drvTypeDef USER_Driver =
{
USER_initialize,
USER_status,
USER_read,
#if _USE_WRITE
USER_write,
#endif /* _USE_WRITE == 1 */
#if _USE_IOCTL == 1
USER_ioctl,
#endif /* _USE_IOCTL == 1 */
};
/* Private functions ---------------------------------------------------------*/
/**
* @brief Initializes a Drive
* @param pdrv: Physical drive number (0..)
* @retval DSTATUS: Operation status
*/
DSTATUS USER_initialize (
BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
/* USER CODE BEGIN INIT */
/* USER CODE BEGIN INIT */
/* 延时一小段时间 */
uint16_t i;
i = 500;
while(--i);
Stat = STA_NOINIT;
if(W25QXX_ReadID() != 0)
{
Stat &= ~STA_NOINIT;
}
return Stat;
/* USER CODE END INIT */
}
/**
* @brief Gets Disk Status
* @param pdrv: Physical drive number (0..)
* @retval DSTATUS: Operation status
*/
DSTATUS USER_status (
BYTE pdrv /* Physical drive number to identify the drive */
)
{
/* USER CODE BEGIN STATUS */
Stat &= ~STA_NOINIT;
return Stat;
/* USER CODE END STATUS */
}
/**
* @brief Reads Sector(s)
* @param pdrv: Physical drive number (0..)
* @param *buff: Data buffer to store read data
* @param sector: Sector address (LBA)
* @param count: Number of sectors to read (1..128)
* @retval DRESULT: Operation result
*/
DRESULT USER_read (
BYTE pdrv, /* Physical drive nmuber to identify the drive */
BYTE *buff, /* Data buffer to store read data */
DWORD sector, /* Sector address in LBA */
UINT count /* Number of sectors to read */
)
{
/* USER CODE BEGIN READ */
DRESULT status = RES_PARERR;
if(!count)
{
return RES_PARERR; //count不能等于0，否则返回参数错误
}
// /* 扇区偏移2MB，外部Flash文件系统空间放在SPI Flash后面6MB空间 */
sector += 512;
W25QXX_BufferRead(buff, sector << 12, count << 12);
status = RES_OK;
return status;
/* USER CODE END READ */
}
/**
* @brief Writes Sector(s)
* @param pdrv: Physical drive number (0..)
* @param *buff: Data to be written
* @param sector: Sector address (LBA)
* @param count: Number of sectors to write (1..128)
* @retval DRESULT: Operation result
*/
#if _USE_WRITE == 1
DRESULT USER_write (
BYTE pdrv, /* Physical drive nmuber to identify the drive */
const BYTE *buff, /* Data to be written */
DWORD sector, /* Sector address in LBA */
UINT count /* Number of sectors to write */
)
{
/* USER CODE BEGIN WRITE */
/* USER CODE HERE */
uint32_t write_addr;
DRESULT status = RES_PARERR;
if(!count)
{
return RES_PARERR; /* Check parameter */
}
///* 扇区偏移2MB，外部Flash文件系统空间放在SPI Flash后面6MB空间 */
sector += 512;
write_addr = sector << 12;
W25QXX_Erase_Sector(write_addr);
W25QXX_BufferWrite((uint8_t *)buff, write_addr, count << 12);
status = RES_OK;
return status;
/* USER CODE END WRITE */
}
#endif /* _USE_WRITE == 1 */
/**
* @brief I/O control operation
* @param pdrv: Physical drive number (0..)
* @param cmd: Control code
* @param *buff: Buffer to send/receive control data
* @retval DRESULT: Operation result
*/
#if _USE_IOCTL == 1
DRESULT USER_ioctl (
BYTE pdrv, /* Physical drive nmuber (0..) */
BYTE cmd, /* Control code */
void *buff /* Buffer to send/receive control data */
)
{
/* USER CODE BEGIN IOCTL */
DRESULT status = RES_OK;
switch(cmd)
{
case CTRL_SYNC :
break;
/* 扇区数量：1536*4096/1024/1024=6(MB) */
case GET_SECTOR_COUNT:
*(DWORD * )buff = 1536;
break;
/* 扇区大小 */
case GET_SECTOR_SIZE :
*(WORD * )buff = 4096;
break;
/* 同时擦除扇区个数 */
case GET_BLOCK_SIZE :
*(DWORD * )buff = 1;
break;
case CTRL_TRIM:
break;
default:
status = RES_PARERR;
break;
}
return status;
/* USER CODE END IOCTL */
}
#endif /* _USE_IOCTL == 1 */c
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
*
* Copyright (c) 2023 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "fatfs.h"
#include "spi.h"
#include "usart.h"
#include "gpio.h"
#include <stdio.h>
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
FATFS fs; /* FatFs文件系统对象 */
FIL fnew; /* 文件对象 */
FRESULT res_flash; /* 文件操作结果 */
UINT fnum; /* 文件成功读写数量 */
BYTE ReadBuffer[1024]={0}; /* 读缓冲区 */
BYTE WriteBuffer[] = "欢迎使用野火STM32开发板 今天是个好日子，新建文件系统测试文件\r\n";
/* USER CODE END 0 */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration--------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* USER CODE BEGIN Init */
/* USER CODE END Init */
/* Configure the system clock */
SystemClock_Config();
/* USER CODE BEGIN SysInit */
/* USER CODE END SysInit */
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_SPI1_Init();
MX_FATFS_Init();
MX_USART1_UART_Init();
/* USER CODE BEGIN 2 */
/* USER CODE END 2 */
printf("hello world");
res_flash = f_mount(&fs,"0:",1);
/*----------------------- 格式化测试 -----------------*/
/* 如果没有文件系统就格式化创建创建文件系统 */
if(res_flash == FR_NO_FILESYSTEM)
{
printf("》FLASH还没有文件系统，即将进行格式化...\r\n");
/* 格式化 */
res_flash=f_mkfs("0:",0,0);
if(res_flash == FR_OK)
{
printf("》FLASH已成功格式化文件系统。\r\n");
/* 格式化后，先取消挂载 */
res_flash = f_mount(NULL,"1:",1);
/* 重新挂载 */
res_flash = f_mount(&fs,"1:",1);
}
else
{
printf("《《格式化失败。》》\r\n");
while(1);
}
}
else if(res_flash!=FR_OK)
{
printf("！！外部Flash挂载文件系统失败。(%d)\r\n",res_flash);
printf("！！可能原因：SPI Flash初始化不成功。\r\n");
while(1);
}
else
{
printf("》文件系统挂载成功，可以进行读写测试\r\n");
}
printf("\r\n****** 即将进行文件写入测试... ******\r\n");
res_flash = f_open(&fnew, "0:FatFs读写测试文件.txt",FA_CREATE_ALWAYS | FA_WRITE );
if ( res_flash == FR_OK )
{
printf("》打开/创建FatFs读写测试文件.txt文件成功，向文件写入数据。\r\n");
/* 将指定存储区内容写入到文件内 */
res_flash=f_write(&fnew,WriteBuffer,sizeof(WriteBuffer),&fnum);
if(res_flash==FR_OK)
{
printf("》文件写入成功，写入字节数据：%d\n",fnum);
printf("》向文件写入的数据为：\r\n%s\r\n",WriteBuffer);
}
else
{
printf("！！文件写入失败：(%d)\n",res_flash);
}
/* 不再读写，关闭文件 */
f_close(&fnew);
}
else
{
printf("！！打开/创建文件失败。\r\n");
}
/*------------------- 文件系统测试：读测试 --------------------------*/
printf("****** 即将进行文件读取测试... ******\r\n");
res_flash = f_open(&fnew, "0:FatFs读写测试文件.txt",FA_OPEN_EXISTING | FA_READ);
if(res_flash == FR_OK)
{
printf("》打开文件成功。\r\n");
res_flash = f_read(&fnew, ReadBuffer, sizeof(ReadBuffer), &fnum);
if(res_flash==FR_OK)
{
printf("》文件读取成功,读到字节数据：%d\r\n",fnum);
printf("》读取得的文件数据为：\r\n%s \r\n", ReadBuffer);
}
else
{
printf("！！文件读取失败：(%d)\n",res_flash);
}
}
else
{
printf("！！打开文件失败。\r\n");
}
/* 不再读写，关闭文件 */
f_close(&fnew);
/* 不再使用文件系统，取消挂载文件系统 */
f_mount(NULL,"1:",1);
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
/**
* @brief System Clock Configuration
* @retval None
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */这时候使用的系统盘是设备0, 使用野火提供的SPI库直接移植会产生问题
在进行写入的时候会有一个缓冲区, 提高写入的性能