File system（文件系统）¶

查看原文

LVGL has a 'File system' abstraction module that enables you to attach any type of file system. The file system is identified by a drive letter. For example, if the SD card is associated with the letter 'S', a file can be reached like "S:path/to/file.txt".

LVGL 有一个“文件系统”抽象模块，使您能够附加任何类型的文件系统。文件系统由驱动器号标识。例如，如果 SD 卡与字母“S”相关联，则可以访问类似“S:path/to/file.txt”的文件。

Ready to use drivers（准备使用驱动程序）¶

查看原文

The lv_fs_if repository contains ready to use drivers using POSIX, standard C and FATFS API. See it's README for the details.

lv_fs_if 存储库包含使用 POSIX、标准 C 和 FATFS 的即用型驱动程序) API。有关详细信息，请参阅 README。

Add a driver（添加驱动程序）¶

Registering a driver（注册驱动）¶

查看原文

To add a driver, lv_fs_drv_t needs to be initialized like below. lv_fs_drv_t needs to be static, global or dynamically allocated and not a local varaible.

要添加驱动程序，lv_fs_drv_t 需要像下面这样初始化。 lv_fs_drv_t 需要是静态的、全局的或动态分配的，而不是局部变量。

static lv_fs_drv_t drv;                   /*Needs to be static or global*/
lv_fs_drv_init(&drv);                     /*Basic initialization*/

drv.letter = 'S';                         /*An uppercase letter to identify the drive */
drv.ready_cb = my_ready_cb;               /*Callback to tell if the drive is ready to use */
drv.open_cb = my_open_cb;                 /*Callback to open a file */
drv.close_cb = my_close_cb;               /*Callback to close a file */
drv.read_cb = my_read_cb;                 /*Callback to read a file */
drv.write_cb = my_write_cb;               /*Callback to write a file */
drv.seek_cb = my_seek_cb;                 /*Callback to seek in a file (Move cursor) */
drv.tell_cb = my_tell_cb;                 /*Callback to tell the cursor position  */

drv.dir_open_cb = my_dir_open_cb;         /*Callback to open directory to read its content */
drv.dir_read_cb = my_dir_read_cb;         /*Callback to read a directory's content */
drv.dir_close_cb = my_dir_close_cb;       /*Callback to close a directory */

drv.user_data = my_user_data;             /*Any custom data if required*/

lv_fs_drv_register(&drv);                 /*Finally register the drive*/

查看原文

Any of the callbacks can be NULL to indicate that operation is not supported.

任何回调都可以为“NULL”以指示不支持该操作。

Implementing the callbacks（实现回调）¶

Open callback（打开回调）¶

查看原文

The prototype of open_cb looks like this:

open_cb 的原型如下所示：

void * (*open_cb)(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode);

查看原文

path is path after the driver letter (e.g. "S:path/to/file.txt" -> "path/to/file.txt"). mode can be LV_FS_MODE_WR or LV_FS_MODE_RD to open for write or read.

The return value is a pointer the file object the describes the opened file or NULL if there were any issues (e.g. the file wasn't found). The returned file object will be passed to to other file system related callbacks. (see below)

path 是驱动程序字母后的路径（例如“S:path/to/file.txt”->“path/to/file.txt”）。 mode 可以是 LV_FS_MODE_WR 或 LV_FS_MODE_RD 来打开写入或读取。

返回值是 file object 的指针，它描述了打开的文件，如果有任何问题（例如找不到文件），则返回“NULL”。返回的文件对象将传递给其他与文件系统相关的回调。（见下文）

Other callbacks（其他回调）¶

查看原文

The other callbacks are quite similar. For example write_cb looks like this:

其他回调非常相似。例如write_cb看起来像这样：

lv_fs_res_t (*write_cb)(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);

查看原文

As file_p LVGL passes the return value of open_cb, buf is the data to write, btw is the Bytes To Write, bw is the actually written bytes.

For a template to the callbacks see lv_fs_template.c.

由于file_p LVGL 传递open_cb 的返回值，buf 是要写入的数据，btw 是要写入的字节数，bw 是实际写入的字节数。

有关回调的模板，请参阅 lv_fs_template.c。

Usage example（使用示例）¶

查看原文

The example below shows how to read from a file:

下面的示例演示如何从文件中读取：

lv_fs_file_t f;
lv_fs_res_t res;
res = lv_fs_open(&f, "S:folder/file.txt", LV_FS_MODE_RD);
if(res != LV_FS_RES_OK) my_error_handling();

uint32_t read_num;
uint8_t buf[8];
res = lv_fs_read(&f, buf, 8, &read_num);
if(res != LV_FS_RES_OK || read_num != 8) my_error_handling();

lv_fs_close(&f);

查看原文

The mode in lv_fs_open can be LV_FS_MODE_WR to open for write or LV_FS_MODE_RD | LV_FS_MODE_WR for both

This example shows how to read a directory's content. It's up to the driver how to mark the directories, but it can be a good practice to insert a '/' in front of the directory name.

lv_fs_open中的模式可以是LV_FS_MODE_WR to open for write 或LV_FS_MODE_RD | LV_FS_MODE_WR 为两者

此示例演示如何读取目录的内容。如何标记目录取决于驱动程序，但在目录名称前插入“/”是一个好习惯。

lv_fs_dir_t dir;
lv_fs_res_t res;
res = lv_fs_dir_open(&dir, "S:/folder");
if(res != LV_FS_RES_OK) my_error_handling();

char fn[256];
while(1) {
    res = lv_fs_dir_read(&dir, fn);
    if(res != LV_FS_RES_OK) {
        my_error_handling();
        break;
    }

    /*fn is empty, if not more files to read*/
    if(strlen(fn) == 0) {
        break;
    }

    printf("%s\n", fn);
}

lv_fs_dir_close(&dir);

Use drivers for images（使用图像驱动程序）¶

查看原文

Image objects can be opened from files too (besides variables stored in the flash).

To use files in image widgets the following callbacks are required:

open
close
read
seek
tell

Image 对象也可以从文件中打开（除了存储在闪存中的变量）。

要在图像小部件中使用文件，需要以下回调：

打开
关
读
寻找
告诉

API¶

Typedefs

typedef uint8_t lv_fs_res_t¶

typedef uint8_t lv_fs_mode_t¶

typedef struct _lv_fs_drv_t lv_fs_drv_t¶

Enums

enum [anonymous]¶

Errors in the file system module.

Values:

enumerator LV_FS_RES_OK¶

enumerator LV_FS_RES_HW_ERR¶

enumerator LV_FS_RES_FS_ERR¶

enumerator LV_FS_RES_NOT_EX¶

enumerator LV_FS_RES_FULL¶

enumerator LV_FS_RES_LOCKED¶

enumerator LV_FS_RES_DENIED¶

enumerator LV_FS_RES_BUSY¶

enumerator LV_FS_RES_TOUT¶

enumerator LV_FS_RES_NOT_IMP¶

enumerator LV_FS_RES_OUT_OF_MEM¶

enumerator LV_FS_RES_INV_PARAM¶

enumerator LV_FS_RES_UNKNOWN¶

enum [anonymous]¶

File open mode.

Values:

enumerator LV_FS_MODE_WR¶

enumerator LV_FS_MODE_RD¶

enum lv_fs_whence_t¶

Seek modes.

Values:

enumerator LV_FS_SEEK_SET¶: Set the position from absolutely (from the start of file)

enumerator LV_FS_SEEK_CUR¶: Set the position from the current position

enumerator LV_FS_SEEK_END¶: Set the position from the end of the file

Functions

void _lv_fs_init(void)¶: Initialize the File system interface

void lv_fs_drv_init(lv_fs_drv_t *drv)¶

Initialize a file system driver with default values. It is used to surly have known values in the fields ant not memory junk. After it you can set the fields.

参数: drv -- pointer to driver variable to initialize

void lv_fs_drv_register(lv_fs_drv_t *drv)¶

Add a new drive

参数: drv -- pointer to an lv_fs_drv_t structure which is inited with the corresponding function pointers. Only pointer is saved, so the driver should be static or dynamically allocated.

lv_fs_drv_t *lv_fs_get_drv(char letter)¶

Give a pointer to a driver from its letter

参数: letter -- the driver letter
返回: pointer to a driver or NULL if not found

bool lv_fs_is_ready(char letter)¶

Test if a drive is ready or not. If the ready function was not initialized true will be returned.

参数: letter -- letter of the drive
返回: true: drive is ready; false: drive is not ready

lv_fs_res_t lv_fs_open(lv_fs_file_t *file_p, const char *path, lv_fs_mode_t mode)¶

Open a file

参数

file_p -- pointer to a lv_fs_file_t variable
path -- path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
mode -- read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR

返回

LV_FS_RES_OK or any error from lv_fs_res_t enum

lv_fs_res_t lv_fs_close(lv_fs_file_t *file_p)¶

Close an already opened file

参数: file_p -- pointer to a lv_fs_file_t variable
返回: LV_FS_RES_OK or any error from lv_fs_res_t enum

lv_fs_res_t lv_fs_read(lv_fs_file_t *file_p, void *buf, uint32_t btr, uint32_t *br)¶

Read from a file

参数

file_p -- pointer to a lv_fs_file_t variable
buf -- pointer to a buffer where the read bytes are stored
btr -- Bytes To Read
br -- the number of real read bytes (Bytes Read). NULL if unused.

返回

LV_FS_RES_OK or any error from lv_fs_res_t enum

lv_fs_res_t lv_fs_write(lv_fs_file_t *file_p, const void *buf, uint32_t btw, uint32_t *bw)¶

Write into a file

参数

file_p -- pointer to a lv_fs_file_t variable
buf -- pointer to a buffer with the bytes to write
btr -- Bytes To Write
br -- the number of real written bytes (Bytes Written). NULL if unused.

返回

LV_FS_RES_OK or any error from lv_fs_res_t enum

lv_fs_res_t lv_fs_seek(lv_fs_file_t *file_p, uint32_t pos, lv_fs_whence_t whence)¶

Set the position of the 'cursor' (read write pointer) in a file

参数

file_p -- pointer to a lv_fs_file_t variable
pos -- the new position expressed in bytes index (0: start of file)
whence -- tells from where set the position. See @lv_fs_whence_t

返回

LV_FS_RES_OK or any error from lv_fs_res_t enum

lv_fs_res_t lv_fs_tell(lv_fs_file_t *file_p, uint32_t *pos)¶

Give the position of the read write pointer

参数

file_p -- pointer to a lv_fs_file_t variable
pos_p -- pointer to store the position of the read write pointer

返回

LV_FS_RES_OK or any error from 'fs_res_t'

lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t *rddir_p, const char *path)¶

Initialize a 'fs_dir_t' variable for directory reading

参数

rddir_p -- pointer to a 'lv_fs_dir_t' variable
path -- path to a directory

返回

LV_FS_RES_OK or any error from lv_fs_res_t enum

lv_fs_res_t lv_fs_dir_read(lv_fs_dir_t *rddir_p, char *fn)¶

Read the next filename form a directory. The name of the directories will begin with '/'

参数

rddir_p -- pointer to an initialized 'fs_dir_t' variable
fn -- pointer to a buffer to store the filename

返回

LV_FS_RES_OK or any error from lv_fs_res_t enum

lv_fs_res_t lv_fs_dir_close(lv_fs_dir_t *rddir_p)¶

Close the directory reading

参数: rddir_p -- pointer to an initialized 'fs_dir_t' variable
返回: LV_FS_RES_OK or any error from lv_fs_res_t enum

char *lv_fs_get_letters(char *buf)¶

Fill a buffer with the letters of existing drivers

参数: buf -- buffer to store the letters ('\0' added after the last letter)
返回: the buffer

const char *lv_fs_get_ext(const char *fn)¶

Return with the extension of the filename

参数: fn -- string with a filename
返回: pointer to the beginning extension or empty string if no extension

char *lv_fs_up(char *path)¶

Step up one level

参数: path -- pointer to a file name
返回: the truncated file name

const char *lv_fs_get_last(const char *path)¶

Get the last element of a path (e.g. U:/folder/file -> file)

参数: path -- pointer to a file name
返回: pointer to the beginning of the last element in the path

struct _lv_fs_drv_t¶

Public Members

char letter¶

uint16_t cache_size¶

bool (*ready_cb)(struct _lv_fs_drv_t *drv)¶

void *(*open_cb)(struct _lv_fs_drv_t *drv, const char *path, lv_fs_mode_t mode)¶

lv_fs_res_t (*close_cb)(struct _lv_fs_drv_t *drv, void *file_p)¶

lv_fs_res_t (*read_cb)(struct _lv_fs_drv_t *drv, void *file_p, void *buf, uint32_t btr, uint32_t *br)¶

lv_fs_res_t (*write_cb)(struct _lv_fs_drv_t *drv, void *file_p, const void *buf, uint32_t btw, uint32_t *bw)¶

lv_fs_res_t (*seek_cb)(struct _lv_fs_drv_t *drv, void *file_p, uint32_t pos, lv_fs_whence_t whence)¶

lv_fs_res_t (*tell_cb)(struct _lv_fs_drv_t *drv, void *file_p, uint32_t *pos_p)¶

void *(*dir_open_cb)(struct _lv_fs_drv_t *drv, const char *path)¶

lv_fs_res_t (*dir_read_cb)(struct _lv_fs_drv_t *drv, void *rddir_p, char *fn)¶

lv_fs_res_t (*dir_close_cb)(struct _lv_fs_drv_t *drv, void *rddir_p)¶

void *user_data¶: Custom file user data

struct lv_fs_file_cache_t¶

Public Members

uint32_t start¶

uint32_t end¶

uint32_t file_position¶

void *buffer¶

struct lv_fs_file_t¶

Public Members

void *file_d¶

lv_fs_drv_t *drv¶

lv_fs_file_cache_t *cache¶

struct lv_fs_dir_t¶

Public Members

void *dir_d¶

lv_fs_drv_t *drv¶