From 518914a714e2ce58f1c672985e576ca9d13d7383 Mon Sep 17 00:00:00 2001 From: fvanroie <15969459+fvanroie@users.noreply.github.com> Date: Wed, 2 Feb 2022 08:04:00 +0100 Subject: [PATCH] Update lv_fs_if library --- include/lv_conf_v7.h | 5 + lib/lv_fs_if/.github/stale.yml | 17 + lib/lv_fs_if/.gitignore | 52 +++ lib/lv_fs_if/README.md | 6 +- lib/lv_fs_if/library.json | 4 + lib/lv_fs_if/lv_fs_fatfs.c | 170 +++++---- lib/lv_fs_if/lv_fs_if.c | 11 +- lib/lv_fs_if/lv_fs_if.h | 3 +- lib/lv_fs_if/lv_fs_pc.c | 67 ++-- lib/lv_fs_if/lv_fs_spiffs.cpp | 494 --------------------------- lib/lv_fs_if/lv_fs_spiffs.h | 19 -- lib/lv_lib_freetype/lv_fs_freetype.c | 2 +- src/font/hasp_font_loader.cpp | 8 +- 13 files changed, 193 insertions(+), 665 deletions(-) create mode 100644 lib/lv_fs_if/.github/stale.yml create mode 100644 lib/lv_fs_if/.gitignore create mode 100644 lib/lv_fs_if/library.json delete mode 100644 lib/lv_fs_if/lv_fs_spiffs.cpp delete mode 100644 lib/lv_fs_if/lv_fs_spiffs.h diff --git a/include/lv_conf_v7.h b/include/lv_conf_v7.h index f2341d4d..f49633ad 100644 --- a/include/lv_conf_v7.h +++ b/include/lv_conf_v7.h @@ -76,6 +76,10 @@ typedef int16_t lv_coord_t; /* LittelvGL's internal memory manager's settings. * The graphical objects and other related data are stored here. */ +//#define LV_FS_SEEK(x, y) lv_fs_seek(x, y, LV_FS_SEEK_SET) +#define LV_FS_SEEK(x, y) lv_fs_seek(x, y) +#define _lv_img_decoder_t _lv_img_decoder + /* 1: use custom malloc/free, 0: use the built-in `lv_mem_alloc` and `lv_mem_free` */ #define LV_MEM_CUSTOM 0 #if LV_MEM_CUSTOM == 0 @@ -211,6 +215,7 @@ typedef void* lv_fs_drv_user_data_t; //# define LV_FS_IF_SPIFFS '\0' // no internal esp Flash #endif #endif /*LV_USE_FS_IF*/ +#define LV_FS_PC_PATH "/littlefs" #endif diff --git a/lib/lv_fs_if/.github/stale.yml b/lib/lv_fs_if/.github/stale.yml new file mode 100644 index 00000000..ea1179b7 --- /dev/null +++ b/lib/lv_fs_if/.github/stale.yml @@ -0,0 +1,17 @@ +# Number of days of inactivity before an issue becomes stale +daysUntilStale: 21 +# Number of days of inactivity before a stale issue is closed +daysUntilClose: 7 +# Issues with these labels will never be considered stale +exemptLabels: + - architecture + - pinned +# Label to use when marking an issue as stale +staleLabel: stale +# Comment to post when marking an issue as stale. Set to `false` to disable +markComment: > + This issue or pull request has been automatically marked as stale because it has not had + recent activity. It will be closed if no further activity occurs. Thank you + for your contributions. +# Comment to post when closing a stale issue. Set to `false` to disable +closeComment: false diff --git a/lib/lv_fs_if/.gitignore b/lib/lv_fs_if/.gitignore new file mode 100644 index 00000000..c6127b38 --- /dev/null +++ b/lib/lv_fs_if/.gitignore @@ -0,0 +1,52 @@ +# Prerequisites +*.d + +# Object files +*.o +*.ko +*.obj +*.elf + +# Linker output +*.ilk +*.map +*.exp + +# Precompiled Headers +*.gch +*.pch + +# Libraries +*.lib +*.a +*.la +*.lo + +# Shared objects (inc. Windows DLLs) +*.dll +*.so +*.so.* +*.dylib + +# Executables +*.exe +*.out +*.app +*.i*86 +*.x86_64 +*.hex + +# Debug files +*.dSYM/ +*.su +*.idb +*.pdb + +# Kernel Module Compile Results +*.mod* +*.cmd +.tmp_versions/ +modules.order +Module.symvers +Mkfile.old +dkms.conf diff --git a/lib/lv_fs_if/README.md b/lib/lv_fs_if/README.md index 97e4c927..bf7c6a03 100644 --- a/lib/lv_fs_if/README.md +++ b/lib/lv_fs_if/README.md @@ -1,9 +1,8 @@ # File System Interface -LittlevGL has a [File system](https://docs.littlevgl.com/en/html/overview/file-system.html) module to attach memories which can manipulate with files. Here you can find interfaces to +LittlevGL has a [File system](https://docs.lvgl.io/latest/en/html/overview/file-system.html) module to attach memories which can manipulate with files. Here you can find interfaces to - FATFS - PC (Linux and Windows) -- SPIFFS (ESP32 and ESP8266) file systems. You still need to provide the drivers and libraries, this repo gives "only" the bridge between FATFS/PC/etc and LittlevGL. @@ -16,10 +15,9 @@ You still need to provide the drivers and libraries, this repo gives "only" the #if LV_USE_FS_IF # define LV_FS_IF_FATFS '\0' # define LV_FS_IF_PC '\0' -# define LV_FS_IF_SPIFFS 'F' #endif /*LV_USE_FS_IF*/ ``` 2. Enable an interface you need by changing `'\0'` to letter you want to use for that drive. E.g. `'S'` for SD card with FATFS. -3. Call `lv_fs_if_init()` to register the enabled interfaces. +3. Call `lv_fs_if_init()` (after `lv_init()`) to register the enabled interfaces. diff --git a/lib/lv_fs_if/library.json b/lib/lv_fs_if/library.json new file mode 100644 index 00000000..65215417 --- /dev/null +++ b/lib/lv_fs_if/library.json @@ -0,0 +1,4 @@ +{ + "name": "lv_fs_if", + "version": "0.0.0+20220202035348" +} \ No newline at end of file diff --git a/lib/lv_fs_if/lv_fs_fatfs.c b/lib/lv_fs_if/lv_fs_fatfs.c index 3448b707..4279b2b7 100644 --- a/lib/lv_fs_if/lv_fs_fatfs.c +++ b/lib/lv_fs_if/lv_fs_fatfs.c @@ -21,30 +21,30 @@ **********************/ /* Create a type to store the required data about your file.*/ -typedef FIL file_t; +typedef FIL file_t; /*Similarly to `file_t` create a type for directory reading too */ -typedef DIR dir_t; +typedef DIR dir_t; /********************** * STATIC PROTOTYPES **********************/ static void fs_init(void); -static lv_fs_res_t fs_open(lv_fs_drv_t* drv, void* file_p, const char* path, lv_fs_mode_t mode); -static lv_fs_res_t fs_close(lv_fs_drv_t* drv, void* file_p); -static lv_fs_res_t fs_read(lv_fs_drv_t* drv, void* file_p, void* buf, uint32_t btr, uint32_t* br); -static lv_fs_res_t fs_write(lv_fs_drv_t* drv, void* file_p, const void* buf, uint32_t btw, uint32_t* bw); -static lv_fs_res_t fs_seek(lv_fs_drv_t* drv, void* file_p, uint32_t pos); -static lv_fs_res_t fs_size(lv_fs_drv_t* drv, void* file_p, uint32_t* size_p); -static lv_fs_res_t fs_tell(lv_fs_drv_t* drv, void* file_p, uint32_t* pos_p); -static lv_fs_res_t fs_remove(lv_fs_drv_t* drv, const char* path); -static lv_fs_res_t fs_trunc(lv_fs_drv_t* drv, void* file_p); -static lv_fs_res_t fs_rename(lv_fs_drv_t* drv, const char* oldname, const char* newname); -static lv_fs_res_t fs_free(lv_fs_drv_t* drv, uint32_t* total_p, uint32_t* free_p); -static lv_fs_res_t fs_dir_open(lv_fs_drv_t* drv, void* dir_p, const char* path); -static lv_fs_res_t fs_dir_read(lv_fs_drv_t* drv, void* dir_p, char* fn); -static lv_fs_res_t fs_dir_close(lv_fs_drv_t* drv, void* dir_p); +static lv_fs_res_t fs_open (lv_fs_drv_t * drv, void * file_p, const char * path, lv_fs_mode_t mode); +static lv_fs_res_t fs_close (lv_fs_drv_t * drv, void * file_p); +static lv_fs_res_t fs_read (lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br); +static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw); +static lv_fs_res_t fs_seek (lv_fs_drv_t * drv, void * file_p, uint32_t pos); +static lv_fs_res_t fs_size (lv_fs_drv_t * drv, void * file_p, uint32_t * size_p); +static lv_fs_res_t fs_tell (lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p); +static lv_fs_res_t fs_remove (lv_fs_drv_t * drv, const char *path); +static lv_fs_res_t fs_trunc (lv_fs_drv_t * drv, void * file_p); +static lv_fs_res_t fs_rename (lv_fs_drv_t * drv, const char * oldname, const char * newname); +static lv_fs_res_t fs_free (lv_fs_drv_t * drv, uint32_t * total_p, uint32_t * free_p); +static lv_fs_res_t fs_dir_open (lv_fs_drv_t * drv, void * dir_p, const char *path); +static lv_fs_res_t fs_dir_read (lv_fs_drv_t * drv, void * dir_p, char *fn); +static lv_fs_res_t fs_dir_close (lv_fs_drv_t * drv, void * dir_p); /********************** * STATIC VARIABLES @@ -70,28 +70,28 @@ void lv_fs_if_fatfs_init(void) *--------------------------------------------------*/ /* Add a simple drive to open images */ - static lv_fs_drv_t fs_drv; /*A driver descriptor*/ - lv_fs_drv_init(&fs_drv); + lv_fs_drv_t fs_drv; /*A driver descriptor*/ + lv_fs_drv_init(&fs_drv); /*Set up fields...*/ - fs_drv.file_size = sizeof(file_t); - fs_drv.letter = LV_FS_IF_FATFS; - 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.file_size = sizeof(file_t); + fs_drv.letter = LV_FS_IF_FATFS; + 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.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.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; + fs_drv.dir_open_cb = fs_dir_open; + fs_drv.dir_read_cb = fs_dir_read; lv_fs_drv_register(&fs_drv); } @@ -115,27 +115,25 @@ static void fs_init(void) * @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR * @return LV_FS_RES_OK or any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_open(lv_fs_drv_t* drv, void* file_p, const char* path, lv_fs_mode_t mode) +static lv_fs_res_t fs_open (lv_fs_drv_t * drv, void * file_p, const char * path, lv_fs_mode_t mode) { uint8_t flags = 0; - if(mode == LV_FS_MODE_WR) - flags = FA_WRITE | FA_OPEN_ALWAYS; - else if(mode == LV_FS_MODE_RD) - flags = FA_READ; - else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) - flags = FA_READ | FA_WRITE | FA_OPEN_ALWAYS; + if(mode == LV_FS_MODE_WR) flags = FA_WRITE | FA_OPEN_ALWAYS; + else if(mode == LV_FS_MODE_RD) flags = FA_READ; + else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) flags = FA_READ | FA_WRITE | FA_OPEN_ALWAYS; FRESULT res = f_open(file_p, path, flags); if(res == FR_OK) { - f_lseek(file_p, 0); - return LV_FS_RES_OK; + f_lseek(file_p, 0); + return LV_FS_RES_OK; } else { - return LV_FS_RES_UNKNOWN; + return LV_FS_RES_UNKNOWN; } } + /** * Close an opened file * @param drv pointer to a driver where this function belongs @@ -143,7 +141,7 @@ static lv_fs_res_t fs_open(lv_fs_drv_t* drv, void* file_p, const char* path, lv_ * @return LV_FS_RES_OK: no error, the file is read * any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_close(lv_fs_drv_t* drv, void* file_p) +static lv_fs_res_t fs_close (lv_fs_drv_t * drv, void * file_p) { f_close(file_p); return LV_FS_RES_OK; @@ -159,13 +157,11 @@ static lv_fs_res_t fs_close(lv_fs_drv_t* drv, void* file_p) * @return LV_FS_RES_OK: no error, the file is read * any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_read(lv_fs_drv_t* drv, void* file_p, void* buf, uint32_t btr, uint32_t* br) +static lv_fs_res_t fs_read (lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br) { FRESULT res = f_read(file_p, buf, btr, (UINT*)br); - if(res == FR_OK) - return LV_FS_RES_OK; - else - return LV_FS_RES_UNKNOWN; + if(res == FR_OK) return LV_FS_RES_OK; + else return LV_FS_RES_UNKNOWN; } /** @@ -177,13 +173,11 @@ static lv_fs_res_t fs_read(lv_fs_drv_t* drv, void* file_p, void* buf, uint32_t b * @param br the number of real written bytes (Bytes Written). NULL if unused. * @return LV_FS_RES_OK or any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_write(lv_fs_drv_t* drv, void* file_p, const void* buf, uint32_t btw, uint32_t* bw) +static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw) { - FRESULT res = f_write(file_p, buf, btw, (UINT*)bw); - if(res == FR_OK) - return LV_FS_RES_OK; - else - return LV_FS_RES_UNKNOWN; + FRESULT res = f_write(file_p, buf, btw, (UINT*)bw); + if(res == FR_OK) return LV_FS_RES_OK; + else return LV_FS_RES_UNKNOWN; } /** @@ -194,7 +188,7 @@ static lv_fs_res_t fs_write(lv_fs_drv_t* drv, void* file_p, const void* buf, uin * @return LV_FS_RES_OK: no error, the file is read * any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_seek(lv_fs_drv_t* drv, void* file_p, uint32_t pos) +static lv_fs_res_t fs_seek (lv_fs_drv_t * drv, void * file_p, uint32_t pos) { f_lseek(file_p, pos); return LV_FS_RES_OK; @@ -207,9 +201,9 @@ static lv_fs_res_t fs_seek(lv_fs_drv_t* drv, void* file_p, uint32_t pos) * @param size pointer to a variable to store the size * @return LV_FS_RES_OK or any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_size(lv_fs_drv_t* drv, void* file_p, uint32_t* size_p) +static lv_fs_res_t fs_size (lv_fs_drv_t * drv, void * file_p, uint32_t * size_p) { - (*size_p) = f_size(((file_t*)file_p)); + (*size_p) = f_size(((file_t *)file_p)); return LV_FS_RES_OK; } @@ -221,9 +215,9 @@ static lv_fs_res_t fs_size(lv_fs_drv_t* drv, void* file_p, uint32_t* size_p) * @return LV_FS_RES_OK: no error, the file is read * any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_tell(lv_fs_drv_t* drv, void* file_p, uint32_t* pos_p) +static lv_fs_res_t fs_tell (lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p) { - *pos_p = f_tell(((file_t*)file_p)); + *pos_p = f_tell(((file_t *)file_p)); return LV_FS_RES_OK; } @@ -233,7 +227,7 @@ static lv_fs_res_t fs_tell(lv_fs_drv_t* drv, void* file_p, uint32_t* pos_p) * @param path path of the file to delete * @return LV_FS_RES_OK or any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_remove(lv_fs_drv_t* drv, const char* path) +static lv_fs_res_t fs_remove (lv_fs_drv_t * drv, const char *path) { lv_fs_res_t res = LV_FS_RES_NOT_IMP; @@ -249,9 +243,9 @@ static lv_fs_res_t fs_remove(lv_fs_drv_t* drv, const char* path) * @return LV_FS_RES_OK: no error, the file is read * any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_trunc(lv_fs_drv_t* drv, void* file_p) +static lv_fs_res_t fs_trunc (lv_fs_drv_t * drv, void * file_p) { - f_sync(file_p); /*If not syncronized fclose can write the truncated part*/ + f_sync(file_p); /*If not syncronized fclose can write the truncated part*/ f_truncate(file_p); return LV_FS_RES_OK; } @@ -263,15 +257,13 @@ static lv_fs_res_t fs_trunc(lv_fs_drv_t* drv, void* file_p) * @param newname path with the new name * @return LV_FS_RES_OK or any error from 'fs_res_t' */ -static lv_fs_res_t fs_rename(lv_fs_drv_t* drv, const char* oldname, const char* newname) +static lv_fs_res_t fs_rename (lv_fs_drv_t * drv, const char * oldname, const char * newname) { - + FRESULT res = f_rename(oldname, newname); - if(res == FR_OK) - return LV_FS_RES_OK; - else - return LV_FS_RES_UNKNOWN; + if(res == FR_OK) return LV_FS_RES_OK; + else return LV_FS_RES_UNKNOWN; } /** @@ -282,7 +274,7 @@ static lv_fs_res_t fs_rename(lv_fs_drv_t* drv, const char* oldname, const char* * @param free_p pointer to store the free size [kB] * @return LV_FS_RES_OK or any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_free(lv_fs_drv_t* drv, uint32_t* total_p, uint32_t* free_p) +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; @@ -298,13 +290,11 @@ static lv_fs_res_t fs_free(lv_fs_drv_t* drv, uint32_t* total_p, uint32_t* free_p * @param path path to a directory * @return LV_FS_RES_OK or any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_dir_open(lv_fs_drv_t* drv, void* dir_p, const char* path) +static lv_fs_res_t fs_dir_open (lv_fs_drv_t * drv, void * dir_p, const char *path) { FRESULT res = f_opendir(dir_p, path); - if(res == FR_OK) - return LV_FS_RES_OK; - else - return LV_FS_RES_UNKNOWN; + if(res == FR_OK) return LV_FS_RES_OK; + else return LV_FS_RES_UNKNOWN; } /** @@ -315,21 +305,21 @@ static lv_fs_res_t fs_dir_open(lv_fs_drv_t* drv, void* dir_p, const char* path) * @param fn pointer to a buffer to store the filename * @return LV_FS_RES_OK or any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_dir_read(lv_fs_drv_t* drv, void* dir_p, char* fn) +static lv_fs_res_t fs_dir_read (lv_fs_drv_t * drv, void * dir_p, char *fn) { - FRESULT res; - FILINFO fno; - fn[0] = '\0'; + FRESULT res; + FILINFO fno; + fn[0] = '\0'; do { - res = f_readdir(dir_p, &fno); - if(res != FR_OK) return LV_FS_RES_UNKNOWN; + res = f_readdir(dir_p, &fno); + if(res != FR_OK) return LV_FS_RES_UNKNOWN; - if(fno.fattrib & AM_DIR) { - fn[0] = '/'; - strcpy(&fn[1], fno.fname); - } else - strcpy(fn, fno.fname); + if(fno.fattrib & AM_DIR) { + fn[0] = '/'; + strcpy(&fn[1], fno.fname); + } + else strcpy(fn, fno.fname); } while(strcmp(fn, "/.") == 0 || strcmp(fn, "/..") == 0); @@ -342,11 +332,11 @@ static lv_fs_res_t fs_dir_read(lv_fs_drv_t* drv, void* dir_p, char* fn) * @param dir_p pointer to an initialized 'fs_read_dir_t' variable * @return LV_FS_RES_OK or any error from lv_fs_res_t enum */ -static lv_fs_res_t fs_dir_close(lv_fs_drv_t* drv, void* dir_p) +static lv_fs_res_t fs_dir_close (lv_fs_drv_t * drv, void * dir_p) { - f_closedir(dir_p); + f_closedir(dir_p); return LV_FS_RES_OK; } -#endif /*LV_USE_FS_IF*/ -#endif /*LV_FS_IF_FATFS*/ +#endif /*LV_USE_FS_IF*/ +#endif /*LV_FS_IF_FATFS*/ diff --git a/lib/lv_fs_if/lv_fs_if.c b/lib/lv_fs_if/lv_fs_if.c index 0b4c8fcc..3f112d8d 100644 --- a/lib/lv_fs_if/lv_fs_if.c +++ b/lib/lv_fs_if/lv_fs_if.c @@ -29,10 +29,6 @@ void lv_fs_if_fatfs_init(void); void lv_fs_if_pc_init(void); #endif -#if LV_FS_IF_SPIFFS != '\0' -#include "lv_fs_spiffs.h" -#endif - /********************** * STATIC VARIABLES **********************/ @@ -51,16 +47,13 @@ void lv_fs_if_pc_init(void); void lv_fs_if_init(void) { #if LV_FS_IF_FATFS != '\0' - lv_fs_if_fatfs_init(); + lv_fs_if_fatfs_init(); #endif #if LV_FS_IF_PC != '\0' - lv_fs_if_pc_init(); + lv_fs_if_pc_init(); #endif -#if LV_FS_IF_SPIFFS != '\0' - lv_fs_if_spiffs_init(); -#endif } /********************** diff --git a/lib/lv_fs_if/lv_fs_if.h b/lib/lv_fs_if/lv_fs_if.h index cc69dc83..7da337dd 100644 --- a/lib/lv_fs_if/lv_fs_if.h +++ b/lib/lv_fs_if/lv_fs_if.h @@ -38,10 +38,11 @@ void lv_fs_if_init(void); * MACROS **********************/ -#endif /*LV_USE_FS_IF*/ +#endif /*LV_USE_FS_IF*/ #ifdef __cplusplus } /* extern "C" */ #endif #endif /*LV_FS_IF_H*/ + diff --git a/lib/lv_fs_if/lv_fs_pc.c b/lib/lv_fs_if/lv_fs_pc.c index f9b1fdc3..48bbafa8 100644 --- a/lib/lv_fs_if/lv_fs_pc.c +++ b/lib/lv_fs_if/lv_fs_pc.c @@ -12,10 +12,8 @@ #include #include -#include -#if !defined(ARDUINO_ARCH_ESP8266) && !defined(STM32F4xx) && !defined(STM32F7xx) #include -#endif +#include #ifdef WIN32 #include #endif @@ -24,12 +22,10 @@ * DEFINES *********************/ #ifndef LV_FS_PC_PATH -#if defined(ESP32) -#define LV_FS_PC_PATH "/littlefs" /*Projet root*/ -#elif defined(WIN32) +#ifndef WIN32 #define LV_FS_PC_PATH "./" /*Projet root*/ #else -#define LV_FS_PC_PATH "" /*Projet root*/ +#define LV_FS_PC_PATH ".\\" /*Projet root*/ #endif #endif /*LV_FS_PATH*/ @@ -41,12 +37,10 @@ typedef FILE* file_t; /*Similarly to `file_t` create a type for directory reading too */ -#if defined(WIN32) -typedef HANDLE dir_t; -#elif defined(ARDUINO_ARCH_ESP8266) || defined(STM32F4xx) -typedef FILE* dir_t; -#else +#ifndef WIN32 typedef DIR* dir_t; +#else +typedef HANDLE dir_t; #endif /********************** @@ -89,7 +83,7 @@ void lv_fs_if_pc_init(void) *--------------------------------------------------*/ /* Add a simple drive to open images */ - static lv_fs_drv_t fs_drv; /*A driver descriptor*/ + lv_fs_drv_t fs_drv; /*A driver descriptor*/ lv_fs_drv_init(&fs_drv); /*Set up fields...*/ @@ -113,6 +107,11 @@ void lv_fs_if_pc_init(void) fs_drv.dir_read_cb = fs_dir_read; lv_fs_drv_register(&fs_drv); + + // char cur_path[512] = ""; + // getcwd(cur_path, sizeof(cur_path)); + LV_LOG_USER("LV_FS_PC is initialized with."); + // LV_LOG_USER("The following path is considered as root directory:\n%s", cur_path); } /********************** @@ -150,13 +149,10 @@ static lv_fs_res_t fs_open(lv_fs_drv_t* drv, void* file_p, const char* path, lv_ char buf[256]; sprintf(buf, LV_FS_PC_PATH "\\%s", path); #endif - // printf("Opening file: %s (%s)\n", buf, path); file_t f = fopen(buf, flags); - if(f == NULL) { - // printf("Failed to open %s\n", buf); - return LV_FS_RES_UNKNOWN; - } + if(f == NULL) return LV_FS_RES_UNKNOWN; + /*Be sure we are the beginning of the file*/ fseek(f, 0, SEEK_SET); @@ -231,7 +227,6 @@ static lv_fs_res_t fs_seek(lv_fs_drv_t* drv, void* file_p, uint32_t pos) (void)drv; /*Unused*/ file_t* fp = file_p; /*Just avoid the confusing casings*/ fseek(*fp, pos, SEEK_SET); - // printf("Seek size: %u\n", pos); return LV_FS_RES_OK; } @@ -251,7 +246,6 @@ static lv_fs_res_t fs_size(lv_fs_drv_t* drv, void* file_p, uint32_t* size_p) fseek(*fp, 0L, SEEK_END); *size_p = ftell(*fp); - // printf("File size: %u\n", *size_p); /*Restore file pointer*/ fseek(*fp, cur, SEEK_SET); @@ -304,9 +298,7 @@ static lv_fs_res_t fs_trunc(lv_fs_drv_t* drv, void* file_p) fflush(*fp); /*If not syncronized fclose can write the truncated part*/ uint32_t p = ftell(*fp); - (void)p; // unused - - // ftruncate(fileno(*fp), p); + // ftruncate(fileno(*fp), p); return LV_FS_RES_OK; } @@ -326,14 +318,12 @@ static lv_fs_res_t fs_rename(lv_fs_drv_t* drv, const char* oldname, const char* sprintf(old, LV_FS_PC_PATH "/%s", oldname); sprintf(new, LV_FS_PC_PATH "/%s", newname); - return LV_FS_RES_UNKNOWN; + int r = rename(old, new); - // int r = rename(old, new); - - // if(r == 0) - // return LV_FS_RES_OK; - // else - // return LV_FS_RES_UNKNOWN; + if(r == 0) + return LV_FS_RES_OK; + else + return LV_FS_RES_UNKNOWN; } /** @@ -369,10 +359,7 @@ static lv_fs_res_t fs_dir_open(lv_fs_drv_t* drv, void* dir_p, const char* path) { (void)drv; /*Unused*/ dir_t d; -#if defined(ARDUINO_ARCH_ESP8266) || defined(STM32F4xx) - return LV_FS_RES_UNKNOWN; - -#elif !defined(WIN32) +#ifndef WIN32 /*Make the path relative to the current directory (the projects root folder)*/ char buf[256]; sprintf(buf, LV_FS_PC_PATH "/%s", path); @@ -429,13 +416,12 @@ static lv_fs_res_t fs_dir_read(lv_fs_drv_t* drv, void* dir_p, char* fn) (void)drv; /*Unused*/ dir_t* dp = dir_p; /*Just avoid the confusing casings*/ -#ifdef ARDUINO_ARCH_ESP32 +#ifndef WIN32 struct dirent* entry; do { entry = readdir(*dp); if(entry) { - if(entry->d_type == DT_DIR) sprintf(fn, "/%s", entry->d_name); else @@ -444,9 +430,7 @@ static lv_fs_res_t fs_dir_read(lv_fs_drv_t* drv, void* dir_p, char* fn) strcpy(fn, ""); } } while(strcmp(fn, "/.") == 0 || strcmp(fn, "/..") == 0); -#endif - -#ifdef WIN32 +#else strcpy(fn, next_fn); strcpy(next_fn, ""); @@ -481,10 +465,7 @@ static lv_fs_res_t fs_dir_close(lv_fs_drv_t* drv, void* dir_p) { (void)drv; /*Unused*/ dir_t* dp = dir_p; -#if defined(ARDUINO_ARCH_ESP8266) || defined(STM32F4xx) - return LV_FS_RES_UNKNOWN; - -#elif !defined(WIN32) +#ifndef WIN32 closedir(*dp); #else FindClose(*dp); diff --git a/lib/lv_fs_if/lv_fs_spiffs.cpp b/lib/lv_fs_if/lv_fs_spiffs.cpp deleted file mode 100644 index f0bbf7d9..00000000 --- a/lib/lv_fs_if/lv_fs_spiffs.cpp +++ /dev/null @@ -1,494 +0,0 @@ -/** - * @file lv_fs_spiffs.c - * - */ - -/********************* - * INCLUDES - *********************/ -#if 0 &&defined(ARDUINO) - -#include -#include "lv_fs_if.h" -#include "lv_fs_spiffs.h" -#include "ArduinoLog.h" - -#if LV_USE_FS_IF -#if LV_FS_IF_SPIFFS != '\0' - -#if defined(ARDUINO_ARCH_ESP32) -#if HASP_USE_SPIFFS > 0 -#include "SPIFFS.h" -#define LV_FS_SPIFFS SPIFFS -#elif HASP_USE_LITTLEFS > 0 - -#ifndef ESP_ARDUINO_VERSION_VAL -#define ESP_ARDUINO_VERSION_VAL(major, minor, patch) ((major << 16) | (minor << 8) | (patch)) -#endif - -#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(2, 0, 0) -#include -#define LV_FS_SPIFFS LittleFS -#else -#include "LITTLEFS.h" -#include "esp_littlefs.h" -#define LV_FS_SPIFFS LITTLEFS -#endif // ESP_ARDUINO_VERSION - -#endif -#elif defined(ARDUINO_ARCH_ESP8266) -#include "LittleFS.h" -#define LV_FS_SPIFFS LittleFS -#endif // ARDUINO_ARCH - -#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32) -#include -#include -#endif // ARDUINO_ARCH - -#define TAG_LVFS 91 - -/********************* - * DEFINES - *********************/ - -/********************** - * TYPEDEFS - **********************/ - -/* Create a type to store the required data about your file.*/ -typedef FILE* lv_spiffs_file_t; - -/*Similarly to `file_t` create a type for directory reading too */ -#if defined(ARDUINO_ARCH_ESP32) -typedef FILE* lv_spiffs_dir_t; -#elif defined(ARDUINO_ARCH_ESP8266) -typedef Dir* lv_spiffs_dir_t; -#define FILE_READ "r" -#define FILE_WRITE "r+" -#endif - -/********************** - * STATIC PROTOTYPES - **********************/ -static void fs_init(void); - -static lv_fs_res_t fs_open(lv_fs_drv_t* drv, void* file_p, const char* path, lv_fs_mode_t mode); -static lv_fs_res_t fs_close(lv_fs_drv_t* drv, void* file_p); -static lv_fs_res_t fs_read(lv_fs_drv_t* drv, void* file_p, void* buf, uint32_t btr, uint32_t* br); -static lv_fs_res_t fs_write(lv_fs_drv_t* drv, void* file_p, const void* buf, uint32_t btw, uint32_t* bw); -static lv_fs_res_t fs_seek(lv_fs_drv_t* drv, void* file_p, uint32_t pos); -static lv_fs_res_t fs_size(lv_fs_drv_t* drv, void* file_p, uint32_t* size_p); -static lv_fs_res_t fs_tell(lv_fs_drv_t* drv, void* file_p, uint32_t* pos_p); -static lv_fs_res_t fs_remove(lv_fs_drv_t* drv, const char* path); -static lv_fs_res_t fs_trunc(lv_fs_drv_t* drv, void* file_p); -static lv_fs_res_t fs_rename(lv_fs_drv_t* drv, const char* oldname, const char* newname); -static lv_fs_res_t fs_free(lv_fs_drv_t* drv, uint32_t* total_p, uint32_t* free_p); -static lv_fs_res_t fs_dir_open(lv_fs_drv_t* drv, void* dir_p, const char* path); -static lv_fs_res_t fs_dir_read(lv_fs_drv_t* drv, void* dir_p, char* fn); -static lv_fs_res_t fs_dir_close(lv_fs_drv_t* drv, void* dir_p); - -/********************** - * STATIC VARIABLES - **********************/ - -/********************** - * MACROS - **********************/ - -/********************** - * GLOBAL FUNCTIONS - **********************/ - -void lv_fs_if_spiffs_init(void) -{ - /*---------------------------------------------------- - * Initialize your storage device and File System - * -------------------------------------------------*/ - Log.verbose(88, "File system init start"); - fs_init(); - - /*--------------------------------------------------- - * Register the file system interface in LittlevGL - *--------------------------------------------------*/ - - /* Add a simple drive to open images */ - static lv_fs_drv_t fs_drv; /*A driver descriptor*/ - lv_fs_drv_init(&fs_drv); - - /*Set up fields...*/ - fs_drv.file_size = sizeof(lv_spiffs_file_t); - fs_drv.letter = LV_FS_IF_SPIFFS; - 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(lv_spiffs_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; - - lv_fs_drv_register(&fs_drv); - Log.verbose(88, "File system init complete"); -} - -/********************** - * STATIC FUNCTIONS - **********************/ - -/* Initialize your Storage device and File system. */ -static void fs_init(void) -{ - esp_vfs_littlefs_conf_t conf = {.base_path = "/lfs", .partition_label = "spiffs", .format_if_mount_failed = false}; - - esp_err_t res = esp_vfs_littlefs_register(&conf); - - if(res != ESP_OK) { - if(res == ESP_FAIL) { - Log.error(88, "Failed to mount or format filesystem"); - } else if(res == ESP_ERR_NOT_FOUND) { - Log.error(88, "Failed to find LittleFS partition"); - } else { - Log.error(88, "Failed to initialize LittleFS (%s)", esp_err_to_name(res)); - } - return; - } - - size_t total = 0, used = 0; - res = esp_littlefs_info(conf.partition_label, &total, &used); - if(res != ESP_OK) { - Log.error(88, "Failed to get LittleFS partition information (%s)", esp_err_to_name(res)); - } else { - Log.verbose(88, "Partition size: total: %d, used: %d", total, used); - } - - // Use POSIX and C standard library functions to work with files. - // First create a file. - Log.verbose(88, "Opening file /lfs/hello.txt"); - FILE* f = fopen("/lfs/hello.txt", "w"); - if(f == NULL) { - Log.error(88, "Failed to open file for writing"); - return; - } - fprintf(f, "LittleFS Rocks!\n"); - fclose(f); - Log.verbose(88, "File written"); - - Log.verbose(88, "LittleFS init OK"); -} - -/** - * Open a file - * @param drv pointer to a driver where this function belongs - * @param file_p pointer to a file_t variable - * @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt) - * @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR - * @return LV_FS_RES_OK or any error from lv_fs_res_t enum - */ -static lv_fs_res_t fs_open(lv_fs_drv_t* drv, void* file_p, const char* path, lv_fs_mode_t mode) -{ - (void)drv; /*Unused*/ - - const char* flags = ""; - - if(mode == LV_FS_MODE_WR) - flags = "w"; - else if(mode == LV_FS_MODE_RD) - flags = "r"; - else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD)) - flags = "rb+"; - - /*Make the path relative to the current directory (the projects root folder)*/ - - char complete_path[strlen(path) + 1]; - complete_path[0] = '/'; - complete_path[1] = '\0'; - strcat(complete_path, path); - - Log.verbose(88, "Opening file %s", path); - lv_spiffs_file_t f = fopen(path, flags); - if(f == NULL) return LV_FS_RES_UNKNOWN; - - /*Be sure we are the beginning of the file*/ - fseek(f, 0, SEEK_SET); - - /* 'file_p' is pointer to a file descriptor and - * we need to store our file descriptor here*/ - lv_spiffs_file_t* fp = (lv_spiffs_file_t*)file_p; /*Just avoid the confusing casings*/ - *fp = f; - Log.verbose(88, "Open eof file_p %d", feof(*fp)); - return LV_FS_RES_OK; -} - -/** - * Close an opened file - * @param drv pointer to a driver where this function belongs - * @param file_p pointer to a file_t variable. (opened with lv_ufs_open) - * @return LV_FS_RES_OK: no error, the file is read - * any error from lv_fs_res_t enum - */ -static lv_fs_res_t fs_close(lv_fs_drv_t* drv, void* file_p) -{ - (void)drv; /*Unused*/ - lv_spiffs_file_t* fp = (lv_spiffs_file_t*)file_p; /*Just avoid the confusing casings*/ - fclose(*fp); - return LV_FS_RES_OK; -} - -/** - * Read data from an opened file - * @param drv pointer to a driver where this function belongs - * @param file_p pointer to a file_t variable. - * @param buf pointer to a memory block where to store the read data - * @param btr number of Bytes To Read - * @param br the real number of read bytes (Byte Read) - * @return LV_FS_RES_OK: no error, the file is read - * any error from lv_fs_res_t enum - */ -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*/ - lv_spiffs_file_t* fp = (lv_spiffs_file_t*)file_p; /*Just avoid the confusing casings*/ - Log.verbose(88, "Read eof %d", feof(*fp)); - *br = fread(buf, 1, btr, *fp); - return LV_FS_RES_OK; -} - -/** - * Write into a file - * @param drv pointer to a driver where this function belongs - * @param file_p pointer to a file_t variable - * @param buf pointer to a buffer with the bytes to write - * @param btr Bytes To Write - * @param br the number of real written bytes (Bytes Written). NULL if unused. - * @return LV_FS_RES_OK or any error from lv_fs_res_t enum - */ -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*/ - lv_spiffs_file_t* fp = (lv_spiffs_file_t*)file_p; /*Just avoid the confusing casings*/ - Log.verbose(88, "Write eof %d", feof(*fp)); - *bw = fwrite(buf, 1, btw, *fp); -} - -/** - * Set the read write pointer. Also expand the file size if necessary. - * @param drv pointer to a driver where this function belongs - * @param file_p pointer to a file_t variable. (opened with lv_ufs_open ) - * @param pos the new position of read write pointer - * @return LV_FS_RES_OK: no error, the file is read - * any error from lv_fs_res_t enum - */ -static lv_fs_res_t fs_seek(lv_fs_drv_t* drv, void* file_p, uint32_t pos) -{ - (void)drv; /*Unused*/ - lv_spiffs_file_t* fp = (lv_spiffs_file_t*)file_p; /*Just avoid the confusing casings*/ - fseek(*fp, pos, SEEK_SET); - return LV_FS_RES_OK; -} - -/** - * Give the size of a file bytes - * @param drv pointer to a driver where this function belongs - * @param file_p pointer to a file_t variable - * @param size pointer to a variable to store the size - * @return LV_FS_RES_OK or any error from lv_fs_res_t enum - */ -static lv_fs_res_t fs_size(lv_fs_drv_t* drv, void* file_p, uint32_t* size_p) -{ - (void)drv; /*Unused*/ - lv_spiffs_file_t* fp = (lv_spiffs_file_t*)file_p; /*Just avoid the confusing casings*/ - fseek(*fp, 0L, SEEK_END); - *size_p = ftell(*fp); - fseek(*fp, 0L, SEEK_SET); - return LV_FS_RES_OK; -} - -/** - * Give the position of the read write pointer - * @param drv pointer to a driver where this function belongs - * @param file_p pointer to a file_t variable. - * @param pos_p pointer to to store the result - * @return LV_FS_RES_OK: no error, the file is read - * any error from lv_fs_res_t enum - */ -static lv_fs_res_t fs_tell(lv_fs_drv_t* drv, void* file_p, uint32_t* pos_p) -{ - (void)drv; /*Unused*/ - lv_spiffs_file_t* fp = (lv_spiffs_file_t*)file_p; /*Just avoid the confusing casings*/ - *pos_p = ftell(*fp); - return LV_FS_RES_OK; -} - -/** - * Delete a file - * @param drv pointer to a driver where this function belongs - * @param path path of the file to delete - * @return LV_FS_RES_OK or any error from lv_fs_res_t enum - */ -static lv_fs_res_t fs_remove(lv_fs_drv_t* drv, const char* path) -{ - (void)drv; /*Unused*/ - - char filename[32]; - snprintf_P(filename, sizeof(filename), PSTR("/%s"), path); - - if(!LV_FS_SPIFFS.exists(filename)) { - return LV_FS_RES_NOT_EX; - - } else if(LV_FS_SPIFFS.remove(filename)) { - return LV_FS_RES_OK; - - } else { - return LV_FS_RES_UNKNOWN; - } -} - -/** - * Truncate the file size to the current position of the read write pointer - * @param drv pointer to a driver where this function belongs - * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_fs_open ) - * @return LV_FS_RES_OK: no error, the file is read - * any error from lv_fs_res_t enum - */ -static lv_fs_res_t fs_trunc(lv_fs_drv_t* drv, void* file_p) -{ - return LV_FS_RES_NOT_IMP; -} - -/** - * Rename a file - * @param drv pointer to a driver where this function belongs - * @param oldname path to the file - * @param newname path with the new name - * @return LV_FS_RES_OK or any error from 'fs_res_t' - */ -static lv_fs_res_t fs_rename(lv_fs_drv_t* drv, const char* oldname, const char* newname) -{ - (void)drv; /*Unused*/ - char fromname[32]; - char toname[32]; - - snprintf_P(fromname, sizeof(fromname), PSTR("/%s"), oldname); - snprintf_P(toname, sizeof(toname), PSTR("/%s"), newname); - - if(LV_FS_SPIFFS.rename(fromname, toname)) { - return LV_FS_RES_OK; - } else { - return LV_FS_RES_UNKNOWN; - } -} - -/** - * Get the free and total size of a driver in kB - * @param drv pointer to a driver where this function belongs - * @param letter the driver letter - * @param total_p pointer to store the total size [kB] - * @param free_p pointer to store the free size [kB] - * @return LV_FS_RES_OK or any error from lv_fs_res_t enum - */ -static lv_fs_res_t fs_free(lv_fs_drv_t* drv, uint32_t* total_p, uint32_t* free_p) -{ - (void)drv; /*Unused*/ - -#if defined(ARDUINO_ARCH_ESP8266) - FSInfo fs_info; - LV_FS_SPIFFS.info(fs_info); - *total_p = (uint32_t)fs_info.totalBytes; - *free_p = (uint32_t)fs_info.totalBytes - fs_info.usedBytes; - return LV_FS_RES_OK; - -#elif defined(ARDUINO_ARCH_ESP32) - *total_p = (uint32_t)LV_FS_SPIFFS.totalBytes(); - *free_p = (uint32_t)LV_FS_SPIFFS.totalBytes() - LV_FS_SPIFFS.usedBytes(); - return LV_FS_RES_OK; - -#endif - - return LV_FS_RES_NOT_IMP; -} - -/** - * Initialize a 'fs_read_dir_t' variable for directory reading - * @param drv pointer to a driver where this function belongs - * @param dir_p pointer to a 'fs_read_dir_t' variable - * @param path path to a directory - * @return LV_FS_RES_OK or any error from lv_fs_res_t enum - */ -// static lv_fs_res_t fs_dir_open(lv_fs_drv_t* drv, void* dir_p, const char* path) -// { -// lv_spiffs_dir_t dir; - -// #if defined(ARDUINO_ARCH_ESP32) -// dir = &LV_FS_SPIFFS.open(path); -// if(!dir) { -// return LV_FS_RES_UNKNOWN; -// } -// #endif - -// #if defined(ARDUINO_ARCH_ESP8266) -// dir = LV_FS_SPIFFS.openDir(path); -// #endif - -// lv_spiffs_dir_t* dp = (lv_spiffs_dir_t*)dir_p; /*Just avoid the confusing casings*/ -// *dp = dir; -// return LV_FS_RES_OK; -// } - -/** - * Read the next filename form a directory. - * The name of the directories will begin with '/' - * @param drv pointer to a driver where this function belongs - * @param dir_p pointer to an initialized 'fs_read_dir_t' variable - * @param fn pointer to a buffer to store the filename - * @return LV_FS_RES_OK or any error from lv_fs_res_t enum - */ -// static lv_fs_res_t fs_dir_read(lv_fs_drv_t* drv, void* dir_p, char* fn) -// { -// lv_spiffs_dir_t dir = *(lv_spiffs_dir_t*)dir_p; /*Convert type*/ - -// #if defined(ARDUINO_ARCH_ESP32) -// File file = dir.openNextFile(); -// if(file) { -// strcpy(fn, file.name()); -// return LV_FS_RES_OK; -// } else { -// return LV_FS_RES_UNKNOWN; -// } -// #endif - -// #if defined(ARDUINO_ARCH_ESP8266) -// if(dir.next()) { -// strcpy(fn, dir.fileName().c_str()); -// return LV_FS_RES_OK; -// } else { -// return LV_FS_RES_UNKNOWN; -// } -// #endif - -// return LV_FS_RES_NOT_IMP; -// } - -/** - * Close the directory reading - * @param drv pointer to a driver where this function belongs - * @param dir_p pointer to an initialized 'fs_read_dir_t' variable - * @return LV_FS_RES_OK or any error from lv_fs_res_t enum - */ -static lv_fs_res_t fs_dir_close(lv_fs_drv_t* drv, void* dir_p) -{ - return LV_FS_RES_OK; -} - -#endif /*LV_USE_FS_IF*/ -#endif /*LV_FS_IF_SPIFFS*/ - -#endif /*ARDUINO*/ \ No newline at end of file diff --git a/lib/lv_fs_if/lv_fs_spiffs.h b/lib/lv_fs_if/lv_fs_spiffs.h deleted file mode 100644 index 38ed9f1a..00000000 --- a/lib/lv_fs_if/lv_fs_spiffs.h +++ /dev/null @@ -1,19 +0,0 @@ -/** - * @file lv_fs_if.h - * - */ - -#ifndef LV_FS_IF_SPIFFS_H -#define LV_FS_IF_SPIFFS_H - -#ifdef __cplusplus -extern "C" { -#endif - -void lv_fs_if_spiffs_init(void); - -#ifdef __cplusplus -} /* extern "C" */ -#endif - -#endif \ No newline at end of file diff --git a/lib/lv_lib_freetype/lv_fs_freetype.c b/lib/lv_lib_freetype/lv_fs_freetype.c index 967195ff..0768fcec 100644 --- a/lib/lv_lib_freetype/lv_fs_freetype.c +++ b/lib/lv_lib_freetype/lv_fs_freetype.c @@ -127,7 +127,7 @@ int lv_ft_fseek(lv_ft_stream_t* stream, long int offset, int origin) offset = 0; } - lv_fs_res_t res = lv_fs_seek(f_ptr, start + offset); + lv_fs_res_t res = LV_FS_SEEK(f_ptr, start + offset); return res == LV_FS_RES_OK ? 0 : -1; } diff --git a/src/font/hasp_font_loader.cpp b/src/font/hasp_font_loader.cpp index 0699cc25..cd8e4179 100644 --- a/src/font/hasp_font_loader.cpp +++ b/src/font/hasp_font_loader.cpp @@ -223,7 +223,7 @@ static int read_bits_signed(bit_iterator_t* it, int n_bits, lv_fs_res_t* res) static int read_label(lv_fs_file_t* fp, int start, const char* label) { - lv_fs_seek(fp, start); + LV_FS_SEEK(fp, start); uint32_t length; char buf[4]; @@ -245,7 +245,7 @@ static bool load_cmaps_tables(lv_fs_file_t* fp, lv_font_fmt_txt_dsc_t* font_dsc, } for(unsigned int i = 0; i < font_dsc->cmap_num; ++i) { - lv_fs_res_t res = lv_fs_seek(fp, cmaps_start + cmap_table[i].data_offset); + lv_fs_res_t res =LV_FS_SEEK(fp, cmaps_start + cmap_table[i].data_offset); if(res != LV_FS_RES_OK) { return false; } @@ -353,7 +353,7 @@ static int32_t load_glyph(lv_fs_file_t* fp, lv_font_fmt_txt_dsc_t* font_dsc, uin for(unsigned int i = 0; i < loca_count; ++i) { lv_font_fmt_txt_glyph_dsc_t* gdsc = &glyph_dsc[i]; - lv_fs_res_t res = lv_fs_seek(fp, start + glyph_offset[i]); + lv_fs_res_t res =LV_FS_SEEK(fp, start + glyph_offset[i]); if(res != LV_FS_RES_OK) { return -1; } @@ -419,7 +419,7 @@ static int32_t load_glyph(lv_fs_file_t* fp, lv_font_fmt_txt_dsc_t* font_dsc, uin cur_bmp_size = 0; for(unsigned int i = 1; i < loca_count; ++i) { - lv_fs_res_t res = lv_fs_seek(fp, start + glyph_offset[i]); + lv_fs_res_t res =LV_FS_SEEK(fp, start + glyph_offset[i]); if(res != LV_FS_RES_OK) { return -1; }