ESP8266 NodeMCU: запись данных в файл (LittleFS) – Arduino IDE

В этом руководстве вы узнаете, как записывать и сохранять данные на постоянной основе в файл, сохраненный в файловой системе ESP8266 (LittleFS). LittleFS – это легковесная файловая система, созданная для микроконтроллеров, которая позволяет получать доступ к flash-памяти так же, как вы бы работали с обычной файловой системой на вашем компьютере, но проще и с большими ограничениями.

У нас есть аналогичное руководство для плат ESP32: ESP32: запись данных в файл (LittleFS) – Arduino IDE.

Содержание

В этом руководстве мы рассмотрим следующие темы:

• Знакомство с LittleFS

• ESP8266 с LittleFS – работа с файлами и папками

• ESP8266 с LittleFS – как сохранить значения переменных в файл

• ESP8266 с LittleFS – проверка существования файла

Предварительные требования

Мы будем программировать плату ESP8266 с помощью Arduino IDE. Поэтому убедитесь, что у вас установлено дополнение ESP8266. Следуйте следующему руководству, если вы еще этого не сделали:

• Установка платы ESP8266 в Arduino IDE

Кроме того, убедитесь, что у вас установлена последняя версия дополнения ESP8266. Перейдите в Tools > Board > Boards Manager, найдите ESP8266 и проверьте, что у вас установлена последняя версия.

Знакомство с LittleFS

LittleFS – это легковесная файловая система, созданная для микроконтроллеров, которая позволяет получать доступ к flash-памяти так же, как вы бы работали с обычной файловой системой на вашем компьютере, но она проще и более ограничена. Вы можете читать, записывать, закрывать и удалять файлы и папки. Использование файловой системы на платах ESP8266 особенно полезно для:

• Создания файлов конфигурации с настройками;

• Постоянного сохранения данных;

• Создания файлов для хранения небольших объемов данных вместо использования карты microSD;

• Сохранения HTML, CSS и JavaScript файлов для создания веб-сервера;

• Сохранения изображений, рисунков и иконок;

• И многое другое.

Вам также может быть интересно: Установка загрузчика файловой системы LittleFS для ESP8266 NodeMCU в Arduino IDE.

ESP8266 с LittleFS – работа с файлами и папками

Прежде чем показать вам, как записывать данные в файл на LittleFS с помощью ESP8266, давайте рассмотрим пример, который показывает, как выполнить практически любую задачу, которая может понадобиться при работе с файлами с использованием LittleFS.

Это официальный пример из ядра ESP8266.

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

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

#include <FS.h>
#include <LittleFS.h>
#include <time.h>
#include <ESP8266WiFi.h>

#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() {

}

Просмотр исходного кода

Этот код охватывает следующее:

• Просмотр содержимого директории;

• Чтение содержимого файла;

• Запись содержимого в файл;

• Добавление содержимого в файл;

• Переименование файла;

• Удаление файла;

• Инициализация файловой системы.

В этом конкретном примере также отображается время создания файла и время последней записи. Поэтому вам нужно будет ввести ваши сетевые учетные данные, чтобы мы могли получить текущее время из интернета.

Как работает код

Во-первых, необходимо подключить следующие библиотеки: FS.h для работы с файлами, LittleFS.h для создания и доступа к файловой системе, time.h для работы с функциями времени и ESP8266WiFi.h для подключения к интернету для получения текущего времени.

#include <FS.h>
#include <LittleFS.h>
#include <time.h>
#include <ESP8266WiFi.h>

Вам необходимо ввести ваши сетевые учетные данные в следующих строках:

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

Настройте часовой пояс в следующих параметрах. В переменной timezone введите число, соответствующее вашему часовому поясу относительно GMT. Дополнительно укажите, использует ли ваш часовой пояс летнее время.

long timezone = 0;
byte daysavetime = 1;

Пример предоставляет несколько функций для работы с файлами в файловой системе LittleFS. Давайте рассмотрим их.

Просмотр содержимого директории

Функция listDir() выводит список директорий в файловой системе. Эта функция принимает в качестве аргумента путь к директории. Она выведет все файлы и папки внутри этого пути, а также дату создания и время последней модификации.

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);
  }
}

Вот пример вызова этой функции. Символ / соответствует корневой директории. Следующая команда выведет список всех директорий и файлов в корневой директории.

listDir("/");

Чтение содержимого файла

Функция readFile() читает содержимое файла и выводит его в монитор последовательного порта. Передайте в качестве аргумента путь к файлу.

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();
}

Например, следующая строка читает содержимое файла hello.txt.

readFile("/hello.txt");

Запись содержимого в файл

Для записи содержимого в файл можно использовать функцию writeFile(). Передайте в качестве аргументов: путь к файлу и сообщение/данные (в виде переменной 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();
}

Следующая строка записывает Hello в файл hello.txt.

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

Добавление содержимого в файл

Аналогичным образом вы можете добавить содержимое в файл (без перезаписи предыдущего содержимого) с помощью функции 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();
}

Следующая строка добавляет сообщение World!\r\n в файл hello.txt. Символ \n означает, что в следующий раз, когда вы будете записывать что-то в файл, это будет записано на новой строке.

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

Переименование файла

Вы можете переименовать файл с помощью функции renameFile(). Передайте в качестве аргументов файловую систему LittleFS, исходное имя файла и новое имя файла.

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");
  }
}

Следующая строка переименовывает файл hello.txt в foo.txt.

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

Удаление файла

Используйте функцию deleteFile() для удаления файла. Передайте в качестве аргумента путь к файлу, который вы хотите удалить.

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");
  }
}

Следующая строка удаляет файл hello.txt из файловой системы.

deleteFile("/hello.txt");

Инициализация Wi-Fi и времени

В функции setup() мы начинаем с инициализации 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());

После инициализации Wi-Fi мы можем настроить время.

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("");

Чтобы узнать больше о функциях времени на ESP8266, ознакомьтесь со следующими руководствами:

• ESP8266 NodeMCU NTP-клиент-сервер: получение даты и времени (Arduino IDE)

• Получение Epoch/Unix времени с ESP8266 NodeMCU (Arduino)

Инициализация файловой системы

В функции setup() следующие строки инициализируют файловую систему LittleFS.

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

Функция LittleFS.begin() возвращает true, если файловая система инициализирована успешно, или false, если нет.

Тестирование файловой системы

Следующие строки вызывают все функции, которые мы рассмотрели ранее, и монтируют и размонтируют файловую систему для целей тестирования.

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("/");

Демонстрация

Загрузите предыдущий скетч на вашу плату ESP8266. После этого откройте монитор последовательного порта и нажмите кнопку сброса на плате. Если инициализация прошла успешно, вы получите аналогичные сообщения в мониторе последовательного порта.

Как видите, при выводе списка файлов отображается время создания и время последней записи.

---

ESP8266 с LittleFS – как сохранить значения переменных в файл

Предыдущий пример продемонстрировал практически все операции, которые могут понадобиться при работе с файлами в файловой системе. В этом разделе мы рассмотрим более простой и конкретный пример: как сохранить содержимое переменной в файловую систему.

Давайте рассмотрим следующий код.

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

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

#include <FS.h>
#include <LittleFS.h>

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);
}

Просмотр исходного кода

В этом примере мы будем непрерывно сохранять значение переменной в файловую систему. В качестве примера мы будем сохранять случайное число, но это легко можно адаптировать для сохранения показаний датчиков, например.

Мы начинаем с создания переменной, которая будет хранить случайное число, называемой mydata.

int mydata;

Для этого конкретного примера нам нужно использовать только функции writeFile(), appendFile() и readFile(). Поэтому у нас есть эти функции, определенные перед 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();
}

В setup() мы инициализируем монитор последовательного порта для целей отладки.

Serial.begin(115200);

И мы инициализируем файловую систему LittleFS:

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

Затем мы создаем файл с именем data.txt со следующим текстом внутри MY ESP8266 DATA:

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

Следует обратить внимание на функцию writeFile(): она создает файл (если он не существует) с именем data.txt с текстом, который мы определяем внутри.

Если этот файл уже существует, функция writeFile() перезапишет любое существующее содержимое внутри этого файла. Поэтому, если вы хотите непрерывно добавлять новые данные без их замены, вам следует использовать функцию appendFile() после создания файла. Если вы хотите заменить содержимое файла, вам следует использовать writeFile().

В loop() мы начинаем с присвоения случайного значения от 0 до 1000 переменной mydata.

mydata = random (0, 1000);

Затем мы добавляем данные в файл, вызывая функцию appendFile().

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

Обратите внимание, что мы конкатенируем переменную mydata с «\r\n», чтобы последующие данные записывались на следующей строке. Поскольку наша переменная имеет тип int, нам нужно сначала преобразовать ее в String перед конкатенацией.

String(mydata)

Дополнительно, затем нам нужно преобразовать ее в const char с помощью метода c_str():

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

После добавления данных в файл мы читаем его содержимое, вызывая функцию readFile().

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

Новые случайные значения генерируются и добавляются в файл каждые 30 секунд.

delay(30000);

Демонстрация

Загрузите код на плату ESP8266. Откройте монитор последовательного порта на скорости 115200 бод.

Он должен инициализировать файловую систему, создать файл и начать добавлять новое случайное число в файл каждые 30 секунд.

Обратите внимание, что если вы перезагрузите плату, вы потеряете все предыдущие данные. Почему это происходит?

Это происходит потому, что мы вызываем функцию writeFile() в setup(). Как мы объяснили ранее, она создаст новый файл, если он не существует, или перезапишет уже существующий файл с тем же именем. Чтобы предотвратить это, мы можем добавить несколько строк в setup() для проверки, существует ли файл уже.

ESP8266 с LittleFS – проверка существования файла

Чтобы проверить, существует ли файл уже в файловой системе, мы можем использовать метод exists() и передать в качестве аргумента путь к файлу. Вы можете добавить следующие строки в setup(), чтобы предотвратить перезапись при перезагрузке 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");
}

Он использует метод exists() для проверки, существует ли файл уже:

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

Он вернет true, если файл уже существует, или false, если нет.

Если он не существует, файл будет создан с содержимым, которое мы определяем.

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");
}

Если он уже существует, просто выводится сообщение File already exists в монитор последовательного порта.

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

Вот полный пример, который проверяет, существует ли файл уже.

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

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

#include <FS.h>
#include <LittleFS.h>

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);
}

Просмотр исходного кода

Если вы протестируете этот пример, вы увидите, что файл сохраняет все данные даже после перезагрузки.

Заключение

С помощью этого руководства вы научились сохранять данные на постоянной основе в файл в файловой системе ESP8266 LittleFS. Вы узнали, как создать файл, добавить данные и прочитать содержимое файла.

Если у вас есть файл с содержимым, которое вы хотите сохранить на ESP8266, и вам не нужно добавлять данные во время выполнения, вы можете использовать плагин LittleFS. Он позволяет сохранять файлы, которые находятся в папке вашего скетча, непосредственно в файловую систему ESP8266: Установка загрузчика файловой системы LittleFS для ESP8266 NodeMCU в Arduino IDE

Мы надеемся, что это руководство было вам полезно. Узнайте больше о ESP8266 с помощью наших ресурсов:

• Home Automation using ESP8266

• Build Web Servers with ESP32 and ESP8266

• Firebase Web App with ESP32 and ESP8266

• Бесплатные проекты и руководства по ESP8266