7. Uso del sistema de archivos M601

1 API del sistema de archivos

La estructura de datos y la API que se presentan en este artículo pueden hacer referencia al archivo zyf_fs.h en el SDK

1.1 Uso

El almacenamiento solo admite el almacenamiento FLASH. Cuando desee crear o abrir un archivo o directorio, debe utilizar una ruta absoluta. Por ejemplo, si desea crear un archivo, puede configurar "/" así.
· La función ZYF_FS_GetDiskTotalSpace se puede utilizar para obtener el tamaño total del espacio
del Flash. La función ZYF_FS_GetDiskFreeSpace se puede utilizar para obtener el tamaño restante
del Flash . La función ZYF_FS_GetFileSize se utiliza para obtener un tamaño de archivo específico en bytes
. La función ZYF_FS_Open a se utiliza para crear. Se debe definir el modo de apertura y acceso. Para obtener más información, consulte la descripción del archivo de encabezado de esta función
. Función ZYF_FS_Read La función ZYF_FS_Write se usa para leer y escribir archivos, y se debe confirmar que
el archivo está abierto
. La función se usa para eliminar y buscar archivos
· La función ZYF_FS_Close se usa para cerrar archivos

1.2 funciones API

1.2.1 ZYF_FS_Open
abre o crea un archivo con un nombre especificado
· Prototipo de función
int32_t ZYF_FS_Open (const char * fileName, uint32_t Flag)
· Parámetro
fileName: [entrada] nombre de archivo. La longitud máxima es de 252 caracteres, y se debe usar la ruta absoluta, como "/"
Bandera: [entrada] Modo de acceso y abierto, los valores posibles son los siguientes:
ZYF_FS_READ_WRITE, leer y escribir
ZYF_FS_READ_ONLY, solo leer
ZYF_FS_CREATE, si el archivo existe, abrir el archivo; Si el archivo no existe, cree el archivo:
ZYF_FS_CREATE_ALWAYS, cree un nuevo archivo; si el archivo existe, sobrescriba el archivo y borre los atributos existentes

Devolver resultado
Correcto: devuelve un valor para especificar el identificador del archivo.
Error: devuelve un número negativo, lo que indica que el archivo no se pudo abrir

1.2.2 ZYF_FS_Close
cierra el archivo con el identificador especificado
· Función prototipo
void ZYF_FS_Close (int32_t fileHandle);
· Parámetro
fileHandle: identificador de archivo. Mango
devuelto al abrir el archivo para ZYF_FS_Open · Valor de retorno
Ninguno

1.2.3 ZYF_FS_Read
leer contenido del archivo
· Prototipo de función
int32_t ZYF_FS_Read (int32_t fileHandle, uint8_t * readBuffer,
uint32_t numberOfBytesToRead, uint32_t * numberOfBytesRead);
· Parámetro
fileHandle: [entrada] Identificador de archivo. El identificador devuelto cuando se abre el archivo para ZYF_FS_Open
readBuffer: [salida] Leer datos, apuntar al búfer de datos
para leer numberOfBytesToRead: [entrada] La longitud de los datos que se leerán
numberOfBytesRead: [Salida] La longitud de los datos leídos del archivo. Antes de realizar operaciones o comprobar errores, establezca este valor en cero
. Valor de retorno
Éxito FS_NO_ERROR
Fallo, consulte fs_error_enum

1.2.4 ZYF_FS_Write
Esta función se usa para escribir archivos
· Prototipo de función
int32_t ZYF_FS_Write (int32_t fileHandle, uint8_t * writeBuffer,
uint32_t numberOfBytesToWrite, uint32_t * numberOfBytesWritten);
· Parámetro
fileHandle: [input] FileHandle. El identificador devuelto al abrir el archivo para ZYF_FS_Open
writeBuffer: [entrada] Los datos que se escribirán en el archivo, apuntando al búfer de datos que se leerán
numberOfBytesToWrite: [entrada] La longitud de los datos que se escribirán
numberOfBytesWritten: [Salida] La longitud de los datos que se escribieron en el archivo . Antes de realizar operaciones o comprobar errores, establezca este valor en cero
. Valor de retorno
Éxito FS_NO_ERROR
Fallo, consulte fs_error_enum

1.2.5 ZYF_FS_Seek
Esta función se utiliza para manipular el desplazamiento del puntero del archivo
· Prototipo de función
int32_t ZYF_FS_Seek (int32_t fileHandle, int32_t offset, uint32_t de
dónde);
· Parámetro
fileHandle: [entrada] identificador de archivo. Identificador devuelto al abrir el archivo para ZYF_FS_Open
offset: [entrada] el número de bytes de compensación desde el puntero del archivo
whyce: [entrada] posición de referencia del puntero del archivo, consulte Enum_FsSeekPos
· Valor de retorno

El resultado de devolución exitoso es mayor o igual a 0 (desplazamiento de archivo), falla, consulte fs_error_enum

1.2.6 ZYF_FS_GetFileSize
Esta función se usa para obtener el tamaño del archivo
Función prototipo
int32_t ZYF_FS_GetFileSize (int32_t fileHandle, uint32_t * size);
· Parámetro
fileHandle: [entrada] identificador de archivo. El identificador devuelto al abrir un archivo para ZYF_FS_Open
size: [salida] El tamaño del archivo recuperado
· Valor de retorno
Éxito FS_NO_ERROR
fallo, consulte fs_error_enum

1.2.7 ZYF_FS_Delete
Esta función se utiliza para eliminar archivos
· Función prototipo
int32_t ZYF_FS_Delete (const char * fileName);
· Parámetro
fileName: [entrada] El nombre del archivo que se eliminará. La longitud máxima es de 252 caracteres y se debe usar una ruta absoluta, como "/".
· Valor de retorno Si falla el
FS_NO_ERROR correctamente
, consulte fs_error_enum

1.2.8 ZYF_FS_CheckFile
Esta función se utiliza para verificar si el archivo existe
· Prototipo de función

int32_t ZYF_FS_CheckFile (const char * fileName);
· Parámetro
fileName: [entrada] El nombre del archivo que se va a verificar
· Valor de retorno
Éxito FS_NO_ERROR
falla, consulte fs_error_enum

1.2.9 ZYF_FS_Rename
Esta función se utiliza para renombrar archivos
· Función prototipo
int32_t ZYF_FS_Rename (const char * fileName, const char * newName);
· Parámetro
fileName: [input] El nombre del archivo a renombrar. La longitud máxima es de 252 caracteres y se debe utilizar una ruta absoluta, como "/"
newName: [entrada] El nuevo nombre del archivo. La longitud máxima es de 252 caracteres y se debe usar una ruta absoluta, como "/".
· Valor de retorno Si falla el
FS_NO_ERROR correctamente
, consulte fs_error_enum

1.2.10 ZYF_FS_GetDiskFreeSpace
Esta función se utiliza para obtener espacio libre en disco
. Prototipo de función
int32_t ZYF_FS_GetDiskFreeSpace (, uint32_t * free_space);
· Parámetro
free_space: [salida] El tamaño del espacio restante en disco
. Valor de retorno Si falla
FS_NO_ERROR correctamente
, consulte fs_error_en

1.2.11 ZYF_FS_CreateDir
Esta función se utiliza para crear un directorio de archivos
· Prototipo de función
int32_t ZYF_FS_CreateDir (constchar * dirName);
· Parámetro dirName
: [entrada] nombre del directorio
· Valor de retorno
Éxito
Fallo de FS_NO_ERROR , consulte fs_error_enum

1.2.12 ZYF_FS_DeleteDir
Esta función se utiliza para eliminar un directorio de archivos
· Prototipo de función
int32_tZYF_FS_DeleteDir (const char * dirName);
· Parámetro
dirName: [entrada] nombre de directorio
· Valor de retorno
Éxito
Fallo de FS_NO_ERROR , consulte fs_error_enum

2 Introducción a las rutinas del sistema de archivos

Este capítulo presenta principalmente cómo usar example_fs.c en el SDK para probar la función del sistema de archivos por separado.
Método de compilación:. \ Examples \ build \ corresponde al archivo .bat haciendo doble clic para ejecutarlo o abriéndolo para compilar.
Archivo generado:. \ Out \ directorio correspondiente \ hex \ M601_example _ **. Pac

Use ZYF_FS_GetDiskFreeSpace () para obtener el espacio restante en el disco, use ZYF_FileWrite () para escribir 0x35 en el disco y luego use ZYF_FileRead () para leer la información en el disco.

#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");
}