Bienvenido al mundo de la memoria flash ESP32, una herramienta indispensable para almacenar datos de forma permanente en tus dispositivos electrónicos. En este artículo, exploraremos todo lo que necesitas saber sobre cómo escribir y leer datos en esta memoria flash de alta tecnología. ¡No te lo pierdas!
En este artículo le mostraremos cómo guardar y leer valores de la memoria flash del ESP32 usando el IDE de Arduino. Los datos almacenados en la memoria flash se conservan incluso si se reinicia el ESP32 o se corta la energía. Como ejemplo, le mostraremos cómo guardar el último estado GPIO.
Este tutorial está desactualizado.. En su lugar, siga el nuevo tutorial: [NEW] ESP32 almacena datos permanentemente usando la biblioteca de configuración
Antes de continuar con este tutorial, debes tener el complemento ESP32 instalado en tu IDE de Arduino. Siga uno de los siguientes tutoriales para instalar ESP32 en el IDE de Arduino si aún no lo ha hecho.
- Instalación de la placa ESP32 en Arduino IDE (Guía de Windows)
- Instalación de la Placa ESP32 en el IDE Arduino (Guía para Mac y Linux)
También recomendamos echar un vistazo a los siguientes recursos:
- Comenzando con el módulo de desarrollo ESP32
- Referencia de distribución de pines de ESP32: ¿Qué pines GPIO debería utilizar?
Mira el vídeotutorial
Este tutorial está disponible en formato de video (ver más abajo) y formato escrito (sigue leyendo).
Piezas requeridas
Para seguir este tutorial necesitarás los siguientes componentes:
- Placa ESP32 DOIT DEVKIT V1 – leer Prueba y comparación de placas de desarrollo ESP32
- LED de 5 mm
- Resistencia de 330 ohmios
- Presionar el botón
- resistencia de 10k ohmios
- tablero de circuitos
- Cables de puente
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Memoria flash
Los datos almacenados en la memoria flash permanecen allí incluso si se reinicia el ESP32 o se interrumpe la alimentación. La memoria flash es muy similar a la EEPROM. Ambos son recuerdos no volátiles.
Almacenar datos en la memoria flash es particularmente útil cuando:
- recordar el último estado de una variable;
- Guardar ajustes;
- almacenar el número de veces que se ha activado un dispositivo;
- o cualquier otro tipo de datos que necesites almacenar de forma permanente.
Una limitación del almacenamiento flash es la cantidad de escrituras. Los datos se pueden leer desde la memoria flash cualquier cantidad de veces, pero la mayoría de los dispositivos están diseñados para entre 100.000 y 1.000.000 de escrituras.
biblioteca EEPROM
Para leer y escribir desde la memoria flash ESP32 usando Arduino IDE, usamos la biblioteca EEPROM. Usar esta biblioteca con ESP32 es muy similar a usarla con Arduino. Entonces, si has usado la EEPROM de Arduino antes, esto no es muy diferente.
Por lo tanto, también le recomendamos que consulte nuestro artículo sobre la EEPROM de Arduino.
Con el ESP32 y la biblioteca EEPROM puedes utilizar hasta 512 bytes en la memoria flash. Esto significa que tiene 512 direcciones diferentes disponibles y puede guardar un valor entre 0 y 255 en cada posición de dirección.
Escribir
Para escribir datos en la memoria flash, utilice el EEPROM.escribir() Función que toma como argumentos la ubicación o dirección donde desea almacenar los datos y el valor (una variable de bytes) que desea almacenar:
EEPROM.write(address, value);
Por ejemplo, para escribir 9 en la dirección 0, necesita:
EEPROM.write(0, 9);
seguido por
EEPROM.commit();
Para que se guarden los cambios.
Leer
Para leer un byte de la memoria flash, utilice el EEPROM.leer() Función. Esta función toma la dirección del byte que desea leer como argumento.
EEPROM.read(address);
Por ejemplo, para leer el byte previamente almacenado en la dirección 0, use:
EEPROM.read(0);
Esto sería 9este es el valor que almacenamos en la dirección 0.
Recordar el último estado de GPIO
Para mostrarle cómo almacenar datos en la memoria flash ESP32, almacenaremos el último estado de una salida, en este caso un LED. Por ejemplo, imagine el siguiente escenario:
- Controlas una lámpara con el ESP32
- Configuras tu lámpara para encenderse
- El ESP32 pierde potencia repentinamente
- Cuando se vuelve a conectar la alimentación, la lámpara permanece apagada, porque no conserva su último estado.
Eso no debería suceder. Se supone que el ESP32 recuerda lo que sucedió antes del corte de energía y regresa al último estado.
Para solucionar este problema, puede guardar el estado de la lámpara en la memoria flash. Luego, todo lo que necesita hacer es agregar una condición al comienzo de su boceto para verificar el último estado de la lámpara y encenderla o apagarla en consecuencia.
La siguiente imagen muestra lo que haremos:
Esquema
Conecte un botón pulsador y un LED al ESP32 como se muestra en el diagrama de cableado a continuación.
código
Copie el siguiente código en el IDE de Arduino y cárguelo en su ESP32. Asegúrese de haber seleccionado la placa y el puerto COM correctos.
/*********
Rui Santos
Complete project details at https://randomnerdtutorials.com
*********/
// include library to read and write from flash memory
#include <EEPROM.h>
// define the number of bytes you want to access
#define EEPROM_SIZE 1
// constants won't change. They're used here to set pin numbers:
const int buttonPin = 4; // the number of the pushbutton pin
const int ledPin = 16; // the number of the LED pin
// Variables will change:
int ledState = HIGH; // the current state of the output pin
int buttonState; // the current reading from the input pin
int lastButtonState = LOW; // the previous reading from the input pin
// the following variables are unsigned longs because the time, measured in
// milliseconds, will quickly become a bigger number than can be stored in an int.
unsigned long lastDebounceTime = 0; // the last time the output pin was toggled
unsigned long debounceDelay = 50; // the debounce time; increase if the output flickers
void setup() {
Serial.begin(115200);
// initialize EEPROM with predefined size
EEPROM.begin(EEPROM_SIZE);
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
// read the last LED state from flash memory
ledState = EEPROM.read(0);
// set the LED to the last stored state
digitalWrite(ledPin, ledState);
}
void loop() {
// read the state of the switch into a local variable:
int reading = digitalRead(buttonPin);
// check to see if you just pressed the button
// (i.e. the input went from LOW to HIGH), and you've waited long enough
// since the last press to ignore any noise:
// If the switch changed, due to noise or pressing:
if (reading != lastButtonState) {
// reset the debouncing timer
lastDebounceTime = millis();
}
if ((millis() - lastDebounceTime) > debounceDelay) {
// whatever the reading is at, it's been there for longer than the debounce
// delay, so take it as the actual current state:
// if the button state has changed:
if (reading != buttonState) {
buttonState = reading;
// only toggle the LED if the new button state is HIGH
if (buttonState == HIGH) {
ledState = !ledState;
}
}
}
// save the reading. Next time through the loop, it'll be the lastButtonState:
lastButtonState = reading;
// if the ledState variable is different from the current LED state
if (digitalRead(ledPin)!= ledState) {
Serial.println("State changed");
// change the LED state
digitalWrite(ledPin, ledState);
// save the LED state in flash memory
EEPROM.write(0, ledState);
EEPROM.commit();
Serial.println("State saved in flash memory");
}
}
Cómo funciona el código
Echemos un vistazo rápido al código.
Este es un código antirrebote que cambia el estado del LED cada vez que presiona el botón. Sin embargo, hay algo especial en este código: recuerda el último estado del LED, incluso después de reiniciar o desconectar la alimentación del ESP32. Veamos lo que debe hacer para que el ESP32 recuerde el último estado de un GPIO.
Primero hay que incluir la biblioteca EEPROM.
#include <EEPROM.h>
Luego defina el tamaño de la EEPROM. Esta es la cantidad de bytes a los que desea acceder en la memoria flash. En este caso solo guardamos el estado del LED por lo que el tamaño de EEPROM se establece en 1.
#define EEPROM_SIZE 1
También definimos otras variables necesarias para que este boceto funcione.
// constants won't change. They're used here to set pin numbers:
const int buttonPin = 4; // the number of the pushbutton pin
const int ledPin = 16; // the number of the LED pin
// Variables will change:
int ledState = HIGH;
// the current state of the output pin
int buttonState; // the current reading from the input pin
int lastButtonState = LOW; // the previous reading from the input pin
// the following variables are unsigned longs because the time, measured in
// milliseconds, will quickly become a bigger number than can be stored in an int. unsigned long lastDebounceTime = 0; // the last time the output pin was toggled unsigned long debounceDelay = 50; // the debounce time; increase if the output flickers
configuración()
En setup() inicializas la EEPROM con el tamaño predefinido.
EEPROM.begin(EEPROM_SIZE);
Para garantizar que su código se inicialice con el último estado del LED, configuración()debe leer el último estado del LED de la memoria flash. Esto se almacena en la dirección cero.
ledState = EEPROM.read(0);
Luego sólo será necesario encender o apagar el LED según el valor leído en la memoria flash.
digitalWrite (ledPin, ledState);
Cinta()
La siguiente parte del Cinta() comprueba si se presionó el botón y lo cambia Estado del LED Variable cada vez que pulsamos el pulsador. Para asegurarnos de no recibir falsas alarmas, utilizamos un cronómetro. Este fragmento de código se basa en el ejemplo del boceto de rebote del botón del IDE de Arduino.
// read the state of the switch into a local variable:
int reading = digitalRead(buttonPin);
// check to see if you just pressed the button
// (i.e. the input went from LOW to HIGH), and you've waited long enough
// since the last press to ignore any noise:
// If the switch changed, due to noise or pressing:
if (reading != lastButtonState) {
// reset the debouncing timer
lastDebounceTime = millis();
}
if ((millis() - lastDebounceTime) > debounceDelay) {
// whatever the reading is at, it's been there for longer than the debounce
// delay, so take it as the actual current state:
// if the button state has changed:
if (reading != buttonState) {
buttonState = reading;
// only toggle the LED if the new button state is HIGH
if (buttonState == HIGH) {
ledState = !ledState;
}
}
}
// save the reading. Next time through the loop, it'll be the lastButtonState:
lastButtonState = reading;
Todo lo que necesita hacer es guardar el estado del LED en la memoria flash cada vez que cambia el estado del LED.
Comprobamos si el estado del GPIO difiere del estado del Estado del LED Variable.
if (digitalRead(ledPin)!= ledState) {
En caso afirmativo, cambiamos el estado del LED con eso. escritura digital() Función.
digitalWrite(ledPin, ledState);
Y luego guardamos el estado actual en la memoria flash. Para esto utilizamos EEPROM.escribir()y pasar como argumentos la posición de la dirección, en este caso 0, y el valor a almacenar, en este caso el Estado del LED Variable.
EEPROM.write(0, ledState);
Finalmente utilizamos el EEPROM.commit() para que los cambios surtan efecto.
EEPROM.commit();
demostración
Después de cargar el código en su ESP32, presione el botón para encender y apagar el LED. El ESP32 debe conservar el último estado del LED después de restablecer o desconectar la alimentación.
Envolver
En resumen, en esta unidad aprendió cómo almacenar datos en la memoria flash ESP32 usando la biblioteca EEPROM. Los datos almacenados en la memoria flash permanecen allí incluso después de un reinicio del ESP32 o un corte de energía.
Tenemos otros artículos sobre ESP32 que te pueden gustar:
- Cómo utilizar ESP32 Dual Core con Arduino IDE
- ESP32 PWM con Arduino IDE
- Referencia de distribución de pines de ESP32: ¿Qué pines GPIO debería utilizar?
- Fuentes ESP32 Deep Sleep y Wake Up
Este es un extracto de nuestro curso: Aprendiendo ESP32 con Arduino IDE. Si te gusta ESP32 y quieres aprender más sobre él, te recomendamos apuntarte al curso Aprende ESP32 con Arduino IDE.
Memoria flash ESP32: almacena datos permanentemente (escritura y lectura)
En este artículo, te mostraremos cómo almacenar y leer valores de la memoria flash del ESP32 utilizando Arduino IDE. Los datos guardados en la memoria flash permanecen allí incluso cuando el ESP32 se reinicia o se desconecta la energía. Como ejemplo, te mostraremos cómo guardar el último estado de un GPIO.
Preguntas Frecuentes:
- ¿Qué es la memoria flash?
- ¿Para qué sirve guardar datos en la memoria flash del ESP32?
- ¿Cuántas veces se pueden escribir datos en la memoria flash del ESP32?
- ¿Cómo se guarda y lee datos en la memoria flash del ESP32?
- ¿Cómo se garantiza que el ESP32 recuerde el último estado de un GPIO?
La memoria flash es un tipo de memoria no volátil que retiene la información incluso cuando no hay alimentación eléctrica. En el caso del ESP32, la memoria flash se utiliza para almacenar datos de forma permanente.
Guardar datos en la memoria flash del ESP32 es útil para recordar el último estado de una variable, guardar configuraciones, contar cuántas veces se ha activado un dispositivo, entre otros usos.
La memoria flash tiene un límite de escritura de alrededor de 100,000 a 1,000,000 operaciones de escritura. Por lo tanto, es importante tener en cuenta este límite al trabajar con ella.
Para escribir datos en la memoria flash, se utiliza la función EEPROM.write(). Para leer datos, se utiliza la función EEPROM.read(). Es importante utilizar la librería EEPROM en Arduino IDE para acceder a la memoria flash del ESP32.
Para asegurarse de que el ESP32 recuerde el último estado de un GPIO, se debe guardar ese estado en la memoria flash utilizando las funciones adecuadas, como EEPROM.write() y EEPROM.read(). De esta manera, el ESP32 puede recuperar el estado incluso después de un reinicio.
Para obtener más información detallada sobre cómo almacenar datos permanentemente en el ESP32, te recomendamos seguir las instrucciones del tutorial completo a través de este enlace.
Además, si deseas aprender más sobre el ESP32 y sus utilidades, te recomendamos revisar los siguientes recursos: