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!

Precipitador electrostático - 8266Software básico

3 comentarios

georg

georg

hallo,
ich habe mit interesse Ihre erklärungen zum SPIFFS system gelesen, es wäre übertrieben wenn ich behaupten würde alles verstanden zu haben…
diesen code habe ich mir nach einem beispiel hier für meine bedürfnisse angepasst, er funktioniert auch:
-———————————
//board: ESP8266 Boards /node mcu 1.0

#include
#include // Nutze die SPIFFS library
int FileSize_frequency;

String sliderValue_frequency = “4”;
String sliderValue_frequency_alt;

File myfile_frequency; // erstelle eine SPIFFS Handling Variable

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

bool Result_frequency = InitalizeFileSystem(); if (!(SPIFFS.exists (“/frequency_config.csv”) )) //Prüfe ob Datei frequency_config.csv schon exisiert. { myfile_frequency = SPIFFS.open(“/frequency_config.csv”, “w”); //Öffne die Datei frequency_config.csv im Root Verzeichnis zum schreiben (w – write) if (!myfile_frequency) { Serial.println(“Fehler beim schreiben der Datei”); } Result_frequency = myfile_frequency.println(“sliderValue_frequency”); Result_frequency = myfile_frequency.println(sliderValue_frequency); myfile_frequency.close(); } else { SPIFFS.remove(“/frequency_config.csv”); //Lösche Datei Serial.println(“Datei frequency_config.csv war schon vorhanden, sie wurde gelöscht.”); }

}

void loop()
{
myfile_frequency = SPIFFS.open(“/frequency_config.csv”, “r”); //Öffne die Datei usage_log.csv im Root Verzeichnis zum lesen (r – read)

while (myfile_frequency.position() < myfile_frequency.size()) // lese Dateiinhalt Zeile für Zeile bis um Ende der Datei { String content = myfile_frequency.readStringUntil(‘\n’); Serial.println(content); } FileSize_frequency = myfile_frequency.size(); myfile_frequency.close(); Serial.print(“Dateigroesse in Bytes:”); // gebe die aktuelle Dateigröße in Bytes aus Serial.println(FileSize_frequency); // gebe die aktuelle Dateigröße in Bytes aus delay (5000); yield(); // interne ESP8266 Funktionen aufrufen if (sliderValue_frequency != sliderValue_frequency_alt) //die config_frequency soll nur einmal bei sich änderndem “sliderValue_frequency” geändert werden { myfile_frequency = SPIFFS.open(“/frequency_config.csv”, “a”); // Öffne Datei um Daten anzuhängen ! (a – append) //myfile_frequency.println(“sliderValue_frequency”); myfile_frequency.println(sliderValue_frequency); myfile_frequency.close(); sliderValue_frequency_alt = sliderValue_frequency; }

}boolean InitalizeFileSystem()
{
bool initok = false;
initok = SPIFFS.begin();
if (!(initok)) // Format SPIFS, if not formatted. – Try 1
{
Serial.println(“Format SPIFFS”);
SPIFFS.format();
initok = SPIFFS.begin();
}
if (!(initok)) // Format SPIFS, if not formatted. – Try 2
{
SPIFFS.format();
initok = SPIFFS.begin();
}
if (initok)
{
Serial.println(“SPIFFS ist OK”);
}
else
{
Serial.println(“SPIFFS ist nicht OK”);
}
return initok;
}
-———————————————
nun muss ich zwei variable in zwei dateien ins SPIFFS schreiben: frequency und power. Die beiden sketsche funktionieren einzeln sehr gut. Der versuch, die beiden sketche in eines zu integrieren scheitern mit einer Exception 9. Ich habe alle stellen, wo es mir notwendig schien entsprechend geändert und wie gesgt – einzeln funktionieren die sketche. Könnten Sie mir bitte einen tipp geben, woran das liegen könnte? Ich würde vermuten es liegt an diesen beiden zeilen:
-—————————-
bool Result_power = InitalizeFileSystem();
bool Result_frequency = InitalizeFileSystem();
-———————————-
ich kann ein system nicht 2x initialiseren, ohne dass was durcheinander gerät, denke ich…

vielen dank
gruss georg

Andre

Andre

Hallo,
in der neusten Arduino IDE funktiniert SPIFFS nicht mehr, es wird im Moment auch nicht weiterentwickelt und soll zuküntig aus dem ESP2866 core entfernt werden. LittleFS dient als Ersatz und ich konnte es mit der neusten Arduino IDE verwenden. Unter folgendem Link findet ihr weitere Infos.
https://arduino-esp8266.readthedocs.io/en/latest/filesystem.html

Viele Grüße,
André

Stumpfbrumme

Stumpfbrumme

Danke das war hilfreich!

Deja un comentario

Todos los comentarios son moderados antes de ser publicados

Artículos de blog

  1. Ahora instalamos el esp32 a través de la administración.
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. Transporte Aéreo - programación de ESP mediante redes locales inalámbricas