ESP32: filesystem integrato LittleFS – 5

Spread the love

ESP32 integrated LittleFS FileSystem
ESP32 integrated LittleFS FileSystem

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. Dopo lo SPIFFS, il filesystem sicuramente più leggero e meno affamato di risorse (con molte limitazioni) andiamo a vedere il LittleFS un buon compromesso tra funzionalità e prestazioni.

Ne puoi trovare alcune varianti qui ESP32 Dev Kit v1 - Selectable - TTGO T-Display 1.14 ESP32 - NodeMCU V3 V2 ESP8266 Lolin32 - NodeMCU ESP-32S - WeMos Lolin32 CP2104 CH340 - ESP32-CAM programmer - ESP32-CAM bundle - ESP32-WROOM-32 - ESP32-S

File system LittleFS

Function Block diagram Espressif esp32 Wi-Fi Bluetooth Microcontroller
Function Block diagram Espressif esp32 Wi-Fi Bluetooth Microcontroller

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.

Il filesystem LittleFS è stato aggiunto di recente e si concentra su prestazioni più elevate e supporto delle directory, ma ha un file system con un overhead per file più elevato (minimo 4K rispetto all’unità di allocazione file al posto di 256 byte di SPIFFS).

L’implementazione di LittleFS per l’ESP8266 ed esp32 supporta nomi di file fino a 31 caratteri + zero di terminazione (cioè  char filename[32]) e tante sottodirectory quante lo spazio lo consente.

Anche se non di default per l’esp32 va fatta menzione che è molto veloce ed occupa molte meno risorse del FatFS che verrà impostato come default dell’esp32.

A differenza di SPIFFS, i descrittori di file effettivi vengono allocati come richiesto dall’applicazione, quindi in condizioni di memoria insufficiente potresti non essere in grado di aprire nuovi file. Al contrario, ciò significa anche che solo i descrittori di file utilizzati occuperanno effettivamente spazio nell’heap.

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), LittleFS 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.

Sketch OTA update File system EEPROM WiFi config

Aggiungere files da IDE al LittleFS

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.

Sketchbook Location, additional file Arduino IDE
Preferences window

Ora devi creare (se non esiste) la cartella tools\ESP32FS\tool e aggiungere lì il file esp32fs.jar.

Arduino IDE esp32 SPIFFS Sketch Data Upload folder jar
Arduino IDE esp32 LITTLEFS Sketch Data Upload folder jar

Ora riavvia l’IDE e nel menu Tools  troverai una nuova riga ESP32 Sketch Data Upload.

Arduino IDE esp32 SPIFFS Sketch Data Upload
Arduino IDE esp32 LITTLEFS Sketch Data Upload

Questo plugin è in grado di gestire 3 tipi di filesystem e può sostituire l’altro visto per lo SPIFFS, quando fai clic su “ESP32 Sketch Data Upload” un popup ti chiede quale operazione vuoi fare

esp32 SPIFFS LittleFS FatFS file uploader from Arduino IDE
esp32 SPIFFS LittleFS FatFS file uploader from Arduino IDE

La tabella delle partizioni è la stessa di SPIFFS, quindi puoi selezionare lo schema di partizione SPIFFS standard.

Aggiungi il file mklittlefs

Se hai installato il core esp8266 probabilmente puoi già caricare il file sulla partizione LittleFS.

Se non riesci a caricare i dati devi aggiungere il file mklittlefs.exe nella relativa cartella.

Devi scaricare mklittlefs da GitHub . Nel mio caso la versione per Windows 10 64bit x86_64-w64-mingw32-mklittlefs-295fe9b.zip .

Quindi è necessario aprire la cartella delle preferenze

ESP32 S2 download Arduino IDE preferences folder
ESP32 S2 download Arduino IDE preferences folder

e la cartella completa

<preferences folder>/packages/esp32/hardware/esp32/1.0.5/tools

dove 1.0.5 è la versione correntemente installata del core esp32, quindi copia il file mklittlefs.exe nella stessa cartella di espota esptool.

esp32 LittleFS mklittlefs position on Arduino IDE
esp32 LittleFS mklittlefs position on Arduino IDE

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.

Sketch to upload data on LITTLEFS on esp8266: directory structure

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

LITTLEFS.begin ()
Questo metodo monta il file system LittleFS e deve essere chiamato prima di utilizzare qualsiasi altra API FS. Restituisce vero se il file system è stato montato correttamente, altrimenti falso.

LITTLEFS.format ()
Formatta il file system. Restituisce vero se la formattazione ha avuto esito positivo.

LITTLEFS.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.

LITTLEFS.exists (percorso)
Restituisce vero se esiste un file con un determinato percorso, altrimenti falso.

LITTLEFS.remove (percorso)
Elimina un file dato il suo percorso assoluto. Restituisce vero se il file è stato eliminato correttamente.

LITTLEFS.rename (pathFrom, pathTo)
Rinomina il file da pathFrom a pathTo. I percorsi devono essere assoluti. Restituisce vero se il file è stato rinominato correttamente.

LITTLEFS .mkdir (percorso):
crea una nuova cartella. Restituisce  true  se la creazione della directory è riuscita,  false in caso  contrario.

LITTLEFS .rmdir (percorso):
rimuove la directory. Restituisce  true  se la directory è stata rimossa correttamente,  false in caso  contrario.

LITTLEFS.totalBytes ()
Restituisce i byte totali abilitati su LITTLEFS. Restituisce byte.

LITTLEFS.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

Dalla versione 2.xx di esp32 Arduino Core LittleFS è stato integrato all’interno del core e non è più LITTLEFS ma con il formato case canonico LittleFS.

Puoi trovare la libreria  qui.

Per scaricare.

Fare clic sul pulsante DOWNLOAD nell’angolo in alto a destra, rinominare la cartella non compressa LITTLEFS.

Posiziona la cartella della libreria LITTLEFS nella tua cartella /libraries.

Potrebbe essere necessario creare la sottocartella delle librerie se è la tua prima libreria.

Riavvia l’IDE.

Puoi anche scaricarlo dal gestore della libreria di Arduino

esp32 select LittleFS library from library manager Arduino IDE
esp32 select LittleFS library from library manager Arduino IDE

Esempi pratici

Qui uno sketch per ottenere informazioni e controllare tutti i file nel tuo LittleFS.

Dalla versione 2.xx di esp32 Arduino Core LittleFS è stato integrato all’interno del core e non è più LITTLEFS ma con il formato case canonico LittleFS.

/*
 *  ESP32
 *  LITTLEFS 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 "LITTLEFS.h"

void printDirectory(File dir, int numTabs = 3);

void setup()
{
	Serial.begin(115200);

	delay(500);

	Serial.println(F("Inizializing FS..."));
	if (LITTLEFS.begin()){
		Serial.println(F("done."));
	}else{
		Serial.println(F("fail."));
	}

	// To format all space in LITTLEFS
	// LITTLEFS.format()

	// Get all information of your LITTLEFS

	unsigned int totalBytes = LITTLEFS.totalBytes();
	unsigned int usedBytes = LITTLEFS.usedBytes();
	unsigned int freeBytes  = LITTLEFS.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 = LITTLEFS.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 del programma

Inizializing FS...
done.
File sistem info.
Total space:      1507328byte
Total space used: 53248byte

			/bombo.png		44236

Qui uno sketch con comandi più pratici, scrivere una stringa in un file, leggere tutto il contenuto del file, posizionarsi sul 9 byte del file e leggere da lì i dati.

Dalla versione 2.xx di esp32 Arduino Core LittleFS è stato integrato all’interno del core e non è più LITTLEFS ma con il formato case canonico LittleFS.

/*
 *  ESP32
 *  LITTLEFS write, read and seek file
 *  by Mischianti Renzo <https://mischianti.org>
 *
 *  https://mischianti.org/
 *
 */
#include "Arduino.h"
#include "LITTLEFS.h"

void setup()
{
  Serial.begin(115200);

  delay(500);

  Serial.println(F("Inizializing FS..."));
  if (LITTLEFS.begin()){
    Serial.println(F("done."));
  }else{
    Serial.println(F("fail."));
  }

  // To remove previous test
  // LITTLEFS.remove(F("/testCreate.txt"));

  File testFile = LITTLEFS.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 = LITTLEFS.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 = LITTLEFS.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

  1. ESP32: piedinatura, specifiche e configurazione dell’Arduino IDE
  2. ESP32: fileSystem integrato SPIFFS
  3. ESP32: gestire più seriali e logging per il debug
  4. ESP32 risparmio energetico pratico
    1. ESP32 risparmio energetico pratico: gestire WiFi e CPU
    2. ESP32 risparmio energetico pratico: modem e light sleep
    3. ESP32 risparmio energetico pratico: deep sleep e ibernazione
    4. ESP32 risparmio energetico pratico: preservare dati al riavvio, sveglia a tempo e tramite tocco
    5. ESP32 risparmio energetico pratico: sveglia esterna e da ULP
    6. ESP32 risparmio energetico pratico: sveglia da UART e GPIO
  5. ESP32: filesystem integrato LittleFS
  6. ESP32: filesystem integrato FFat (Fat/exFAT)
  7. ESP32-wroom-32
    1. ESP32-wroom-32: flash, piedinatura, specifiche e configurazione dell’Arduino IDE
  8. ESP32-CAM
    1. ESP32-CAM: piedinatura, specifiche e configurazione dell’Arduino IDE
    2. ESP32-CAM: upgrade CamerWebServer con gestione della luce flash
  9. ESP32: ethernet w5500 con chiamate standard (HTTP) e SSL (HTTPS)
  10. ESP32: ethernet enc28j60 con chiamate standard (HTTP) e SSL (HTTPS)
  11. Come usare la scheda SD con l’esp32
  12. esp32 e esp8266: file system FAT su memoria SPI flash esterna
  13. Gestione aggiornamenti firmware e OTA
    1. Gestione del firmware
      1. ESP32: flash del firmware binario compilato (.bin)
      2. ESP32: flash del firmware e filesystem (.bin) con strumenti grafici
    2. Aggiornamento OTA con Arduino IDE
      1. Aggiornamenti OTA su ESP32 con Arduino IDE: filesystem, firmware e password
    3. Aggiornamento OTA con browser web
      1. Aggiornamenti OTA su ESP32 tramite browser web: firmware, filesystem e autenticazione
      2. Aggiornamenti OTA su ESP32 tramite browser web: caricamento in HTTPS (SSL/TLS) con certificato autofirmato
      3. Aggiornamenti OTA su ESP32 tramite browser web: interfaccia web personalizzata
    4. Aggiornamenti automatici OTA da un server HTTP
      1. Aggiornamento automatico Firmware OTA dell’ESP32 dal server
      2. Aggiornamento automatico Firmware OTA dell’ESP32 dal server con controllo della versione
      3. Aggiornamento automatico Firmware OTA dell’ESP32 in HTTPS (SSL/TLS) con certificato autofirmato affidabile
    5. Aggiornamento del firmware non standard
      1. Aggiornamento firmware e filesystem ESP32 dalla scheda SD
      2. Aggiornamento firmware e filesystem ESP32 con client FTP
  14. Integrare LAN8720 con ESP32 per la connettività Ethernet con plain (HTTP) e SSL (HTTPS)
  15. i2c esp32: gestione rete a 5v, 3.3v e interfaccia aggiuntiva
  16. […]


Spread the love

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *