/**
  * @file lv_fs_fatfs.c
  *
  */
 
 /*********************
  *      INCLUDES
  *********************/
 #include "../../../lvgl.h"
 
 #if LV_USE_FS_FATFS
 #include "ff.h"
 
 /*********************
  *      DEFINES
  *********************/
 
 #if LV_FS_FATFS_LETTER == '\0'
     #error "LV_FS_FATFS_LETTER must be an upper case ASCII letter"
 #endif
 
 /**********************
  *      TYPEDEFS
  **********************/
 
 /**********************
  *  STATIC PROTOTYPES
  **********************/
 static void fs_init(void);
 
 static void * fs_open(lv_fs_drv_t * drv, 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, lv_fs_whence_t whence);
 static lv_fs_res_t fs_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
 static void * fs_dir_open(lv_fs_drv_t * drv, 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_fatfs_init(void)
 {
     /*----------------------------------------------------
      * Initialize your storage device and File System
      * -------------------------------------------------*/
     fs_init();
 
     /*---------------------------------------------------
      * Register the file system interface in LVGL
      *--------------------------------------------------*/
 
     /*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.letter = LV_FS_FATFS_LETTER;
     fs_drv.cache_size = LV_FS_FATFS_CACHE_SIZE;
 
     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.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);
 }
 
 /**********************
  *   STATIC FUNCTIONS
  **********************/
 
 /*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 untouched for easy updating*/
 }
 
 /**
  * Open a file
  * @param drv pointer to a driver where this function belongs
  * @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 pointer to FIL struct or NULL in case of fail
  */
 static void * fs_open(lv_fs_drv_t * drv, const char * path, lv_fs_mode_t mode)
 {
     LV_UNUSED(drv);
     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;
 
     FIL * f = lv_mem_alloc(sizeof(FIL));
     if(f == NULL) return NULL;
 
     FRESULT res = f_open(f, path, flags);
     if(res == FR_OK) {
         return f;
     }
     else {
         lv_mem_free(f);
         return NULL;
     }
 }
 
 /**
  * Close an opened file
  * @param drv pointer to a driver where this function belongs
  * @param file_p pointer to a FIL variable. (opened with 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_close(lv_fs_drv_t * drv, void * file_p)
 {
     LV_UNUSED(drv);
     f_close(file_p);
     lv_mem_free(file_p);
     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 FIL 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)
 {
     LV_UNUSED(drv);
     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;
 }
 
 /**
  * Write into a file
  * @param drv pointer to a driver where this function belongs
  * @param file_p pointer to a FIL variable
  * @param buf pointer to a buffer with the bytes to write
  * @param btw Bytes To Write
  * @param bw 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)
 {
     LV_UNUSED(drv);
     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;
 }
 
 /**
  * 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 FIL variable. (opened with fs_open )
  * @param pos the new position of read write pointer
  * @param whence only LV_SEEK_SET is supported
  * @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, lv_fs_whence_t whence)
 {
     LV_UNUSED(drv);
     switch(whence) {
         case LV_FS_SEEK_SET:
             f_lseek(file_p, pos);
             break;
         case LV_FS_SEEK_CUR:
             f_lseek(file_p, f_tell((FIL *)file_p) + pos);
             break;
         case LV_FS_SEEK_END:
             f_lseek(file_p, f_size((FIL *)file_p) + pos);
             break;
         default:
             break;
     }
     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 FIL 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)
 {
     LV_UNUSED(drv);
     *pos_p = f_tell((FIL *)file_p);
     return LV_FS_RES_OK;
 }
 
 /**
  * Initialize a 'DIR' variable for directory reading
  * @param drv pointer to a driver where this function belongs
  * @param path path to a directory
  * @return pointer to an initialized 'DIR' variable
  */
 static void * fs_dir_open(lv_fs_drv_t * drv, const char * path)
 {
     LV_UNUSED(drv);
     DIR * d = lv_mem_alloc(sizeof(DIR));
     if(d == NULL) return NULL;
 
     FRESULT res = f_opendir(d, path);
     if(res != FR_OK) {
         lv_mem_free(d);
         d = NULL;
     }
     return d;
 }
 
 /**
  * Read the next filename from 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 'DIR' 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_UNUSED(drv);
     FRESULT res;
     FILINFO fno;
     fn[0] = '\0';
 
     do {
         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);
 
     } while(strcmp(fn, "/.") == 0 || strcmp(fn, "/..") == 0);
 
     return LV_FS_RES_OK;
 }
 
 /**
  * Close the directory reading
  * @param drv pointer to a driver where this function belongs
  * @param dir_p pointer to an initialized 'DIR' 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)
 {
     LV_UNUSED(drv);
     f_closedir(dir_p);
     lv_mem_free(dir_p);
     return LV_FS_RES_OK;
 }
 
 #else /*LV_USE_FS_FATFS == 0*/
 
 #if defined(LV_FS_FATFS_LETTER) && LV_FS_FATFS_LETTER != '\0'
     #warning "LV_USE_FS_FATFS is not enabled but LV_FS_FATFS_LETTER is set"
 #endif
 
 #endif /*LV_USE_FS_POSIX*/
 

© 2023 acidvegas, inc • generated with stagit