Sistema de archivos ESP8266 SPIFFS

ESP8266 - ¿Todos los SPIFFS o qué? O también: un sistema de archivos separado en nuestro microcontrolador

Hola y bienvenidos a mi nuevo blog. En un post anterior tenemos brevemente sobre los SPIFFS  hablado Hoy queremos analizar más de cerca qué es SPIFFS, qué opciones nos ofrece y cómo podemos usarlo con nuestro microcontrolador ESP 8266. En primer lugar, ¿qué significa realmente SPIFFS? SPIFFS significa (S) erial (P) eripheral (I) nterface (F) lash (F) ile (S) ystem y significa que nuestro ESP puede contener un sistema de archivos simple en la memoria del programa SPI, que también contiene nuestro código de programa . Los archivos se pueden crear, cambiar o eliminar en este sistema de archivos. Nuestro código de programa puede usar o cambiar estos archivos durante el tiempo de ejecución, ya que ya los hemos creado nosotros. Volveremos a cómo se hace esto más adelante. Sin embargo, la mayor ventaja es que esta área de memoria, una vez creada, se conserva con actualizaciones de código. Es decir un programa actualizado puede continuar trabajando con los datos que se han guardado como un archivo directamente con referencia al nombre del archivo.

Instalación

Para poder trabajar con un sistema de archivos, primero debe inicializarse en nuestro ESP con un tamaño definido. Este tamaño depende, por un lado, del módulo ESP utilizado (tamaño máximo) y de nuestra configuración.

Por defecto, los módulos ESP-01 tienen 512 KB de flash hasta 1 MB de flash. Los módulos ESP-12, ESP-12E y ESP-12F (también conocido como módulo NodeMcu) tienen al menos 4 MB de flash hasta 8 MB de flash. De todo este flash, ahora estamos usando el IDE de Arduino para reservar un área de memoria para nuestro sistema de archivos:

Antes de cargar un boceto, elegimos el tamaño de nuestro futuro sistema de archivos. En lo anterior Por ejemplo, elegí un tamaño de 2 MB para mi ESP8266-12. Ahora podemos formatear nuestro sistema de archivos para el primer uso con el siguiente código. Este paso es obligatorio para nuevas instalaciones o al reconfigurar el tamaño SPIFFS:

#include <SPI.h>
#include <FS.h>           // Incluye la biblioteca SPIFFS

booleano InitalizeFileSystem() {   bool initok = falso;   initok = SPIFFS.comenzar();   si (!(initok)) // Formato SPIFS, de no formateado. - Prueba 1   {     De serie.println("Sistema de archivos SPIFFS formateado".);     SPIFFS.formatear();     initok = SPIFFS.comenzar();   }   si (!(initok)) // formatear SPIFS. - Prueba 2   {     SPIFFS.formatear();     initok = SPIFFS.comenzar();   }   si (initok) { De serie.println("SPIFFS está bien"); } otra cosa { De serie.println("SPIFFS no está bien"); }   volver initok;
}

nulo configuración() {     SPI.comenzar();                      // Inicializa la comunicación SPI     bool Resultado  = InitalizeFileSystem(); 

}

nulo bucle() {    }

Después de compilar y cargar, nuestro sistema de archivos está listo para usar. Podemos crear, cambiar y eliminar archivos. Los archivos se abren con los llamados "Modos", que especifican el tipo de acceso deseado. Dice

 • W: para escribir (escribir o crear un nuevo archivo)
 • R - para leer (leer un archivo)
 • A: para agregar (agregar datos al final de un archivo)

Uso:

Se utiliza un puntero de datos dentro del archivo, que indica la posición actual de lectura / escritura dentro de un archivo. Para mostrar un ejemplo práctico y al mismo tiempo usar tantos comandos como sea posible para las operaciones de archivo, creamos un archivo en el siguiente ejemplo y agregamos una nueva entrada cada 5 segundos. La próxima vez que se reinicie el controlador, eliminaremos el archivo y comenzaremos nuevamente. El contenido del archivo se emite secuencialmente en la interfaz en serie. Finalmente el tamaño del archivo actual en bytes. +

#include <SPI.h>
#include <FS.h>           // Usa la biblioteca SPIFFS

Archivo myfile;                   crear una variable de manejo SPIFFS

Booleana InitalizeFileSystem() 
{   Bool initok = Falso;   initok = SPIFFS.Comenzar();   Si (!(initok)) Formatear SPIFS, sin formato. - Prueba 1   {     Serial.println("Formato SPIFFS");     SPIFFS.Formato();     initok = SPIFFS.Comenzar();   }   Si (!(initok)) Formatear SPIFS, sin formato. - Prueba 2   {     SPIFFS.Formato();     initok = SPIFFS.Comenzar();   }   Si (initok) { Serial.println("SPIFFS está bien"); } Más { Serial.println("SPIFFS no está bien"); }   devolución initok;
}

Vacío Configuración() 
{   Serial.Comenzar(9600);     Spi.Comenzar();                        Bool Resultado  = InitalizeFileSystem();    Si (!(SPIFFS.Existe ("/usage_log.csv") ))  Compruebe si el archivo usage_log.csvschon se ha exactivado.   {        Mi_archivo = SPIFFS.Abierto("/usage_log.csv", "W");  Abra el archivo usage_log.csv en el directorio raíz para escribir (w - write)     Si (!Mi_archivo)        {       Serial.println("No se pudo escribir el archivo");       }     Resultado = Mi_archivo.println("01.01.1980 12:00:00; Registro borrado o eliminado");      Resultado = Mi_archivo.println("01.01.1980 12:00:01; Primera entrada, segunda línea");     Mi_archivo.Cerca();   } Más   {    SPIFFS.eliminar("/usage_log.csv");  Eliminar archivo      Serial.println("Archivo usage_log.csv ya exized ! Se ha eliminado.");   }
}

Vacío Bucle() 
{   Mi_archivo = SPIFFS.Abierto("/usage_log.csv", "R");  Abra el archivo usage_log.csv en el directorio raíz para leer (r - lectura)   Cadena Contenido=Mi_archivo.readStringUntil('n');   Serial.println("Método: readStringUntil:");   Mientras (Mi_archivo.Posición()<Mi_archivo.Tamaño())            leer archivo inhbalt línea por línea al final del archivo         {           Contenido =Mi_archivo.readStringUntil('n');           Serial.println(Contenido);         }    Int Tamaño = Mi_archivo.Tamaño();   Mi_archivo.Cerca();   Serial.Impresión("Tamaño del archivo en bytes:");           generar el tamaño actual del archivo en bytes   Serial.println(Tamaño);                                     generar el tamaño actual del archivo en bytes   Retraso (5000);   Rendimiento();               Llamar a funciones internas ESP8266   Mi_archivo = SPIFFS.Abierto("/usage_log.csv", "A");  Abrir archivo para anexar datos ! (a - añadir)   Mi_archivo.println("01.01.1980 12:00:xx;Línea agregada.");   Mi_archivo.Cerca();
}

Copiamos el código en nuestro DIE y subimos el boceto a nuestro ESP.
El ESP comenzará a agregar entradas al archivo interno usage_log.csv. Deberíamos obtener una salida como esta:

Los comandos más importantes son

SPIFFS.open("/nombre de archivo", "r"); Lectura de un archivo

SPIFFS.open("/file name", "w"); Escritura o re-adjunto de un archivo

SPIFFS.open("/nombre de archivo", "a"); Añadir datos al final de un archivo

Una referencia completa de los comandos posibles en torno a SPIFFS y el manejo de archivos se puede encontrar en el siguiente enlace:

http://arduino.esp8266.com/Arduino/versions/2.0.0/doc/filesystem.html#file-system-object-spiffs

SPIFFS Plugin

El esp Arduino IDE Plugin es un plugin IDE de Arduino que carga archivos desde la subcarpeta "Datos" de un boceto a un sistema de archivos SPIFFS existente. Para ello, los archivos SPIFFS existentes IM ESP se eliminan y se sustituyen por los archivos de la carpeta "datos". Para ello, descargamos el archivo Zip en https://github.com/esp8266/arduino-esp8266fs-plugin y lo descomprimimos en cualquier lugar. El "esp8266fs.jar" ahora desempaquetado se coloca bajo la siguiente estructura de carpetas que creamos antes: Mis archivos->Documentos->Arduino->Herramientas->ESP8266FS->Herramienta. Después de un reinicio, se crea un nuevo subelemento en Herramientas -> Carga de datos de boceto ESP8266":

Diviértete experimentando y hasta el próximo post!