0

Como guardar informação no Arduino mesmo após desligar?

A resposta a esta pergunta é: Usando a memória EEPROM do nosso Arduino. Mesmo depois de desligar a alimentação, as informações guardadas na EEPROM ficam guardadas para sempre.

Neste tutorial, vamos aprender como usar a memória EEPROM de Arduino de um modo fácil e prático. Em primeiro lugar, vejamos os 3 tipos de memória que o nosso Arduino usa:

FLASH (Memória de programa): É uma memória que não é volátil e que usa a mesma tecnologia dos cartões SD e as memórias USB. Geralmente tem um tamanho entre 32Kb (Arduino UNO) e 512 Kb (Arduino DUE). Nesta memória do Arduino guarda-se o sketch já compilado e tem uma vida útil de uns 100.000 ciclos de escritura aproximadamente.

SRAM (Static Random Access Memory): É uma memória volátil, onde o sketch cria, armazena e manipula variáveis em tempo de execução, mas quando interrompemos a alimentação do Arduino ou o desligamos, os dados que estão armazenados simplesmente desaparecem.

EEPROM (Electrically Erasable Programmable Read-Only Memory): Uma memória não volátil e algo mais lenta que a SRAM que geralmente se usa para armazenar dados de configuração ou calibração para que possam sobreviver a um reset, a uma reprogramação (atualização) do sketch e a um corte na alimentação. Pode-se aceder a esta memória (ler/escrever) fazendo chamadas a partir do próprio sketch.

Pode programar facilmente a memória EEPROM do Arduino, utilizando a livraria EEPROM.h do IDE do Arduino. Tem um método para escrever chamado write(), e outro para ler chamado read(). Tanto para ler como para escrever trabalha-se por direções byte a byte.  Agora vou ensinar a seguir como o fazer.

 

Como escrever um byte no EEPROM

Escrever um byte no EEPROM do Arduino pode-nos servir, por exemplo, para armazenar o estado de um sensor, a posição do relé ou até para armazenar um valor de calibração. Para escrever um byte no EEPROM apenas tem-se que apontar uma direção e marcar um valor:

 
/*Escrever um byte de informação na memória EEPROM*/

#include <EEPROM.h>           //Incluimos a livraria EEPROM
int Direção = 0;           //Direção da memória EEPROM onde vamos armazenar o byte
byte Informação = B01011;   //Valor do byte que vamos a armazenar (É o número decimal 11 convertido a formato byte)
byte ValorEEPROM;            //Variável de tipo byte para ler os valores da memória EEPROM

void setup()
{
Serial.begin(9600);                      //Iniciamos a comunicação de série
EEPROM.write(Direção, Informação);    //Escrevemos na direção 0 o byte B01011
}

void loop()
{
ValorEEPROM = EEPROM.read(Direção);    //Lê-mos a direção 0 de la EEPROM
Serial.println(ValorEEPROM);             //Traçamos o resultado pelo monitor serie
Serial.println(ValorEEPROM, DEC);        //Traçamos o resultado pelo monitor serie em formato decimal
delay(10000);                            //Pausa entre leituras de 10 segundos 
}

Aqui tem ferramentas online para converter de binario a decimal e de decimal a binario.

Como escrever texto na EEPROM

Se necessitarmos de guardar uma cadeia de texto na EEPROM, existem 2 funções muito úteis:

Ler_EEPROM() e Escrever_EEPROM(), aqui tem a continuação:

/*Escrever texto na memória EEPROM*/

#include <EEPROM.h> //Incluímos a livraria EEPROM 
char MinhaCadeiaDeTexto[] = "Olá visitantes"; //Declaramos a cadeia de texto a armazenar 
const int Tamanho_EEPROM = 18; //Especificamos o seu tamanho + 1 
char buffer_EEPROM[Tamanho_EEPROM]; //Criamos uma variável char do tamanho da constante "Tamanho_EEPROM" 

void setup() { 
Serial.begin(9600); //Iniciamos a comunicação serie 
Serial.println("Gravando dados na EEPROM..."); //Avisamos por comunicação serie 
Escrever_EEPROM(MinhaCadeiaDeTexto); //Gravamos a cadeia de texto na EEPROM 
} 

void loop() {
Ler_EEPROM(buffer_EEPROM); //Lemos a cadeia de texto da EEPROM 
Serial.print("Estes são os dados da EEPROM: "); //Avisamos por comunicação serie 
Serial.println(buffer_EEPROM); //Traçamos o string armazenado na EEPROM por comunicação serie 
delay(10000); //Pequena pausa 
} //Função para escrever na EEPROM 

void Escrever_EEPROM(char *UnString){ 
for(int i = 0; i < strlen(UnString); i++){ 
EEPROM.write(i, UnString[i]); 
} 
} 
//Função para ler da EEPROM 
void Ler_EEPROM(char *bufferIn){ 
for(int i = 0; i < Tamanho_EEPROM; i++){ 
bufferIn[i] = EEPROM.read(i); 
} 
}

Função para excluir toda a EEPROM

Para finalizar aqui tem uma simples função para excluir toda a EEPROM, por isso, necessita de começar do zero:

#include <EEPROM.h>
void Excluir_EEPROM() { 

//Limpamos a EEPROM byte a byte 
for (int i = 0 ; i < EEPROM.length() ; i++) { 
EEPROM.write(i, 0);
} 

Serial.println("Memoria EEPROM excluida!"); }

 

Gostaram deste artigo ? Deixem o vosso comentário no formulário a baixo.

Não se esqueçam de fazer like na nossa página no facebook.

Todos os produtos utilizados neste artigo podem ser encontrados na loja de componentes eletrónicos ElectroFun.

Comments

Comentários

Jaime Mota

Deixar uma resposta