Système de fichiers ESP8266 SPIFFS

ESP8266 - Tous les SPIFFS ou quoi? Ou : Un système de fichiers distinct sur notre microcontrôleur

Bonjour et bienvenue sur mon nouveau blog. Dans un article précédent, nous avons déjà via SPIFFS Parlé. Aujourd’hui, nous voulons examiner de plus près ce qu’est vraiment SPIFFS, quelles sont les possibilités qu’il nous offre et comment nous pouvons l’utiliser avec notre microcontrôleur polyvalent ESP 8266. Tout d’abord, qu’est-ce que SPIFFS signifie réellement? SPIFFS signifie (S)erial (P)eripheral (I)nterface (F)lash (F)ile (S)ystem et signifie que notre ESP peut contenir un système de fichiers simple dans la mémoire du programme SPI, qui contient également notre code de programme. Les fichiers peuvent être créés, modifiés ou supprimés dans ce système de fichiers. Ces fichiers peuvent être utilisés ou modifiés par notre code de programme pendant le temps d’exécution, ainsi que ont été créés par nous avant. Comment cela se fera, nous y reverons plus tard. Le plus grand avantage, cependant, est que cette zone de mémoire, une fois générée, est préservée avec des mises à jour de code! Cela signifie qu’un programme mis à jour peut continuer à travailler avec les données stockées sous forme de fichier sur elle directement en référence au nom du fichier.

Configuration

Afin de travailler avec un système de fichiers, il doit d’abord être initialisé sur notre ESP avec une taille définie. Cette taille dépend du module ESP (taille maximale) utilisé ainsi que de notre configuration.

Par défaut, les modules ESP-01 ont 512 KB Flash jusqu’à 1 Mo Flash. Les modules ESP-12, ESP-12E et ESP-12F (également connus sous le nom de modules NodeMcu) ont au moins 4 Mo flash jusqu’à 8 Mo Flash. À l’aide de l’IDE Arduino, nous réservons maintenant une zone de mémoire pour notre système de fichiers à partir de tout ce flash:

Avant de télécharger une esquisse, nous sélectionnons la taille de notre futur système de fichiers. Dans l’exemple ci-dessus, j’ai choisi une taille de 2 Mo pour mon ESP8266-12. Maintenant, nous pouvons formater notre système de fichiers pour la première utilisation avec le code suivant. Cette étape est obligatoire pour la nouvelle installation ou reconfiguration de la taille SPIFFS:

 

#include <Spi.H (en)>
#include <Fs.H (en)>           Inclure la bibliothèque SPIFFS

Boolean InitalizeFileSystem() {   Bool initok = Faux;   initok = SPIFFS SPIFFS.Commencer();   Si (!(initok)) Format SPIFS, de non formaté. - Essayez 1   {     Série.println(« Système de fichiers SPIFFS formaté. »);     SPIFFS SPIFFS.Format();     initok = SPIFFS SPIFFS.Commencer();   }   Si (!(initok)) Format SPIFS. - Essayez 2   {     SPIFFS SPIFFS.Format();     initok = SPIFFS SPIFFS.Commencer();   }   Si (initok) { Série.println("SPIFFS est OK"); } Autre { Série.println("SPIFFS n’est pas OK"); }   Retour initok;
}

Vide Configuration() {     Spi.Commencer();                      Initialiser la communication SPI     Bool Résultat  = InitalizeFileSystem(); 

}

Vide Boucle() {    }

 

Après la compilation et le téléchargement, notre système de fichiers est prêt à être utilisé. Nous pouvons créer, modifier et supprimer des fichiers. Les fichiers sont ouverts avec ce que l’on appelle les «modes» qui spécifient le type d’accès souhaité. Ce faisant, le

W - pour écrire (écriture ou réé pièces jointe d’un fichier)
R - pour lecture (lecture d’un fichier)
A - pour l’appendice (ajout de données à la fin d’un fichier)

Utiliser:

Dans le fichier, un pointeur de données est utilisé pour indiquer la position actuelle de lecture/écriture dans un fichier. Pour montrer un exemple pratique et en même temps utiliser autant de commandes que possible autour des opérations de fichiers, nous créons un fichier dans l’exemple suivant et ajoutons une nouvelle entrée toutes les 5 secondes. La prochaine fois que nous réinitialiser le contrôleur, nous supprimons le fichier et repartons à zéro. Le contenu du fichier est la sortie séquentiellement sur l’interface sérielle. Enfin, la taille actuelle du fichier dans les octets. +

 

 

#include <Spi.H (en)>
#include <Fs.H (en)>           Utiliser la bibliothèque SPIFFS

Fichier Monfichier;                   créer une variable de manutention SPIFFS

Boolean InitalizeFileSystem() 
{   Bool initok = Faux;   initok = SPIFFS SPIFFS.Commencer();   Si (!(initok)) Format SPIFS, de non formaté. - Essayez 1   {     Série.println("Format SPIFFS");     SPIFFS SPIFFS.Format();     initok = SPIFFS SPIFFS.Commencer();   }   Si (!(initok)) Format SPIFS, de non formaté. - Essayez 2   {     SPIFFS SPIFFS.Format();     initok = SPIFFS SPIFFS.Commencer();   }   Si (initok) { Série.println("SPIFFS est OK"); } Autre { Série.println("SPIFFS n’est pas OK"); }   Retour initok;
}

Vide Configuration() 
{   Série.Commencer(9600);     Spi.Commencer();                        Bool Résultat  = InitalizeFileSystem();    Si (!(SPIFFS SPIFFS.Existe ("/usage_log.csv") ))  Vérifiez si le fichier usage_log.csvschon a été exized.   {        Monfichier = SPIFFS SPIFFS.Ouvert("/usage_log.csv", "w");  Ouvrez le fichier usage_log.csv dans le répertoire racine pour écrire (w - écrire)     Si (!Monfichier)        {       Série.println("Échec à écrire le fichier");       }     Résultat = Monfichier.println("01.01.1980 12:00:00; Journal effacé ou supprimé");      Résultat = Monfichier.println("01.01.1980 12:00:01; Première entrée, deuxième ligne");     Monfichier.Proche();   } Autre   {    SPIFFS SPIFFS.Retirer("/usage_log.csv");  Supprimer le fichier      Série.println("File usage_log.csv déjà exized ! Il a été supprimé.);   }
}

Vide Boucle() 
{   Monfichier = SPIFFS SPIFFS.Ouvert("/usage_log.csv", "r");  Ouvrez le fichier usage_log.csv dans l’annuaire racine pour la lecture (r - lire)   String Contenu=Monfichier.lireStringUntil('n');   Série.println("Méthode: lireStringUntil:");   Tandis que (Monfichier.Position()<Monfichier.Taille())            lire le fichier inhbalt ligne par ligne à la fin du fichier         {           Contenu =Monfichier.lireStringUntil('n');           Série.println(Contenu);         }    Int Taille = Monfichier.Taille();   Monfichier.Proche();   Série.Imprimer("Taille de fichier dans les octets:");           la sortie de la taille actuelle du fichier dans les octets   Série.println(Taille);                                     la sortie de la taille actuelle du fichier dans les octets   Retard (5000);   Rendement();               Appelez les fonctions INTERNES ESP8266   Monfichier = SPIFFS SPIFFS.Ouvert("/usage_log.csv", "a");  Fichier ouvert pour appendice de données ! (a - annexe)   Monfichier.println("01.01.1980 12:00:xx;Line a ajouté.");   Monfichier.Proche();
}

 

Nous copions le code dans notre DIE et téléchargeons le croquis sur notre ESP.
L’ESP commencera à ajouter des entrées au fichier interne usage_log.csv. Nous devrions obtenir une sortie comme celle-ci:

Les commandes les plus importantes sont

SPIFFS.open ("/nom de fichier", "r"); Lecture d’un fichier

SPIFFS.open ("/nom de fichier", "w"); Rédaction ou réécout ment d’un fichier

SPIFFS.open ("/nom de fichier", "a"); Ajouter des données à la fin d’un fichier

Une référence complète des commandes possibles autour du SPIFFS et de la manipulation des fichiers peut être trouvée au lien suivant :

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

 

SPIFFS Plugin

L’ESP Arduino IDE Plugin est un plugin Arduino IDE qui télécharge des fichiers à partir du sous-pliage "Data" d’une esquisse à un système de fichiers SPIFFS existant. Pour ce faire, les fichiers SPIFFS existants IM ESP sont supprimés et remplacés par les fichiers du dossier "données". Pour ce faire, nous téléchargeons le fichier Zip sous https://github.com/esp8266/arduino-esp8266fs-plugin et le décompresser n’importe où. Le maintenant déballé "esp8266fs.jar" est maintenant placé sous la structure de dossier suivante que nous avons créé avant: Mes fichiers-gt;Documents-gt;Arduino-gt;Tools-gt;ESP8266FS-gt;Tool. Après un redémarrage, un nouveau sous-élément est créé sous outils - -gt; ESP8266 Sketch Data Upload":

Amusez-vous à expérimenter et jusqu’au prochain post!

Esp-8266Grundlagen software

3 commentaires

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!

Laisser un commentaire

Tous les commentaires sont modérés avant d'être publiés

Messages de blogs recommandés

  1. Installez maintenant ESP32 via l'administrateur de la carte
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA-Over the Air-ESP Programmation par WiFi

Produits recommandés