Neste tutorial vamos mostrar como usar a memória EEPROM interna do Arduino. A EEPROM está presente em todas as versões do Arduino, mas muitas vezes a falta de conhecimento de sua existência é contornada com a instalação de memórias EEPROM externas ou mesmo de um cartão de memória SD de vários gibabytes para armazenar algumas poucas variáveis ou dados.

Uma EEPROM (de Electrically-Erasable Programmable Read-Only Memory) é um tipo de memória que pode armazenar valores que serão retidos mesmo quando a energia é desligada e pode ser programada e apagada várias vezes, eletricamente. Pode ser lida um número ilimitado de vezes, mas só pode ser apagada e programada um número limitado de vezes, que varia normalmente entre 100.000 e 1 milhão.

 A quantidade de memória EEPROM presente em um Arduino varia conforme o microcontrolador instalado na placa: 1024 bytes para o ATmega328, 512 bytes no ATmega168 e ATmega8, e 4 KB (4096 bytes) sobre o ATmega1280 e ATmega2560.

 Vamos usar a biblioteca EEPROM para ler e escrever valores na memória EEPROM, esta biblioteca já vem instalada na IDE e existem três exemplos de uso na aba File/Examples/EEPROM.

Para usar esta função basta incluir a biblioteca no início do sketch desta forma:

            #include <EEPROM.h>

Uma vez que a biblioteca é incluída no programa, um objeto EEPROM está disponível para o acesso a memória. A biblioteca fornece comandos para ler e escrever dados na memória. A biblioteca EEPROM requer que você especifique o endereço de memória que você deseja ler ou escrever. Isto significa que você precisa se manter a par de onde cada valor é escrito de forma que quando você for ler o valor, acesse a partir do endereço correto.

Para escrever um valor na memória, use:

           EEPROM.write(address, value);

Onde:

address – posição da memória que será escrito, é um inteiro entre 0 e 1023  (UNO);

value -  valor a ser armazenado inteiro entre 0 e 255 (um único byte).

Agora vamos entender o exemplo que está disponivel na IDE do arduino para a utilização deste comando, primeiro devemos montar um potenciometro na entrada 0 do arduino conforme mostrado na figura abaixo, em seguida devemos fazer o upload do código do sketch mostrado mais abaixo para o arduino.

Este exemplo simplesmente salva periodicamente na EEPROM os valores lidos na entrada analógica para que possam ser acessados posteriormente.          

Código exemplo para o comando EEPROM.write:

/*
 * Exemplo EEPROM Write
 * Armazena valores lidos na entrada analógica na EEPROM.
 * Estes valores permanecerão guardados mesmo que a placa
 *  seja desligada e podem ser recuperados posteriormente pelo próximo  sketch
 */

#include <EEPROM.h> // incluir a biblioteca
int addr = 0;    // endereço de escrita na memória

void setup()
{
}

void loop()
{
  // é preciso dividir val por 4 porque o range da entrada analógica
  // vai de 0 a 1023 e cada byte da EEPROM só pode guardar
  // valores compreendidos entre 0 e 255.
  int val = analogRead(0) / 4;
 
  // escreve o valor de val na EEPROM no endereço selecionado em addr.
  // este valor permanecerá guardado mesmo
  // que placa seja desligada da fonte de alimentação
  EEPROM.write(addr, val);
 
  // avança para o próximo endereço indo até o byte 512 da  
  // EEPROM, quando então retorna para o byte 0.
  addr = addr + 1;
  if (addr == 512)
    addr = 0;
 
  delay(100);
}

Este sketch começa com a inclusão da biblioteca EEPROM e da declaração da variável  addr que define o endereço da EPROM a ser gravado. Em seguida é iniciado o loop principal com a realização da leitura do valor presente na entrada analógica 0 divido por 4 que é salvo em val. O valor de val é escrito no endereço da EEPROM indicado por addr. Em seguida o endereço é incrementado em uma unidade e se for igual a 512 é zerado. O programa aguarda por 100ms para então repetir indefinidamente o loop principal.

Para ler uma determinada posição de memória, use:

value = EEPROM.read(address);

Onde:

address – posição da memória que será lido, é um inteiro entre 0 e 1023  (UNO);

value -  valor do endereço da EEPROM é um inteiro entre 0 e 255 (um único byte).

Abaixo vemos o exemplo da IDE do arduino para a utilização deste comando, não é necessário alterar o circuito montado para o exemplo anterior visto que este sketch usa apenas o canal serial do arduino através do cabo USB. Faça o upload do sketch abaixo para o arduino e abra o monitor serial, voce verá que os valores salvos na EEPROM pelo sketch anterior serão mostrados na tela do computador.

Código exemplo para o comando EEPROM.read:

/*
 * EEPROM Read
 * Le o valor de cada byte da EEPROM e imprime na tela do computador.
 * o código deste exemplo é de domíno público
 */

#include <EEPROM.h>    // incluir a biblioteca

// inicia lendo apartir do primeiro byte (endereço 0) da EEPROM
int address = 0;    // endereço de escrita na memória
byte value;    // valor lido da EEPROM    

void setup()
{
  Serial.begin(9600);    // inicializa o canal de comunicação serial
}

void loop()
{
  // lê o byte no endereço atual da EEPROM
  value = EEPROM.read(address);
 
// envia o valor lido para o computador pela porta serial
  Serial.print(address);    
  Serial.print("\t");
  Serial.print(value, DEC);
  Serial.println();
 
  // avança para o próximo endereço da EEPROM
  address = address + 1;
 
  // quando atingir o endereço 512 retorna
  // para o endereço 0
  if (address == 512)
    address = 0;
    
  delay(500);
}

Estes exemplos foram feitos para rodar em qualquer versão do arduino, por isso que só foram escritos ou lidos os endereços de 0 a 511 da EEPROM, se voce quiser pode ficar a vontade e tentar alterar o sketch para ler e escrever em todos endereços disponiveis na sua placa.

Agora voce pode estar se perguntando: 

“Existe alguma forma de armazenar um valor maior que 255 na EEPROM?”

A resposta é sim e é algo fácil de se fazer, usando os comandos para a conversão de valores de 16 ou de 32 bits em bytes.

loByte = highByte(val);

hiByte = lowByte(val);

Onde:

val - qualquer tipo de variavel

loByte - byte com a parte mais baixa de val

hiByte - byte com a parte mais alta de val

Vamos agora alterar o primeiro programa de forma a salvarmos os valores lidos da entrada analógica sem ter dividir o valor por 4 de forma a não perder a resolução da medida.

/*

 * Exemplo EEPROM Write
 * Armazena valores lidos na entrada analógica na EEPROM.
 * Estes valores permanecerão guardados mesmo que a placa
 *  seja desligada e podem ser recuperados posteriormente pelo próximo  sketch
 */

#include <EEPROM.h> // incluir a biblioteca
int addr = 0;    // endereço de escrita na memória

void setup()
{
}

void loop()
{
  // lê o valor na entrada analógica e guarda em val
  int val = analogRead(0);
 
  // divide val que é um inteiro de 16 bits em dois bytes
  byte hiByte = highByte(val);
  byte loByte = lowByte(val);

  // escreve o byte mais significativo de  val na EEPROM no endereço selecionado em addr
  EEPROM.write(addr, hiByte);

 // escreve o byte menos significativo de  val na EEPROM no endereço selecionado em addr+1.
  EEPROM.write(addr+1, loByte);
    
  // avança para o próximo endereço pulando de 2 em 2, pois estamos armazenando
  // valores com dois bytes cada até alcançar o byte 512 da  
  // EEPROM, quando então retorna para o byte 0.
  addr = addr + 2;
  if (addr == 512)
    addr = 0;
 
  delay(100);
}

O código anterior divide o valor lido na entrada analógica em dois bytes que são armazenados em dois endereços consecutivos da EEPROM.

Agora devemos alterar o segundo sketch para poder recuperar os valores salvos na EEPROM, para isso usaremos a função word que converte dois bytes em um inteiro de 16bits. A sintaxe deste comando é mostrada abaixo.

value  = word(x)
value  = word(h, l)

Onde:

value - uma word

x -  uma variável de qualquer tipo

h -  a parte alta de uma word

l -  a parte baixa de uma word

/*
 * EEPROM Read
 * Le o valor de cada byte da EEPROM e imprime na tela do computador.
 * o código deste exemplo é de domíno público
 */

#include <EEPROM.h>    // incluir a biblioteca

// inicia lendo apartir do primeiro byte (endereço 0) da EEPROM
int address = 0;    // endereço de escrita na memória
byte value;    // valor lido da EEPROM    

void setup()
{
  Serial.begin(9600);    // inicializa o canal de comunicação serial
}

void loop()
{
  // lê o byte no endereço atual da EEPROM
  byte hiByte = EEPROM.read(address);
  byte lowByte = EEPROM.read(address +1);
  value  = word(hiByte, lowByte);

  // envia o valor lido para o computador pela porta serial
  Serial.print(address);    
  Serial.print("\t");
  Serial.print(value, DEC);
  Serial.println();
 
  // avança para o próximo endereço da EEPROM
  address = address + 2;
 
  // quando atingir o endereço 512 retorna
  // para o endereço 0
  if (address == 512)
    address = 0;
    
  delay(500);
}

Para a utilização da EEPROM, é aconselhável sempre fazer um mapa das variáveis que estão sendo guardadas e os seus respectivos endereços, para assegurar que nenhum endereço seja usado por mais de uma variavel, e que os valores de bytes múltiplos não sobresecrevam outras informações.

É isso, a EEPROM é um recurso muito útil e fácil de usar no arduino, porém relativamente pouco utilizado.

Referências:

http://arduino.cc/en/Reference/EEPROM

http://arduino.cc/en/Reference/EEPROMRead

http://arduino.cc/en/Reference/EEPROMWrite

http://arduino.cc/en/Reference/LowByte

http://arduino.cc/en/Reference/HighByte

http://arduino.cc/en/Reference/WordCast

Margolis, Michael. Arduino Cookbook. Editora O’REILLY, 2011. Capítulo 18.