EEPROM de Arduino: memoria que sobrevive a un reinicio
Principiante
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Todo lo que está en las variables de tu sketch se pierde en el momento en que el Arduino se reinicia o pierde energía. Para la mayoría de las cosas eso está bien, pero no para un puntaje máximo, una configuración o un conteo que quieras conservar. Para eso, el Uno tiene 1024 bytes de EEPROM dentro de su chip: memoria que conserva su contenido sin energía.
El circuito de arriba es solo un Uno, porque la EEPROM está dentro del chip y no hay nada que conectar. El sketch escribe un int y un long, los lee de vuelta y cuenta cuántas veces ha iniciado. Abre el monitor serie, presiona el reset de la placa y el conteo sube en uno. Funciona en tu navegador con el sketch de abajo.
Cinco funciones cubren todo
Incluye EEPROM.h y tienes cinco funciones. EEPROM.read(address) te da un byte, de la dirección 0 a la 1023 en un Uno. EEPROM.write(address, value) guarda un byte. EEPROM.update(address, value) lo guarda solo si es diferente del que ya está ahí, lo que ahorra desgaste. EEPROM.put(address, value) guarda un valor de cualquier tipo, un int, un long, un float o un struct, usando los bytes que necesite. EEPROM.get(address, variable) lee uno de vuelta en una variable del mismo tipo.
Tú eliges las direcciones. Un int ocupa dos bytes en un Uno y un long cuatro, así que en el ejemplo el int vive en la dirección 0, el long en la dirección 2 y el conteo de inicios en la dirección 6. Si dos valores se traslapan, uno sobrescribe al otro sin avisar, así que conviene anotar las direcciones como constantes al inicio del sketch.
El ejemplo, paso a paso
El sketch guarda 2000 en la dirección 0 y 65539 en la dirección 2, y luego lee ambos en variables nuevas. El monitor serie imprime "int leído: 2000" y "long leído: 65539". 65539 necesita más de dos bytes, por eso es un long y por eso put() y get() son la forma fácil de almacenarlo.
Then it reads one byte at address 6, adds one and saves it with update(). A brand new EEPROM reads 255 at every address, so the sketch treats 255 as zero. The first run prints "this sketch has started 1 time". Press reset and it prints "this sketch has started 2 times", because the byte at address 6 kept its value.
#include <EEPROM.h>
const int INT_ADDRESS = 0;
const int LONG_ADDRESS = 2;
const int COUNT_ADDRESS = 6;
void setup() {
Serial.begin(9600);
Serial.println("Mokxi Uno: EEPROM");
int smallIn = 2000;
long bigIn = 65539;
EEPROM.put(INT_ADDRESS, smallIn);
EEPROM.put(LONG_ADDRESS, bigIn);
int smallOut = 0;
long bigOut = 0;
EEPROM.get(INT_ADDRESS, smallOut);
EEPROM.get(LONG_ADDRESS, bigOut);
Serial.print("int read back: ");
Serial.println(smallOut);
Serial.print("long read back: ");
Serial.println(bigOut);
byte starts = EEPROM.read(COUNT_ADDRESS);
if (starts == 255) starts = 0; // a blank EEPROM reads 255 everywhere
starts++;
EEPROM.update(COUNT_ADDRESS, starts);
Serial.print("this sketch has started ");
Serial.print(starts);
Serial.println(starts == 1 ? " time" : " times");
}Se desgasta, así que escribe con cuidado
Cada byte de la EEPROM del ATmega328P está calificado para unas 100,000 escrituras. Suena a mucho, pero un sketch que escribe en la misma dirección en cada loop puede agotarlo en minutos. Leer es gratis; solo escribir lo desgasta.
Así que escribe solo cuando algo cambie. Usa update() en lugar de write(), porque omite la escritura cuando el valor ya es el mismo; put() ya funciona así. Guarda una configuración cuando el usuario la cambia, no con un temporizador. Y nunca pongas una escritura de EEPROM dentro de loop() sin una condición alrededor.
Las escrituras también son lentas, unos 3.3 milisegundos por byte en el Uno, así que escribir un struct grande con prisa puede hacer que un sketch se trabe.
En otras placas
El tamaño depende del chip. El Uno y el Nano tienen 1 KB, y el Mega 2560 tiene 4 KB. En esas placas AVR Mokxi usa la EEPROM del propio chip, y conserva sus bytes tras un reset, como puedes ver arriba.
El ESP32, el Pico y la mayoría de las placas más recientes no tienen EEPROM. Su biblioteca EEPROM finge tenerla guardando una copia en la memoria flash. En esas placas en Mokxi, EEPROM.h compila y funciona mientras el sketch se ejecuta, pero conserva 4 KB en RAM, así que un reset la borra. En un ESP32 real también necesitas EEPROM.begin(size) antes de usarla y EEPROM.commit() para guardar, y la biblioteca Preferences es la opción habitual para código nuevo.
Pruébalo en el editor
Cambia bigIn a 123456 y ejecútalo. Luego guarda un float con put() en la dirección 7 y léelo con get(). Fíjate que un float ocupa cuatro bytes, así que la siguiente dirección libre después es la 11.
Convierte el contador en algo útil: un sketch que recuerda el brillo de un LED entre resets, guardado con update() solo cuando un botón lo cambia.
Errores comunes
Escribir en cada ciclo. Esto desgasta la EEPROM. Escribe solo cuando cambie el valor.
Direcciones superpuestas. Un long en la dirección 2 usa las direcciones 2, 3, 4 y 5. Pon el siguiente valor en la 6, no en la 3.
Olvidar que un byte en blanco es 255. La primera vez que se ejecuta un sketch, todas las direcciones se leen como 255, no como 0. Verifícalo, como lo hace el ejemplo.
Usar write() para un número mayor que 255. write() guarda un byte y descarta el resto. Usa put() y get() para cualquier cosa más grande.
Leer con un tipo distinto al que escribiste. Si haces put() de un int y get() en un long, lees dos bytes de otra cosa junto con él.
Abre este circuito en el editor. Arduino Uno: contador de arranques con EEPROM, cableado como se ejecuta al inicio de esta página. Cambia un componente o un valor y vuelve a ejecutarlo.
Abrir el circuitoPreguntas
¿Cuánta EEPROM tiene un Arduino Uno?
1024 bytes, en las direcciones 0 a 1023. El Nano tiene lo mismo, y el Mega 2560 tiene 4096.
¿Cuál es la diferencia entre EEPROM.write y EEPROM.put?
write() guarda exactamente un byte. put() guarda un valor completo de cualquier tipo, usando tantos bytes como necesite ese tipo, y solo escribe los bytes que cambiaron. Léelos con read() y get() para que coincidan.
¿Cuántas veces puedo escribir en la EEPROM de Arduino?
Unas 100,000 veces por byte en el ATmega328P del Uno. Las lecturas no cuentan. Usa update() o put() para que se omita una escritura que no cambiaría nada.
¿La EEPROM sobrevive cuando se carga un nuevo sketch?
Normalmente, sí. Cargar el programa reescribe la memoria de programa, no la EEPROM, a menos que la placa esté configurada para borrarla. En Mokxi, las placas AVR conservan su EEPROM al presionar el botón de reinicio.
Sigue así
Ármalo en la vida real
Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.