LittleFS — файловое хранилище на ESP32

26.02.2024Вольтик.руПрограммирование в Arduino IDE, Уроки по ArduinoКомментариев нет

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

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

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

Создания файлов конфигурации с настройками;
Постоянного сохранения данных;
Создания файлов для хранения небольших объемов данных вместо использования карты microSD;
Сохранения файлов HTML, CSS и JavaScript для создания веб-сервера;
Сохранения изображений, графиков и иконок.

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

Работа с файлами и папками в LittleFS

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

#include <Arduino.h>
#include <LittleFS.h>

// Необходимо форматировать LittleFS только при первом запуске
#define FORMAT_LITTLEFS_IF_FAILED true

void listDir(fs::FS &fs, const char *dirname, uint8_t levels) {
  Serial.printf("Содержимое папки \"%s\":\n", dirname);

  File root = fs.open(dirname);
  if (!root) {
    Serial.println("\t- не удалось открыть папку");
    return;
  }
  if (!root.isDirectory()) {
    Serial.println("\t- это не папка");
    return;
  }

  File file = root.openNextFile();
  while (file) {
    if (file.isDirectory()) {
      Serial.print("\tПАПКА: ");
      Serial.println(file.name());
      if (levels) {
        listDir(fs, file.path(), levels - 1);
      }
    } else {
      Serial.print("\tФАЙЛ: ");
      Serial.print(file.name());
      Serial.print("\tРАЗМЕР: ");
      Serial.println(file.size());
    }
    file = root.openNextFile();
  }
}

void createDir(fs::FS &fs, const char *path) {
  Serial.printf("Создание папки \"%s\"\n", path);
  if (fs.mkdir(path)) {
    Serial.println("\t- Папка создана");
  } else {
    Serial.println("\t- Не удалось создать папку");
  }
}

void removeDir(fs::FS &fs, const char *path) {
  Serial.printf("Удаление папки \"%s\"\n", path);
  if (fs.rmdir(path)) {
    Serial.println("\t- Папка удалена");
  } else {
    Serial.println("\t- Не удалось удалить папку");
  }
}

void readFile(fs::FS &fs, const char *path) {
  Serial.printf("Чтение файла \"%s\":\n", path);

  File file = fs.open(path);
  if (!file || file.isDirectory()) {
    Serial.println("\t- не удалось открыть файл для чтения");
    return;
  }

  Serial.println("\t- содержимое файла:");
  while (file.available()) {
    Serial.write(file.read());
  }
  file.close();
}

void writeFile(fs::FS &fs, const char *path, const char *message) {
  Serial.printf("Запись файла \"%s\":\n", path);

  File file = fs.open(path, FILE_WRITE);
  if (!file) {
    Serial.println("\t- не удалось открыть файл для записи");
    return;
  }
  if (file.print(message)) {
    Serial.println("\t- файл записан");
  } else {
    Serial.println("\t- запись не удалась");
  }
  file.close();
}

void appendFile(fs::FS &fs, const char *path, const char *message) {
  Serial.printf("Добавление в файл \"%s\":\n", path);

  File file = fs.open(path, FILE_APPEND);
  if (!file) {
    Serial.println("\t- не удалось открыть файл");
    return;
  }
  if (file.print(message)) {
    Serial.println("\t- текст добавлен");
  } else {
    Serial.println("\t- добавление не удалось");
  }
  file.close();
}

void renameFile(fs::FS &fs, const char *path1, const char *path2) {
  Serial.printf("Переименование файла \"%s\" в \"%s\":\n", path1, path2);
  if (fs.rename(path1, path2)) {
    Serial.println("\t- файл переименован");
  } else {
    Serial.println("\t- переименование не удалось");
  }
}

void deleteFile(fs::FS &fs, const char *path) {
  Serial.printf("Удаление файла \"%s\":\n", path);
  if (fs.remove(path)) {
    Serial.println("\t- файл удален");
  } else {
    Serial.println("\t- удаление не удалось");
  }
}

void testFileIO(fs::FS &fs, const char *path) {
  Serial.printf("Тестирование ввода-вывода с файлом \"%s\":\n", path);

  static uint8_t buf[512];
  size_t len = 0;
  File file = fs.open(path, FILE_WRITE);
  if (!file) {
    Serial.println("\t- не удалось открыть файл для записи");
    return;
  }

  size_t i;
  Serial.print("\t- запись");
  uint32_t start = millis();
  for (i = 0; i < 2048; i++) {
    if ((i & 0x001F) == 0x001F) {
      Serial.print(".");
    }
    file.write(buf, 512);
  }
  Serial.println("");
  uint32_t end = millis() - start;
  Serial.printf("\t - %u байтов записано за %u мс\r\n", 2048 * 512, end);
  file.close();

  file = fs.open(path);
  start = millis();
  end = start;
  i = 0;
  if (file && !file.isDirectory()) {
    len = file.size();
    size_t flen = len;
    start = millis();
    Serial.print("\t- чтение");
    while (len) {
      size_t toRead = len;
      if (toRead > 512) {
        toRead = 512;
      }
      file.read(buf, toRead);
      if ((i++ & 0x001F) == 0x001F) {
        Serial.print(".");
      }
      len -= toRead;
    }
    Serial.println("");
    end = millis() - start;
    Serial.printf("\t- %u байтов прочитано за %u мс\r\n", flen, end);
    file.close();
  } else {
    Serial.println("\t- не удалось открыть файл для чтения");
  }
}

void setup() {
  Serial.begin(115200);

  if (!LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED)) {
    Serial.println("Не удалось cмонтировать LittleFS");
    return;
  }

  createDir (LittleFS, "/mydir");                      // Создание папки mydir
  writeFile (LittleFS, "/mydir/hello1.txt", "Hello1"); // Создание файла hello1.txt с содержимым "Hello1"
  listDir   (LittleFS, "/", 1);                        // Вывод списка директорий до уровня одной, начиная с корневой директории
  deleteFile(LittleFS, "/mydir/hello1.txt");           // Удаление созданного ранее файла
  removeDir (LittleFS, "/mydir");                      // Удаление созданной ранее папки
  listDir   (LittleFS, "/", 1);                        // Вывод списка всех директорий для проверки удаления

  writeFile (LittleFS, "/hello.txt", "Hello ");       // Создание и запись нового файла в корневой директории
  appendFile(LittleFS, "/hello.txt", "World!\r\n");   // Добавление текста к предыдущему файлу
  readFile  (LittleFS, "/hello.txt");                 // Чтение всего файла
  renameFile(LittleFS, "/hello.txt", "/foo.txt");     // Переименование предыдущего файла
  readFile  (LittleFS, "/foo.txt");                   // Чтение файла с новым именем
  deleteFile(LittleFS, "/foo.txt");                   // Удаление файла
  testFileIO(LittleFS, "/test.txt");                  // Тестирование
  deleteFile(LittleFS, "/test.txt");                  // Удаление файла

  Serial.println("Тест завершен!");
}

void loop() {
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

#include <Arduino.h>

#include <LittleFS.h>

// Необходимо форматировать LittleFS только при первом запуске

#define FORMAT_LITTLEFS_IF_FAILED true

void listDir(fs::FS &fs, const char *dirname, uint8_t levels) {

Serial.printf("Содержимое папки \"%s\":\n", dirname);

File root = fs.open(dirname);

if (!root) {

Serial.println("\t- не удалось открыть папку");

return;

}

if (!root.isDirectory()) {

Serial.println("\t- это не папка");

return;

}

File file = root.openNextFile();

while (file) {

if (file.isDirectory()) {

Serial.print("\tПАПКА: ");

Serial.println(file.name());

if (levels) {

listDir(fs, file.path(), levels - 1);

}

} else {

Serial.print("\tФАЙЛ: ");

Serial.print(file.name());

Serial.print("\tРАЗМЕР: ");

Serial.println(file.size());

}

file = root.openNextFile();

}

void createDir(fs::FS &fs, const char *path) {

Serial.printf("Создание папки \"%s\"\n", path);

if (fs.mkdir(path)) {

Serial.println("\t- Папка создана");

} else {

Serial.println("\t- Не удалось создать папку");

}

void removeDir(fs::FS &fs, const char *path) {

Serial.printf("Удаление папки \"%s\"\n", path);

if (fs.rmdir(path)) {

Serial.println("\t- Папка удалена");

} else {

Serial.println("\t- Не удалось удалить папку");

}

void readFile(fs::FS &fs, const char *path) {

Serial.printf("Чтение файла \"%s\":\n", path);

File file = fs.open(path);

if (!file || file.isDirectory()) {

Serial.println("\t- не удалось открыть файл для чтения");

return;

}

Serial.println("\t- содержимое файла:");

while (file.available()) {

Serial.write(file.read());

}

file.close();

}

void writeFile(fs::FS &fs, const char *path, const char *message) {

Serial.printf("Запись файла \"%s\":\n", path);

File file = fs.open(path, FILE_WRITE);

if (!file) {

Serial.println("\t- не удалось открыть файл для записи");

return;

}

if (file.print(message)) {

Serial.println("\t- файл записан");

} else {

Serial.println("\t- запись не удалась");

}

file.close();

}

void appendFile(fs::FS &fs, const char *path, const char *message) {

Serial.printf("Добавление в файл \"%s\":\n", path);

File file = fs.open(path, FILE_APPEND);

if (!file) {

Serial.println("\t- не удалось открыть файл");

return;

}

if (file.print(message)) {

Serial.println("\t- текст добавлен");

} else {

Serial.println("\t- добавление не удалось");

}

file.close();

}

void renameFile(fs::FS &fs, const char *path1, const char *path2) {

Serial.printf("Переименование файла \"%s\" в \"%s\":\n", path1, path2);

if (fs.rename(path1, path2)) {

Serial.println("\t- файл переименован");

} else {

Serial.println("\t- переименование не удалось");

}

void deleteFile(fs::FS &fs, const char *path) {

Serial.printf("Удаление файла \"%s\":\n", path);

if (fs.remove(path)) {

Serial.println("\t- файл удален");

} else {

Serial.println("\t- удаление не удалось");

}

void testFileIO(fs::FS &fs, const char *path) {

Serial.printf("Тестирование ввода-вывода с файлом \"%s\":\n", path);

static uint8_t buf[512];

size_t len = 0;

File file = fs.open(path, FILE_WRITE);

if (!file) {

Serial.println("\t- не удалось открыть файл для записи");

return;

}

size_t i;

Serial.print("\t- запись");

uint32_t start = millis();

for (i = 0; i < 2048; i++) {

if ((i & 0x001F) == 0x001F) {

Serial.print(".");

}

file.write(buf, 512);

}

Serial.println("");

uint32_t end = millis() - start;

Serial.printf("\t - %u байтов записано за %u мс\r\n", 2048 * 512, end);

file.close();

file = fs.open(path);

start = millis();

end = start;

i = 0;

if (file && !file.isDirectory()) {

len = file.size();

size_t flen = len;

start = millis();

Serial.print("\t- чтение");

while (len) {

size_t toRead = len;

if (toRead > 512) {

toRead = 512;

}

file.read(buf, toRead);

if ((i++ & 0x001F) == 0x001F) {

Serial.print(".");

}

len -= toRead;

}

Serial.println("");

end = millis() - start;

Serial.printf("\t- %u байтов прочитано за %u мс\r\n", flen, end);

file.close();

} else {

Serial.println("\t- не удалось открыть файл для чтения");

}

void setup() {

Serial.begin(115200);

if (!LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED)) {

Serial.println("Не удалось cмонтировать LittleFS");

return;

}

createDir (LittleFS, "/mydir"); // Создание папки mydir

writeFile (LittleFS, "/mydir/hello1.txt", "Hello1"); // Создание файла hello1.txt с содержимым "Hello1"

listDir (LittleFS, "/", 1); // Вывод списка директорий до уровня одной, начиная с корневой директории

deleteFile(LittleFS, "/mydir/hello1.txt"); // Удаление созданного ранее файла

removeDir (LittleFS, "/mydir"); // Удаление созданной ранее папки

listDir (LittleFS, "/", 1); // Вывод списка всех директорий для проверки удаления

writeFile (LittleFS, "/hello.txt", "Hello "); // Создание и запись нового файла в корневой директории

appendFile(LittleFS, "/hello.txt", "World!\r\n"); // Добавление текста к предыдущему файлу

readFile (LittleFS, "/hello.txt"); // Чтение всего файла

renameFile(LittleFS, "/hello.txt", "/foo.txt"); // Переименование предыдущего файла

readFile (LittleFS, "/foo.txt"); // Чтение файла с новым именем

deleteFile(LittleFS, "/foo.txt"); // Удаление файла

testFileIO(LittleFS, "/test.txt"); // Тестирование

deleteFile(LittleFS, "/test.txt"); // Удаление файла

Serial.println("Тест завершен!");

}

void loop() {

}

Пояснения к коду

Для начала необходимо подключить библиотеку LittleFS.h для создания файлов и доступа к файловой системе:

#include <LittleFS.h>

1	#include <LittleFS.h>

При первом использовании LittleFS на ESP32 необходимо отформатировать файловую систему, чтобы создать раздел, который будет выделен для этой неё:

#define FORMAT_LITTLEFS_IF_FAILED true

1	#define FORMAT_LITTLEFS_IF_FAILED true

Наш пример предоставляет несколько функций для работы с файлами в файловой системе LittleFS. Рассмотрим каждую из них более подробно.

Функция для вывода списка файлов

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

void listDir(fs::FS &fs, const char *dirname, uint8_t levels) {
  Serial.printf("Содержимое папки \"%s\":\n", dirname);

  // Открываем корневую папку
  File root = fs.open(dirname);
  if (!root) {
    Serial.println("\t- не удалось открыть папку");
    return;
  }
  
  // Проверяем, является ли корневой элемент папкой
  if (!root.isDirectory()) {
    Serial.println("\t- это не папка");
    return;
  }

  // Открываем первый файл в папке
  File file = root.openNextFile();
  
  // Перебираем все файлы и подпапки в папке
  while (file) {
    if (file.isDirectory()) {
      Serial.print("\tПАПКА: ");
      Serial.println(file.name());
      
      // Рекурсивно вызываем функцию для вложенных подпапок, если уровень не равен 0
      if (levels) {
        listDir(fs, file.path(), levels - 1);
      }
    } else {
      Serial.print("\tФАЙЛ: ");
      Serial.print(file.name());
      Serial.print("\tРАЗМЕР: ");
      Serial.println(file.size());
    }
    
    // Переходим к следующему файлу в папке
    file = root.openNextFile();
  }

void listDir(fs::FS &fs, const char *dirname, uint8_t levels) {

Serial.printf("Содержимое папки \"%s\":\n", dirname);

// Открываем корневую папку

File root = fs.open(dirname);

if (!root) {

Serial.println("\t- не удалось открыть папку");

return;

}

// Проверяем, является ли корневой элемент папкой

if (!root.isDirectory()) {

Serial.println("\t- это не папка");

return;

}

// Открываем первый файл в папке

File file = root.openNextFile();

// Перебираем все файлы и подпапки в папке

while (file) {

if (file.isDirectory()) {

Serial.print("\tПАПКА: ");

Serial.println(file.name());

// Рекурсивно вызываем функцию для вложенных подпапок, если уровень не равен 0

if (levels) {

listDir(fs, file.path(), levels - 1);

}

} else {

Serial.print("\tФАЙЛ: ");

Serial.print(file.name());

Serial.print("\tРАЗМЕР: ");

Serial.println(file.size());

}

// Переходим к следующему файлу в папке

file = root.openNextFile();

}

Функция для создания папки

Функция createDir() создает новую папку. В качестве аргумента передается файловая система (LittleFS) и путь с именем новой папки.

void createDir(fs::FS &fs, const char *path) {
  Serial.printf("Создание папки \"%s\"\n", path);

  // Попытка создания папки с указанным путем
  if (fs.mkdir(path)) {
    Serial.println("\t- Папка создана");
  } else {
    Serial.println("\t- Не удалось создать папку");
  }
}

void createDir(fs::FS &fs, const char *path) {

Serial.printf("Создание папки \"%s\"\n", path);

// Попытка создания папки с указанным путем

if (fs.mkdir(path)) {

Serial.println("\t- Папка создана");

} else {

Serial.println("\t- Не удалось создать папку");

}

Функция для удаления папки

Для удаления папки из файловой системы мы используем функцию removeDir(). В качестве аргументов передаем объект файловой системы и путь к папке, которую хотим удалить.

oid removeDir(fs::FS &fs, const char *path) {
  Serial.printf("Удаление папки \"%s\"\n", path);

  // Попытка удаления папки с указанным путем
  if (fs.rmdir(path)) {
    Serial.println("\t- Папка удалена");
  } else {
    Serial.println("\t- Не удалось удалить папку");
  }
}

oid removeDir(fs::FS &fs, const char *path) {

Serial.printf("Удаление папки \"%s\"\n", path);

// Попытка удаления папки с указанным путем

if (fs.rmdir(path)) {

Serial.println("\t- Папка удалена");

} else {

Serial.println("\t- Не удалось удалить папку");

}

Функция для чтения содержимого файла

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

void readFile(fs::FS &fs, const char *path) {
  Serial.printf("Чтение файла \"%s\":\n", path);

  File file = fs.open(path);
  if (!file || file.isDirectory()) {
    Serial.println("\t- не удалось открыть файл для чтения");
    return;
  }

  Serial.println("\t- содержимое файла:");
  while (file.available()) {
    Serial.write(file.read());
  }
  file.close();
}

void readFile(fs::FS &fs, const char *path) {

Serial.printf("Чтение файла \"%s\":\n", path);

File file = fs.open(path);

if (!file || file.isDirectory()) {

Serial.println("\t- не удалось открыть файл для чтения");

return;

}

Serial.println("\t- содержимое файла:");

while (file.available()) {

Serial.write(file.read());

}

file.close();

}

Записать информацию в файл

Чтобы записать содержимое в файл, вы можете использовать функцию writeFile(). В качестве аргументов передайте файловую систему LittleFS, путь к файлу и сообщение.

void writeFile(fs::FS &fs, const char *path, const char *message) {
  Serial.printf("Запись файла \"%s\":\n", path);

  // Открываем файл для записи
  File file = fs.open(path, FILE_WRITE);
  if (!file) {
    Serial.println("\t- не удалось открыть файл для записи");
    return;
  }

  // Записываем сообщение в файл
  if (file.print(message)) {
    Serial.println("\t- файл записан");
  } else {
    Serial.println("\t- запись не удалась");
  }

  // Закрываем файл
  file.close();

void writeFile(fs::FS &fs, const char *path, const char *message) {

Serial.printf("Запись файла \"%s\":\n", path);

// Открываем файл для записи

File file = fs.open(path, FILE_WRITE);

if (!file) {

Serial.println("\t- не удалось открыть файл для записи");

return;

}

// Записываем сообщение в файл

if (file.print(message)) {

Serial.println("\t- файл записан");

} else {

Serial.println("\t- запись не удалась");

}

// Закрываем файл

file.close();

Функция для дополнения файла

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

void appendFile(fs::FS &fs, const char *path, const char *message) {
  Serial.printf("Добавление в файл \"%s\":\n", path);

  // Открываем файл для добавления текста в конец
  File file = fs.open(path, FILE_APPEND);
  if (!file) {
    Serial.println("\t- не удалось открыть файл");
    return;
  }

  // Добавляем текст в конец файла
  if (file.print(message)) {
    Serial.println("\t- текст добавлен");
  } else {
    Serial.println("\t- добавление не удалось");
  }

  // Закрываем файл
  file.close();

void appendFile(fs::FS &fs, const char *path, const char *message) {

Serial.printf("Добавление в файл \"%s\":\n", path);

// Открываем файл для добавления текста в конец

File file = fs.open(path, FILE_APPEND);

if (!file) {

Serial.println("\t- не удалось открыть файл");

return;

}

// Добавляем текст в конец файла

if (file.print(message)) {

Serial.println("\t- текст добавлен");

} else {

Serial.println("\t- добавление не удалось");

}

// Закрываем файл

file.close();

Функция для переименования файла

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

void renameFile(fs::FS &fs, const char *path1, const char *path2) {
  Serial.printf("Переименование файла \"%s\" в \"%s\":\n", path1, path2);
  if (fs.rename(path1, path2)) {
    Serial.println("\t- файл переименован");
  } else {
    Serial.println("\t- переименование не удалось");
  }
}

void renameFile(fs::FS &fs, const char *path1, const char *path2) {

Serial.printf("Переименование файла \"%s\" в \"%s\":\n", path1, path2);

if (fs.rename(path1, path2)) {

Serial.println("\t- файл переименован");

} else {

Serial.println("\t- переименование не удалось");

}

Функция для удаления файла

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

void deleteFile(fs::FS &fs, const char *path) {
  Serial.printf("Удаление файла \"%s\":\n", path);
  if (fs.remove(path)) {
    Serial.println("\t- файл удален");
  } else {
    Serial.println("\t- удаление не удалось");
  }
}

void deleteFile(fs::FS &fs, const char *path) {

Serial.printf("Удаление файла \"%s\":\n", path);

if (fs.remove(path)) {

Serial.println("\t- файл удален");

} else {

Serial.println("\t- удаление не удалось");

}

Функция для теста производительности чтения\записи информации

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

void testFileIO(fs::FS &fs, const char *path) {
  Serial.printf("Тестирование ввода-вывода с файлом \"%s\":\n", path);

  static uint8_t buf[512];
  size_t len = 0;

  // Открываем файл для записи
  File file = fs.open(path, FILE_WRITE);
  if (!file) {
    Serial.println("\t- не удалось открыть файл для записи");
    return;
  }

  size_t i;
  Serial.print("\t- запись");
  // Засекаем время
  uint32_t start = millis();

  // Записываем 2048 байт в файл
  for (i = 0; i < 2048; i++) {
    if ((i & 0x001F) == 0x001F) {
      Serial.print(".");
    }
    file.write(buf, 512);
  }
  Serial.println("");

  // Считаем, сколько времени заняла запись
  uint32_t end = millis() - start;
  Serial.printf("\t - %u байтов записано за %u мс\r\n", 2048 * 512, end);
  // Закрываем файл
  file.close();

  // Открываем файл для чтения
  file = fs.open(path);
  start = millis();
  end = start;
  i = 0;

  // Проверяем, удалось ли открыть файл
  if (file && !file.isDirectory()) {
    len = file.size();
    size_t flen = len;
    // Засекаем время
    start = millis();
    Serial.print("\t- чтение");

    // Читаем данные из файла
    while (len) {
      size_t toRead = len;
      if (toRead > 512) {
        toRead = 512;
      }
      file.read(buf, toRead);
      if ((i++ & 0x001F) == 0x001F) {
        Serial.print(".");
      }
      len -= toRead;
    }
    Serial.println("");
    // Считаем, сколько времени заняла запись
    end = millis() - start;
    Serial.printf("\t- %u байтов прочитано за %u мс\r\n", flen, end);
    // Закрываем файл
    file.close();
  } else {
    Serial.println("\t- не удалось открыть файл для чтения");
  }
}

void testFileIO(fs::FS &fs, const char *path) {

Serial.printf("Тестирование ввода-вывода с файлом \"%s\":\n", path);

static uint8_t buf[512];

size_t len = 0;

// Открываем файл для записи

File file = fs.open(path, FILE_WRITE);

if (!file) {

Serial.println("\t- не удалось открыть файл для записи");

return;

}

size_t i;

Serial.print("\t- запись");

// Засекаем время

uint32_t start = millis();

// Записываем 2048 байт в файл

for (i = 0; i < 2048; i++) {

if ((i & 0x001F) == 0x001F) {

Serial.print(".");

}

file.write(buf, 512);

}

Serial.println("");

// Считаем, сколько времени заняла запись

uint32_t end = millis() - start;

Serial.printf("\t - %u байтов записано за %u мс\r\n", 2048 * 512, end);

// Закрываем файл

file.close();

// Открываем файл для чтения

file = fs.open(path);

start = millis();

end = start;

i = 0;

// Проверяем, удалось ли открыть файл

if (file && !file.isDirectory()) {

len = file.size();

size_t flen = len;

// Засекаем время

start = millis();

Serial.print("\t- чтение");

// Читаем данные из файла

while (len) {

size_t toRead = len;

if (toRead > 512) {

toRead = 512;

}

file.read(buf, toRead);

if ((i++ & 0x001F) == 0x001F) {

Serial.print(".");

}

len -= toRead;

}

Serial.println("");

// Считаем, сколько времени заняла запись

end = millis() - start;

Serial.printf("\t- %u байтов прочитано за %u мс\r\n", flen, end);

// Закрываем файл

file.close();

} else {

Serial.println("\t- не удалось открыть файл для чтения");

}

Пример сохранения переменных в файл

...

void setup() {
  Serial.begin(115200);

  if (!LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED)) {
    Serial.println("Не удалось cмонтировать LittleFS");
    return;
  }

  randomSeed(analogRead(0));
}

void loop() {
  // Инициализируем строку, в которую будем записывать данные
  String data = "";

  // Генерируем случайные значения переменных для примера
  int someValue1 = random(1000);
  int someValue2 = random(1000);
  int someValue3 = random(1000);

  // Проверяем, существует ли файл
  if (!LittleFS.exists("/mydata.txt")) {
    // Если нет, то создаем его и записываем в него данных

    Serial.println("Файла mydata.txt не существует");
    Serial.println("Создаю новый файл...");

    // Формируем строку с данными
    data += "someValue1=" + String(someValue1) + ", ";
    data += "someValue2=" + String(someValue2) + ", ";
    data += "someValue3=" + String(someValue3) + "\n";

    writeFile(LittleFS, "/mydata.txt", data.c_str());
  } else {
    // Если да, то дописываем данные, сохраняя при этом предыдущие значения

    // Формируем строку с данными
    data += "someValue1=" + String(someValue1) + ", ";
    data += "someValue2=" + String(someValue2) + ", ";
    data += "someValue3=" + String(someValue3) + "\n";

    appendFile(LittleFS, "/mydata.txt", data.c_str());
  }

...

void setup() {

Serial.begin(115200);

if (!LittleFS.begin(FORMAT_LITTLEFS_IF_FAILED)) {

Serial.println("Не удалось cмонтировать LittleFS");

return;

}

randomSeed(analogRead(0));

}

void loop() {

// Инициализируем строку, в которую будем записывать данные

String data = "";

// Генерируем случайные значения переменных для примера

int someValue1 = random(1000);

int someValue2 = random(1000);

int someValue3 = random(1000);

// Проверяем, существует ли файл

if (!LittleFS.exists("/mydata.txt")) {

// Если нет, то создаем его и записываем в него данных

Serial.println("Файла mydata.txt не существует");

Serial.println("Создаю новый файл...");

// Формируем строку с данными

data += "someValue1=" + String(someValue1) + ", ";

data += "someValue2=" + String(someValue2) + ", ";

data += "someValue3=" + String(someValue3) + "\n";

writeFile(LittleFS, "/mydata.txt", data.c_str());

} else {

// Если да, то дописываем данные, сохраняя при этом предыдущие значения

// Формируем строку с данными

data += "someValue1=" + String(someValue1) + ", ";

data += "someValue2=" + String(someValue2) + ", ";

data += "someValue3=" + String(someValue3) + "\n";

appendFile(LittleFS, "/mydata.txt", data.c_str());

}

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

Заключение

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

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

Данный материал был переведен с сайта RandomNerdTutorials.com. Авторские права принадлежат ее автору - Rui Santos.

Вольтик.ру

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

LittleFS — файловое хранилище на ESP32

Работа с файлами и папками в LittleFS

Пояснения к коду

Пример сохранения переменных в файл

Заключение

Добавить комментарий Отменить ответ