7. M601 文件系统的使用

1 文件系统 API

本文介绍的数据结构和 API 可以参考 SDK 中 zyf_fs.h 文件

1.1 用法

存储只支持 FLASH 存储，想要创建或者打开一个文件或者目录时，必须使用绝对路径。例如，想要创建一个文件，可以这样设置 "/"。
·ZYF_FS_GetDiskTotalSpace 函数可以用来获得 Flash 的总空间大小
·ZYF_FS_GetDiskFreeSpace 函数可以用来获得 Flash 的剩余大小
·ZYF_FS_GetFileSize 函数用来获取特定文件大小，单位字节
·ZYF_FS_Open 函数用来创建或者打开文件。必须定义打开和访问模式。更多信息请参考此函数的头文件描述
·ZYF_FS_Read 函数 ZYF_FS_Write 函数用来读写文件，必须确认文件已经打开
·ZYF_FS_Seek 函数 ZYF_FS_GetFilePosition 函数用来设置或者获取文件指针位置，必须确认文件已经打开
·ZYF_FS_Delete 函数 ZYF_FS_CheckFile 函数用来删除和查找文件
·ZYF_FS_Close 函数用来关闭文件

1.2 API 函数

1.2.1. ZYF_FS_Open
打开或者创建指定名称的文件
· 函数原型
int32_t ZYF_FS_Open(const char *fileName, uint32_t Flag)
· 参数
fileName:[输入] 文件名称。最长 252 个字符，必须使用绝对路径，如"/"
Flag:[输入] 打开和访问模式，可能的值如下所示：
ZYF_FS_READ_WRITE, 可读写
ZYF_FS_READ_ONLY, 只读
ZYF_FS_CREATE, 如果文件存在，打开文件；如果文件不存在，则创建文件：
ZYF_FS_CREATE_ALWAYS, 创建新文件；如果文件存在，覆盖文件并清除现有的属性

返回结果
成功：返回一个值指定文件句柄
失败：返回一个负数，表示打开文件失败

1.2.2 ZYF_FS_Close
关闭指定句柄的文件
· 函数原型
void ZYF_FS_Close(int32_t fileHandle);
· 参数
fileHandle：文件句柄。为 ZYF_FS_Open 打开文件时返回的句柄
· 返回值
无

1.2.3 ZYF_FS_Read
读取文件内容
· 函数原型
int32_t ZYF_FS_Read(int32_t fileHandle, uint8_t *readBuffer,
uint32_t numberOfBytesToRead, uint32_t *numberOfBytesRead);
· 参数
fileHandle:[输入] 文件句柄。为 ZYF_FS_Open 打开文件时返回的句柄
readBuffer:[输出] 读取数据，指向读取的数据缓冲区
numberOfBytesToRead:[输入] 要读取的数据长度
numberOfBytesRead:[输出] 从文件读取到的数据长度。在执行操作或检查错误之前，将此值设置为零
· 返回值
成功 FS_NO_ERROR
失败请参考 fs_error_enum

1.2.4 ZYF_FS_Write
此函数用于写文件
· 函数原型
int32_t ZYF_FS_Write(int32_t fileHandle, uint8_t *writeBuffer,
uint32_t numberOfBytesToWrite, uint32_t *numberOfBytesWritten);
· 参数
fileHandle:[输入] 文件句柄。为 ZYF_FS_Open 打开文件时返回的句柄
writeBuffer:[输入] 要写入文件的数据，指向读取的数据缓冲区
numberOfBytesToWrite:[输入] 要写入的数据长度
numberOfBytesWritten:[输出] 已经写入文件的数据长度。在执行操作或检查错误之前，将此值设置为零
· 返回值
成功 FS_NO_ERROR
失败请参考 fs_error_enum

1.2.5 ZYF_FS_Seek
此函数用来操作文件指针偏移
· 函数原型
int32_t ZYF_FS_Seek(int32_t fileHandle, int32_t offset, uint32_t
whence)；
· 参数
fileHandle：[输入] 文件句柄。为 ZYF_FS_Open 打开文件时返回的句柄
offset:[输入] 从文件指针偏移的字节数
whence:[输入] 文件指针参考位置，见 Enum_FsSeekPos
·返回值

成功返回结果大于等于 0（文件偏移量）， 失败请参考 fs_error_enum

1.2.6 ZYF_FS_GetFileSize
此函数用来获取文件大小
· 函数原型
int32_t ZYF_FS_GetFileSize(int32_t fileHandle, uint32_t *size)；
· 参数
fileHandle:[输入] 文件句柄。为 ZYF_FS_Open 打开文件时返回的句柄
size:[输出] 检索到的文件大小
· 返回值
成功 FS_NO_ERROR
失败请参考 fs_error_enum

1.2.7 ZYF_FS_Delete
此函数用来删除文件
· 函数原型
int32_t ZYF_FS_Delete(const char *fileName)；
· 参数
fileName:[输入] 需要删除的文件名称。最长 252 个字符，必须使用绝对路径，如"/"
· 返回值
成功 FS_NO_ERROR
失败请参考 fs_error_enum

1.2.8 ZYF_FS_CheckFile
此函数用来检查文件是否存在
·函数原型

int32_t ZYF_FS_CheckFile(const char *fileName);
· 参数
fileName:[输入] 需要检查的文件名称
· 返回值
成功 FS_NO_ERROR
失败请参考 fs_error_enum

1.2.9 ZYF_FS_Rename
此函数用来文件重命名
· 函数原型
int32_t ZYF_FS_Rename(const char *fileName, const char *newName);
· 参数
fileName:[输入] 需要重命名的文件名称。最长 252 个字符，必须使用绝对路径，如"/"
newName:[输入] 文件的新名称。最长 252 个字符，必须使用绝对路径，如"/"
· 返回值
成功 FS_NO_ERROR
失败请参考 fs_error_enum

1.2.10 ZYF_FS_GetDiskFreeSpace
此函数用来获取磁盘剩余空间
· 函数原型
int32_t ZYF_FS_GetDiskFreeSpace(, uint32_t *free_space)；
· 参数
free_space:[输出] 对应磁盘的剩余空间大小
· 返回值
成功 FS_NO_ERROR
失败请参考 fs_error_enum

1.2.11 ZYF_FS_CreateDir
此函数用来创建文件目录
· 函数原型
int32_t ZYF_FS_CreateDir(constchar *dirName)；
· 参数
dirName:[输入] 目录名称
· 返回值
成功 FS_NO_ERROR
失败请参考 fs_error_enum

1.2.12 ZYF_FS_DeleteDir
此函数用来删除文件目录
· 函数原型
int32_tZYF_FS_DeleteDir (const char *dirName)；
· 参数
dirName:[输入] 目录名称
· 返回值
成功 FS_NO_ERROR
失败请参考 fs_error_enum

2 文件系统例程介绍

本章节主要介绍如何在 SDK 中使用 example_fs.c 单独测试文件系统功能。
编译方法：.\examples\build\对应的.bat 文件双击执行或打开就可以编译。
生成文件：.\out\对应目录\hex\M601_example_**.pac

使用 ZYF_FS_GetDiskFreeSpace()获取磁盘剩余空间大小，使用 ZYF_FileWrite()向磁盘中写入0x35，再用 ZYF_FileRead()将磁盘中的信息读出来。

#include <string.h>
#include "zyf_fs.h"
#include "zyf_trace.h"
#include "zyf_app.h"
#include "zyf_uart.h"
#include "zyf_thread.h"



#define USER_DIR "user"

#define USER_FILE "user_test.txt"

#define SD_USER_FILE "/user_test.txt"

static Uart_Param_t g_uart1param;

void UartWriteCallBack(void* Param) // general com
{
    Uart_Param_t *uartparam = (Uart_Param_t *)Param; 
    if(Param == NULL)
    {
        return;
    }    

    ZYF_UartWrite(uartparam->port,(uint8_t *)"UartWrite succeed\r\n",strlen("UartWrite succeed\r\n"));
    ZYF_UartWriteCallbackSwitch(uartparam->port,false);

}

void UartReadCallBack(void* Param) // 
{
    uint32_t recvlen = 0;
    Uart_Param_t *uartparam = (Uart_Param_t *)Param; 

    ZYF_LOG("Uart%d recv",uartparam->port);

    while(ZYF_UartRead(uartparam->port, &(uartparam->uartbuf[recvlen]), 1))
    {
        ZYF_LOG("recv :%02x",uartparam->uartbuf[recvlen]);
        recvlen++;
    }
    ZYF_UartWrite(uartparam->port,uartparam->uartbuf,recvlen);
    ZYF_UartWriteCallbackSwitch(uartparam->port,true);
}


static void AppUartInit(void)
{
    int32_t ret;
    g_uart1param.port = DEBUG_PORT;
    ZYF_UartRegister(g_uart1param.port, UartReadCallBack,&g_uart1param);
    ZYF_UartWriteCbRegister(g_uart1param.port,UartWriteCallBack,&g_uart1param);
    ZYF_UartOpen(g_uart1param.port, 115200, ZYF_FC_NONE);

    ZYF_LOG("AppUartInit");
    return;
}



uint32_t ZYF_FileRead(const char *path, void *dst, uint32_t size)
{
    int fd = ZYF_FS_Open(path, ZYF_RDONLY);
    if (fd < 0)
        return -1;

    uint32_t read_len  = 0;
    ZYF_FS_Read(fd, dst, size,&read_len);
    ZYF_FS_Close(fd);
    return read_len;
}

uint32_t ZYF_SD_FileRead(const char *path, void *dst, uint32_t size)
{
    int fd = ZYF_FS_SD_Open(path, ZYF_RDONLY);
    if (fd < 0)
        return -1;

    uint32_t read_len  = 0;
    ZYF_FS_Read(fd, dst, size,&read_len);
    ZYF_FS_Close(fd);
    return read_len;
}


uint32_t ZYF_FileWrite(const char *path, void *dst, uint32_t size)
{
    //check size


    int fd = ZYF_FS_Open(path, ZYF_RDWR | ZYF_CREAT | ZYF_TRUNC);
    if (fd < 0)
        return -1;

    uint32_t write_len  = 0;
    ZYF_FS_Write(fd, dst, size,&write_len);
    ZYF_FS_Close(fd);
    return write_len;
}

uint32_t ZYF_SD_FileWrite(const char *path, void *dst, uint32_t size)  //added by ldk for sdcard
{
    //check size


    int fd = ZYF_FS_SD_Open(path, ZYF_RDWR | ZYF_CREAT | ZYF_TRUNC);
    if (fd < 0)
        return -1;

    uint32_t write_len  = 0;
    ZYF_FS_Write(fd, dst, size,&write_len);
    ZYF_FS_Close(fd);
    return write_len;
}


void ZYF_FSTest(void)
{

    uint8_t buf[128] = {0};
    uint32_t len = 0;

    ZYF_FS_GetDiskFreeSpace( &len);
    ZYF_LOG("Free Space:%lu",len);



    #if 1
    memset(buf,0x35,sizeof(buf));
    len = ZYF_FileWrite(USER_FILE,buf,sizeof(buf));
    if(len != sizeof(buf))
    {
        ZYF_LOG("ZYF_FS_Write fail!ret:%d",len);
        return;
    }
    
    ZYF_LOG("ZYF_FS_Write succeed!");
    #endif
    
    len = 0;
    memset(buf,0x00,sizeof(buf));
    len = ZYF_FileRead(USER_FILE,buf,sizeof(buf));
    if(len != sizeof(buf))
    {
        ZYF_LOG("ZYF_FS_Read fail!ret:%d",len);
        return;
    }
    buf[127] = '\0';
    ZYF_LOG("ZYF_FS_Read data:%s",buf);

    if(ZYF_FS_CheckFile(USER_FILE))
    {
        ZYF_LOG("%s file exists",USER_FILE);
        //ZYF_FS_Delete(USER_FILE);
    }
    else
    {
        ZYF_LOG("%s file does not exist",USER_FILE);
    }
/* //unimplement
    memset(buf,0x35,sizeof(buf));
    len = ZYF_SD_FileWrite(SD_USER_FILE,buf,sizeof(buf));
    if(len != sizeof(buf))
    {
        ZYF_LOG("ZYF_SD_FileWrite fail!ret:%d",len);
        return;
    }
    
    ZYF_LOG("ZYF_SD_FileWrite succeed!");
    
    len = 0;
    memset(buf,0x00,sizeof(buf));
    len = ZYF_SD_FileRead(SD_USER_FILE,buf,sizeof(buf));
    if(len != sizeof(buf))
    {
        ZYF_LOG("ZYF_SD_FileRead fail!ret:%d",len);
        return;
    }
    buf[127] = '\0';
    ZYF_LOG("ZYF_SD_FileRead data:%s",buf);

    if(ZYF_FS_SD_CheckFile(SD_USER_FILE))
    {
        ZYF_LOG("%s file exists",SD_USER_FILE);
        //ZYF_FS_Delete(USER_FILE);
    }
    else
    {
        ZYF_LOG("%s file does not exist",SD_USER_FILE);
    }
 */   
}

void FileSystemThread_Example(void * Param)
{
    ZYF_MsgQ_t *ptMsg;
    ZYF_AppMsg_t tMsg;
    int iRet = -1;
    ptMsg = ZYF_MsgQCreate(10, sizeof(ZYF_AppMsg_t));
    ZYF_LOG("thread enter!");

    ZYF_FSTest();
    
    while (1) {
        ZYF_LOG("in while.");
        iRet = ZYF_MsgQGet(ptMsg, (void *)&tMsg);
        if (iRet < 0) {
            ZYF_LOG("Failed to get msg");
            ZYF_ThreadSleep(1000);
        }
    }

}


static void prvInvokeGlobalCtors(void)
{
    extern void (*__init_array_start[])();
    extern void (*__init_array_end[])();

    size_t count = __init_array_end - __init_array_start;
    for (size_t i = 0; i < count; ++i)
        __init_array_start[i]();
}


int appimg_enter(void *param)
{
    AppUartInit();
    ZYF_LOG("application image enter, param 0x%x", param);

    prvInvokeGlobalCtors();

    ZYF_ThreadCreate("FileSystemThread_Example", FileSystemThread_Example, NULL, ZYF_PRIORITY_HIGH, 10*1024);
    return 0;
}

void appimg_exit(void)
{
    OSI_LOGI(0, "application image exit");
}