COMO USAR LA MEMORIA EPROM DE ARDUINO

Cómo Usar La Memoria EEPROM De Arduino

21 NOVIEMBRE, 2014 POR ENRIQUE88 COMENTARIOS

Por si todavía no lo sabías, te diré que tu Arduino dispone de una memoria EEPROM, es decir, una memoria no volátil (como la de un disco duro) en la que puedes almacenar datos sin preocuparte de perderlos cuando le quites la alimentación a tu Arduino. En este post aprenderás cómo usar la memoria EEPROM de Arduino para reutilizar los datos importantes, recuperar la configuración de tu Arduino o incluso pasar datos de un sketch a otro.

Haz click para ir a lo que más te interese.

• 1 Tutorial Para Usar La Memoria EEPROM De Arduino
  • 1.1 Capacidad De La Memoria EEPROM De Tu Arduino
  • 1.2 Programando la EEPROM
    • 1.2.1 Utilizando Un Solo Byte
    • 1.2.2 Utilizando Dos Bytes
    • 1.2.3 Utilizando Más Bytes
  • 1.3 Componiendo Bytes
  • 1.4 Información Adicional: Trabajando Con Texto

Tutorial Para Usar La Memoria EEPROM De Arduino

Generalmente la memoria EEPROM de Arduino suele estar bastante desaprovechada. No sé si será por desconocimiento o miedo a la hora de utilizarla pero es una lástima ya que, con unas cuantas líneas de código y por menos de 1kB de aumento en el tamaño del sketch, puedes tener a tu disposición un recurso realmente interesante.

Utilizar la EEPROM de tu placa es especialmente útil a la hora de guardar la configuración de tu Arduino (como por ejemplo las direcciones MAC e IP que aprendiste a usar en este artículo) pero su uso va mucho más allá. Si quieres calibrar un sensor (por ejemplo una LDR) para fijar sus valores límite, no tienes por qué utilizar un código que siempre calibre el sistema al iniciarse (en el setup), puedes implementar un código que calibre y guarde los datos en la memoria EEPROM y, una vez los hayas guardado, utilizarlos en otro sketch. Gracias a ello ahorrarás espacio en tu microcontrolador y te asegurarás de que esos datos no dependen del día o la zona en la que utilices tu sistema (volviendo al ejemplo de la LDR, puedes conseguir, por ejemplo, que si reinicias tu Arduino por la noche, conserve los dato almacenados durante el día).

Capacidad De La Memoria EEPROM De Tu Arduino

Cada modelo de placa posee una EEPROM distinta. Aunque en casi cualquier tipo de proyecto te va a sobrar espacio con independencia de tu Arduino, aquí tienes una lista con las diferentes capacidades de las memorias EEPROM:

Si quieres más información sobre las características de las distintas placas de Arduino puedes hacerlo a través de este link. Debes tener en cuenta que algunas placas (como la Lilypad) tienen varios modelos y la capacidad de sus memorias puede variar.

Programando la EEPROM

Puedes programar la memoria EEPROM de tu Arduino fácilmente utilizando la librería EEPROM.h (podrás encontrarla por defecto en la IDE).

En la memoria de tu Arduino debes trabajar por direcciones y byte a byte tanto para leer como para escribir. Esto significa que para una memoria de 1kB tendrás desde la dirección 0 hasta la 999 y podrás utilizar valores de 0 a 255. En caso de que quieras guardar valores mayores tendrás que dividirlos por bytes.

Utilizando Un Solo Byte

Leer y escribir un solo byte es realmente sencillo. Aquí te dejo un ejemplo para que veas cómo se hace.

/*Uso De La Memoria EEPROM Con Bytes*/

//Se incluye la librería EEPROM
#include <EEPROM.h>

//Se crea una variable con el valor de la posición de memoria
//en la que se va a almacenar el byte.
int Direccion = 0;

//Se crean una variables para leer los valores de la memoria EEPROM
byte Val1;
byte Val2;

void setup()
{
  Serial.begin(9600);
  //Se almacena la información a guardar en un byte.
  byte Informacion = B11001;// La “B” indica que el formato es binario

  //También es posible almacenar la información leída a través de un
  //sensor. Hay que tener en cuenta que el valor máximo de una variable
  //tipo int es de 1023, mientras que el mayor valor que se puede almacenar
  //en un solo byte es 255. Por tanto, se divide el valor resultante entre 4
  //y a la hora de utilizar el valor se vuelve a multiplicar por 4. En el
  //proceso se pierde precisión.
  // need to divide by 4 because analog inputs range from
  int Valor = analogRead(0) / 4;

  //Se almacenan consecutivamente los valores anteriores.
  EEPROM.write(Direccion, Informacion);
  EEPROM.write(Direccion + 1, Valor);
}

void loop()
{
  Val1 = EEPROM.read(Direccion);
  Val2 = EEPROM.read(Direccion + 1);

  Serial.print(“En la dirección “);
  Serial.print(Direccion);
  Serial.print(” se encuentra la información: “);
  Serial.print(Val1, DEC);// DEC para datos en decimal.
  delay(100);
  Serial.print(“En la dirección “);
  Serial.print(Direccion + 1);
  Serial.print(” se encuentra la información: “);
  Serial.print(Val2, DEC);// DEC para datos en decimal.
  delay(100);
}

Utilizando Dos Bytes

El software de Arduino tiene instrucciones pensadas para obtener el byte más significativo y el menos significativo, esto es, el que está más a la izquierda y el que está más a la derecha. Si el elemento que quieres gestionar está compuesto solamente por un par de bytes, puedes utilizar estas instrucciones para separar fácilmente tu dato en dos bytes y almacenarlos de forma independiente.

//Se tiene una variable compuesta por 2 bytes, por ejemplo un tipo int.
int A = 800;

//Se crean dos variables de tipo byte para almacenar la información.
byte L;
byte H;

//Se almacenan los bytes más y menos significativos.
H = highByte(A);
L = lowByte(A);

//Se escriben los bytes en direcciones de memoria contiguas.
EEPROM.write(Direccion, H);
EEPROM.write(Direccion + 1, L);

Utilizando Más Bytes

Una cosa que no te he dicho en el caso anterior y que seguramente te habrás imaginado es que hay más de una forma posible de separar los datos. Si ya podías usar varios métodos para el caso anterior, imagínate en este.

La forma en la que yo lo suelo hacer es la siguiente:

• Almaceno el dato entero en una variable auxiliar (para no perder el dato original).
• Compruebo el número de bytes que tiene el dato.
• Guardo el byte más significativo en una variable de tipo byte.
• Almaceno el byte en la EEPROM.
• Desplazo ocho bits (un byte) de la variable auxiliar hacia la izquierda, de forma que el segundo byte de esa variable pase a ser el más significativo.
• Repito la operación tantas veces como grande sea el tamaño de la variable inicial.

Sé que así visto puede parecerte un poco lioso pero lo entenderás cuando veas el código.

//Se utiliza un elemento de tipo long (contiene 4 bytes).
long Dato = 123456789;

//Se almacena el dato en una variable auxiliar.
long AuxDato = Dato;

//Se define un byte para almacenar la información en la EEPROM.
byte B;

//La instrucción sizeof() devuelve el número de bytes de una variable
for (int i = 0; i < sizeof(Dato); i++) {
  //Se guarda el byte más significativo
  B = highByte(AuxDato);
  EEPROM.write(i, B);
  //Se desplazan 8 bits hacia la izquierda de modo que los 8 primeros
  //bits se pierden y los 8 siguientes pasan a ser los primeros
  AuxDato = AuxDato & lt; < 8;
}

Componiendo Bytes

Después de separar una variable en bytes para almacenarla en la memoria EEPROM de Arduino surge el problema de volverla a componer para recuperar la información. Si, por ejemplo, tienes una variable de tipo long separada en cuatro bytes dentro de tu EEPROM, al leer esos datos lo que tienes es cuatro bytes, no un long.

De nuevo existen varias formas de solucionar este problema. Te dejo la mía:

• Creo una variable del tipo que quiero recuperar y le asigno el valor 0 (de forma que sé que todos sus bits son 0).
• Defino otra variable igual a la anterior (la variable auxiliar).
• Leo un byte de la memoria EEPROM y lo almaceno en la variable auxiliar utilizando la instrucción OR, con lo que el byte queda almacenado en los ocho bits menos significativos de la variable auxiliar.
• Desplazo los bits de la variable auxiliar hacia la izquierda de modo que queden en la posición que me interesa.
• Realizo una nueva operación OR entre la variable auxiliar y la final.
• Limpio la variable auxiliar y repito el proceso tantas veces como sea necesario.

Con un vistazo rápido al código seguro que lo entiendes mejor.

//Variable que almacenará el resultado final.
long Dato = 0;
//Variable auxiliar (utilizada al mismo tiempo como byte).
long B;

for (int i = sizeof(Dato); i > 0 ; i–) {

  //Se almacena el valor de la EEPROM en los bits menos significativos.
  B = EEPROM.read(i - 1);

  //Se desplazan los bits tantos bytes como sea necesario, teniendo en
  //cuenta que el byte final no debe ser desplazado.
  if (i != 1) {
    B = B & lt; < (8 * i);
  }

  //Se almacena en la variable final el resultado de la operación OR de
  //ambos datos. Al realizar la operación OR con una variable que solo
  //contiene ceros (variable Dato), el resultado es el valor de la otra
  //variable. OR implica => 0+0=0, 0+1=1, 1+0=1, 1+1=1.
  Dato = Dato | B;
  //Se limpia la variable auxiliar para que en las siguientes iteraciones
  //no se cambie el resultado de los otros bytes.
  B = 0;
}

Información Adicional: Trabajando Con Texto

Si los datos que vas a usar en la memoria EEPROM de tu Arduino son caracteres textuales (char o string) necesitas un paso previo antes de guardar la información. Debes gestionar los datos utilizando el código ASCII.

En este código cada letra corresponde a un byte por lo que, una vez separadas las cadenas de caracteres (string) utilizando la librería String.h y conocido el código de cada carácter (aquí te dejo un link con la tabla del código ASCII), no deberías tener ningún problema a la hora de almacenar texto (si tienes alguna duda, deja un comentario).

Ahora ya sabes cómo usar la memoria EEPROM de Arduino… ¿En qué proyecto la vas a utilizar? ¿Se te ocurre alguna mejora del código? ¡Seguro que sí!

Bueno, como siempre me despido recordándote que compartas el contenido si te gustó y animándote a suscribirte al blog.

ARCHIVADA EN: TUTORIALES DE ARDUINOETIQUETADA CON: EEPROM, TUTORIALES DE ARDUINO

Interacciones del lector

Actualmente me dedico, entre otras cosas, a crear contenidos sobre Arduino y otros dispositivos eléctricos. Me encanta todo lo relacionado con el “Universo Maker”. Siempre estoy activo en los comentarios. Si tienes cualquier pregunta, no dudes en dejármela. Intentaré responderte lo antes posible… ¡Un abrazo! smile

Pasos para poner código en los comentarios:

1. Pega el código en el software de Arduino (IDE).
2. Selecciona el segmento que te interese y pulsa el botón secundario del ratón.
3. Pulsa en la opción "Copiar como HTML".
4. Pégalo en el comentario dentro de las etiquetas:

<div class="arduino_code"><code>PEGA AQUÍ TU CÓDIGO</code></div>

DEJA UN COMENTARIO