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.