Continuiamo ad esplorare i dispositivi e32, dei microcontrollori molto potenti. Le possibilità offerte dalle SPI Flash integrate sono molteplici, ma la prima problematica è sicuramente scegliere un filesystem adeguato, ognuno di questi ha delle caratteristiche che li rendono unici ed utili in vari aspetti. Il filesystem di default per gli ESP32 è diventato ufficialmente il FAT, il più potente e stabile, ma anche affamato di risorse, a parità di file occupa più spazio rispetto allo SPIFFS ed il LittleFS.
Puoi tovare vari tipi di ESP32 su ESP32 Dev Kit v1 - TTGO T-Display 1.14 ESP32 - NodeMCU V3 V2 ESP8266 Lolin32 - NodeMCU ESP-32S - WeMos Lolin32 - WeMos Lolin32 mini - ESP32-CAM programmer - ESP32-CAM bundle - ESP32-WROOM-32 - ESP32-S
FFat FatFS File System
SPIFFS è il filesystem originale ed è ideale per applicazioni con limitazioni di spazio e RAM che utilizzano molti file di piccole dimensioni ed ha una particolare attenzione al livellamento statico e dinamico dell’usura e non necessita di un vero supporto alle directory. Anche il sovraccarico del filesystem sul flash è minimale.
FatFs è un’implementazione del file system FAT/exFAT per piccoli sistemi embedded. Il modulo FatFs è scritto in conformità con ANSI C (C89) e completamente separato dal livello di I/O del disco. Pertanto è indipendente dalla piattaforma. Può essere incorporato in piccoli microcontrollori con risorse limitate.
Il modulo FFAT utilizza 8 KB più 4KB per ogni file aperto. Per impostazione predefinita, consente di aprire 10 file, il che significa che utilizza 48 KB. Ss vuoi ridurre il suo utilizzo di memoria, puoi dirgli di supportare solo un file e risparmierai 36KB, rimanendo con solo 12KB usati.
if (!FFat.begin(0, "", 1)) die("Fat FS mount failed. Not enough RAM?");
Poiché sono presenti directory, il metodo open si comporta in modo diverso dallo SPIFFS. Mentre lo SPIFFS restituirà i file tutti in “sottodirectory” singole quando si carica un con File::openNextFile() (perché in realtà non sono sottodirectory ma semplicemente file con “/” nei loro nomi), FatFS restituirà solo i file nella sottodirectory specifica. Questo imita il comportamento POSIX per l’attraversamento delle directory a cui è abituata la maggior parte dei programmatori C.
In questa memoria flash ESP memorizza il programma, ed insieme al programma puoi memorizzare i tuoi file. Il limite di questa memoria è che ha solo 10000 (diecimila) cicli di scrittura.
Aggiungere file da IDE al FFat
Questa operazione senza estensione per l’IDE di Arduino non è così semplice, ma qui andremo a vedere il modo più semplice.
Innanzitutto devi scaricare il plugin per l’Arduino IDE qui.
Quindi devi trovare la tua cartella dei Shetckbook, se non sai dove è dislocata puoi andare su File --> Preferences, in quella schermata puoi trovare nella parte superiore della finestra lo Sketchbook location.
Ora devi creare (se non esiste) la cartella tools\ESP32FS\tool e aggiungere lì il file esp32fs.jar.
Ora riavvia l’IDE e nel menu Tools troverai una nuova riga ESP32 Sketch Data Upload.
Questo plugin è in grado di gestire 3 tipi di filesystem e può sostituire l’altro visto per lo SPIFFS ed il LittleFS, quando fai clic su “ESP32 Sketch Data Upload” un popup ti chiede quale operazione vuoi fare
La tabella delle partizioni è diversa dallo SPIFFS, quindi, se specificato, è necessario selezionare lo schema di partizione FatFS e, se nelle opzioni del microcontrollore non è specificato il filesystem dovete tenere a mente che dalla versione <=1.0.4 verrà impostato un filesystem SPIFFS, dalla versione 1.0.5 in su sarà impostato un filesystem FFat, ma è possibile utilizzare una semplice soluzione alternativa per selezionare un filesystem differente, basta selezionare la scheda generica e configurarla come la scheda specificata.
Dalla versione ESP32 core <= 1.0.4 verrà impostato un filesystem predefinito SPIFFS, dalla versione 1.0.5 in poi sarà il filesystem FFat
Perciò per WeMos LOLIN32 e la versione 1.0.4 dell’ESP32 core selezionerò i parametri per il FFat come vedete in questa immagine:
Aggiungi il file mkfatfs
Se non riesci a caricare i dati devi aggiungere il file mkfatfs.exe nella relativa cartella.
Devi scaricare mkfatfsfs da GitHub. Nel mio caso la versione per Windows 10 64bit mkfatfs.rar .
Quindi è necessario aprire la cartella delle preferenze
e la cartella completa
<preferences folder>/packages/esp32/hardware/esp32/1.0.5/tools
dove 1.0.5 è la versione corrente installata del core esp32, quindi copia il file mkfatfs.exe e gli altri file nella stessa cartella di espota e esptool.
Crea la cartella data
Sull’Arduino IDE fai Ctrl+K per aprire un file browser nella directory dello sketch.
Crea una directory data in cui inserire i dati che desideri caricare.
Imposta la dimensione di LittleFS su Tools --> Flash size cioè la dimensione del tuo filesystem del microcontrollore (puoi usare SPIFFS se non vedi LittleFS).
Carica il tuo sketch e poi fai clic su ESP32 Sketch Data Upload.
Ora vai allo sketch di esempio per verificare se è tutto a posto.
Comandi
Ci sono alcuni comandi standard che puoi usare con questo filesystem
FFat.begin (formatIfNeeded)
Questo metodo monta il file system FFAT e deve essere chiamato prima di utilizzare qualsiasi altra API FS. formatIfNeeded a true formatta il filesystem se necessario. Restituisce vero se il file system è stato montato correttamente, altrimenti falso.
FFat.format ()
Formatta il file system. Restituisce vero se la formattazione ha avuto esito positivo.
FFat.open (percorso, modalità)
Apre un file. il percorso dovrebbe essere un percorso assoluto che inizia con una barra (ad es. /dir/filename.txt). modalità è una stringa che specifica la modalità di accesso. Può essere uno di “r”, “w”, “a”. Il significato di queste modalità è lo stesso della funzione C fopen.
Restituisce l’oggetto File. Per verificare se il file è stato aperto correttamente, utilizzare l’operatore booleano.
FFat.exists (percorso)
Restituisce vero se esiste un file con un determinato percorso, altrimenti falso.
FFat.remove (percorso)
Elimina un file dato il suo percorso assoluto. Restituisce vero se il file è stato eliminato correttamente.
FFat.rename (pathFrom, pathTo)
Rinomina il file da pathFrom a pathTo. I percorsi devono essere assoluti. Restituisce vero se il file è stato rinominato correttamente.
FFat.mkdir (percorso):
crea una nuova cartella. Restituisce true se la creazione della directory è riuscita, false in caso contrario.
FFat.rmdir (percorso):
rimuove la directory. Restituisce true se la directory è stata rimossa correttamente, false in caso contrario.
FFat.totalBytes ()
Restituisce i byte totali abilitati su LITTLEFS. Restituisce byte.
FFat.usedBytes ()
Restituisce il totale dei byte utilizzati abilitati su LITTLEFS. Restituisce byte.
file.seek (offset, mode)
Questa funzione si comporta come la funzione C di fseek. A seconda del valore di mode, sposta la posizione corrente in un file come segue:
- se la modalità è SeekSet, la posizione è impostata per sfalsare i byte dall’inizio.
- se la modalità è SeekCur, la posizione corrente viene spostata di byte offset.
- se la modalità è SeekEnd, la posizione è impostata per sfalsare i byte dalla fine del file.
- Restituisce vero se la posizione è stata impostata correttamente.
file.position ()
Restituisce la posizione corrente all’interno del file, in byte.
file.size ()
Restituisce la dimensione del file, in byte.
file.name ()
Restituisce il nome del file, come const char *.
file.close ()
Chiude il file.
file.getLastWrite ()
Epoch time of last write (utilizza l’ora interna per gestire la data).
file.isDirectory ()
Restituisce se è directory
file.openNextFile ()
Imposta il puntatore del file successivo nella directory.
file.rewindDirectory ()
Riavvia il puntatore al primo file della directory.
Libreria
La libreria è collocata nel core, quindi non devi scaricare nulla.
Esempi pratici
Qui uno sketch per ottenere informazioni e controllare tutti i file nel tuo FatFS.
/*
* ESP32
* FFat get info, read dir and show all file uploaded
* add a data folder to use with ESP32 Sketch data uploader
* by Mischianti Renzo <https://mischianti.org>
*
* https://mischianti.org
*
*/
#include "Arduino.h"
#include "FS.h"
#include "FFat.h"
void printDirectory(File dir, int numTabs = 3);
void setup()
{
Serial.begin(115200);
delay(500);
Serial.println(F("Inizializing FS..."));
if (FFat.begin()){
Serial.println(F("done."));
}else{
Serial.println(F("fail."));
}
// To format all space in FFat
// FFat.format()
// Get all information of your FFat
unsigned int totalBytes = FFat.totalBytes();
unsigned int usedBytes = FFat.usedBytes();
unsigned int freeBytes = FFat.freeBytes();
Serial.println("File sistem info.");
Serial.print("Total space: ");
Serial.print(totalBytes);
Serial.println("byte");
Serial.print("Total space used: ");
Serial.print(usedBytes);
Serial.println("byte");
Serial.print("Total space free: ");
Serial.print(freeBytes);
Serial.println("byte");
Serial.println();
// Open dir folder
File dir = FFat.open("/");
// Cycle all the content
printDirectory(dir);
}
void loop()
{
}
void printDirectory(File dir, int numTabs) {
while (true) {
File entry = dir.openNextFile();
if (! entry) {
// no more files
break;
}
for (uint8_t i = 0; i < numTabs; i++) {
Serial.print('\t');
}
Serial.print(entry.name());
if (entry.isDirectory()) {
Serial.println("/");
printDirectory(entry, numTabs + 1);
} else {
// files have sizes, directories do not
Serial.print("\t\t");
Serial.println(entry.size(), DEC);
}
entry.close();
}
}
Il risultato della richiesta
Inizializing FS...
done.
File sistem info.
Total space: 1478656byte
Total space used: 81920byte
Total space free: 1396736byte
/bombo.png 44236
/colori.svg 19086
/other/
/other/bn.svg 8493
Qui uno Sketch con comandi più pratici, scrivere una stringa in un file, leggere tutto il contenuto del file, posizionarsi sul nono byte del file e leggere da lì i dati.
/*
* ESP32
* FFat write, read and seek file
* by Mischianti Renzo <https://mischianti.org>
*
* https://mischianti.org/
*
*/
#include "Arduino.h"
#include "FFat.h"
void setup()
{
Serial.begin(115200);
delay(500);
Serial.println(F("Inizializing FS..."));
if (FFat.begin()){
Serial.println(F("done."));
}else{
Serial.println(F("fail."));
}
// To remove previous test
// FFat.remove(F("/testCreate.txt"));
File testFile = FFat.open(F("/testCreate.txt"), "w");
if (testFile){
Serial.println("Write file content!");
testFile.print("Here the test text!!");
testFile.close();
}else{
Serial.println("Problem on create file!");
}
testFile = FFat.open(F("/testCreate.txt"), "r");
if (testFile){
Serial.println("Read file content!");
/**
* File derivate from Stream so you can use all Stream method
* readBytes, findUntil, parseInt, println etc
*/
Serial.println(testFile.readString());
testFile.close();
}else{
Serial.println("Problem on read file!");
}
testFile = FFat.open(F("/testCreate.txt"), "r");
if (testFile){
/**
* mode is SeekSet, position is set to offset bytes from the beginning.
* mode is SeekCur, current position is moved by offset bytes.
* mode is SeekEnd, position is set to offset bytes from the end of the file.
* Returns true if position was set successfully.
*/
Serial.println("Position inside the file at 9 byte!");
testFile.seek(9, SeekSet);
Serial.println("Read file content!");
Serial.println(testFile.readString());
testFile.close();
}else{
Serial.println("Problem on read file!");
}
}
void loop()
{
}
Qui il risultato dello sketch
Inizializing FS...
done.
Write file content!
Read file content!
Here the test text!!
Position inside the file at 9 byte!
Read file content!
test text!!
Grazie
- ESP32: piedinatura, specifiche e configurazione dell’Arduino IDE
- ESP32: fileSystem integrato SPIFFS
- ESP32: gestire più seriali e logging per il debug
- ESP32 risparmio energetico pratico
- ESP32 risparmio energetico pratico: gestire WiFi e CPU
- ESP32 risparmio energetico pratico: modem e light sleep
- ESP32 risparmio energetico pratico: deep sleep e ibernazione
- ESP32 risparmio energetico pratico: preservare dati al riavvio, sveglia a tempo e tramite tocco
- ESP32 risparmio energetico pratico: sveglia esterna e da ULP
- ESP32 risparmio energetico pratico: sveglia da UART e GPIO
- ESP32: filesystem integrato LittleFS
- ESP32: filesystem integrato FFat (Fat/exFAT)
- ESP32-wroom-32
- ESP32-CAM
- ESP32: ethernet w5500 con chiamate standard (HTTP) e SSL (HTTPS)
- ESP32: ethernet enc28j60 con chiamate standard (HTTP) e SSL (HTTPS)
- Come usare la scheda SD con l’esp32
- esp32 e esp8266: file system FAT su memoria SPI flash esterna
- Gestione aggiornamenti firmware e OTA
- Gestione del firmware
- Aggiornamento OTA con Arduino IDE
- Aggiornamento OTA con browser web
- Aggiornamenti automatici OTA da un server HTTP
- Aggiornamento del firmware non standard
- Integrare LAN8720 con ESP32 per la connettività Ethernet con plain (HTTP) e SSL (HTTPS)
- Collegare l’EByte E70 (CC1310) ai dispositivi ESP32 c3/s3 ed un semplice sketch di esempio
- ESP32-C3: piedinatura, specifiche e configurazione dell’IDE Arduino
- Integrazione del modulo W5500 su ESP32 con Core 3: supporto nativo ai protocolli Ethernet con SSL e altre funzionalità
- Integrazione del modulo LAN8720 su ESP32 con Core 3: supporto nativo del protocollo Ethernet con SSL e altre funzionalità.