1）实验平台：正点原子stm32f103战舰开发板V4
2）平台购买地址：https://detail.tmall.com/item.htm?id=609294757420
3）全套实验源码+手册+视频下载地址： http://www.openedv.com/thread-340252-1-1.html#

第五十章 FATFS实验

上一章，我们学习了SD卡的使用，并实现了简单的读写扇区功能。在电脑上我们的资料常以文件的形式保存，通过文件名我们可以快速对自己的文件数据等进行分类。对于SD卡这种容量可以达到非常大的存储介质，按扇区去管理数据已经变得不方便，我们希望单片机也可以像电脑一样方便地用文件的形式去管理，在需要做数据采集的场合也会更加便利。
本章，我们将介绍FATFS这个软件工具，利用它在STM32上实现类似电脑上的文件管理功能，方便管理SD卡上的数据，并设计例程在SD卡上生成文件并对文件实现读写操作。本章分为如下几个部分：
50.1 FATFS简介
50.2 硬件设计
50.3 软件设计
50.4 下载验证

50.1 FATFS简介

FATFS是一个完全免费开源的FAT/exFAT文件系统模块，专门为小型的嵌入式系统而设计。它完全用标准C语言（ANSI C C89）编写，所以具有良好的硬件平台独立性，只需做简单的修改就可以移植到8051、PIC、AVR、ARM、Z80、RX等系列单片机上。它支持FATl2、FATl6和FAT32，支持多个存储媒介；有独立的缓冲区，可以对多个文件进行读／写，并特别对8位单片机和16位单片机做了优化。
FATFS的特点有：。
Windows/dos系统兼容的FAT/exFAT文件系统
独立于硬件平台，方便跨硬件平台移植
代码量少、效率高
多种配置选项
支持多卷（物理驱动器或分区，最多10个卷）
多个ANSI/OEM代码页包括DBCS
支持长文件名、ANSI/OEM或Unicode
支持RTOS
支持多种扇区大小
只读、最小化的API和I/O缓冲区等
新版的exFAT文件系统，突破了原来FAT32对容量管理32Gb的上限，可支持更巨大容量的存储器
FATFS的这些特点，加上免费、开源的原则，使得FATFS应用非常广泛。FATFS模块的层次结构如图50.1.1所示：
在这里插入图片描述

图50.1.1 FATFS层次结构图
最顶层是应用层，使用者无需理会FATFS的内部结构和复杂的FAT协议，只需要调用FATFS模块提供给用户的一系列应用接口函数，如f_open，f_read，f_write和f_close等，就可以像在PC上读／写文件那样简单。
中间层FATFS模块，实现了FAT文件读／写协议。FATFS模块提供的是ff.c和ff.h。除非有必要，使用者一般不用修改，使用时将头文件直接包含进去即可。
需要我们编写移植代码的是FATFS模块提供的底层接口，它包括存储媒介读／写接口（diskI/O）和供给文件创建修改时间的实时时钟。
FATFS的源码及英文详述，大家可以在：http://elm-chan.org/fsw/ff/00index_e.html这个网站下载到，教程目前使用的版本为R0.14。本章我们就使用最新版本的FATFS作为介绍，下载最新版本的FATFS软件包，解压后可以得到两个文件夹：documents和source。documents里面主要是对FATFS的介绍，而source里面才是我们需要的源码。source文件夹详情表，如表41.1.1.1所示：
在这里插入图片描述

表41.1.1.1 source文件夹详情表
FATFS模块在移植的时候，我们一般只需要修改2个文件，即ffconf.h和diskio.c。FATFS模块的所有配置项都是存放在ffconf.h里面，我们可以通过配置里面的一些选项，来满足自己的需求。接下来我们介绍几个重要的配置选项。
1） FF_FS_TINY。这个选项在R0.07版本中开始出现，之前的版本都是以独立的C文件出现（FATFS和TinyFATFS），有了这个选项之后，两者整合在一起了，使用起来更方便。我们使用FATFS，所以把这个选项定义为0即可。
2） FF_FS_READONLY。这个用来配置是不是只读，本章我们需要读写都用，所以这里设置为0即可。
3） FF_USE_STRFUNC。这个用来设置是否支持字符串类操作，比如f_putc，f_puts等，本章我们需要用到，故设置这里为1。
4） FF_USE_MKFS。用来定时是否使能格式化，本章需要用到，所以设置这里为1。
5） FF_USE_FASTSEEK。这个用来使能快速定位，我们设置为1，使能快速定位。
6） FF_USE_LABEL。这个用来设置是否支持磁盘盘符（磁盘名字）读取与设置。我们设置为1，使能，就可以通过相关函数读取或者设置磁盘的名字了。
7） FF_CODE_PAGE。这个用于设置语言类型，包括很多选项（见FATFS官网说明），我们这里设置为936，即简体中文（GBK码，同一个文件夹下的ffunicode.c根据这个宏选择对应的语言设置）。
8） FF_USE_LFN。该选项用于设置是否支持长文件名（还需要_CODE_PAGE支持），取值范围为0_{3。0，表示不支持长文件名，1}3是支持长文件名，但是存储地方不一样，我们选择使用3，通过ff_memalloc函数来动态分配长文件名的存储区域。
9） FF_VOLUMES。用于设置FATFS支持的逻辑设备数目，我们设置为2，即支持2个设备。
10）FF_MAX_SS。扇区缓冲的最大值，一般设置为512。
11）FF_FS_EXFAT。新版本增加的功能，使用exFAT文件系统，用于支持超过32Gb的超大存储。它们使用的是exFAT文件系统，使用它时必须要根据设置FF_USE_LFN这个参数的值以决定exFATs系统使用的内存来自堆栈还是静态数组。
其他配置项，我们这里就不一一介绍了，FATFS的说明文档里面有很详细的介绍，大家自己阅读http://elm-chan.org/fsw/ff/doc/config.html即可。下面我们来讲讲FATFS的移植，FATFS的移植主要分为3步：
①数据类型：在integer.h里面去定义好数据的类型。这里需要了解你用的编译器的数据类型，并根据编译器定义好数据类型。
②配置：通过ffconf.h配置FATFS的相关功能，以满足你的需要。
③函数编写：打开diskio.c，进行底层驱动编写，一般需要编写5个接口函数，如图41.1.2所示：
在这里插入图片描述

图41.1.2 diskio需要实现的函数
通过以下三步，我们即可完成对FATFS的移植。
第一步，我们使用的是MDK5.34编译器，器数据类型和integer.h里面定义的一致，所以此步，我们不需要做任何改动。
第二步，关于ffconf.h里面的相关配置，我们在前面已经有介绍（之前介绍的11个配置），我们将对应配置修改为我们介绍时候的值即可，其他的配置用默认配置。
第三步，因为FATFS模块完全与磁盘I/O层分开，因此需要下面的函数来实现底层物理磁盘的读写与获取当前时间。底层磁盘I/O模块并不是FATFS的一部分，并且必须由用户提供。这些函数一般有5个，在diskio.c里面。
首先是disk_initialize函数，该函数介绍如表41.1.2所示：
在这里插入图片描述

表41.1.2 disk_initialize函数介绍
第二个函数是disk_status函数，该函数介绍如图41.1.3所示：
在这里插入图片描述

表41.1.3 disk_status函数介绍
第三个函数是disk_read函数，该函数介绍如表41.1.4所示：
函数名称 disk_read
函数原型 DRESULT disk_read (BYTE Drive, BYTE* Buffer, DWORD SectorNumber, BYTE SectorCount)
功能描述从磁盘驱动器上读取扇区
函数参数 Drive：指定逻辑驱动器号，即盘符，应当取值0~9
Buffer：指向存储读取数据字节数组的指针，需要为所读取字节数的大小，扇区统计的扇区大小是需要的
（注：FaFts指定的内存地址并不总是字对齐的，如果硬件不支持不对齐的数据传输，函数里需要进行处理）
SectorNumber：指定起始扇区的逻辑块（LBA）上的地址
SectorCount：指定要读取的扇区数，取值1~128
返回值 RES_OK(0)：函数成功
RES_ERROR：读操作期间产生了任何错误且不能恢复它
RES_PARERR：非法参数
RES_NOTRDY：磁盘驱动器没有初始化
所在文件 ff.c
表41.1.4 disk_read函数介绍
第四个函数是disk_write函数，该函数介绍如表41.1.5所示：
函数名称 disk_write
函数原型 DRESULT disk_write (BYTE Drive, const BYTE* Buffer, DWORD SectorNumber, BYTE SectorCount)
功能描述向磁盘写入一个或多个扇区
函数参数 Drive：指定逻辑驱动器号，即盘符，应当取值0~9
Buffer：指向要写入字节数组的指针
（注：FaFts指定的内存地址并不总是字对齐的，如果硬件不支持不对齐的数据传输，函数里需要进行处理）
SectorNumber：指定起始扇区的逻辑块（LBA）上的地址
SectorCount：指定要写入的扇区数，取值1~128
返回值 RES_OK(0)：函数成功
RES_ERROR：写操作期间产生了任何错误且不能恢复它
RES_WRPER：媒体被写保护
RES_PARERR：非法参数
RES_NOTRDY：磁盘驱动器没有初始化
所在文件 ff.c
注意事项只读配置中不需要此函数
表41.1.5 disk_write函数介绍
第五个函数是disk_ioctl函数，该函数介绍如表41.1.6所示：
函数名称 disk_ioctl
函数原型 DRESULT disk_ioctl (BYTE Drive, BYTE Command, void* Buffer)
功能描述控制设备指定特性和除了读/写外的杂项功能
函数参数 Drive：指定逻辑驱动器号，即盘符，应当取值0~9
Command：指定命令代码
Buffer：指向参数缓冲区的指针，取决于命令代码，不使用时，指定一个NULL指针
返回值 RES_OK(0)：函数成功
RES_ERROR：写操作期间产生了任何错误且不能恢复它
RES_PARERR：非法参数
RES_NOTRDY：磁盘驱动器没有初始化
所在文件 ff.c
注意事项 CTRL_SYNC：确保磁盘驱动器已经完成了写处理，当磁盘I/O有一个写回缓存，立即刷新原扇区，只读配置下不适用此命令
GET_SECTOR_SIZE：返回磁盘的扇区大小，只用于f_mkfs()
GET_SECTOR_COUNT：返回可利用的扇区数，_MAX_SS ≥ 1024时可用
GET_BLOCK_SIZE：获得擦除块大小，只用于f_mkfs()
CTRL_ERASE_SECTOR：强制擦除一块的扇区，_USE_ERASE ＞ 0时可用
表41.1.6 disk_ioctl函数介绍
以上五个函数，我们将在软件设计部分一一实现。通过以上3个步骤，我们就完成了对FATFS的移植，就可以在我们的代码里面使用FATFS了。
FATFS提供了很多API函数，这些函数FATFS的自带介绍文件里面都有详细的介绍(包括参考代码)，我们这里就不多说了。这里需要注意的是，在使用FATFS的时候，必须先通过f_mount函数注册一个工作区，才能开始后续API的使用，关于FATFS的介绍，我们就介绍到这里。大家可以通过FATFS自带的介绍文件进一步了解和熟悉FATFS的使用。
50.2 硬件设计

例程功能
本章实验功能简介：开机的时候先初始化SD卡，初始化成功之后，注册两个磁盘：一个给SD卡用，一个给SPI FLASH用，之所以把SPI FLASH也当成磁盘来用，一方面是为了演示大容量的SPI Flash也可以用FATFS管理，说明FATFS的灵活性；另一方面可以展示FATFS方式比原来直接按地址管理数据便利性，使板载SPI Flash的使用更具灵活性。挂载成功后获取SD卡的容量和剩余空间，并显示在LCD模块上，最后定义USMART输入指令进行各项测试。本实验通过DS0指示程序运行状态。
硬件资源
1）LED灯
LED0 – PB5
2）KEY0按键
3）TFTLCD 模块
4）microSD Card（使用大卡的情况类似，大家可根据自己设计的硬件匹配选择）
5）NOR FLASH
这几个外设原理图我们在之前的章节已经介绍过了，这里就不重复介绍了，不清楚的话可以查看本文之前章节的描述或对光盘资料提供的开发板原理图。
50.3 程序设计
FATFS的驱动为一个硬件独立的组件，因此我们把FATFS的移植代码放到“Middlewares”文件夹下。
本章，我们在“SD卡实验”的基础上进行拓展。在“Middlewares”下新建一个 FATFS 的文件夹，然后将 FATFS R0.14 程序包解压到该文件夹下。同时，我们在 FATFS 文件夹里面新建一个exfuns的文件夹，用于存放我们针对FATFS做的一些扩展代码（这个我们后面再讲）。操作结果如图 50.3.1 所示：

图50.3.1 FATFS 文件夹子目录
50.3.1 程序流程图
在这里插入图片描述

图50.3.2.1 FATFS实验程序流程图
我们初始化stm32内核和LCD、LED、串口等用于显示信息，然后初始化内存管理单元用于分配程序需要大内存的部分，我们用SD卡和NOR FLASH作为磁盘介质，然后挂载磁盘到文件系统，成功后即可用文件操作函数访问磁盘上的资源。
50.3.2 程序解析

FATFS驱动代码
这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。
diskio.c/.h为我们提供了规定好的底层驱动接口的返回值。这个函数需要使用到我们的硬件接口，所以需要把使用到的硬件驱动的头文件包进来。

#include "./MALLOC/malloc.h"
#include "./FATFS/source/diskio.h"
#include "./BSP/SDIO/sdio_sdcard.h"
#include "./BSP/NORFLASH/norflash.h"

按照47.1的描述，接下来我们来对这几个接口进行补充实现。本章，我们用FATFS管理了2个磁盘：SD卡和SPI FLASH，我们设置SD_CARD为0，EX_FLASH位为1，对应到disk_read/disk_write函数里面。SD卡比较好说，但是SPI FLASH，因为其扇区是4K字节大小，我们为了方便设计，强制将其扇区定义为512字节，这样带来的好处就是设计使用相对简单，坏处就是擦除次数大增，所以不要随便往SPI FLASH里面写数据，非必要最好别写，如果频繁写的话，很容易将SPI FLASH写坏。

#define SD_CARD     0       /* SD卡,卷标为0 */
#define EX_FLASH    1       /* 外部qspi flash,卷标为1 */
/**
 * 对于25Q128 FLASH芯片, 我们规定前 12M 给FATFS使用, 12M以后
 * 紧跟字库, 3个字库 + UNIGBK.BIN, 总大小3.09M, 共占用15.09M
 * 15.09M以后的存储空间大家可以随便使用. 
 */
#define SPI_FLASH_SECTOR_SIZE   512
#define SPI_FLASH_SECTOR_COUNT  12 * 1024 * 2  /* 25Q128,前12M字节给FATFS占用 */
#define SPI_FLASH_BLOCK_SIZE    8                 /* 每个BLOCK有8个扇区 */
#define SPI_FLASH_FATFS_BASE    0           /* FATFS 在外部FLASH

的起始地址从0开始 */
另外，diskio.c里面的函数，直接决定了磁盘编号（盘符/卷标）所对应的具体设备，比如，以上代码中，我们就通过switch来判断，到底要操作SD卡，还是SPI FLASH，然后，分别执行对应设备的相关操作。以此实现磁盘编号和磁盘的关联。
(1) disk_initialize函数
要使用FAFTS管理，首先要对它进行初始化，所以先看磁盘的初始化函数，其声明如下：
DSTATUS disk_initialize ( BYTE pdrv)
函数描述：
初始化指定编号的磁盘，磁盘所指定的存储区。使用每个磁盘前进行初始化，那在代码中直接根据编号调用硬件的初始化接口即可，这样也能保证代码的扩展性，硬件的顺序可以根据自己的喜好定义。
函数形参：
形参1是FATFS管理的磁盘编号pdrv : 磁盘编号0~9，我们配置FF_VOLUMES为2来支持两个磁盘，因此可选值为0和1。
代码实现如下：

#define SD_CARD     0     	/* SD卡,卷标为0 */
#define EX_FLASH    1       	/* 外部qspi flash,卷标为1 */

/**
 * @brief       	初始化磁盘
 * @param       	pdrv : 磁盘编号0~9
 * @retval      	无
 */
DSTATUS disk_initialize (
    BYTE pdrv       /* Physical drive nmuber to identify the drive */
)
{
    uint8_t res = 0;

    switch (pdrv)
    {
        case SD_CARD:           	/* SD卡 */
            res = sd_init();    	/* SD卡初始化 */
            break;

        case EX_FLASH:          	/* 外部flash */
            norflash_init(); 		/* 外部flash初始化 */
            break;

        default:
            res = 1;
    }

    if (res)
    {
        return  STA_NOINIT;
    }
    else
    {
        return 0; /* 初始化成功*/
    }
}

函数返回值：
DSTATUS枚举类型的值，FATFS规定了自己的返回值来管理各接口函数的操作结果,方便后续函数的操作和判断，我们看看它的定义：

/* Status of Disk Functions */
typedef BYTE    DSTATUS;
/* Disk Status Bits (DSTATUS) */
#define STA_NOINIT      0x01    /* Drive not initialized */
#define STA_NODISK      0x02    /* No medium in the drive */
#define STA_PROTECT     0x04    /* Write protected */

定义时也写出了各个参数的含义，根据ff.c中的调用实例可知操作返回0才是正常的状态，其它情况发生的话就需要结合硬件进行分析了。
(2) disk_status函数
便于我们知道当前磁盘驱动器的状态，所以FATFS也有disk_status函数提供给我们使用，其声明如下：
DSTATUS disk_status (BYTE pdrv)
函数描述：
返回当前磁盘驱动器的状态。
函数形参：
FATFS管理的磁盘编号pdrv : 磁盘编号0~9。我们配置FF_VOLUMES为2来支持两个磁盘，因此可选值为0和1。为了简单测试，所以我们这里没有加入硬件状态的判断，测试代码很简单，这里就不贴出来了。
函数返回值：
直接返回RES_OK。
(3) disk_read函数
disk_read实现直接从硬件接口读取数据，这个函数接口是给FATFS的其它读操作接口函数调用，其声明如下：
DRESULT disk_read (BYTE pdrv, BYTE *buff, DWORD sector, UINT count)
函数描述：
从磁盘驱动器上读取扇区数据。
函数形参：
形参1：是FATFS管理的磁盘编号pdrv : 磁盘编号0~9，我们配置FF_VOLUMES为2来支持两个磁盘，因此可选值为0和1。
形参2：buff指向要保存数据的内存区域指针，为字节类型。
形参3：sector为实际物理操作时要访问的扇区地址。
形参4：count为本次要读取的数据量，最长为unsigned int，读到的数量为字节数。
代码实现如下，同样要根据我们定义的设备标号，在swich-case中添加对应硬件的驱动：

DRESULT disk_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 */)
{
uint8_t res = 0;

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

    switch (pdrv)
    {
        case SD_CARD:     /* SD卡 */
            res = sd_read_disk(buff, sector, count);

            while (res)   /* 读出错 */
            {
                if (res != 2)sd_init(); /* 重新初始化SD卡 */

                res = sd_read_disk(buff, sector, count);
                //printf("sd rd error:%d\r\n", res);
            }
            break;

        case EX_FLASH:/* 外部flash */
            for (; count > 0; count--)
            {
                norflash_read(buff, SPI_FLASH_FATFS_BASE + sector * 
SPI_FLASH_SECTOR_SIZE, SPI_FLASH_SECTOR_SIZE);
                sector++;
                buff += SPI_FLASH_SECTOR_SIZE;
            }
            res = 0;
            break;

        default:
            res = 1;
    }
    /* 处理返回值，将返回值转成ff.c的返回值 */
    if (res == 0x00)
    {
        return RES_OK;
    }
    else
    {
        return RES_ERROR; 
    }
}
函数返回值：
DRESULT为枚举类型，diskio.h中有其定义，根据返回值的含义确认操作结果即可。在这里也把该结果展示出来，如下所示：
/* Results of Disk Functions */
typedef enum
{
    RES_OK = 0,     	/* 0: 操作成功 */
    RES_ERROR,      	/* 1: 读/写错误 */
    RES_WRPRT,      	/* 2: 写保护状态 */
    RES_NOTRDY,     	/* 3: 设备忙 */
    RES_PARERR      	/* 4: 其它情形 */
} DRESULT;

根据返回值的含义确认操作结果即可。
(4) disk_write函数
disk_write实现直接从硬件接口写入数据，这个函数接口给FATFS的其它写操作接口函数调用，其声明如下：
DRESULT disk_write ( BYTE pdrv, const BYTE *buff, DWORD sector, UINT count)
函数描述：
初始化指定编号的磁盘，磁盘所指定的存储区。
函数形参：
形参1：是FATFS管理的磁盘编号pdrv : 磁盘编号0~9，我们配置FF_VOLUMES为2来支持两个磁盘，因此可选值为0和1。
形参2：buff指向要保存数据的内存区域指针，为字节类型。
形参3：sector为实际物理操作时要访问的扇区地址。
形参4：count为本次要读取的数据量，最长为unsigned int，读到的数量为字节数。
代码实现如下，同样要根据我们定义的设备标号，在swich-case中添加对应硬件的驱动：

DRESULT disk_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 */
)
{
    uint8_t res = 0;

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

    switch (pdrv)
    {
        case SD_CARD:       /* SD卡 */
            res = sd_write_disk((uint8_t *)buff, sector, count);
            while (res)     /* 写出错 */
            {
                sd_init();  /* 重新初始化SD卡 */
                res = sd_write_disk((uint8_t *)buff, sector, count);
                //printf("sd wr error:%d\r\n", res);
            }
            break;

        case EX_FLASH:      /* 外部flash */
            for (; count > 0; count--)
            {
                norflash_write((uint8_t *)buff, 
SPI_FLASH_FATFS_BASE + sector* SPI_FLASH_SECTOR_SIZE,
 SPI_FLASH_SECTOR_SIZE);
                sector++;
                buff += SPI_FLASH_SECTOR_SIZE;
            }
            res = 0;
            break;

        default:
            res = 1;
    }
    /* 处理返回值，将返回值转成ff.c的返回值 */
    if (res == 0x00)
    {
        return RES_OK;
    }
    else
    {
        return RES_ERROR; 
    }
}

函数返回值：
DRESULT为枚举类型,diskio.h中有其定义，编写读函数时已经介绍了，注意要把返回值转成这个枚举类型的参数。
(5) disk_ioctl函数
disk_ioctl实现一些控制命令，这个接口为FATFS提供一些硬件操作信息，其声明如下：
DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void *buff)
函数描述：
控制设备指定特性和除了读/写外得杂项功能。
函数形参：
形参1：FATFS管理的磁盘编号pdrv :磁盘编号0~9，我们配置FF_VOLUMES为2来支持两个磁盘，因此可选值为0和1。
形参2： cmd是FATFS定义好的一些宏，用于访问硬盘设备的一些状态。我们实现几个简单的操作接口，用于获取磁盘容量这些基础信息（diskio.h中已经定义好了），为方便，我们先只实现几个标准的应用接口，关于SDIO/MMC的一些扩展命令我们再根据需要进行支持。

/* Command code for disk_ioctrl fucntion */
/* Generic command (Used by FatFs) */
#define CTRL_SYNC           0 	/* 完成挂起的写入过程(当FF_FS_READONLY == 0) */
#define GET_SECTOR_COUNT   1 	/* 获取磁盘扇区数(当FF_USE_MKFS == 1) */
#define GET_SECTOR_SIZE    2 	/* 获取磁盘存储空间大小(当FF_MAX_SS != FF_MIN_SS) */
#define GET_BLOCK_SIZE     3 	/* 每个扇区块的大小(当FF_USE_MKFS == 1) */

下面是从http://elm-chan.org/fsw/ff/doc/dioctl.html得到的参数实现效果，我们也可以参考原有的disk_ioctl的实现来理解这几个参数。
命令说明
CTRL_SYNC 确保设备已完成挂起的写入过程。如果磁盘I/O层或存储设备具有回写缓存，则必须立即将缓存数据提交到介质。如果对介质的每个写入操作都正常完成，则此命令无任何动作。
GET_SECTOR_COUNT 返回对应标号的硬盘的可用扇区数。此命令由f_mkfs\f_fdisk函数用于确定要创建的卷/分区的大小。使用时需要设置FF_USE_MKFS为1。
GET_SECTOR_SIZE 将用于读/写函数的扇区大小检索到buff指向的WORD变量中。有效扇区大小为512、1024、2048和4096。只有在FF_MAX_SS>FF_MIN_SS执行此命令时。当FF_MAX_SS=FF_MIN_SS时，将永远不会使用此命令，并且读/写函数必须仅在FF_MAX_SSbytes/扇区中工作。
GET_BLOCK_SIZE 将扇区单位中闪存介质的块大小以DWORD指针存到buff中。允许的值为1到32768。如果擦除块大小未知或非闪存介质，则返回1。此命令仅由f_mkfs函数使用，并尝试对齐擦除块边界上的数据区域。使用时需要设置FF_USE_MKFS为1。
形参3：buff为void形指针，根据命令的格式和需要，我们把对应的值转成对应的形式传给它。
参考原有的disk_ioctl的实现，我们的函数实现如下。

DRESULT disk_ioctl (
    BYTE pdrv,      	/* Physical drive nmuber (0..) */
    BYTE cmd,       	/* Control code */
    void *buff      	/* Buffer to send/receive control data */
)
{
    DRESULT res;

    if (pdrv == SD_CARD)    /* SD卡 */
    {
        switch (cmd)
        {
            case CTRL_SYNC:
                res = RES_OK;
                break;

            case GET_SECTOR_SIZE:
                *(DWORD *)buff = 512;
                res = RES_OK;
                break;

            case GET_BLOCK_SIZE:
                *(WORD *)buff = g_sdcard_handler.SdCard.BlockSize;
                res = RES_OK;
                break;

            case GET_SECTOR_COUNT:
                *(DWORD *)buff = ((long long) g_sdcard_handler.SdCard.Block
Nbr*g_sdcard_handler.SdCard.BlockSize)/512;
                res = RES_OK;
                break;

            default:
                res = RES_PARERR;
                break;
        }
    }
    else if (pdrv == EX_FLASH)  /* 外部FLASH */
    {
        switch (cmd)
        {
            case CTRL_SYNC:
                res = RES_OK;
                break;

            case GET_SECTOR_SIZE:
                *(WORD *)buff = SPI_FLASH_SECTOR_SIZE;
                res = RES_OK;
                break;

            case GET_BLOCK_SIZE:
                *(WORD *)buff = SPI_FLASH_BLOCK_SIZE;
                res = RES_OK;
                break;

            case GET_SECTOR_COUNT:
                *(DWORD *)buff = SPI_FLASH_SECTOR_COUNT;
                res = RES_OK;
                break;

            default:
                res = RES_PARERR;
                break;
        }
    }
    else
    {
        res = RES_ERROR;    /* 其他的不支持 */
    }
    return res;
}

函数返回值：
DRESULT为枚举类型,diskio.h中有其定义，编写读函数时已经介绍了，注意要把返回值转成这个枚举类型的参数。
以上实现了我们47.1节提到的5个函数，ff.c中需要实现get_fattime (void)，同时因为在ffconf.h里面设置对长文件名的支持为方法3，所以必须在ffsystem.c中实现get_fattime、ff_memalloc和ff_memfree这三个函数。这部分比较简单，直接参考我们修改后的ffsystem.c的源码。
至此，我们已经可以直接使用FATFS下的ff.c下的f_mount的接口挂载磁盘，然后使用类似标准C的文件操作函数，就可以实现文件操作。但f_mount还需要一些文件操作的内存，为了方便操作，我们在FATFS文件夹下还新建了一个exfuns的文件夹，该文件夹用于保存一些FATFS一些针对FATFS的扩展代码，如刚才提到的FATFS相关函数的内存申请方法等。
本章，我们编写了4个文件，分别是：exfuns.c、exfuns.h、fattester.c和fattester.h。其中exfuns.c主要定义了一些全局变量，方便FATFS的使用，同时实现了磁盘容量获取等函数。而fattester.c文件则主要是为了测试FATFS用，因为FATFS的很多函数无法直接通过USMART调用，所以我们在fattester.c里面对这些函数进行了一次再封装，使得可以通过USMART调用。
这几个文件的代码，大家可以直接使用本例程源码，我们将exfuns.c/.h和fattester.c/.h加入FATFS组下的exfuns文件下，直接使用即可。
(6) exfuns_init函数
我们在使用文件操作前，需要用f_mount函数挂载磁盘，我们在挂载SD卡前需要一些文件系统的内存，为了方便管理，我们定义一个全局的fs[FF_VOLUMES]指针，定成数组是我们要管理多个磁盘，而f_mount也需要一个FATFS类型的指针，定义如下：
/* 逻辑磁盘工作区(在调用任何FATFS相关函数之前,必须先给fs申请内存) */
FATFS *fs[FF_VOLUMES];
接下来只要用内存管理部分的知识来实现对fs指针的内存申请即可。

/**
 * @brief       为exfuns申请内存
 * @param       无
 * @retval      0, 成功; 1, 失败.
 */
uint8_t exfuns_init(void)
{
    uint8_t i;
    uint8_t res = 0;
    for (i = 0; i < FF_VOLUMES; i++)
    {
     fs[i] = (FATFS *)mymalloc(SRAMIN, sizeof(FATFS));	/* 为磁盘i工作区申请内存 */
        if (!fs[i])break;
}

#if USE_FATTESTER == 1  	/* 如果使能了文件系统测试 */
    res = mf_init();    		/* 初始化文件系统测试(申请内存) */
#endif
    
    if (i == FF_VOLUMES && res == 0)
        return 0;   /* 申请有一个失败,即失败. */
    else 
        return 1;
}

其它的函数我们暂时没有使用到，这里先不介绍了，大家使用时查阅源码即可。
2. main.c代码
在main.c就比较简单了，按照我们的流程图的思路编写即可，在成功初始化后，我们通过LCD显示文件操作的结果。
最后，我们编写的main函数如下：

int main(void)
{
    uint32_t total, free;
    uint8_t t = 0;
    uint8_t res = 0;

    HAL_Init();                              /* 初始化HAL库 */
    sys_stm32_clock_init(RCC_PLL_MUL9); /* 设置时钟, 72Mhz */
    delay_init(72);                         /* 延时初始化 */
    usart_init(115200);                    /* 串口初始化为115200 */
    usmart_dev.init(72);                   /* 初始化USMART */
    led_init();                              /* 初始化LED */
    lcd_init();                              /* 初始化LCD */
    key_init();                              /* 初始化按键 */
    sram_init();                             /* SRAM初始化 */
    my_mem_init(SRAMIN);                   /* 初始化内部SRAM内存池 */
    my_mem_init(SRAMEX);                   /* 初始化外部SRAM内存池 */

    lcd_show_string(30, 50, 200, 16, 16, "STM32F103", RED);
    lcd_show_string(30, 70, 200, 16, 16, "FATFS TEST", RED);
    lcd_show_string(30, 90, 200, 16, 16, "ATOM@ALIENTEK", RED);
    lcd_show_string(30, 110, 200, 16, 16, "2020/4/28", RED);
    lcd_show_string(30, 130, 200, 16, 16, "Use USMART for test", RED);

    while (sd_init()) /* 检测不到SD卡 */
    {
        lcd_show_string(30, 150, 200, 16, 16, "SD Card Error!", RED);
        delay_ms(500);
        lcd_show_string(30, 150, 200, 16, 16, "Please Check! ", RED);
        delay_ms(500);
        LED0_TOGGLE(); 				/* LED0闪烁 */
    }

    exfuns_init();                 	/* 为fatfs相关变量申请内存 */
    f_mount(fs[0], "0:", 1);       	/* 挂载SD卡 */
    res = f_mount(fs[1], "1:", 1); 	/* 挂载FLASH. */

    if (res == 0X0D) /* FLASH磁盘,FAT文件系统错误,重新格式化FLASH */
{
/* 格式化FLASH */
        lcd_show_string(30, 150, 200, 16, 16, "Flash Disk Formatting...", RED);
/* 格式化FLASH,1:,盘符;0,使用默认格式化参数 */ 
res = f_mkfs("1:", 0, 0, FF_MAX_SS); 
        if (res == 0)
        {
/* 设置Flash磁盘的名字为：ALIENTEK */   
            f_setlabel((const TCHAR *)"1:ALIENTEK"); 
lcd_show_string(30, 150, 200, 16, 16, "Flash Disk Format Finish", 
RED); 	/* 格式化完成 */
        }
        else
            lcd_show_string(30, 150, 200, 16, 16, "Flash Disk Format Error ", 
RED); 	/* 格式化失败 */
        delay_ms(1000);
    }
    lcd_fill(30, 150, 240, 150 + 16, WHITE);	/* 清除显示 */
    while (exfuns_get_free("0", &total, &free))	/* 得到SD卡的总容量和剩余容量 */
    {
        lcd_show_string(30, 150, 200, 16, 16, "SD Card Fatfs Error!", RED);
        delay_ms(200);
        lcd_fill(30, 150, 240, 150 + 16, WHITE);/* 清除显示 */
        delay_ms(200);
        LED0_TOGGLE(); /* LED0闪烁 */
    }
    lcd_show_string(30, 150, 200, 16, 16, "FATFS OK!", BLUE);
    lcd_show_string(30, 170, 200, 16, 16, "SD Total Size:     MB", BLUE);
    lcd_show_string(30, 190, 200, 16, 16, "SD  Free Size:     MB", BLUE);
    lcd_show_num(30 + 8 * 14, 170, total >> 10, 5, 16, BLUE);/*显示SD卡总容量MB*/
    lcd_show_num(30 + 8 * 14, 190, free >> 10, 5, 16, BLUE);/*显示SD卡剩余容量*/
    while (1)
    {
        t++;
        delay_ms(200);
        LED0_TOGGLE(); /* LED0闪烁 */
    }
}