A EEPROM interna do Arduino


Acessando a memória EEPROM interna do Arduino

Os Arduinos que se utilizam da CPU ATMEGA328 possuem uma memória EEPROM interna de 1Kbyte, acessados byte a byte. Esta memória é a posição perfeita pra armazenarmos valores de configuração, calibração ou outros itens semelhantes. Suporta até 100.000 ciclos de escrita/apagamento, o que normalmente atende aos requisitos de um sistema de controle microprocessado. De qualquer forma não vale a pena utilizar esta memória nas situações onde são necessários muitos acesso de escrita. Se isto estiver ocorrendo no seu programa, avalie a possibilidade de utilizar a memória RAM e uma bateria para manter o sistema sempre energizado. Outro ponto importante a ser levado em consideração quando decidir utilizar a memória EEPROM interna é que cada byte gasta 3.3 ms para ser armazenado.

O ambiente Arduino disponibiliza uma biblioteca que facilita em muito a interação com a EEPROM interna da CPU.


A biblioteca EEPROM

Esta biblioteca possui a seguinte API:

EEPROM.read(endereço)

Retorna o byte na posição indicada por endereço. Veja o trecho de código a seguir:


#include <EEPROM.h>

void setup()
{
byte value= EEPROM.read(0); //le o byte na posição zero
}

EEPROM.write(endereço, valor)

escreve o byte valor no endereço endereço. Não retorna nada.


#include <EEPROM.h>

void setup()
{
  for (int i = 0; i < 255; i++) //preenche as 255 posições iniciais com zero
    EEPROM.write(i, 0);
}

void loop()
{
}

EEPROM.update(endereço, valor)

Similar a EEPROM.write, mas só escreve o valor no endereço se o valor a ser armazenado diferir do valor já existente. Utilizando esta função aumentamos a vida útil da memória por diminuir os acessos de escrita.


#include <EEPROM.h>

void setup()
{
  for (int i = 0; i < 255; i++) //preenche as 255 posições iniciais com zero
    EEPROM.update(i, 0);        // se a posição estiver com zero, não grava 
}

void loop()
{
}

As funções que vimos até o momento operam com bytes na escrita e leitura. Mas muitas vezes precisamos de ler ou escrever tipos de dados mais complexos, como ponto flutuante , inteiros, structs e outros. A biblioteca EEPROM possui uma forma muito interessante de implementar a leitura e gravação destes tipos mais complexos:

EEPROM.get(endereço, dado)

dado é uma referência para onde será transferido o valor lido na EEPROM. Endereço é o endereço inicial da variável armazenada.

É importante levar sempre em consideração o número de bytes que cada tipo de dado irá ocupar na memória, para não sobrescrever partes de cada variável.

#include <EEPROM.h>



void setup(){

  float fVar = 0.00;   // variável para onde será lida Variable to store data read from EEPROM.

  EEPROM.get( 0, fVar ); //le o float iniciando na posição zero
  
}

void loop(){ }

#include <EEPROM.h>

struct stdataInicio
    {
    byte bDia;
    byte bmes;
    int  nAno;
    };


void setup(){

  struct stDataInicio dataInicio;   // variável para onde será lida a read from EEPROM.

  EEPROM.get( 10, dataInicio ); //transfere para a variável dataInicio os valores armazenados a partir do endereço 10 
  
}

void loop(){  }

EEPROM.put(endereço, dado)

Escreve no endereço endereço da EEPROM o dado especificado por dado. O dado pode ser um tipo primitivo ou uma estrutura.

Diferente do método EEPROM.write, a escrita só ocorre caso os dados a serem armazenados forem diferentes dos dados já gravados na EEPROM, ou seja, tem um comportamento idêntico ao update.


#include <EEPROM.h>

struct stdataInicio
    {
    byte bDia;
    byte bmes;
    int  nAno;
    };

void setup() {
  struct stDataInicio dataInicio;   // variável que será escrita

  dataInicio.bDia= 02;
  dataInicio.bMes= 10;
  dataInicio.nAno= 2017;


   EEPROM.put(10,dataInicio);  //grava a partir do endereço 10 os dados em dataInicio
  
}

void loop() {}

O operador EEPROM[]

Este operador permite o acesso de leitura e escrita na EEPROM interna como estivéssemos operando sobre um vetor. Opera somente sobre um byte por vez. Observe o exemplo a seguir:


#include <EEPROM.h>

void setup(){

unsigned char bValor;

bValor = EEPROM[ 10 ]; // transfere o valor na posição 10 da EEPROM para a variável bValor

++bValor;

EEPROM[ 10 ] = bValor; //armazena na posição 10 o valor incrementado

}

void loop(){ }

Experimentando na prática

O programa “eepromInterna.ino” grava um ponto flutuante, um inteiro e uma string, organizados segundo uma estrutura em “C” , na memoria EEPROM interna do Arduino. Depois , lê estes dados para outra variável, e imprime o resultado na tela. A sua tela deve ficar com algo simular a apresentada a seguir. Neste experimentos reiniciamos (reset) o Arduino por 3 vezes.

Resultado do programa eepromInterna.ino

Para obter este programa acesse a página https://cadernodelaboratorio.com.br/scripts-softwares-e-arquivos-de-configuracao/ , e transfira o programa pack171004.tar.gz.

Até a próxima!

Deixe um comentário