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".

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.

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.

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.

Implementing the callbacks

Open callback

The prototype of open_cb looks like this:

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)

Other callbacks

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

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.

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_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

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.

Parameters

drv -- pointer to driver variable to initialize

void lv_fs_drv_register(lv_fs_drv_t *drv)

Add a new drive

Parameters

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

Parameters

letter -- the driver letter

Returns

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.

Parameters

letter -- letter of the drive

Returns

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

Parameters
  • 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

Returns

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

Parameters

file_p -- pointer to a lv_fs_file_t variable

Returns

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

Parameters
  • 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.

Returns

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

Parameters
  • 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.

Returns

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

Parameters
  • 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

Returns

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

Parameters
  • file_p -- pointer to a lv_fs_file_t variable

  • pos_p -- pointer to store the position of the read write pointer

Returns

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

Parameters
  • rddir_p -- pointer to a 'lv_fs_dir_t' variable

  • path -- path to a directory

Returns

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 '/'

Parameters
  • rddir_p -- pointer to an initialized 'fs_dir_t' variable

  • fn -- pointer to a buffer to store the filename

Returns

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

Parameters

rddir_p -- pointer to an initialized 'fs_dir_t' variable

Returns

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

Parameters

buf -- buffer to store the letters ('\0' added after the last letter)

Returns

the buffer

const char *lv_fs_get_ext(const char *fn)

Return with the extension of the filename

Parameters

fn -- string with a filename

Returns

pointer to the beginning extension or empty string if no extension

char *lv_fs_up(char *path)

Step up one level

Parameters

path -- pointer to a file name

Returns

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)

Parameters

path -- pointer to a file name

Returns

pointer to the beginning of the last element in the path

struct _lv_fs_drv_t

Public Members

char letter
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_t

Public Members

void *file_d
lv_fs_drv_t *drv
struct lv_fs_dir_t

Public Members

void *dir_d
lv_fs_drv_t *drv