Aprender

EEPROM do Arduino: memória que sobrevive a um reset

Iniciante

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: contador de inicializações com EEPROMao vivo0.000 s 0.00x
Clique para abrir no editor
O exemplo de EEPROM em um ATmega328P simulado. Abra o monitor serial e aperte reset: a contagem de inicializações aumenta.

Tudo o que está nas variáveis do seu sketch se perde no momento em que o Arduino reseta ou perde energia. Isso serve para a maioria das coisas, mas não para um recorde, uma configuração ou uma contagem que você quer manter. Para isso, o Uno tem 1024 bytes de EEPROM dentro do chip: memória que guarda o conteúdo mesmo sem energia.

O circuito acima é só um Uno, porque a EEPROM fica dentro do chip e não há nada para ligar. O sketch grava um int e um long, lê de volta e conta quantas vezes foi iniciado. Abra o monitor serial, aperte o reset da placa, e a contagem sobe em um. Ele roda no seu navegador com o sketch abaixo.

Cinco chamadas cobrem tudo

Inclua EEPROM.h e você ganha cinco chamadas. EEPROM.read(address) devolve um byte, do endereço 0 ao 1023 em um Uno. EEPROM.write(address, value) grava um byte. EEPROM.update(address, value) grava só se for diferente do que já está lá, o que economiza desgaste. EEPROM.put(address, value) grava um valor de qualquer tipo, um int, um long, um float ou um struct, usando quantos bytes precisar. EEPROM.get(address, variable) lê de volta para uma variável do mesmo tipo.

Você escolhe os endereços. Um int tem dois bytes em um Uno e um long tem quatro, então no exemplo o int fica no endereço 0, o long no endereço 2, e a contagem de inicializações no endereço 6. Se dois valores se sobrepõem, um sobrescreve o outro sem aviso, então vale a pena anotar os endereços como constantes no topo do sketch.

O exemplo, passo a passo

O sketch grava 2000 no endereço 0 e 65539 no endereço 2, depois lê os dois de volta para variáveis novas. O monitor serial imprime "int read back: 2000" e "long read back: 65539". 65539 precisa de mais de dois bytes, e é por isso que ele é um long e por isso que put() e get() são a maneira fácil de armazená-lo.

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.

O setup(), do exemplo de EEPROM
#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");
}

Ela se desgasta, então escreva com cuidado

Cada byte da EEPROM do ATmega328P é avaliado para cerca de 100.000 escritas. Parece muito, mas um sketch que escreve no mesmo endereço a cada loop pode gastar tudo em minutos. Ler é de graça; só escrever desgasta.

Então escreva apenas quando algo muda. Use update() em vez de write(), porque ele pula a escrita quando o valor já é o mesmo; put() já funciona assim. Salve uma configuração quando o usuário a muda, não num temporizador. E nunca coloque uma escrita na EEPROM dentro do loop() sem nenhuma condição em volta.

As escritas também são lentas, cerca de 3,3 milissegundos por byte no Uno, então escrever um struct grande com pressa pode fazer o sketch engasgar.

Em outras placas

O tamanho depende do chip. O Uno e o Nano têm 1 KB, e o Mega 2560 tem 4 KB. Nessas placas AVR o Mokxi usa a própria EEPROM do chip, e ela guarda seus bytes entre um reset e outro, como você pode ver acima.

O ESP32, o Pico e a maioria das placas mais novas não têm EEPROM nenhuma. A biblioteca EEPROM delas finge ter uma, mantendo uma cópia na memória flash. Nelas, no Mokxi, a EEPROM.h compila e funciona enquanto o sketch roda, mas mantém 4 KB na RAM, então um reset apaga tudo. Num ESP32 de verdade você também precisa de EEPROM.begin(size) antes de usar e EEPROM.commit() para salvar, e a biblioteca Preferences é a escolha usual para código novo.

Experimente no editor

Mude bigIn para 123456 e rode. Depois guarde um float com put() no endereço 7 e leia de volta com get(). Repare que um float tem quatro bytes, então o próximo endereço livre depois dele é 11.

Transforme a contagem em algo útil: um sketch que lembra o brilho de um LED entre resets, salvo com update() só quando um botão o muda.

Erros comuns

Escrever a cada loop. Isso desgasta a EEPROM. Escreva apenas quando o valor muda.

Endereços sobrepostos. Um long no endereço 2 usa os endereços 2, 3, 4 e 5. Coloque o próximo valor no 6, não no 3.

Esquecer que um byte em branco é 255. Na primeira vez que um sketch roda, todo endereço lê 255, não 0. Verifique isso, como o exemplo faz.

Usar write() para um número maior que 255. write() guarda um byte e joga o resto fora. Use put() e get() para qualquer coisa maior.

Ler com um tipo diferente do que você escreveu. Dê put() num int e get() num long, e você lê dois bytes de outra coisa junto.

Abra este circuito no editor. Arduino Uno: contador de inicialização com EEPROM, ligado como roda no topo desta página. Mude um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Quanta EEPROM um Arduino Uno tem?

1024 bytes, nos endereços 0 a 1023. O Nano tem o mesmo, e o Mega 2560 tem 4096.

Qual é a diferença entre EEPROM.write e EEPROM.put?

write() guarda exatamente um byte. put() guarda um valor completo de qualquer tipo, usando tantos bytes quanto esse tipo precisa, e só escreve os bytes que mudaram. Leia de volta com read() e get() para combinar.

Quantas vezes posso escrever na EEPROM do Arduino?

Cerca de 100.000 vezes por byte no ATmega328P do Uno. Leituras não contam. Use update() ou put() para pular uma escrita que não mudaria nada.

A EEPROM sobrevive ao upload de um novo sketch?

Normalmente, sim. O upload regrava a memória de programa, não a EEPROM, a menos que a placa tenha sido configurada para apagá-la. No Mokxi, as placas AVR guardam a EEPROM mesmo ao apertar o botão de reset.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.