ESP8266 NodeMCU : Écrire des données dans un fichier (LittleFS)

Dans ce guide, vous apprendrez comment écrire et enregistrer des données de manière permanente dans un fichier enregistré sur le système de fichiers ESP8266 (LittleFS). LittleFS est un système de fichiers léger créé pour les microcontrôleurs qui vous permet d’accéder à la mémoire flash comme vous le feriez dans un système de fichiers standard sur votre ordinateur, mais simple et plus limité.

Nous avons un tutoriel similaire pour les cartes ESP32 : ESP32 : Écrire des données dans un fichier (LittleFS) – Arduino IDE.

Table des matières

Tout au long de ce didacticiel, nous aborderons les sujets suivants :

Conditions préalables

Nous allons programmer la carte ESP8266 à l’aide de l’IDE Arduino. Assurez-vous donc que le module complémentaire ESP8266 est installé. Suivez le tutoriel suivant si ce n’est pas déjà fait :

De plus, assurez-vous que vous utilisez la dernière version du module complémentaire ESP8266. Accédez à Outils > Carte > Gestionnaire de cartes, recherchez ESP8266 et vérifiez que vous utilisez la dernière version.

Présentation de LittleFS

LittleFS est un système de fichiers léger créé pour les microcontrôleurs qui vous permet d’accéder à la mémoire flash comme vous le feriez dans un système de fichiers standard sur votre ordinateur, mais il est plus simple et plus limité. Vous pouvez lire, écrire, fermer et supprimer des fichiers et des dossiers. L’utilisation d’un système de fichiers avec les cartes ESP8266 est particulièrement utile pour :

Créez des fichiers de configuration avec des paramètres ;
Sauvegarder les données de manière permanente ;
Créez des fichiers pour enregistrer de petites quantités de données au lieu d’utiliser une carte microSD ;
Enregistrez les fichiers HTML, CSS et JavaScript pour créer un serveur Web ;
Enregistrez des images, des figures et des icônes ;
Et bien plus encore.

Vous aimerez peut-être aussi lire : Installez le téléchargeur de système de fichiers ESP8266 NodeMCU LittleFS dans l’IDE Arduino.

ESP8266 avec LittleFS – Gestion des fichiers et dossiers

Avant de vous montrer comment écrire des données dans un fichier sur LittleFS avec l’ESP8266, jetons un coup d’œil à un exemple qui montre comment effectuer pratiquement toutes les tâches dont vous pourriez avoir besoin lorsque vous traitez des fichiers à l’aide de LittleFS.

Il s’agit de l’exemple officiel du noyau ESP8266.

/* Example showing timestamp support in LittleFS - Released into the public domain.
   Earle F. Philhower, III <[email protected]> Official example: https://github.com/esp8266/Arduino/blob/master/libraries/LittleFS/examples/LittleFS_Timestamp/LittleFS_Timestamp.ino
*/

// Project details: https://Raspberryme.com/esp8266-nodemcu-write-data-littlefs-arduino/

#include 
#include 
#include 
#include 

#ifndef STASSID
#define STASSID "REPLACE_WITH_YOUR_SSID"
#define STAPSK "REPLACE_WITH_YOUR_PASSWORD"
#endif

const char *ssid = STASSID;
const char *pass = STAPSK;

long timezone = 0;
byte daysavetime = 1;

void listDir(const char *dirname) {
  Serial.printf("Listing directory: %s\n", dirname);

  Dir root = LittleFS.openDir(dirname);

  while (root.next()) {
    File file = root.openFile("r");
    Serial.print("  FILE: ");
    Serial.print(root.fileName());
    Serial.print("  SIZE: ");
    Serial.print(file.size());
    time_t cr = file.getCreationTime();
    time_t lw = file.getLastWrite();
    file.close();
    struct tm *tmstruct = localtime(&cr);
    Serial.printf("    CREATION: %d-%02d-%02d %02d:%02d:%02d\n", (tmstruct->tm_year) + 1900, (tmstruct->tm_mon) + 1, tmstruct->tm_mday, tmstruct->tm_hour, tmstruct->tm_min, tmstruct->tm_sec);
    tmstruct = localtime(&lw);
    Serial.printf("  LAST WRITE: %d-%02d-%02d %02d:%02d:%02d\n", (tmstruct->tm_year) + 1900, (tmstruct->tm_mon) + 1, tmstruct->tm_mday, tmstruct->tm_hour, tmstruct->tm_min, tmstruct->tm_sec);
  }
}

void readFile(const char *path) {
  Serial.printf("Reading file: %s\n", path);

  File file = LittleFS.open(path, "r");
  if (!file) {
    Serial.println("Failed to open file for reading");
    return;
  }

  Serial.print("Read from file: ");
  while (file.available()) { Serial.write(file.read()); }
  file.close();
}

void writeFile(const char *path, const char *message) {
  Serial.printf("Writing file: %s\n", path);

  File file = LittleFS.open(path, "w");
  if (!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  if (file.print(message)) {
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  delay(2000);  // Make sure the CREATE and LASTWRITE times are different
  file.close();
}

void appendFile(const char *path, const char *message) {
  Serial.printf("Appending to file: %s\n", path);

  File file = LittleFS.open(path, "a");
  if (!file) {
    Serial.println("Failed to open file for appending");
    return;
  }
  if (file.print(message)) {
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

void renameFile(const char *path1, const char *path2) {
  Serial.printf("Renaming file %s to %s\n", path1, path2);
  if (LittleFS.rename(path1, path2)) {
    Serial.println("File renamed");
  } else {
    Serial.println("Rename failed");
  }
}

void deleteFile(const char *path) {
  Serial.printf("Deleting file: %s\n", path);
  if (LittleFS.remove(path)) {
    Serial.println("File deleted");
  } else {
    Serial.println("Delete failed");
  }
}

void setup() {
  Serial.begin(115200);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, pass);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
  Serial.println("Contacting Time Server");
  configTime(3600 * timezone, daysavetime * 3600, "time.nist.gov", "0.pool.ntp.org", "1.pool.ntp.org");
  struct tm tmstruct;
  delay(2000);
  tmstruct.tm_year = 0;
  getLocalTime(&tmstruct, 5000);
  Serial.printf("\nNow is : %d-%02d-%02d %02d:%02d:%02d\n", (tmstruct.tm_year) + 1900, (tmstruct.tm_mon) + 1, tmstruct.tm_mday, tmstruct.tm_hour, tmstruct.tm_min, tmstruct.tm_sec);
  Serial.println("");
  Serial.println("Formatting LittleFS filesystem");
  LittleFS.format();
  Serial.println("Mount LittleFS");
  if (!LittleFS.begin()) {
    Serial.println("LittleFS mount failed");
    return;
  }
  listDir("/");
  deleteFile("/hello.txt");
  writeFile("/hello.txt", "Hello ");
  appendFile("/hello.txt", "World!\n");
  listDir("/");

  Serial.println("The timestamp should be valid above");

  Serial.println("Now unmount and remount and perform the same operation.");
  Serial.println("Timestamp should be valid, data should be good.");
  LittleFS.end();
  Serial.println("Now mount it");
  if (!LittleFS.begin()) {
    Serial.println("LittleFS mount failed");
    return;
  }
  readFile("/hello.txt");
  listDir("/");
}

void loop() {

}

Afficher le code brut

Ce code couvre les éléments suivants :

Cet exemple particulier affiche également la date de création d’un fichier et la dernière fois qu’il a été écrit. Vous devrez donc insérer vos informations d’identification réseau afin que nous puissions obtenir l’heure actuelle sur Internet.

Comment fonctionne le code

Tout d’abord, vous devez inclure les bibliothèques suivantes : FS.h pour gérer les fichiers, LittleFS.h pour créer et accéder au système de fichiers, time.h pour gérer les fonctions temporelles et ESP8266WiFi.h pour que nous puissions nous connecter à Internet pour récupérer l’heure actuelle.

#include 
#include 
#include 
#include

Vous devez insérer vos identifiants réseau sur les lignes suivantes :

#define STASSID "REPLACE_WITH_YOUR_SSID"
#define STAPSK "REPLACE_WITH_YOUR_PASSWORD"

Ajustez votre fuseau horaire dans les paramètres suivants. Dans la variable de fuseau horaire, insérez un nombre en fonction de votre fuseau horaire par rapport à GMT. De plus, ajoutez si votre fuseau horaire utilise l’heure d’été.

long timezone = 0;
byte daysavetime = 1;

L’exemple fournit plusieurs fonctions pour gérer les fichiers sur le système de fichiers LittleFS. Jetons un coup d’oeil à eux.

Lister un répertoire

La fonction listDir() répertorie les répertoires du système de fichiers. Cette fonction accepte comme arguments le chemin du fichier du répertoire. Cela affichera tous les fichiers et dossiers contenus dans ce chemin, ainsi que la date de création et la dernière fois qu’ils ont été modifiés.

void listDir(const char *dirname) {
  Serial.printf("Listing directory: %s\n", dirname);

  Dir root = LittleFS.openDir(dirname);

  while (root.next()) {
    File file = root.openFile("r");
    Serial.print("  FILE: ");
    Serial.print(root.fileName());
    Serial.print("  SIZE: ");
    Serial.print(file.size());
    time_t cr = file.getCreationTime();
    time_t lw = file.getLastWrite();
    file.close();
    struct tm *tmstruct = localtime(&cr);
    Serial.printf("    CREATION: %d-%02d-%02d %02d:%02d:%02d\n", (tmstruct->tm_year) + 1900, (tmstruct->tm_mon) + 1, tmstruct->tm_mday, tmstruct->tm_hour, tmstruct->tm_min, tmstruct->tm_sec);
    tmstruct = localtime(&lw);
    Serial.printf("  LAST WRITE: %d-%02d-%02d %02d:%02d:%02d\n", (tmstruct->tm_year) + 1900, (tmstruct->tm_mon) + 1, tmstruct->tm_mday, tmstruct->tm_hour, tmstruct->tm_min, tmstruct->tm_sec);
  }
}

Voici un exemple de la façon d’appeler cette fonction. Le / correspond au répertoire root. La commande suivante listera tous les répertoires et fichiers du répertoire root.

 listDir("/");

Lire le contenu du fichier

La fonction readFile() lit le contenu d’un fichier et imprime le contenu dans Serial Monitor. Passez en argument le chemin du fichier.

void readFile(const char *path) {
  Serial.printf("Reading file: %s\n", path);

  File file = LittleFS.open(path, "r");
  if (!file) {
    Serial.println("Failed to open file for reading");
    return;
  }

  Serial.print("Read from file: ");
  while (file.available()) { Serial.write(file.read()); }
  file.close();
}

Par exemple, la ligne suivante lit le contenu du fichier hello.txt.

readFile("/hello.txt");

Écrire du contenu dans un fichier

Pour écrire du contenu dans un fichier, vous pouvez utiliser la fonction writeFile(). Passez en argument : le chemin du fichier et le message/les données (en tant que variable const char).

void writeFile(const char *path, const char *message) {
  Serial.printf("Writing file: %s\n", path);

  File file = LittleFS.open(path, "w");
  if (!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  if (file.print(message)) {
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  delay(2000);  // Make sure the CREATE and LASTWRITE times are different
  file.close();
}

La ligne suivante écrit Hello dans le fichier hello.txt.

writeFile("/hello.txt", "Hello ");

Ajouter du contenu à un fichier

De même, vous pouvez ajouter du contenu à un fichier (sans écraser le contenu précédent) à l’aide de la fonction appendFile().

void appendFile(const char *path, const char *message) {
  Serial.printf("Appending to file: %s\n", path);

  File file = LittleFS.open(path, "a");
  if (!file) {
    Serial.println("Failed to open file for appending");
    return;
  }
  if (file.print(message)) {
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

La ligne suivante ajoute le message World!\r\n dans le fichier hello.txt. Le \n signifie que la prochaine fois que vous écrirez quelque chose dans le fichier, il sera écrit sur une nouvelle ligne.

appendFile("/hello.txt", "World!\n");

Renommer un fichier

Vous pouvez renommer un fichier à l’aide de la fonction renameFile(). Passez en arguments le système de fichiers LittleFS, le nom de fichier d’origine et le nouveau nom de fichier.

void renameFile(const char *path1, const char *path2) {
  Serial.printf("Renaming file %s to %s\n", path1, path2);
  if (LittleFS.rename(path1, path2)) {
    Serial.println("File renamed");
  } else {
    Serial.println("Rename failed");
  }
}

La ligne suivante renomme le fichier hello.txt en foo.txt.

renameFile("/hello.txt", "/foo.txt");

Supprimer un fichier

Utilisez la fonction deleteFile() pour supprimer un fichier. Passez en argument le chemin du fichier que vous souhaitez supprimer.

void deleteFile(const char *path) {
  Serial.printf("Deleting file: %s\n", path);
  if (LittleFS.remove(path)) {
    Serial.println("File deleted");
  } else {
    Serial.println("Delete failed");
  }
}

La ligne suivante supprime le fichier hello.txt du système de fichiers.

deleteFile("/hello.txt");

Initialiser le Wi-Fi et l’heure

Dans le setup(), nous commençons par initialiser le Wi-Fi.

WiFi.begin(ssid, pass);

while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.print(".");
}
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());

Après avoir initialisé le Wi-Fi, nous pouvons régler l’heure.

Serial.println("Contacting Time Server");
configTime(3600 * timezone, daysavetime * 3600, "time.nist.gov", "0.pool.ntp.org", "1.pool.ntp.org");
struct tm tmstruct;
delay(2000);
tmstruct.tm_year = 0;
getLocalTime(&tmstruct, 5000);
Serial.printf("\nNow is : %d-%02d-%02d %02d:%02d:%02d\n", (tmstruct.tm_year) + 1900, (tmstruct.tm_mon) + 1, tmstruct.tm_mday, tmstruct.tm_hour, tmstruct.tm_min, tmstruct.tm_sec);
Serial.println("");

Pour en savoir plus sur les fonctions horaires avec l’ESP8266, consultez les tutoriels suivants :

Initialiser le système de fichiers

Dans setup(), les lignes suivantes initialisent le système de fichiers LittleFS.

if(!LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED)){
  Serial.println("LittleFS Mount Failed");
  return;
}

La fonction LittleFS.begin() renvoie true si le système de fichiers est initialisé avec succès ou false dans le cas contraire.

Tester le système de fichiers

Les lignes suivantes appellent toutes les fonctions que nous avons vues précédemment et montent et démontent le système de fichiers à des fins de test

listDir("/");
deleteFile("/hello.txt");
writeFile("/hello.txt", "Hello ");
appendFile("/hello.txt", "World!\n");
listDir("/");

Serial.println("The timestamp should be valid above");

Serial.println("Now unmount and remount and perform the same operation.");
Serial.println("Timestamp should be valid, data should be good.");
LittleFS.end();
Serial.println("Now mount it");
if (!LittleFS.begin()) {
  Serial.println("LittleFS mount failed");
  return;
}
readFile("/hello.txt");
listDir("/");

Démonstration

Téléchargez le croquis précédent sur votre carte ESP8266. Après cela, ouvrez le moniteur série, appuyez sur et réinitialisez votre carte. Si l’initialisation réussit, vous recevrez des messages similaires sur le moniteur série.

Comme vous pouvez le voir, lors de la liste des fichiers, l’heure de création et la dernière fois qu’ils ont été écrits sont affichés.

ESP8266 avec LittleFS – Comment enregistrer les valeurs des variables dans un fichier

L’exemple précédent illustre presque toutes les opérations que vous pourriez avoir besoin d’effectuer lorsque vous traitez des fichiers sur le système de fichiers. Dans cette section, nous examinerons un exemple plus simple et spécifique : comment enregistrer le contenu d’une variable dans le système de fichiers.

Jetons un coup d’œil au code suivant.

/* Example showing timestamp support in LittleFS - Released into the public domain.
   Earle F. Philhower, III <[email protected]> Official example: https://github.com/esp8266/Arduino/blob/master/libraries/LittleFS/examples/LittleFS_Timestamp/LittleFS_Timestamp.ino
*/

// Project details: https://Raspberryme.com/esp8266-nodemcu-write-data-littlefs-arduino/

#include 
#include 

int mydata;

void readFile(const char *path) {
  Serial.printf("Reading file: %s\n", path);

  File file = LittleFS.open(path, "r");
  if (!file) {
    Serial.println("Failed to open file for reading");
    return;
  }

  Serial.print("Read from file: ");
  while (file.available()) { Serial.write(file.read()); }
  file.close();
}

void writeFile(const char *path, const char *message) {
  Serial.printf("Writing file: %s\n", path);

  File file = LittleFS.open(path, "w");
  if (!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  if (file.print(message)) {
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  delay(2000);  // Make sure the CREATE and LASTWRITE times are different
  file.close();
}

void appendFile(const char *path, const char *message) {
  Serial.printf("Appending to file: %s\n", path);

  File file = LittleFS.open(path, "a");
  if (!file) {
    Serial.println("Failed to open file for appending");
    return;
  }
  if (file.print(message)) {
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

void setup() {
  Serial.begin(115200);
  
  Serial.println("Mount LittleFS");
  if (!LittleFS.begin()) {
    Serial.println("LittleFS mount failed");
    return;
  }
  else{
    Serial.println("Little FS Mounted Successfully");
  }
  writeFile("/data.txt", "MY ESP8266 DATA \r\n");
}

void loop() {
  mydata = random (0, 1000);
  appendFile("/data.txt", (String(mydata)+ "\r\n").c_str()); //Append data to the file
  readFile("/data.txt"); // Read the contents of the file
  delay(30000);
}

Afficher le code brut

Pour cet exemple, nous enregistrerons en permanence la valeur d’une variable dans le système de fichiers. À titre d’exemple, nous enregistrerons un nombre aléatoire, mais celui-ci peut être facilement ajusté pour enregistrer les lectures du capteur, par exemple.

Nous commençons par créer une variable qui contiendra le nombre aléatoire appelé mydata.

int mydata;

Pour cet exemple particulier, il suffit d’utiliser les fonctions writeFile(), appendFile() et readFile(). Nous avons donc ces fonctions définies avant le setup() :

void readFile(const char *path) {
  Serial.printf("Reading file: %s\n", path);

  File file = LittleFS.open(path, "r");
  if (!file) {
    Serial.println("Failed to open file for reading");
    return;
  }

  Serial.print("Read from file: ");
  while (file.available()) { Serial.write(file.read()); }
  file.close();
}

void writeFile(const char *path, const char *message) {
  Serial.printf("Writing file: %s\n", path);

  File file = LittleFS.open(path, "w");
  if (!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  if (file.print(message)) {
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  delay(2000);  // Make sure the CREATE and LASTWRITE times are different
  file.close();
}

void appendFile(const char *path, const char *message) {
  Serial.printf("Appending to file: %s\n", path);

  File file = LittleFS.open(path, "a");
  if (!file) {
    Serial.println("Failed to open file for appending");
    return;
  }
  if (file.print(message)) {
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

Dans setup(), nous initialisons le Serial Monitor à des fins de débogage.

Serial.begin(115200);

Et nous initialisons le système de fichiers LittleFS :

Serial.println("Mount LittleFS");
if (!LittleFS.begin()) {
  Serial.println("LittleFS mount failed");
  return;
}
else{
  Serial.println("Little FS Mounted Successfully");
}

Ensuite, nous créons un fichier appelé data.txt avec le texte suivant dans MY ESP8266 DATA :

writeFile("/data.txt", "MY ESP8266 DATA \r\n");

Quelque chose à remarquer à propos de la fonction writeFile() : elle crée un fichier (s’il n’existe pas) appelé data.txt avec le texte que nous définissons à l’intérieur.

Si ce fichier existe déjà, la fonction writeFile() écrasera tout contenu existant dans ce fichier. Ainsi, si vous souhaitez ajouter continuellement de nouvelles données sans les remplacer, vous devez utiliser la fonction appendFile() après avoir créé le fichier. Si vous souhaitez remplacer le contenu du fichier, vous devez utiliser writeFile().

Dans la boucle(), on commence par attribuer une valeur aléatoire comprise entre 0 et 1000 à la variable mydata.

mydata = random (0, 1000);

Ensuite, nous ajoutons des données au fichier en appelant la fonction appendFile().

appendFile("/data.txt", (String(mydata)+ "\r\n").c_str()); // Append data to the file

Notez que nous concaténons la variable mydata avec « \r\n » afin que les données suivantes soient écrites sur la ligne suivante. Parce que notre variable est de type int, nous devons la convertir en String avant de concaténer.

String(mydata)

De plus, nous devons le convertir en const char en utilisant la méthode c_str() :

String(mydata)+ "\r\n").c_str()

Après avoir ajouté des données au fichier, nous lirons son contenu en appelant la fonction readFile().

readFile("/data.txt"); // Read the contents of the file

De nouvelles valeurs aléatoires sont générées et ajoutées au fichier toutes les 30 secondes.

delay(30000);

Démonstration

Téléchargez le code sur la carte ESP8266. Ouvrez le moniteur série à un débit en bauds de 115 200.

Il doit initialiser le système de fichiers, créer le fichier et commencer à ajouter un nouveau nombre aléatoire au fichier toutes les 30 secondes.

ESP8266 Enregistrer les données dans un fichier Exemple de moniteur série LittleFS

Notez que si vous redémarrez votre tableau, vous perdrez toutes vos données précédentes. Pourquoi cela se produit-il ?

Cela se produit parce que nous appelons la fonction writeFile() dans setup(). Comme nous l’avons expliqué précédemment, il créera un nouveau fichier s’il n’existe pas, ou écrasera un fichier déjà existant du même nom. Pour éviter cela, nous pouvons ajouter quelques lignes à setup() pour vérifier si le fichier existe déjà.

ESP8266 avec LittleFS – Vérifiez si un fichier existe déjà

Pour vérifier si un fichier existe déjà dans le système de fichiers, nous pouvons utiliser la méthode exist() et passer en argument le chemin du fichier. Vous pouvez ajouter les lignes suivantes au setup() pour éviter l’écrasement au redémarrage de l’ESP8266 :

// Check if the file already exists to prevent overwritting existing data
bool fileexists = LittleFS.exists("/data.txt");
Serial.print(fileexists);
if(!fileexists) {
  Serial.println("File doesn’t exist");
   Serial.println("Creating file...");
  // Create File and add header
   writeFile("/data.txt", "MY ESP8266 DATA \r\n");
}
else {
  Serial.println("File already exists");
}

Il utilise la méthode exist() pour vérifier si le fichier existe déjà :

bool fileexists = LittleFS.exists("/data.txt");

Il renverra vrai si le fichier existe déjà ou faux dans le cas contraire.

S’il n’existe pas, il créera le fichier avec le contenu défini.

if(!fileexists) {
  Serial.println("File doesn’t exist");
  Serial.println("Creating file...");
  // Create File and add header
  writeFile("/data.txt", "MY ESP8266 DATA \r\n");
}

S’il existe déjà, il écrit simplement que le fichier existe déjà dans le moniteur série.

else {
  Serial.println("File already exists");
}

Voici l’exemple complet qui vérifie si le fichier existe déjà.

/* Example showing timestamp support in LittleFS - Released into the public domain.
   Earle F. Philhower, III <[email protected]> Official example: https://github.com/esp8266/Arduino/blob/master/libraries/LittleFS/examples/LittleFS_Timestamp/LittleFS_Timestamp.ino
*/

// Project details: https://Raspberryme.com/esp8266-nodemcu-write-data-littlefs-arduino/

#include 
#include 

int mydata;

void readFile(const char *path) {
  Serial.printf("Reading file: %s\n", path);

  File file = LittleFS.open(path, "r");
  if (!file) {
    Serial.println("Failed to open file for reading");
    return;
  }

  Serial.print("Read from file: ");
  while (file.available()) { Serial.write(file.read()); }
  file.close();
}

void writeFile(const char *path, const char *message) {
  Serial.printf("Writing file: %s\n", path);

  File file = LittleFS.open(path, "w");
  if (!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  if (file.print(message)) {
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  delay(2000);  // Make sure the CREATE and LASTWRITE times are different
  file.close();
}

void appendFile(const char *path, const char *message) {
  Serial.printf("Appending to file: %s\n", path);

  File file = LittleFS.open(path, "a");
  if (!file) {
    Serial.println("Failed to open file for appending");
    return;
  }
  if (file.print(message)) {
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

void setup() {
  Serial.begin(115200);
  
  Serial.println("Mount LittleFS");
  if (!LittleFS.begin()) {
    Serial.println("LittleFS mount failed");
    return;
  }
  else{
    Serial.println("Little FS Mounted Successfully");
  }
   // Check if the file already exists to prevent overwritting existing data
   bool fileexists = LittleFS.exists("/data.txt");
   Serial.print(fileexists);
   if(!fileexists) {
       Serial.println("File doesn’t exist");
       Serial.println("Creating file...");
       // Create File and add header
       writeFile("/data.txt", "MY ESP8266 DATA \r\n");
   }
   else {
       Serial.println("File already exists");
   }
}

void loop() {
  mydata = random (0, 1000);
  appendFile("/data.txt", (String(mydata)+ "\r\n").c_str()); //Append data to the file
  readFile("/data.txt"); // Read the contents of the file
  delay(30000);
}

Afficher le code brut

Si vous testez cet exemple, vous verrez que le fichier conserve toutes les données même après un redémarrage.

ESP8266 Enregistrer les données dans un fichier Exemple de moniteur série LittleFS - empêcher l'écrasement

Conclusion

Avec ce didacticiel, vous avez appris à enregistrer des données de manière permanente sur un fichier du système de fichiers ESP8266 LittleFS. Vous apprendrez à créer un fichier, à ajouter des données et à lire le contenu d’un fichier.

Si vous souhaitez enregistrer un fichier dont le contenu est sur l’ESP8266 et que vous n’avez pas besoin d’ajouter de données pendant l’exécution, vous souhaiterez peut-être utiliser le plugin LittleFS à la place. Il vous permet d’enregistrer les fichiers que vous avez dans votre dossier de croquis directement dans le système de fichiers ESP8266 : Installez le téléchargeur de système de fichiers ESP8266 NodeMCU LittleFS dans l’IDE Arduino.

Nous espérons que vous avez trouvé ce tutoriel utile. Apprenez-en davantage sur l’ESP8266 grâce à nos ressources :

Apprenez l’histoire de Raspberry Pi à travers cette vidéo :

AZDelivery 3 x D1 Mini NodeMCU Lua avec ESP8266-12F Module WLAN CH340G Compatible avec Arduino incluant Un E-Book!
EPLZON 3 Pièces ESP8266 Mini développement Module ESP8266-12F NodeMcu Lua WiFi Board Binghe Compatible avec Arduino Interface de Type C

ESP8266 NodeMCU : Écrire des données dans un fichier (LittleFS) – Arduino

Conditions préalables

Présentation de LittleFS

ESP8266 avec LittleFS – Gestion des fichiers et dossiers

Comment fonctionne le code

Lister un répertoire

Lire le contenu du fichier

Écrire du contenu dans un fichier

Ajouter du contenu à un fichier

Renommer un fichier

Supprimer un fichier

Initialiser le Wi-Fi et l’heure

Initialiser le système de fichiers

Tester le système de fichiers

Démonstration

ESP8266 avec LittleFS – Comment enregistrer les valeurs des variables dans un fichier

Démonstration

ESP8266 avec LittleFS – Vérifiez si un fichier existe déjà

Conclusion

MicroPython : ESP32/ESP8266 TM1637 Affichage LED à 4 chiffres et 7 segments

ESP32 : 10 projets faciles pour les débutants

ESP32 avec lecteur MP3 YX5300/YX6300 (Arduino)

ESP32 : affichage TM1637 à 4 chiffres et 7 segments (Arduino)

Clintech Pico : nouvelle carte de développement Raspberry Pi RP2354B avec 48 GPIO

Grinn GenioSoM-360 : Un SoM puissant pour l’IA dans les applications compactes

Construisez un réveil parlant à l’aide du XIAO ESP32-S3

Exécutez des périphériques USB hors de l’alimentation de votre banc avec USBpwrMe

PycoClaw : la solution IA pour microcontrôleurs compatibilité OpenClaw