ESP32开发学习 LVGL Littlevgl 使用文件系统

绝地灬酷狼 2022-08-31 00:43 2430阅读 0赞

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

官方提供了“文件系统”抽象模块，用于上层GUI来读取文件，图片，字体等操作。你可以像使用FatFS一样使用LVGL的文件系统API，在LVGL使用外部存储设备的资源时会被自动调用，例如下面列出的都是LVGL的函数，对接文件系统后，这些函数会自动读取文件系统中的文件，只要添加其对应的解码库即可实现图片的显示

扩展文章：

[LVGL Littlevgl 加载外部SD卡字库显示][LVGL Littlevgl _SD]

[ESP32开发学习 LVGL Littlevgl 使用文件系统加载PNG解码显示][ESP32_ LVGL Littlevgl _PNG]

[LVGL Littlevgl 解码显示JPG图片三种方式JPG\_SJPG\_C Array][LVGL Littlevgl _JPG_JPG_SJPG_C Array]

lv_img_set_src(img, "P:lv_lib_lodepng/png_decoder_test.png");

lv_img_set_src(img2,  "S.\\lv_lib_split_jpg\\example\\images\\small_image.sjpg");

lv_img_set_src(img, "S/path/to/image.bmp");

lv_obj_t * img = lv_gif_create_from_file(parent, "S/path/to/example.gif");

### 本文开发环境： ###

Visual Studio Code **V1.58.2**

LVGL版本 **V7.10.0**

芯片平台：**ESP32**

IDF库版本：**4.3.0**

IDF TOOLS编译工具链版本：**2.9**

**本文软件基于LVGL官方提供的ESP32工程lv\_port\_esp32修改而来**

**LVGL ESP32官方地址：**[https://github.com/lvgl/lv\_port\_esp32][https_github.com_lvgl_lv_port_esp32]

**开发板平台基于HelloBug ESP32开发板**

**开发板购买链接：**[https://hellobug.taobao.com/][https_hellobug.taobao.com]

# 一、lvgl文件系统接口移植 #

LVGL官方的ESP32项目中是没有接口代码的，但在官方git可以下载到。

地址：[https://github.com/lvgl/lv\_fs\_if][https_github.com_lvgl_lv_fs_if]

下载后直接复制到项目工程中的components文件夹中。目录结构如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70][]

光复制接口文件还不行，要把它作为LVGL的一个模块，还要编写添加一个CMakeLists.txt放在lv\_fs\_if文件夹下，内容和目录结构如下：![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70 1][]

包含此文件夹下所有.c文件，另外引用idf库中的文件系统和底层SD卡驱动部分，将lv\_fs\_if注册到idf组件，最后添加两个需要用到的组件lvgl和my\_sd\_fatfs组件，lvgl都知道是LVGL的核心组件，my\_sd\_fatfs看名字就知道是自己写的，用来初始化SD卡底层并挂载底层的文件系统，这个怎么写后面会讲到。

# 二、修改配置 #

打开工程目录中LVGL目录中的lv\_conf.h。\\components\\lvgl\\lv\_conf.h，在.h文件中最后添加如下配置来启用LVGL的文件系统

// File system interface
    #define LV_USE_FS_IF	1
    #if LV_USE_FS_IF
    #define LV_FS_IF_FATFS    'S'
    #define LV_FS_IF_PC       '\0'
    #define LV_FS_IF_POSIX    '\0'
    #endif

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70 2][]

#  三、初始化底层SD卡驱动 #

要对接lvgl的文件系统，必须先初始化底层的存储器初始化及挂载文件系统。

在工程目录components中创建一个文件夹my\_sd\_fatfs，名字你们随便起，意思为初始化底层FATFS的源码目录，然后再其中再创建include文件夹，接着创建CMakeLists.txt，component.mk，my\_sd\_fatfs.c，my\_sd\_fatfs.h，文件夹结构如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70 3][]

CMakeLists.txt文件主要为这个组件添加文件和其它组件包含，其内容如下：

set(mysrcs "my_sd_fatfs.c")
    
    idf_component_register(SRCS "${mysrcs}"
                           INCLUDE_DIRS "include"
    					   REQUIRES fatfs)

component.mk文件内容

COMPONENT_ADD_INCLUDEDIRS := include
    COMPONENT_SRCDIRS := .

my\_sd\_fatfs.h文件内容

#ifndef MY_SD_FATFS_H
    #define MY_SD_FATFS_H
    
    #ifdef __cplusplus
    extern "C" {
    #endif
    
    #include <string.h>
    #include <unistd.h>
    #include <sys/stat.h>
    #include "esp_vfs_fat.h"
    #include "driver/sdspi_host.h"
    #include "driver/spi_common.h"
    #include "sdmmc_cmd.h"
    #include "driver/sdmmc_host.h"
    
    void SD_Fatfs_Init(void);
    
    #endif /* LVGL_HELPERS_H */

my\_sd\_fatfs.c文件内容：

#include "my_sd_fatfs.h"
    
    static const char *TAG = "TFCardFat";
    
    #define MOUNT_POINT		"/sdcard"		// 第一个字节必须是‘/’
    #define SPI_DMA_CHAN    2
    
    //在测试SD和SPI模式时，请记住，一旦在SPI模式下初始化了卡，在不接通卡电源的情况下就无法在SD模式下将其重新初始化。
    #define PIN_NUM_MISO 19
    #define PIN_NUM_MOSI 23
    #define PIN_NUM_CLK  18
    #define PIN_NUM_CS   5
    
    static void get_fatfs_usage(size_t* out_total_bytes, size_t* out_free_bytes);
    
    
    void SD_Fatfs_Init(void)
    {
    	esp_err_t ret;								// ESP错误定义
    	sdmmc_card_t* card;							// SD / MMC卡信息结构
    	const char mount_point[] = MOUNT_POINT;		// 根目录
    	char ReadFileBuff[64];
    
    	esp_vfs_fat_sdmmc_mount_config_t mount_config = {	// 文件系统挂载配置
    		.format_if_mount_failed = false,				// 如果挂载失败：true会重新分区和格式化/false不会重新分区和格式化
    		.max_files = 5,									// 打开文件最大数量
    		.allocation_unit_size = 16 * 1024
    	};
    
    	ESP_LOGI(TAG,"->Initializing SD card");
    	ESP_LOGI(TAG,"->Using SPI peripheralr");
    	sdmmc_host_t host = SDSPI_HOST_DEFAULT();
    	spi_bus_config_t bus_cfg = {
    		.mosi_io_num = PIN_NUM_MOSI,
    		.miso_io_num = PIN_NUM_MISO,
    		.sclk_io_num = PIN_NUM_CLK,
    		.quadwp_io_num = -1,
    		.quadhd_io_num = -1,
    		.max_transfer_sz = 4 * 1024 * sizeof(uint8_t),
    	};
    	host.slot = 2;
    	// SPI总线初始化
    	ret = spi_bus_initialize(host.slot, &bus_cfg, SPI_DMA_CHAN);
    	if (ret != ESP_OK) {
    		printf("%s->Failed to initialize bus.\r\n",TAG);
    		return;
    	}
    	// 这将初始化没有卡检测（CD）和写保护（WP）信号的插槽。
    	// 如果您的主板有这些信号，请修改slot_config.gpio_cd和slot_config.gpio_wp。
    	sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();// SPI2_HOST  1
    	slot_config.gpio_cs = PIN_NUM_CS;
    	slot_config.host_id = host.slot;
    	// 挂载文件系统
    	ret = esp_vfs_fat_sdspi_mount(mount_point, &host, &slot_config, &mount_config, &card);
    	if (ret != ESP_OK) {
    		if (ret == ESP_FAIL) {
    			printf("%s->Failed to mount filesystem.%s\r\n",TAG,
    				"If you want the card to be formatted, set the EXAMPLE_FORMAT_IF_MOUNT_FAILED menuconfig option.");
    		} else {
    			printf("%s->Failed to initialize the card %s  (%s). ",TAG,
    				"Make sure SD card lines have pull-up resistors in place.", esp_err_to_name(ret));
    		}
    		return;
    	}
    	// TF卡已经初始化，打印TF卡属性
    	sdmmc_card_print_info(stdout, card);
    
    
    	// Print FAT FS size information
    	size_t bytes_total, bytes_free;
    	get_fatfs_usage(&bytes_total, &bytes_free);
    	printf("%s->FAT FS Total: %d MB, Free: %d MB \r\n",TAG, bytes_total / 1024, bytes_free / 1024);
    }

此时使用使用POSIX和C标准库函数其实已经可以进行SD卡的文件进行各种操作了，接下来就是把C标准函数与LVGL的文件系统函数做一个对接。

# 四、对接文件操作函数 #

LVGL的文件操作函数在components\\lvgl\\lvgl\\src\\lv\_misc\\lv\_fs.h文件中有定义，这里把大概要对接的函数列出如下：（这个文件不要修改！！）

lv_fs_res_t lv_fs_open(lv_fs_file_t * file_p, const char * path, lv_fs_mode_t mode);
    lv_fs_res_t lv_fs_close(lv_fs_file_t * file_p);
    lv_fs_res_t lv_fs_remove(const char * path);
    lv_fs_res_t lv_fs_read(lv_fs_file_t * file_p, void * buf, uint32_t btr, uint32_t * br);
    lv_fs_res_t lv_fs_write(lv_fs_file_t * file_p, const void * buf, uint32_t btw, uint32_t * bw);
    lv_fs_res_t lv_fs_seek(lv_fs_file_t * file_p, uint32_t pos);
    lv_fs_res_t lv_fs_tell(lv_fs_file_t * file_p, uint32_t * pos);
    lv_fs_res_t lv_fs_trunc(lv_fs_file_t * file_p);
    lv_fs_res_t lv_fs_size(lv_fs_file_t * file_p, uint32_t * size);
    lv_fs_res_t lv_fs_rename(const char * oldname, const char * newname);
    lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t * rddir_p, const char * path);
    lv_fs_res_t lv_fs_dir_read(lv_fs_dir_t * rddir_p, char * fn);
    lv_fs_res_t lv_fs_dir_close(lv_fs_dir_t * rddir_p);
    lv_fs_res_t lv_fs_free_space(char letter, uint32_t * total_p, uint32_t * free_p);
    char * lv_fs_get_letters(char * buf);
    const char * lv_fs_get_ext(const char * fn);
    char * lv_fs_up(char * path);
    const char * lv_fs_get_last(const char * path);

其实不用所的函数都实现对接，实现最常用的即可。我随便看看一个lv文件操作的函数是怎么一步一步调用到底层的。如components\\lvgl\\lvgl\\src\\lv\_misc\\lv\_fs.c中lv\_fs\_open函数，原型如下：（此文件不要修改）

lv_fs_res_t lv_fs_open(lv_fs_file_t * file_p, const char * path, lv_fs_mode_t mode)
    {
        file_p->drv    = NULL;
        file_p->file_d = NULL;
        if(path == NULL) return LV_FS_RES_INV_PARAM;
        char letter = path[0];
        file_p->drv = lv_fs_get_drv(letter);
        if(file_p->drv == NULL) {
            return LV_FS_RES_NOT_EX;
        }
        if(file_p->drv->ready_cb != NULL) {
            if(file_p->drv->ready_cb(file_p->drv) == false) {
                file_p->drv = NULL;
                return LV_FS_RES_HW_ERR;
            }
        }
        if(file_p->drv->open_cb == NULL) {
            file_p->drv = NULL;
            return LV_FS_RES_NOT_IMP;
        }
        const char * real_path = lv_fs_get_real_path(path);
        if(file_p->drv->file_size == 0) {  /*Is file_d zero size?*/
            /*Pass file_d's address to open_cb, so the implementor can allocate memory byself*/
            return file_p->drv->open_cb(file_p->drv, &file_p->file_d, real_path, mode);
        }
        file_p->file_d = lv_mem_alloc(file_p->drv->file_size);
        LV_ASSERT_MEM(file_p->file_d);
        if(file_p->file_d == NULL) {
            file_p->drv = NULL;
            return LV_FS_RES_OUT_OF_MEM; /* Out of memory */
        }
        lv_fs_res_t res = file_p->drv->open_cb(file_p->drv, file_p->file_d, real_path, mode);
        if(res != LV_FS_RES_OK) {
            lv_mem_free(file_p->file_d);
            file_p->file_d = NULL;
            file_p->drv    = NULL;
        }
        return res;
    }

函数前面是各种检查，申请开文件的必要内存，主要看这一句，参数为设备操作指针，文件指针，真实的目录，操作模式。

open_cb(file_p->drv, &file_p->file_d, real_path, mode);

这个函数的函数指针又指向components\\lv\_fs\_if\\lv\_fs\_fatfs.c中的fs\_open函数。lv\_fs\_if组件即是我们在第一步从LVGL官方下载的文件系统组件，通过lv\_conf.h中配置的\#define LV\_USE\_FS\_IF    1开关来指向到这里。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70 4][]

要实现对接主要来更改components\\lv\_fs\_if\\lv\_fs\_fatfs.c这个文件里面的每一个文件操作函数。在这个文件中的lv\_fs\_if\_fatfs\_init函数中列出了要实现的函数

fs_drv.open_cb = fs_open;
        fs_drv.close_cb = fs_close;
        fs_drv.read_cb = fs_read;
        fs_drv.write_cb = fs_write;
        fs_drv.seek_cb = fs_seek;
        fs_drv.tell_cb = fs_tell;
        fs_drv.free_space_cb = fs_free;
        fs_drv.size_cb = fs_size;
        fs_drv.remove_cb = fs_remove;
        fs_drv.rename_cb = fs_rename;
        fs_drv.trunc_cb = fs_trunc;
    
        fs_drv.rddir_size = sizeof(dir_t);
        fs_drv.dir_close_cb = fs_dir_close;
        fs_drv.dir_open_cb = fs_dir_open;
        fs_drv.dir_read_cb = fs_dir_read;

这个.c文件中已经把所有要实现的函数都写了出来，只不过都直接返回

lv_fs_res_t res = LV_FS_RES_NOT_IMP;

第一步先修改初始化函数，这里调用我们第三步初始化底层SD卡驱动的函数，进行底层文件系统的初始化。

/* Initialize your Storage device and File system. */
    static void fs_init(void)
    {
    	/* Initialize the SD card and FatFS itself.
    	* Better to do it in your code to keep this library utouched for easy updating*/
    	// 初始化 SD 卡和 FatFS 本身。
    	// 最好在您的代码中执行此操作，以保持此库不变以便于更新
    	SD_Fatfs_Init();
    }

接下来我们把几个文件操作函数全部修改一下。

## fs\_open ##

static lv_fs_res_t fs_open(lv_fs_drv_t * drv, void * file_p, const char * path, lv_fs_mode_t mode)
    {
    	// 打开文件
    	(void)file_p;
    	const char * flags = "";
    	if(mode == LV_FS_MODE_WR) flags = "wb";
    	else if(mode == LV_FS_MODE_RD) flags = "rb";
    	else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) flags = "rb+";
    	sprintf(f_path, "/sdcard/%s", path);
    	file_t f = fopen(f_path, flags);
    	if (NULL == f) {
    		return LV_FS_RES_NOT_EX;
    	}
    	fseek(f, 0, SEEK_SET);
    
    	/* 'file_p' 是指向文件描述符的指针，我们需要在这里存储我们的文件描述符*/
    	file_t * fp = file_p;
    	*fp = f;
    	return LV_FS_RES_OK;
    }

## fs\_close ##

static lv_fs_res_t fs_close (lv_fs_drv_t * drv, void * file_p)
    {
    	// 关闭文件
    	(void) drv;		/*Unused*/
    	(void) drv;		/*Unused*/
    	file_t * fp = file_p;	// 取出文件操作句柄
    	if (NULL == fp) {
    		ESP_LOGE(TAG, "NULL file pointer");
    		return LV_FS_RES_NOT_EX;
    	}
    	if (EOF == fclose(fp)) {
    		ESP_LOGE(TAG, "Failed close file pointer");
    		return LV_FS_RES_NOT_EX;
    	}
    	return LV_FS_RES_OK;
    }

## fs\_read ##

static lv_fs_res_t fs_read (lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
    {
    	// 读取文件
    	(void) drv;		/*Unused*/
    	file_t * fp = file_p;// 取出文件操作句柄
    	*br = fread(buf, 1, btr, (FILE *)file_p);
    	return LV_FS_RES_OK;
    }

## fs\_write ##

static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
    {
    	// 操作文件写入数据
    	(void) drv;		/*Unused*/
    	file_t * fp = file_p;// 取出文件操作句柄
    	*bw = fwrite(buf, 1, btw, (FILE *)file_p);
    	return LV_FS_RES_OK;
    }

## fs\_seek ##

static lv_fs_res_t fs_seek(lv_fs_drv_t * drv, void * file_p, uint32_t pos, int whence)
    {
    	// 设置文件操作指针偏移
    	(void) drv;		/*Unused*/
    	fseek((FILE *)file_p, pos, SEEK_SET);
    	return LV_FS_RES_OK;
    }

## fs\_size ##

static lv_fs_res_t fs_size(lv_fs_drv_t * drv, void * file_p, uint32_t * size_p)
    {
    	// 获取当前文件大小（Byte）
    	(void) drv;		/*Unused*/
    	file_t * fp = file_p;// 取出文件操作句柄
    	uint32_t cur = ftell((FILE *)file_p);
    	fseek((FILE *)file_p, 0L, SEEK_END);
    	*size_p = ftell((FILE *)file_p);
    	fseek((FILE *)file_p, cur, SEEK_SET);// 恢复文件指针
    	return LV_FS_RES_OK;
    }

## fs\_tell ##

static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
    {
    	// 获取文件当前操作指针位置
    	(void) drv;		/*Unused*/
    	*pos_p = ftell((FILE *)file_p);
    	return LV_FS_RES_OK;
    }

## fs\_remove ##

static lv_fs_res_t fs_remove(lv_fs_drv_t * drv, const char *path)
    {
    	char * pathbuf = lv_mem_alloc(128);
    	sprintf(pathbuf,"/sdcard/%s",path);
    	lv_fs_res_t res = LV_FS_RES_UNKNOWN;
    	if(remove(pathbuf)==0){
    		lv_mem_free(pathbuf);
    		return LV_FS_RES_OK;
    	}else{
    		lv_mem_free(pathbuf);
    		return res;
    	}
    }

## fs\_rename ##

static lv_fs_res_t fs_rename (lv_fs_drv_t * drv, const char * oldname, const char * newname)
    {
    	(void) drv;		/*Unused*/
    	char * oldnamebuf = lv_mem_alloc(128);
    	char * newnamebuf = lv_mem_alloc(128);
    	sprintf(oldnamebuf,"/sdcard/%s",oldname);
    	sprintf(newnamebuf,"/sdcard/%s",newname);	
    	//
    	lv_fs_res_t res = LV_FS_RES_UNKNOWN;
    	if(rename(oldnamebuf,newnamebuf)==0){
    		lv_mem_free(oldnamebuf);
    		lv_mem_free(newnamebuf);
    		return LV_FS_RES_OK;
    	}else{
    		lv_mem_free(oldnamebuf);
    		lv_mem_free(newnamebuf);
    		return res;
    	}
    }

## fs\_free ##

static lv_fs_res_t fs_free(lv_fs_drv_t * drv, uint32_t * total_p, uint32_t * free_p)
    {
    	lv_fs_res_t res = LV_FS_RES_NOT_IMP;
    
    	size_t total_sectors = 0,free_sectors = 0;
    	size_t sd_total = 0,sd_total_KB = 0,sd_total_MB = 0;
    	size_t sd_free = 0,sd_free_KB = 0,sd_free_MB = 0;
    
    	FATFS *fs;
    	size_t free_clusters;
    	FRESULT fres = f_getfree("0:", &free_clusters, &fs);
    	if(fres == FR_OK){
    		total_sectors = (fs->n_fatent - 2) * fs->csize;
    		free_sectors = free_clusters * fs->csize;
    
    		sd_total = total_sectors/1024;
    		sd_total_KB = sd_total*fs->ssize;
    		sd_total_MB = (sd_total*fs->ssize)/1024;
    		sd_free = free_sectors/1024;
    		sd_free_KB = sd_free*fs->ssize;
    		sd_free_MB = (sd_free*fs->ssize)/1024;
    		if (total_p != NULL) {
    			*total_p = sd_total_KB;
    		}
    		if (free_p != NULL) {
    			*free_p = sd_free_KB;
    		}
    		return LV_FS_RES_OK;
    	}else{
    		*total_p = sd_total_KB;
    		*free_p = sd_free_KB;
    		return LV_FS_RES_UNKNOWN;
    	}
    	//printf("SD Cart sd_total_KB %d KByte\r\n ", sd_total_KB);	
    	// printf("SD Cart sd_total_MB %d MByte\r\n ", sd_total_MB);	
    	// printf("SD Cart sd_free_KB %d KByte\r\n ", sd_free_KB);	
    	// printf("SD Cart sd_free_MB %d MByte\r\n ", sd_free_MB);	
    	// 假设总大小小于4GiB，对于SPI Flash应该为true
    }

## fs\_dir\_open ##

static lv_fs_res_t fs_dir_open (lv_fs_drv_t * drv, void * dir_p, const char *path)
    {
    
    	dir_t file_dir = NULL;
     	//file_dir = opendir("/sdcard/");
    
    
    	(void)dir_p;
    	(void) drv;		/*Unused*/
    	char * pathbuf = lv_mem_alloc(128);
    	sprintf(pathbuf,"/sdcard/%s",path);	
    	printf("fs_dir_open   %s\r\n",pathbuf);
    	file_dir = opendir(pathbuf);
    	if (NULL == file_dir) {
    		lv_mem_free(pathbuf);
    		return LV_FS_RES_FS_ERR;
    	}
    	lv_mem_free(pathbuf);
    		/* 'file_p' 是指向文件描述符的指针，我们需要在这里存储我们的文件描述符*/
    	dir_t * fd = dir_p;
    	*fd = file_dir;
    	return LV_FS_RES_OK;
    }

## fs\_dir\_read ##

static lv_fs_res_t fs_dir_read (lv_fs_drv_t * drv, void * dir_p, char *fn)
    {
    	struct dirent *entry;
    	dir_t *mdir_p = dir_p;
    	do {
    		entry = readdir(*mdir_p);
    		if(entry) {
    			if(entry->d_type == DT_DIR) sprintf(fn, "/%s", entry->d_name);
    			else strcpy(fn, entry->d_name);
    		} else {
    			strcpy(fn, "");
    		}
    	} while(strcmp(fn, "/.") == 0 || strcmp(fn, "/..") == 0);
    	
    	return LV_FS_RES_OK;
    }

## fs\_dir\_close ##

static lv_fs_res_t fs_dir_close (lv_fs_drv_t * drv, void * dir_p)
    {
    	(void) drv;		/*Unused*/
    	closedir(dir_p);
    	return LV_FS_RES_OK;
    }

# 五、测试代码 #

接下来就是用lvgl提示的函数来实际操作一下文件，测试一下，在这之前，要先在主函数中初始化LVGL文件系统，在lv\_init函数之后调用lv\_fs\_if\_init();初始化文件系统，并定义一些一会用到的东西，例文件操作句柄，文件夹操作句柄，返回值，数量变量，读取内容数组等

lv_init();										// 初始化LittlevGL
    	lvgl_driver_init();								// 初始化液晶SPI驱动 触摸芯片SPI/IIC驱动
    
    	lv_fs_if_init();
    
    	lv_fs_file_t f;
    	lv_fs_dir_t d;
    	lv_fs_res_t res;
    	uint32_t resCount;
    	uint8_t buf[64];

## 编写操作函数 ##

具体操作说明如下：

用只读方式打开S:/hello.txt文件，测试文件是否存在  
用写入方式打开S:/hello.txt文件，并写入hellobug esp32字符串，然后关闭文件  
用只读方式打开S:/hello.txt文件，并读取内容并打印，然后关闭文件  
删除S:/bug.txt（第一次运行时，肯定不存在）  
将hello.txt重命名为bug.txt

只读方式打开bug.txt，获取一下文件大小  
读取bug.txt所有内容并打印  
操作文件指针移到第7字节  
获取文件当前指针位置  
从指针当前位置读取文件内容并打印  
关闭文件

打开根目录  
循环读取目录下所有目录及文件  
关闭目录

然后添加如下测试代码。基本上用到了刚才改写的所有接口。

// 用只读方式打开一个文件，来判断文件是否存在
    	res = lv_fs_open(&f,"S:/hello.txt", LV_FS_MODE_RD);
    	if (res == LV_FS_RES_OK) {	// 文件存在
    		lv_fs_close(&f);		// 关闭文件
    		ESP_LOGI(TAG,"'hello.txt' file is existsres : %d",res);
    	}else if(res == LV_FS_RES_NOT_EX){// 文件不存在
    		ESP_LOGI(TAG,"'hello.txt' file is not exists res : %d",res);
    	}
    
    
    	/创建一个文件并写入内容
    	res = lv_fs_open(&f,"S:/hello.txt", LV_FS_MODE_WR);// 创建一个文件
    	if (res == LV_FS_RES_OK) {
    		ESP_LOGI(TAG,"Create file 'hello.txt' Success res : %d",res);
    		res = lv_fs_write(&f,"hellobug esp32", sizeof("hellobug esp32"), &resCount);// 创建一个文件
    		if (res == LV_FS_RES_OK) {
    			ESP_LOGI(TAG,"Write file 'hello.txt' Success res : %d WriteByte: %d",res,resCount);
    		}		
    	}
    	lv_fs_close(&f);
    
    	/读取刚才创建的文件并打印内容
    	res = lv_fs_open(&f,"S:/hello.txt", LV_FS_MODE_RD);// 只读方式打开一个文件
    	if(res == LV_FS_RES_OK) {
    		ESP_LOGI(TAG,"lv_fs_open->Success %d",res);
    		memset(buf,0,64);
    		res = lv_fs_read(&f, buf, 64, &resCount);
    		if(res != LV_FS_RES_OK) {
    			ESP_LOGI(TAG,"lv_fs_read->Failed %d",res);
    		}else{
    			ESP_LOGI(TAG,"lv_fs_read->Success %d",res);
    		}
    		ESP_LOGI(TAG,"lv_fs_read ReadByte : %d Content : %s",resCount,buf);
    		lv_fs_close(&f);
    	}else{
    		ESP_LOGI(TAG,"lv_fs_open->Failed %d",res);
    	}
    
    	// 删除文件
    	res = lv_fs_remove("S:/bug.txt");
    	ESP_LOGI(TAG,"lv_fs_remove-> bug.txt   res:%d",res);
    
    	// 重命名文件
    	res = lv_fs_rename("S:/hello.txt","S:/bug.txt");
    	ESP_LOGI(TAG,"lv_fs_rename-> oldname:hello.txt     newname:bug.txt   res:%d",res);
    
    
    
    	/读取刚才改名的文件并打印内容
    	res = lv_fs_open(&f,"S:/bug.txt", LV_FS_MODE_RD);// 只读方式打开一个文件
    	if(res == LV_FS_RES_OK) {
    		// 获取文件大小
    		res = lv_fs_size(&f,&resCount);
    		ESP_LOGI(TAG,"lv_fs_size-> bug.txt   file size : %d Byte",resCount);
    
    		ESP_LOGI(TAG,"lv_fs_open-> S:/bug.txt Success %d",res);
    		memset(buf,0,64);
    		res = lv_fs_read(&f, buf, 64, &resCount);
    		if(res != LV_FS_RES_OK) {
    			ESP_LOGI(TAG,"lv_fs_read-> S:/bug.txt Failed %d",res);
    		}else{
    			ESP_LOGI(TAG,"lv_fs_read-> S:/bug.txt Success %d",res);
    		}
    		ESP_LOGI(TAG,"lv_fs_read S:/bug.txt ReadByte : %d Content : %s",resCount,buf);
    
    		// 定位文件操作指针示例
    		res = lv_fs_seek(&f, 7);
    		ESP_LOGI(TAG,"lv_fs_seek-> S:/bug.txt res %d",res);
    		// 获取文件操作指针示例
    		res = lv_fs_tell(&f, &resCount);
    		ESP_LOGI(TAG,"lv_fs_tell-> S:/bug.txt res %d   index: %d",res,resCount);
    
    		memset(buf,0,64);
    		res = lv_fs_read(&f, buf, 64, &resCount);
    		ESP_LOGI(TAG,"lv_fs_read seek 7Byte S:/bug.txt ReadByte : %d Content : %s",resCount,buf);
    
    
    		lv_fs_close(&f);
    	}else{
    		ESP_LOGI(TAG,"lv_fs_open-> S:/bug.txt Failed %d",res);
    	}
    
    
    
    
    	res = lv_fs_dir_open(&d,"S:/");
    	ESP_LOGI(TAG,"lv_fs_dir_open-> res %d",res);
    
    	while(1){
    		memset(buf,0,64);
    		res = lv_fs_dir_read(&d,(char *)buf);
    		if(buf[0] == '\0'){
    			break;
    		}
    		ESP_LOGI(TAG,"lv_fs_dir_read   res : %d Content : %s",res,buf);
    	}
    	res = lv_fs_dir_close(&d);
    	ESP_LOGI(TAG,"lv_fs_dir_close   res : %d ",res);

## 测试结果打印： ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70 5][]

[LVGL Littlevgl _SD]: https://hellobug.blog.csdn.net/article/details/119411924
[ESP32_ LVGL Littlevgl _PNG]: https://hellobug.blog.csdn.net/article/details/119318468
[LVGL Littlevgl _JPG_JPG_SJPG_C Array]: https://blog.csdn.net/cnicfhnui/article/details/119377567
[https_github.com_lvgl_lv_port_esp32]: https://github.com/lvgl/lv_port_esp32
[https_hellobug.taobao.com]: https://hellobug.taobao.com/
[https_github.com_lvgl_lv_fs_if]: https://github.com/lvgl/lv_fs_if
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70]: /images/20220829/c8b38c9d22d041d0b89916b1ff70f2ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70 1]: /images/20220829/519e9f0296c04172ba7195d3e47ecf96.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70 2]: /images/20220829/24dd862b07474d808f696d2fcfcbaaee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70 3]: /images/20220829/f0625002e7c5401eb05fcbb8a63e5d50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70 4]: /images/20220829/0f285099315047ff80042373b758f713.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuaWNmaG51aQ_size_16_color_FFFFFF_t_70 5]: /images/20220829/6effee94b7d54c2da5de539aecfc1a62.png