jeans/openHASP
jeans/openHASP
1
0
Fork 0
mirror of https://github.com/HASwitchPlate/openHASP.git synced 2025-07-19 09:16:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

First working spiffs driver

Browse Source
This commit is contained in:
fvanroie 2020-04-19 22:58:46 +02:00
parent 2bd9371dce
commit 2c06912ac3
1 changed files with 104 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

204
lib/lv_fs_if/lv_fs_spiffs.cpp
View File

@ -9,6 +9,7 @@
//#include <Arduino.h> //#include <Arduino.h>
#include "lv_fs_if.h" #include "lv_fs_if.h"
#include "lv_fs_spiffs.h" #include "lv_fs_spiffs.h"
#include "ArduinoLog.h"
#if LV_USE_FS_IF #if LV_USE_FS_IF
#if LV_FS_IF_SPIFFS != '\0' #if LV_FS_IF_SPIFFS != '\0'
@ -30,7 +31,7 @@
typedef File lv_spiffs_file_t; typedef File lv_spiffs_file_t;
/*Similarly to `file_t` create a type for directory reading too */ /*Similarly to `file_t` create a type for directory reading too */
typedef File lv_spiffs_dir_t; typedef File * lv_spiffs_dir_t;
/********************** /**********************
* STATIC PROTOTYPES * STATIC PROTOTYPES
@ -122,43 +123,27 @@ 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_open(lv_fs_drv_t * drv, void * file_p, const char * path, lv_fs_mode_t mode)
{ {
Serial.print("Opening: "); (void)drv; /*Unused*/
Serial.println(path);
String fullpath = "/" + String(path); char filename[32];
Serial.println(fullpath); snprintf_P(filename, sizeof(filename), PSTR("/%s"), path);
const char * fullfilename = fullpath.c_str(); Log.verbose(F("LVFS: Opening %s"), filename);
Serial.println(fullfilename); File f = SPIFFS.open(filename, mode == LV_FS_MODE_WR ? FILE_WRITE : FILE_READ);
Serial.flush(); if(!f) return LV_FS_RES_NOT_EX;
if(!SPIFFS.exists(fullfilename)) { Log.verbose(F("LVFS: Opened %s"), filename);
Serial.println("File does not exist");
return LV_FS_RES_NOT_EX;
}
// return LV_FS_RES_UNKNOWN;
static lv_spiffs_file_t file; if(!f || f.isDirectory()) {
if(mode == LV_FS_MODE_WR)
file = SPIFFS.open(fullfilename, "a");
else if(mode == LV_FS_MODE_RD)
file = SPIFFS.open(fullfilename, "r");
else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD))
file = SPIFFS.open(fullfilename, "r+");
if(file) {
lv_spiffs_file_t * fp = (lv_spiffs_file_t *)file_p; /*Just avoid the confusing casings*/
*fp = file;
Serial.println("Opened OK");
Serial.flush();
// return LV_FS_RES_UNKNOWN;
return LV_FS_RES_OK;
} else {
Serial.println("Open failed");
return LV_FS_RES_UNKNOWN; return LV_FS_RES_UNKNOWN;
} else {
f.seek(0, SeekSet);
Log.verbose(F("LVFS: Assigning %s"), f.name());
lv_spiffs_file_t * fp = (lv_spiffs_file_t *)file_p; /*Just avoid the confusing casings*/
Log.verbose(F("LVFS: Copying %s"), f.name());
*fp = f;
// memcpy(*file_p,&f,sizeof(lv_spiffs_file_t));
return LV_FS_RES_OK;
} }
} }
@ -171,16 +156,21 @@ static lv_fs_res_t fs_open(lv_fs_drv_t * drv, void * file_p, const char * path,
*/ */
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)
{ {
// File file = *(File *)(file_p); (void)drv; /*Unused*/
lv_spiffs_file_t * file = (lv_spiffs_file_t *)file_p; /*Convert type*/ lv_spiffs_file_t * fp = (lv_spiffs_file_t *)file_p;
File file = *fp;
char * msg = nullptr; if(!file) {
sprintf(msg, "Closing: %s", file->name()); Log.verbose(F("LVFS: Invalid file"));
Serial.println(msg); return LV_FS_RES_NOT_EX;
Serial.flush(); }
file->close();
return LV_FS_RES_OK; if(!file || file.isDirectory()) {
return LV_FS_RES_UNKNOWN;
} else {
file.close();
return LV_FS_RES_OK;
}
} }
/** /**
@ -195,20 +185,21 @@ 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_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
{ {
lv_spiffs_file_t * file = (lv_spiffs_file_t *)file_p; /*Convert type*/ (void)drv; /*Unused*/
// lv_spiffs_file_t file = *(lv_spiffs_file_t *)(file_p); lv_spiffs_file_t * fp = (lv_spiffs_file_t *)file_p;
File file = *fp;
char * msg = nullptr; if(!file) {
sprintf(msg, "Reading: %s", file->name()); Log.verbose(F("LVFS: Invalid file"));
Serial.println(msg); return LV_FS_RES_NOT_EX;
Serial.flush();
if(!*file || file->isDirectory()) {
return LV_FS_RES_UNKNOWN;
} }
return LV_FS_RES_UNKNOWN; // Log.verbose(F("LVFS: Reading %u bytes from %s at position %u"), btr, file.name(), file.position());
*br = file->readBytes((char *)buf, btr);
int len = file.readBytes((char *)buf, btr);
// Log.verbose(F("LVFS: Read %u bytes from %s at position %u"), len, file.name(), file.position());
*br = (uint32_t)len;
return LV_FS_RES_OK; return LV_FS_RES_OK;
} }
@ -223,21 +214,17 @@ static lv_fs_res_t fs_read(lv_fs_drv_t * drv, void * file_p, void * buf, uint32_
*/ */
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)
{ {
return LV_FS_RES_NOT_IMP; (void)drv; /*Unused*/
/* lv_spiffs_file_t * fp = (lv_spiffs_file_t *)file_p;
File file = SPIFFS.open((char *)file_p, "w"); File file = *fp;
if(!file) {
return LV_FS_RES_UNKNOWN; if(!file) {
} Log.verbose(F("LVFS: Invalid file"));
char * message; return LV_FS_RES_NOT_EX;
strncpy(buf, message, btw); }
if(file.print(message)) {
*bw = (uint32_t)sizeof(message); *bw = file.write((byte *)buf, btw);
return LV_FS_RES_OK; return LV_FS_RES_OK;
} else {
bw = 0;
return LV_FS_RES_UNKNOWN;
}*/
} }
/** /**
@ -250,18 +237,17 @@ static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf,
*/ */
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)
{ {
lv_spiffs_file_t * file = (lv_spiffs_file_t *)file_p; /*Convert type*/ (void)drv; /*Unused*/
// lv_spiffs_file_t file = *(lv_spiffs_file_t *)(file_p); lv_spiffs_file_t * fp = (lv_spiffs_file_t *)file_p;
char * msg = nullptr; File file = *fp;
sprintf(msg, "Seeking: %s", file->name());
Serial.println(msg);
Serial.flush();
if(file->seek(pos, SeekSet)) { if(!file) {
return LV_FS_RES_OK; Log.verbose(F("LVFS: Invalid file"));
} else { return LV_FS_RES_NOT_EX;
return LV_FS_RES_UNKNOWN;
} }
file.seek(pos, SeekSet);
return LV_FS_RES_OK;
} }
/** /**
@ -273,14 +259,17 @@ 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_size(lv_fs_drv_t * drv, void * file_p, uint32_t * size_p)
{ {
lv_spiffs_file_t * file = (lv_spiffs_file_t *)file_p; /*Convert type*/ (void)drv; /*Unused*/
// lv_spiffs_file_t file = *(lv_spiffs_file_t *)(file_p); lv_spiffs_file_t * fp = (lv_spiffs_file_t *)file_p;
char * msg = nullptr; File file = *fp;
sprintf(msg, "Filesize: %s", file->name());
Serial.println(msg); if(!file) {
Serial.flush(); Log.verbose(F("LVFS: Invalid file"));
return LV_FS_RES_NOT_EX;
}
*size_p = (uint32_t)file.size();
*size_p = file->size();
return LV_FS_RES_OK; return LV_FS_RES_OK;
} }
@ -294,15 +283,17 @@ 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_tell(lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
{ {
lv_spiffs_file_t * file = (lv_spiffs_file_t *)file_p; /*Convert type*/ (void)drv; /*Unused*/
// lv_spiffs_file_t file = *(lv_spiffs_file_t *)(file_p); lv_spiffs_file_t * fp = (lv_spiffs_file_t *)file_p;
char * msg = nullptr; File file = *fp;
sprintf(msg, "Telling: %s", file->name());
Serial.println(msg); if(!file) {
Serial.flush(); Log.verbose(F("LVFS: Invalid file"));
return LV_FS_RES_NOT_EX;
}
*pos_p = (uint32_t)file.position();
uint32_t pos = file->position();
pos_p = &pos;
return LV_FS_RES_OK; return LV_FS_RES_OK;
} }
@ -314,8 +305,7 @@ 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_remove(lv_fs_drv_t * drv, const char * path)
{ {
Serial.println("Deleteing: " + (String)path); (void)drv; /*Unused*/
Serial.flush();
if(SPIFFS.remove(path)) { if(SPIFFS.remove(path)) {
return LV_FS_RES_OK; return LV_FS_RES_OK;
@ -345,6 +335,8 @@ 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_rename(lv_fs_drv_t * drv, const char * oldname, const char * newname)
{ {
(void)drv; /*Unused*/
if(SPIFFS.rename(oldname, newname)) { if(SPIFFS.rename(oldname, newname)) {
return LV_FS_RES_OK; return LV_FS_RES_OK;
} else { } else {
@ -362,11 +354,23 @@ static lv_fs_res_t fs_rename(lv_fs_drv_t * drv, const char * oldname, const char
*/ */
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; (void)drv; /*Unused*/
/* Add your code here*/ #if defined(ARDUINO_ARCH_ESP8266)
FSInfo fs_info;
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;
return res; #elif defined(ARDUINO_ARCH_ESP32)
*total_p = (uint32_t)SPIFFS.totalBytes();
*free_p = (uint32_t)SPIFFS.totalBytes() - SPIFFS.usedBytes();
return LV_FS_RES_OK;
#endif
return LV_FS_RES_NOT_IMP;
} }
/** /**
@ -378,7 +382,7 @@ static lv_fs_res_t fs_free(lv_fs_drv_t * drv, uint32_t * total_p, uint32_t * fre
*/ */
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)
{ {
lv_spiffs_dir_t * dir = (lv_spiffs_file_t *)dir_p; /*Convert type*/ lv_spiffs_dir_t dir = (lv_spiffs_dir_t)dir_p; /*Convert type*/
Serial.print("Open directory: "); Serial.print("Open directory: ");
Serial.println(path); Serial.println(path);
@ -403,8 +407,8 @@ static lv_fs_res_t fs_dir_open(lv_fs_drv_t * drv, void * dir_p, const char * pat
*/ */
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)
{ {
lv_spiffs_dir_t * dir = (lv_spiffs_file_t *)dir_p; /*Convert type*/ lv_spiffs_dir_t dir = (lv_spiffs_dir_t)dir_p; /*Convert type*/
lv_spiffs_file_t file = dir->openNextFile(); File file = dir->openNextFile();
if(file) { if(file) {
strcpy(fn, file.name()); strcpy(fn, file.name());