ESP8266 SPIFFS-bestandssysteem

ESP8266 - Alle SPIFFS of wat? Of: Een apart bestandssysteem op onze microcontroller

Hallo en welkom op mijn nieuwe blog. In een vorig artikel hebben we al via SPIFFS Gesproken. Vandaag willen we een kijkje nemen op wat SPIFFS werkelijk is, welke mogelijkheden het ons biedt en hoe we het kunnen gebruiken met onze all-rounder microcontroller ESP 8266's. Allereerst, wat betekent SPIFFS eigenlijk? SPIFFS staat voor (S)erial (P)eripheral (I)nterface (F)lash (F)ile (S)ystem en betekent dat onze ESP een eenvoudig bestandssysteem kan bevatten in het SPI-programmageheugen, dat ook onze programmacode bevat. Bestanden kunnen worden gemaakt, gewijzigd of verwijderd in dit bestandssysteem. Deze bestanden kunnen worden gebruikt of gewijzigd door onze programmacode tijdens de runtime, evenals zijn gemaakt door ons eerder. Hoe dit gebeurt, komen we later nog terug. Het grootste voordeel is echter dat dit geheugengebied, eenmaal gegenereerd, wordt bewaard met code-updates! Dit betekent dat een bijgewerkt programma kan blijven werken met de gegevens die als bestand zijn opgeslagen, rechtstreeks met betrekking tot de bestandsnaam.

Setup

Om met een bestandssysteem te werken, moet het eerst worden geïnitialiseerd op ons ESP met een gedefinieerde grootte. Deze grootte is afhankelijk van de ESP-module (maximale grootte) die wordt gebruikt, evenals van onze configuratie.

Standaard hebben de ESP-01-modules 512 KB Flash tot 1 MB Flash. De ESP-12, ESP-12E en ESP-12F modules (ook bekend als NodeMcu modules) hebben ten minste 4 MB flash tot 8 MB Flash. Met behulp van de Arduino IDE reserveren we nu een geheugengebied voor ons bestandssysteem van deze hele flitser:

Voordat we een schets uploaden, selecteren we de grootte van ons toekomstige bestandssysteem. In het bovenstaande voorbeeld koos ik voor een 2 MB maat voor mijn ESP8266-12. Nu kunnen we ons bestandssysteem opmaken voor het eerste gebruik met de volgende code. Deze stap is verplicht voor nieuwe installatie of herconfiguratie van spiffs-grootte:

 

#include <Spi.H>
#include <Fs.H>           Neem de SPIFFS-bibliotheek op

Booleaanse InitalizeFileSystem() {   Bool initok = Valse;   initok = SPIFFS (SPIFFS).Beginnen();   Als (!(initok)) Indeling SPIFS, van niet opgemaakt. - Probeer 1   {     Seriële.println("SPIFFS-bestandssysteem opgemaakt.");     SPIFFS (SPIFFS).Formaat();     initok = SPIFFS (SPIFFS).Beginnen();   }   Als (!(initok)) SpIFS opmaken. - Probeer 2   {     SPIFFS (SPIFFS).Formaat();     initok = SPIFFS (SPIFFS).Beginnen();   }   Als (initok) { Seriële.println("SPIFFS is OK"); } Anders { Seriële.println("SPIFFS is niet OK"); }   Terug initok;
}

Void Setup() {     Spi.Beginnen();                      Spi-communicatie initialiseren     Bool Resultaat  = InitalizeFileSystem(); 

}

Void Lus() {    }

 

Na het samenstellen en uploaden is ons bestandssysteem klaar voor gebruik. We kunnen bestanden maken, wijzigen en verwijderen. De bestanden worden geopend met zogenaamde "modi" die het gewenste toegangstype opgeven. Daarbij is de

• W - voor schrijven (schrijven of herbijlagen van een bestand)
• R - voor lezen (het lezen van een bestand)
• A - voor toevoegen (gegevens toevoegen aan het einde van een bestand)

Gebruiken:

In het bestand wordt een gegevensaanwijzer gebruikt om de huidige lees-/schrijfpositie in een bestand aan te geven. Om een praktisch voorbeeld weer te geven en tegelijkertijd zoveel mogelijk opdrachten te gebruiken rond bestandsbewerkingen, maken we een bestand in het volgende voorbeeld en voegen we elke 5 seconden een nieuw item toe. De volgende keer dat we de controller resetten, verwijderen we het bestand en beginnen opnieuw. De bestandsinhoud wordt achtereenvolgens uitgevoerd op de seriële interface. Ten slotte is de huidige bestandsgrootte in bytes. +

 

 

#include <Spi.H>
#include <Fs.H>           De SPIFFS-bibliotheek gebruiken

Bestand Myfile;                   een SPIFFS Handling Variable maken

Booleaanse InitalizeFileSystem() 
{   Bool initok = Valse;   initok = SPIFFS (SPIFFS).Beginnen();   Als (!(initok)) Indeling SPIFS, van niet opgemaakt. - Probeer 1   {     Seriële.println("Formaat SPIFFS");     SPIFFS (SPIFFS).Formaat();     initok = SPIFFS (SPIFFS).Beginnen();   }   Als (!(initok)) Indeling SPIFS, van niet opgemaakt. - Probeer 2   {     SPIFFS (SPIFFS).Formaat();     initok = SPIFFS (SPIFFS).Beginnen();   }   Als (initok) { Seriële.println("SPIFFS is OK"); } Anders { Seriële.println("SPIFFS is niet OK"); }   Terug initok;
}

Void Setup() 
{   Seriële.Beginnen(9600);     Spi.Beginnen();                        Bool Resultaat  = InitalizeFileSystem();    Als (!(SPIFFS (SPIFFS).Bestaat ("/usage_log.csv") ))  Controleer of bestand usage_log.csvschon is geëexized.   {        Myfile = SPIFFS (SPIFFS).Open("/usage_log.csv", "w");  Open het bestand usage_log.csv in de hoofdmap om te schrijven (w - schrijven)     Als (!Myfile)        {       Seriële.println("Niet te schrijven het bestand");       }     Resultaat = Myfile.println("01.01.1980 12:00:00; Log gewist of verwijderd");      Resultaat = Myfile.println("01.01.1980 12:00:01; Eerste inzending, tweede lijn");     Myfile.Sluiten();   } Anders   {    SPIFFS (SPIFFS).Verwijderen("/usage_log.csv");  Bestand verwijderen      Seriële.println("Bestand usage_log.csv al geëexized ! Het is verwijderd.");   }
}

Void Lus() 
{   Myfile = SPIFFS (SPIFFS).Open("/usage_log.csv", "r");  Open het bestand usage_log.csv in de hoofdmap voor lezen (r - lezen)   Tekenreeks Inhoud=Myfile.leesStringUntil('n');   Seriële.println("Methode: readStringUntil:");   Terwijl (Myfile.Positie()<Myfile.Grootte())            bestand inhbalt regel voor regel lezen tot einde van het bestand         {           Inhoud =Myfile.leesStringUntil('n');           Seriële.println(Inhoud);         }    Int Bestandsgrootte = Myfile.Grootte();   Myfile.Sluiten();   Seriële.Afdrukken('Bestandsgrootte in bytes:');           de huidige bestandsgrootte in bytes uitvoeren   Seriële.println(Bestandsgrootte);                                     de huidige bestandsgrootte in bytes uitvoeren   Vertraging (5000);   Opbrengst();               Interne ESP8266-functies bellen   Myfile = SPIFFS (SPIFFS).Open("/usage_log.csv", "A");  Open bestand om gegevens toe te voegen! (a - toevoegen)   Myfile.println("01.01.1980 12:00:xx;Line toegevoegd.");   Myfile.Sluiten();
}

 

We kopiëren de code in onze DIE en uploaden de schets naar ons ESP.
Het ESP begint met het toevoegen van vermeldingen aan het interne usage_log.csv-bestand. We moeten een output als deze krijgen:

De belangrijkste commando's zijn

SPIFFS.open("/bestandsnaam", "r"); Een bestand lezen

SPIFFS.open("/bestandsnaam", "w"); Schrijven of opnieuw aanhet toevoegen van een bestand

SPIFFS.open("/bestandsnaam", "a"); Gegevens toevoegen aan het einde van een bestand

Een volledige verwijzing naar de mogelijke opdrachten rond SPIFFS en bestandsverwerking is te vinden op de volgende link:

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

 

SPIFFS Plugin

De ESP Arduino IDE Plugin is een Arduino IDE plugin die bestanden uploadt van de "Data" submap van een schets naar een bestaand SPIFFS bestandssysteem. Om dit te doen, worden de bestaande SPIFFS-bestanden IM ESP verwijderd en vervangen door de bestanden uit de map 'gegevens'. Om dit te doen, downloaden we het Zip-bestand onder https://github.com/esp8266/arduino-esp8266fs-plugin en overal uittepakken. De nu uitgepakte "esp8266fs.jar" wordt nu geplaatst onder de volgende mapstructuur die we eerder hebben gemaakt: My Files->Documents->Arduino->Tools->ESP8266FS->Tool. Na een reboot wordt een nieuw subitem gemaakt onder Extra -> ESP8266 Sketch Data Upload":

Veel plezier experimenteren en tot de volgende post!

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

Aanbevolen blog berichten

  1. Installeer ESP32 nu van de raad van bestuur
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - ESP Programmeren via Wi-Fi