Guarda variables ESP32 y la biblioteca EEPROM

La librería EEPROM en ESP32 proporciona una forma confiable de almacenar datos de manera persistente, de forma que estén accesibles incluso cuando la fuente de alimentación se desconecta.

EEPROM (Electrically Erasable Programmable Read-Only Memory) es un tipo de memoria no volátil, que se incluye en algunos modelos de Arduino.

El ESP32 no tiene una EEPROM como tal. Sin embargo, los desarrolladores del Core del ESP32 para Arduino incluyeron una librería EEPROM que emula el comportamiento, para que fuera sencillo de usar.

Con el ESP32 y la biblioteca EEPROM, puedes utilizar hasta 512 bytes en la memoria flash. Esto significa que tienes 512 direcciones diferentes, y puedes guardar un valor entre 0 y 255 en cada posición de dirección.

A diferencia de la memoria RAM, los datos que guardemos con la librería EEPROM no se pierden cuando se corta la energía. Esta característica la convierte en una elección ideal para retener configuraciones, ajustes y otros datos importantes en dispositivos embebidos como el ESP32.

Cómo usar la biblioteca EEPROM en el ESP32

Configuración Inicial

Antes de utilizar la EEPROM en ESP32, es necesario realizar una configuración inicial.

#include <EEPROM.h>

Luego, es necesario inicializar la EEPROM con el tamaño adecuado en el método setup():

void setup() {
  EEPROM.begin(size);
  // Resto del código de inicialización
}

Reemplaza size con el tamaño en bytes que deseas asignar a la EEPROM para tus datos.

Almacenar y leer Datos

La EEPROM se puede utilizar para almacenar diversos tipos de datos, como enteros, flotantes, caracteres y estructuras personalizadas. A continuación, se muestra cómo almacenar y leer un entero en la EEPROM:

int valor = 42;
int direccion = 0; // Dirección de memoria donde se almacenará el valor

EEPROM.write(direccion, valor); // Almacena el valor en la dirección dada
EEPROM.commit(); // Guarda los cambios en la memoria EEPROM

int valorLeido = EEPROM.read(direccion); // Lee el valor almacenado en la dirección dada

Recuerda que debes llamar a EEPROM.commit() después de escribir datos en la EEPROM para asegurarte de que los cambios se guarden de manera permanente.

Ejemplo de código

Supongamos que estás trabajando en un proyecto que utiliza una conexión WiFi para comunicarse con un servidor. Sería útil guardar las credenciales de WiFi en la EEPROM para que el dispositivo pueda conectarse automáticamente después de reiniciar.

Aquí tienes un ejemplo de cómo hacerlo:

#include <EEPROM.h>
#include <WiFi.h>

const char* ssid = "nombre-de-la-red";
const char* password = "contraseña-de-la-red";
int direccionSSID = 0;
int direccionPassword = sizeof(ssid);

void setup() {
  EEPROM.begin(512);
  EEPROM.writeString(direccionSSID, ssid);
  EEPROM.writeString(direccionPassword, password);
  EEPROM.commit();
  
  // Resto del código de inicialización, conexión a WiFi, etc.
}

En este ejemplo, utilizamos el método writeString() para almacenar las credenciales de WiFi en la EEPROM.

Funciones adicionales

Algunas funciones útiles adicionales, que aparecen en el fichero eeprom.h

uint8_t readByte(int address);
int8_t readChar(int address);
uint8_t readUChar(int address);
int16_t readShort(int address);
uint16_t readUShort(int address);
int32_t readInt(int address);
uint32_t readUInt(int address);
int32_t readLong(int address);
uint32_t readULong(int address);
int64_t readLong64(int address);
uint64_t readULong64(int address);
float_t readFloat(int address);
double_t readDouble(int address);
bool readBool(int address);
size_t readString(int address, char* value, size_t maxLen);
String readString(int address);
size_t readBytes(int address, void * value, size_t maxLen);
template <class T> T readAll (int address, T &);

size_t writeByte(int address, uint8_t value);
size_t writeChar(int address, int8_t value);
size_t writeUChar(int address, uint8_t value);
size_t writeShort(int address, int16_t value);
size_t writeUShort(int address, uint16_t value);
size_t writeInt(int address, int32_t value);
size_t writeUInt(int address, uint32_t value);
size_t writeLong(int address, int32_t value);
size_t writeULong(int address, uint32_t value);
size_t writeLong64(int address, int64_t value);
size_t writeULong64(int address, uint64_t value);
size_t writeFloat(int address, float_t value);
size_t writeDouble(int address, double_t value);
size_t writeBool(int address, bool value);
size_t writeString(int address, const char* value);
size_t writeString(int address, String value);
size_t writeBytes(int address, const void* value, size_t len);