ESP8266 SPIFFS File System

ESP8266 - Tutti SPIFFS o cosa? O anche: un file system separato sul nostro microcontrollore

Ciao e benvenuto nel mio nuovo blog. In un post precedente abbiamo brevemente sullo SPIFFS  parlato. Oggi vogliamo dare un'occhiata più da vicino a ciò che è SPIFFS, quali opzioni ci offre e come possiamo usarlo con il nostro microcontrollore versatile ESP 8266. Prima di tutto, cosa significa effettivamente SPIFFS? SPIFFS sta per (S) erial (P) eripheral (I) nterface (F) lash (F) ile (S) ystem e significa che il nostro ESP può contenere un semplice file system nella memoria del programma SPI, che contiene anche il nostro codice del programma , I file possono essere creati, modificati o eliminati in questo file system. Questi file possono essere utilizzati o modificati dal nostro codice del programma durante il runtime, poiché sono già stati creati da noi. Torneremo su come farlo in seguito. Il più grande vantaggio, tuttavia, è che questa area di memoria, una volta creata, viene mantenuta con gli aggiornamenti del codice! che un programma aggiornato può continuare a lavorare con i dati che sono stati salvati come file direttamente con riferimento al nome del file.

facilità

Per poter lavorare con un file system, deve prima essere inizializzato sul nostro ESP con una dimensione definita. Questa dimensione dipende da un lato sul modulo ESP utilizzato (dimensione massima) e dalla nostra configurazione.

Per impostazione predefinita, i moduli ESP-01 hanno una memoria flash da 512 KB fino a una memoria flash da 1 MB. I moduli ESP-12, ESP-12E e ESP-12F (noti anche come modulo NodeMcu) hanno almeno 4 MB di flash fino a 8 MB di flash. Da questo intero flash, ora stiamo usando l'IDE Arduino per riservare un'area di memoria per il nostro file system:

Prima di caricare uno schizzo, scegliamo le dimensioni del nostro futuro file system. Nel sopra Esempio, ho scelto una dimensione di 2 MB per il mio ESP8266-12. Ora possiamo formattare il nostro file system per il primo utilizzo con il seguente codice. Questo passaggio è obbligatorio per le nuove installazioni o per la riconfigurazione della dimensione SPIFFS:

 

#include <SPI.B>
#include <FS.B>           // Include la libreria SPIFFS

booleano InitalizeFileSystem() {   bool initok = falso;   initok = spiffs.iniziare();   se (!(initok)) // Formato SPIFS, non formattato. - Prova 1   {     serial.println("File system SPIFFS formattato.");     spiffs.formato();     initok = spiffs.iniziare();   }   se (!(initok)) // formatta SPIFS. - Prova 2   {     spiffs.formato();     initok = spiffs.iniziare();   }   se (initok) { serial.println("SPIFFS è OK"); } altro { serial.println("SPIFFS non è OK"); }   ritorno initok;
}

vuoto configurazione() {     SPI.iniziare();                      // Inizializza la comunicazione SPI     bool risultato  = InitalizeFileSystem(); 

}

vuoto cappio() {    }

 

Dopo la compilazione e il caricamento, il nostro file system è pronto per l'uso. Siamo in grado di creare, modificare ed eliminare file. I file vengono aperti con le cosiddette "Modalità", che specificano il tipo di accesso desiderato. Dice

 • W - per scrivere (scrivere o creare un nuovo file)
 • R - per leggere (leggere un file)
 • A - per append (aggiunta di dati alla fine di un file)

utilizzare:

Un puntatore di dati viene utilizzato all'interno del file, che indica la posizione di lettura / scrittura corrente all'interno di un file. Per mostrare un esempio pratico e allo stesso tempo utilizzare il maggior numero possibile di comandi per le operazioni sui file, creiamo un file nell'esempio seguente e aggiungiamo una nuova voce ogni 5 secondi. Alla successiva reimpostazione del controller, eliminiamo il file e ricominciamo. Il contenuto del file viene emesso in sequenza sull'interfaccia seriale. Infine, la dimensione del file corrente in byte. +

 

 

#include <SPI.B>
#include <FS.B>           // Usa la libreria SPIFFS

file myfile;                   // creare una variabile di gestione SPIFFS

boolean InitalizeFileSystem() 
{   booli initok = false;   initok = SPIFFS.begin();   if (!(initok)) // formato SPIFS, of not formatted. - Try 1   {     Seriale.println("formato SPIFFS");     SPIFFS.formato();     initok = SPIFFS.begin();   }   if (!(initok)) // formato SPIFS, of not formatted. - Try 2   {     SPIFFS.formato();     initok = SPIFFS.begin();   }   if (initok) { Seriale.println("SPIFFS è OK"); } else { Seriale.println("SPIFFS non è OK"); }   return initok;
}

void Impostazione() 
{   Seriale.begin(9600);     SPI.begin();                        booli Result  = InitalizeFileSystem();    if (!(SPIFFS.exists ("/usage_log.csv") ))  // Verifica se il file usage_log.csvè è già in esecuzione.   {        myfile = SPIFFS.Apri("/usage_log.csv", "w");  // Apri il file usage_log.csv nella directory root di scrittura (w - write)     if (!myfile)        {       Seriale.println("Errore di scrittura file");       }     Result = myfile.println("01.01.1980 12:00:00; Log cleared or deleted");      Result = myfile.println("01.01.1980 12:00:01; First Entry, second Line");     myfile.close();   } else   {    SPIFFS.remove("/usage_log.csv");  // Ricostituire il file      Seriale.println(" Il file usage_log.csv è già stato espitato! È stata cancellata. ");   }
}

void loop() 
{   myfile = SPIFFS.Apri("/usage_log.csv", "r");  // Apri il file usage_log.csv nella directory root di lettura (r - read)   String contenuto=myfile.readStringUntil('\n');   Seriale.println("Metodo: readStringUntil:");   while (myfile.ubicazione()<myfile.dimensione())            // lese Fileinhbalt Riga per la riga fino alla fine del file         {           contenuto =myfile.readStringUntil('\n');           Seriale.println(contenuto);         }    int Dimensione file = myfile.dimensione();   myfile.close();   Seriale.print("Indossamento dati in byte:");           // restituendo la dimensione file corrente in byte   Seriale.println(Dimensione file);                                     // restituendo la dimensione file corrente in byte   delay (5000);   yield();               // richiamare le funzioni interne ESP8266   myfile = SPIFFS.Apri("/usage_log.csv", "a");  // Il file aperto per impiccare i dati. (a - append)   myfile.println("01.01.1980 12 :00 :xx; riga aggiunta.");   myfile.close();
}

 

Stiamo copiando il codice nelle nostre copie e cariciamo lo Sketch sul nostro ESP.
Il PESP deve aggiungere voci all'interno del file interno usage_log.csv. Dovremmo ricevere un output come questo.

I comandi principali sono:

SPIFFS.open ("/nomefile", "r"); // la lettura di un file

SPIFFS.open ("/nomefile", "w"); // scrittura o nuovo asset di un file

SPIFFS.open ("/nomefile", "a"); // aggiungere i dati alla fine di un file

Il seguente link contiene un riferimento completo dei possibili comandi di SPIFFS e di file di fine file:

http://arduino.esp8266.com/Arduino/versions/2.0.0/doc/filesystem.html#file-system-object-spiffs

 

SPIFFS Plugin

Il programma ESP Arduino IDE Plugin è un plugin dell'IDE di Arduino che carica i file della sottocartella "Data" di uno Sketch in un file system SPIFFS esistente. I file SPIFFS esistenti vengono eliminati dal SEP e i file vengono sostituiti con i file della cartella data. Scaricare ed estrarre il file Zip all'indirizzo https://github.com/esp8266/arduino-esp8266fs - plugin per impacchettare in qualsiasi punto. Ora, i pacchetti "esp8266fs.jar" vengono ora creati nella seguente struttura di cartelle, che abbiamo creato precedentemente: File personali - > Documento - > Arduino - > Tools - > ESP8266FS - > Tool. Quando viene riavviato, il nuovo punto secondario viene creato in Strumenti - > ESP8266 Sketch Data Upload ":

Goditi il divertimento e il prossimo contributo!

Esp-8266Grundlagen software

3 Kommentare

georg

georg

hallo,
ich habe mit interesse Ihre erklärungen zum SPIFFS system gelesen, es wäre übertrieben wenn ich behaupten würde alles verstanden zu haben…
diesen code habe ich mir nach einem beispiel hier für meine bedürfnisse angepasst, er funktioniert auch:
-———————————
//board: ESP8266 Boards /node mcu 1.0

#include
#include // Nutze die SPIFFS library
int FileSize_frequency;

String sliderValue_frequency = “4”;
String sliderValue_frequency_alt;

File myfile_frequency; // erstelle eine SPIFFS Handling Variable

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

bool Result_frequency = InitalizeFileSystem(); if (!(SPIFFS.exists (“/frequency_config.csv”) )) //Prüfe ob Datei frequency_config.csv schon exisiert. { myfile_frequency = SPIFFS.open(“/frequency_config.csv”, “w”); //Öffne die Datei frequency_config.csv im Root Verzeichnis zum schreiben (w – write) if (!myfile_frequency) { Serial.println(“Fehler beim schreiben der Datei”); } Result_frequency = myfile_frequency.println(“sliderValue_frequency”); Result_frequency = myfile_frequency.println(sliderValue_frequency); myfile_frequency.close(); } else { SPIFFS.remove(“/frequency_config.csv”); //Lösche Datei Serial.println(“Datei frequency_config.csv war schon vorhanden, sie wurde gelöscht.”); }

}

void loop()
{
myfile_frequency = SPIFFS.open(“/frequency_config.csv”, “r”); //Öffne die Datei usage_log.csv im Root Verzeichnis zum lesen (r – read)

while (myfile_frequency.position() < myfile_frequency.size()) // lese Dateiinhalt Zeile für Zeile bis um Ende der Datei { String content = myfile_frequency.readStringUntil(‘\n’); Serial.println(content); } FileSize_frequency = myfile_frequency.size(); myfile_frequency.close(); Serial.print(“Dateigroesse in Bytes:”); // gebe die aktuelle Dateigröße in Bytes aus Serial.println(FileSize_frequency); // gebe die aktuelle Dateigröße in Bytes aus delay (5000); yield(); // interne ESP8266 Funktionen aufrufen if (sliderValue_frequency != sliderValue_frequency_alt) //die config_frequency soll nur einmal bei sich änderndem “sliderValue_frequency” geändert werden { myfile_frequency = SPIFFS.open(“/frequency_config.csv”, “a”); // Öffne Datei um Daten anzuhängen ! (a – append) //myfile_frequency.println(“sliderValue_frequency”); myfile_frequency.println(sliderValue_frequency); myfile_frequency.close(); sliderValue_frequency_alt = sliderValue_frequency; }

}boolean InitalizeFileSystem()
{
bool initok = false;
initok = SPIFFS.begin();
if (!(initok)) // Format SPIFS, if not formatted. – Try 1
{
Serial.println(“Format SPIFFS”);
SPIFFS.format();
initok = SPIFFS.begin();
}
if (!(initok)) // Format SPIFS, if not formatted. – Try 2
{
SPIFFS.format();
initok = SPIFFS.begin();
}
if (initok)
{
Serial.println(“SPIFFS ist OK”);
}
else
{
Serial.println(“SPIFFS ist nicht OK”);
}
return initok;
}
-———————————————
nun muss ich zwei variable in zwei dateien ins SPIFFS schreiben: frequency und power. Die beiden sketsche funktionieren einzeln sehr gut. Der versuch, die beiden sketche in eines zu integrieren scheitern mit einer Exception 9. Ich habe alle stellen, wo es mir notwendig schien entsprechend geändert und wie gesgt – einzeln funktionieren die sketche. Könnten Sie mir bitte einen tipp geben, woran das liegen könnte? Ich würde vermuten es liegt an diesen beiden zeilen:
-—————————-
bool Result_power = InitalizeFileSystem();
bool Result_frequency = InitalizeFileSystem();
-———————————-
ich kann ein system nicht 2x initialiseren, ohne dass was durcheinander gerät, denke ich…

vielen dank
gruss georg

Andre

Andre

Hallo,
in der neusten Arduino IDE funktiniert SPIFFS nicht mehr, es wird im Moment auch nicht weiterentwickelt und soll zuküntig aus dem ESP2866 core entfernt werden. LittleFS dient als Ersatz und ich konnte es mit der neusten Arduino IDE verwenden. Unter folgendem Link findet ihr weitere Infos.
https://arduino-esp8266.readthedocs.io/en/latest/filesystem.html

Viele Grüße,
André

Stumpfbrumme

Stumpfbrumme

Danke das war hilfreich!

Einen Kommentar hinterlassen

Alle Kommentare werden vor der Veröffentlichung moderiert