Si aunque no lo parezca, el ESP8266 tiene una memoria interna (Flash) con mucha más capacidad que sus primos Arduinos. Si bien dependiendo del ESP8266 tendremos diferentes capacidades de memoria.
Los más pequeños como el ESP8266-01 con 1MB y el ESP8266-01S que tiene 4MB. Y a partir de aquí casi todos los demás modelos ESP8266 tienen mínimo 4MB.
Esta cantidad de memoria suele ser más que suficiente para nuestros proyectos, pero si necesitas más memoria como por ejemplo para una estación meteorológica desatendida se puede utilizar un módulo al que podemos conectar una memoras SD o microSD.
De esta manera y siguiendo el ejemplo de la estación meteorológica, podríamos almacenar los datos de todo un mes y luego simplemente sacar la tarjeta y volcar los datos a nuestra computadora.
Hasta aquí la idea de tener alrededor de 3 (o más) MB disponibles suena muy bien, ahora, ¿como interactuamos con esta memoria?
Diferentes sistemas de archivos para ESP8266
- SPIFFS: SPI Flash File System, es un sistema de archivos diseñado específicamente para dispositivos embebidos con poca memoria como el ESP8266.
- LittleFS: La alternativa más reciente a SPIFFS, diseñada para ser más eficiente en cuanto al uso de la memoria y más robusta ante errores. Ofrece mejores prestaciones en términos de velocidad y capacidad de recuperación.
- FAT: Un sistema de archivos ampliamente utilizado en dispositivos de almacenamiento masivo. Sin embargo, su implementación en microcontroladores como el ESP8266 puede ser más compleja y consumir más recursos.
Con todos los sistemas de archivos podremos manejar las funciones básicas con archivos:
- Crear
- Abrir
- Leer
- Escribir
- Borrar
- Formatear unidad
Para este ejemplo usaremos LittleFS, tiene algunas mejoras en eficiencia y control de errores que su hermana SPIFFS.
La Librería LittleFS viene incluida cuando instalamos y configuramos las placas esp8266 al IDE de Arduino, así que por esa parte no necesitamos hacer nada más, simplemente cargar la librería como cualquier otra:
#include "LittleFS.h"
Y a partir de aquí veremos las diferentes funciones básicas de LittleFS, empezando por su configuración en el setup(). Al final del mismo tenemos las diferentes funciones que podemos utilizar:
#include "LittleFS.h"
String data = "FS ESP8266 Flash memory test";
void setup() {
Serial.begin(115200);
delay(100);
if (!LittleFS.begin()){
Serial.println("Error montando LittleFS");
return;
}
Serial.println("\n\nLittleFS se cargo correctamente");
Create_file("/data.txt", data);
Read_file("/data.txt");
Delete_file("/data.txt");
// Add_data_file("/data.txt", data);
// Read_file("/data.txt");
// Show_filetree("/");
// Show_memory();
// Format_all();
Serial.println();
}
- char* ConvertStringToCharArray(String S)
Transforma datos de tipo String a una cadena char (chararray). Esta función se utiliza en conjunto con Create_file y Add_data_file
char* ConvertStringToCharArray(String S)
{
int ArrayLength = S.length() + 1;
char CharArray[ArrayLength];
S.toCharArray(CharArray,ArrayLength);
return(CharArray);
}
- Create_file("/FILENAME", data);
Crea el archivo FILENAME y almacena "data" en el.
void Create_file(const char *path, String data)
{
Serial.println(path);
File file = LittleFS.open(path, "w");
if (!file){
Serial.println("Error open file");
return;
}
if (file.print(data)){
Serial.println("Writing file...");
} else {
Serial.println("Error Writing");
}
file.close();
}
- Add_data_file("/FILENAME", data);
Añade datos al final del archivo FILENAME. El archivo tiene que estar creado previamente.
void Add_data_file(const char *path, String data)
{
Serial.println(path);
File file = LittleFS.open(path, "a");
if (!file){
Serial.println("Error open file");
return;
}
if (file.print(data)){
Serial.println("Writing data...");
} else {
Serial.println("Error Writing");
}
file.close();
}
- Read_file("/FILENAME");
Lee los datos almacenados en el archivo FILENAME
void Read_file(const char *path)
{
File file = LittleFS.open(path, "r");
if (!file){
Serial.println("Error open file");
return;
}
Serial.println("File content: ");
while (file.available())
{
Serial.write(file.read());
}
Serial.println();
file.close();
}
- Delete_file("/FILENAME");
Borra el archivo seleccionado
void Delete_file(const char *filename)
{
if (LittleFS.remove(filename)){
Serial.print("Removed ");
Serial.println(filename);
} else {
Serial.println("Deleting error");
}
}
- Format_all();
Elimina todos los datos de la memoria Flash (Esta acción no se puede deshacer).
void Format_all()
{
if (!LittleFS.format()){
Serial.println("Error montando LittleFS");
return;
} else {
Serial.println("All files deleted");
}
LittleFS.end();
}
- Show_filetree("/");
Muestra la árbol de archivos y directorios desde la raíz "/".
void Show_filetree(const char *path)
{
Dir folder = LittleFS.openDir(path);
while (folder.next())
{
File file = folder.openFile("r");
Serial.print (" Name: ");
Serial.print (file.name());
Serial.print (" Size: ");
Serial.print (file.size());
Serial.print (" Folder:");
Serial.print (file.isDirectory() ? "Yes" : "No");
Serial.println ();
file.close();
}
Serial.println("End file off filetree");
}
- Show_memory();
Muestra el uso de memoria y cuanta memoria tenemos disponible
void Show_memory()
{
FSInfo fs_info;
LittleFS.info(fs_info);
Serial.print("Used: ");
int used = fs_info.usedBytes / 1024;
Serial.print(used);
Serial.print(" total Kbit: ");
int total_kbits = (fs_info.totalBytes / 1024);
Serial.print(total_kbits);
Serial.print(" Used Kbits Used Memory: " );
int used_memory = (fs_info.usedBytes / fs_info.totalBytes) * 100;
Serial.print(used_memory);
Serial.println();
}
Un punto importante del uso de archivos, es que una vez que terminemos de usar el archivo tenemos que cerrarlo con file.close(). Esto nos evitará perdida de información o que se pueda corromper el archivo.
Lo mejor es que en esta memoria podemos almacenar cualquier tipo de información, desde archivos de texto o archivos html o css.
Por el momento esto es todo, pero se vienen proyectos usando esta memoria. Si te ha gustado tienes el programa completo en mi repositorio.
Descargar ESP8266 librería LittleFS desde GitHubSaludos!!!
