Arduino: Recuperar datos guardados en varios bytes de la memoria EEPROM

Seguimos con la memoria EEPROM de Arduino, su memoria no volátil: vimos cómo leer y escribir de forma básica, y vimos cómo guardar un dato mayor de un byte recortándolo y almacenándolo repartido en varias posiciones de memoria. Pero lo que no vimos en ese apartado fue ¿cómo lo recuperamos?

Pues básicamente vamos a hacer lo mismo que en el ejemplo anterior pero al revés, volviendo a tirar de opreaciones de desplazamiento de bit. Declararemos una variable con el tipo de lo que queremos recuperar y junto a ella otra variable contenedor, leo un byte, lo almaceno en la auxiliar, lo desplazo hacia la izquierda para que sea el más significativo y lo anexo al total con una operación OR, y finalmente limpiamos la variable auxiliar.

Enchurrado en código es similar a esto:

   long Numero = 0;
   //Variable contenedor inicializada a 0
   long Contenedor = 0;

  //recorremos el bucle hacia atrás, al revés que en el ejemplo anterior
   for (int i = sizeof(Numero); i > 0 ; i--){

     //Aquí guardamos en el contenedor
     // un byte de datos
     Contenedor = EEPROM.read(i-1);

     //Desplazamos tantos bits como toque
//en esta iteración del bucle.
//El if es porque en la última iteración
//no habría que desplazar.
     if (i != 1){
     Contenedor = Contenedor  << (8*i);
     }

     //Utilizamos la operación a nivel de bit OR para
     //añadir a nuestro resultado final
     //el valor del byte leído.
     Dato = Dato | Contenedor;

    //Reiniciamos la variable
    //auxiliar para evitar problemas
    //con datos leídos previamente
     Contenedor = 0;
   }

Este ejemplo es limitado, ya que sólo te valdría en caso de que hayas guardado un único valor repartido en bytes, como en el ejemplo anterior. En el futuro veremos cómo usar los métodos get() y put() que simplican el tema.

Como en el ejemplo anterior es necesario conocerse las operaciones de desplazamiento de bit y las operaciones lógicas a nivel de bit.

Si tienes interés en Arduino a mi me ha servido de ayuda la wiki de Arduinobot y su manual en PDF.

Arduino: Escribir varios bytes en la memoria EEPROM

Pensaba hablar sobre las finales de la NBA, pero creo que me voy a esperar a que acaben y voy a volver con el tema del Arduino y seguir con la EEPROM de la que ya hablamos en otro artículo.

Si en el primer artículo veíamos cómo escribir en esta memoria no volátil, en este veremos otro punto ¿Cómo guardamos información mayor de un byte? En ese caso tenemos que distribuirla entre varios ¿recuerdas el tema de los punteros en C? Pues es similar.

En el ejemplo vamos a guardar un entero largo, de 32 bits. Empezaremos por volcarlo a una variable auxiliar que servirá de contenedor del valor original, y declararemos también una variable byte para la operación de escritura. Lo que haremos será ir guardando en cada byte de la EEPROM el byte más significativo de nuestra variable auxiliar y luego aplico un desplazamiento de 8 bits hacia la izquierda a la variable auxiliar para que el siguiente byte pase a ser el más significativo. Todo esto dentro de un bucle for que repita la operación tantas veces como bytes tenga nuestra variable. En el código explicado paso a paso lo verás mejor:

   long Numero = 666777999;   

   //Usamos el contenedor para no perder el dato.
   long Contenedor = Numero;

   //Definimos una variable byte
   //para trocear el dato largo
   byte X;

   //Bucle: recorremos tantas veces como
   //bytes tiene el tipo de dato
   //que queremos almacenar
   for (int i = 0; i < sizeof(Numero); i++){
     //Guardamos la fracción más
     //a la izquierda. Es el byte
     //más significativo
     X = highByte(Contenedor);
     EEPROM.write(i, X);
     //Aplicamos un desplazamiento
     //de un byte (8 bits)
     // hacia la izquierda.
     //De esta forma en cada iteración
     //la siguiente porción pasa a ser
     //el byte más significativo
     Contenedor = Contenedor << 8;
   }

Es importante tener claras las operaciones de desplazamiento de bit en Arduino para trabajar con múltiples bytes. Próximamente hablaré de esos temas (operaciones a nivel de bit y cómo recuperar estos datos escritos).

Arduino básico: escribir y leer datos de la memoria EEPROM

Si bien el grueso de la memoria de un Arduino está representado por la memoria volátil, que se borra una vez se corta la alimentación o resetea, estas placas poseen también una memoria no volátil donde almacenar permanentemente una serie de datos: La memoria EEPROM (Electrically Erasable Programmable Read-Only Memory) . Según el modelo varía entre los 512 bytes y los 4KB.

Para trabajar con esta memoria necesitamos hacer uso de la librería EEPROM, que viene junto al IDE oficial de Arduino. Posee un método para escribir, write(), y otro para leer, read(). Tanto para leer como para escribir se trabaja por direcciones y byte a byte. Esto implica que enl modelo de 512 bytes tendías posiciones de 0 a 511 y en cada una de ellas podrías guardar un valor comprendido entre 0 y 255. El primer ejemplo que vamos a ver es muy simple: vamos a escribir el mismo valor en todas las posiciones de la memoria y luego a leerlo. Una chorrada, pero muy didáctico:

 

//Se incluye la librería EEPROM
#include <EEPROM.h>
//Creamos una variable para el valor de la posición de memoria
//en la que se va a almacenar el dato.
int Direccion = 0;

//Creamos una variable para leer los valores de la memoria EEPROM
byte valor;

void setup()
{
  Serial.begin(9600);
  // La "B" indica que pasamos los datos
  // en binario (en decimal sería un 18)
  byte Informacion = B10010;
  
  //para el ejemplo nos pateamos
  //512 bytes.
   for (int i = 0; i < 512; i++){
     EEPROM.write(i, i);
   }
}

void loop()
{
  while(Direccion < 512){
    valor = EEPROM.read(Direccion);  
    Serial.print("En la dirección ");
    Serial.print(Direccion);
    Serial.print(" almacenamos el valor: ");
    // DEC para mostrar el resultado en decimal
    Serial.print(valor, DEC);
    delay(100);
    Direccion++;
  }
}

Más adelante seguiremos viendo otros ejemplos de programación con el IDE de Arduino.