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!