Os imaginis estar haciendo un experimento con Arduino por horas guardando

variables y, de repente ste se apaga? Qu pasa con todas las variables que
se han ido almacenando? Perdemos toda la informacin? En este tutorial os
explicaremos cmo gestionar la memoria EEPROM de Arduino.

EEPROM?
La EEPROM (de las siglas en ingls Electrically Erasable Programmable Read-Only
Memory) es un tipo de memoria que no necesita energa para mantenerse (por ello la llaman
memoria no voltil), y es, por decirlo de alguna manera, como un disco duro, dado que la
podemos usar para almacenar datos incluso cuando nuestra placa est apagada.
Cunta memoria EEPROM tiene mi placa?
Depende de la placa con la que ests programando hay ms o menos memoria EEPROM, lo
que te va a permitir almacenar ms o menos variables. Veamos algunas de las placas
Arduino:

Arduino Uno Rev3: 1 KB (1024 bytes en placas basadas en ATmega328).

Arduino Leonardo: 1 KB. (1024 bytes en placas basadas en ATmega32U4).

Arduino Yn: 1 KB. (1024 bytes en placas basadas en ATmega32U4).

Arduino Mega: 4 KB. 4 KB (4096 bytes en placas basadas en ATmega1280 y

ATmega2560).

Uso de la librera EEPROM.h

Nuestro IDE de Arduino viene con una librera que nos permite gestionar la memoria
EEPROM de nuestra placa llamada EEPROM.h y que incluye dos funciones bsicamente:

uint8_t read(int): Lee un byte de una direccin especfica de la memoria

EEPROM.

void write(int, uint8_t): Escribe un byte a una direccin especfica de la memoria

EEPROM.

Veamos un ejemplo que nos muestre qu tiene la EEPROM de nuestra placa Arduino:
Vamos a utilizar dos sketch diferentes para comprobar que, una vez apagamos y
encendemos el Arduino para cargar el segundo sketch, la temperatura sigue almacenada.

Necesito ms EEPROM

Est bien, la cantidad de EEPROM de las placas puede que no nos sea suficiente para
almacenarlo todo si ese es nuestro caso se puede conseguir poner una memoria externa.
La comunicacin entre una placa Arduino y una EEPROM se realiza va bus I2C. En la
pgina oficial de Arduino tenis un tutorial que os explica a cmo conectar una externa.
********************************************************

Tipos de memoria en Arduino: Flash, SRAM y EEPROM

Existen tres tipos de memoria en los microcontroladores utilizados por las placas Arduino
(ATmega168, ATmega328, ATmega1280, etc.): memoria Flash, memoria SRAM y memoria
EEPROM. A continuacin indicamos las diferencias de cada una de ellas y el uso que
Arduino puede darles.

Tipos de memoria en Arduino: Flash, SRAM y EEPROM

Existen tres tipos de memoria en los microcontroladores utilizados por las placas Arduino
(ATmega168, ATmega328, ATmega1280, etc.): memoria Flash, memoria SRAM y memoria
EEPROM. A continuacin indicamos las diferencias de cada una de ellas y el uso que
Arduino puede darles.

Memoria Flash (espacio del programa) en Arduino

La memoria Flash (espacio del programa) es donde Arduino almacena el sketch. Un

sketch es el nombre que usa Arduino para un programa. Es la unidad de cdigo que se sube
y ejecuta en la placa Arduino. Esta memoria es no voltil, si Arduino deja de ser alimentado
elctricamente los datos que haya en esta memoria permanecern.
El tamao de la memoria Flash de Arduino puede variar dependiendo del microcontrolador,
aunque no es muy grande. Por ejemplo, para el chip ATmega168 el tamao de la memoria
Flash es de 16 kilobytes, de los cuales 2 kilobytes son utilizados por el bootloader. Para el
caso del microcontrolador ATmega328 (como el que incorpora Arduino UNO) el tamao de
la memoria Flash es de 32KB, de los cuales el bootloader usa 0,5KB. Por lo que debemos
desarrollar los programas de forma muy optimizada, usando los tipos de variables que
menos memoria requieran, en la medida de lo posible. Tambin debemos optimizar el
cdigo fuente de la aplicacin para no repetir lneas de cdigo.

Memoria SRAM (Static Random Access Memory memoria esttica de

acceso aleatorio) en Arduino

La memoria SRAM (Static Random Access Memory memoria esttica de acceso

aleatorio) es de tipo voltil, es el espacio donde los sketches (programas) almacenan y
manipulan variables al ejecutarse. La informacin guardada en esta memoria ser eliminada
cuando Arduino pierda la alimentacin. Esta memoria es de uso exclusivo para el programa
en ejecucin.
La memoria SRAM de Arduino es muy pequea, por lo que debemos optimizar nuestros
programas al mximo y no abusar de variables de tipo char muy grandes. Hay que tener en
cuenta que cada carcter de una variable char utiliza un byte. En el microcontrolador
ATmega 168 el tamao de la memoria SRAM es de 1024 bytes, para el caso de un chip
ATmega328 (como el que incorpora Arduino UNO) el tamao es de 2KB (2048 bytes).
Si la SRAM se queda sin espacio, el programa de Arduino fallar de forma imprevista,
aunque se compile y se suba a Arduino correctamente la aplicacin no se ejecutar o se
ejecutara de manera extraa.
A continuacin mostramos algunos consejos para optimizar los programas y evitar que
consuman toda la memoria SRAM disponible:

Si el programa se comunica con una aplicacin ejecutndose en un

ordenador, se puede intentar trasladar los datos o clculos al ordenador,
reduciendo la carga en el Arduino.

Si el programa usa tablas de referencia u otros arreglos de gran tamao,

es recomendable utilizar el tipo de datos ms pequeo que se pueda
para almacenar estos datos; por ejemplo, un int utliza 2 bytes, mientras
que un byte utiliza solo 1 byte (pero puede almacenar un rango menor
de datos).

Si no se necesita modificar las cadenas o datos mientras el programa se

ejecuta, se pueden almacenar en la memoria Flah (de programa) en vez
de la SRAM; para esto, hay que utilizar el keyword PROGMEM.

Memoria EEPROM en Arduino

EEPROM es un espacio de memoria que puede ser utilizado por los programadores para
almacenar informacin a largo plazo. Este tipo de memoria es no voltil, por lo que los
datos guardados en ella permanecern aunque Arduino pierda la alimentacin. Esta
memoria puede ser usada para guardar valores si es necesario. Ms adelante explicaremos
cmo guardar y leer valores de esta memoria.

El tamao de la EEPROM para un chip ATmega128 es de 512 bytes, para un chip

ATmega328 es de 1KB (1024 bytes). Hay que tener en cuenta que el tamao de la memoria
EEPROM interna de Arduino es "pequeo" pero Arduino admite aadir mdulos de
memoria EEPROM externa de mayor tamao.

Escribir y leer en la memoria EEPROM de Arduino

A continuacin mostramos un ejemplo de escritura y otro de lectura en la memoria
EEPROM interna de Arduino UNO. Para el ejemplo necesitaremos conectar Arduino al PC
y disponer del IDE de desarrollo de Arduino, todo ello lo explicamos en el siguiente
artculo paso a paso:
Escribir en la memoria EEPROM de Arduino

A continuacin mostramos un sencillo ejemplo para escribir 1024 valores en la memoria

EEPROM de Arduino UNO:
#include
void setup()
{
//usamos un bucle que se ejecutar 1024 veces
//en la posicin i de la memoria EEPROM
//guardaremos el valor de i
for (int i = 0; i < 1024; i++)
if (i <= 255)
{
EEPROM.write(i, i);
}
else
{
EEPROM.write(i, i - 255);
}
}
void loop()
{
}

El ejemplo anterior se ejecutar una sola vez (no hemos usado "loop"). El bucle for se
ejecutar 1024 veces y guardar en cada posicin de la memoria el valor actual de i,
teniendo en cuenta que el valor mximo que se puede guardar en una posicin de memoria
es de 255, por ello cuando llegamos a 255 guardamos el valor de i menos 255.

Leer valores de la memoria EEPROM de Arduino

A continuacin mostramos un sencillo ejemplo que lee y enva por el puerto serie de
Arduino todos los valores guardados en la memoria EEPROM (de un Arduino UNO, que
tiene 1024 valores):
#include
int posicionActual = 0;
int valorLeido;
void setup()
{
Serial.begin(9600);
}
void loop()
{
//obtenemos el valor de la posicin "posicionActual" de la EEPROM
valorLeido = EEPROM.read(posicionActual);
//enviamos por el puerto serie la posicin leda
Serial.print(posicionActual);
Serial.print("
");
//enviamos por el puerto serie el valor ledo de la posicin
Serial.print(valorLeido);
Serial.println();
//incrementamos la posicin actual, puesto que el programa se
//ejecuta indefinidamente leeremos todas las posiciones de memoria
EEPROM
posicionActual = posicionActual + 1;
//puesto que el programa se ejecuta indefinidamente
//para evitar que d error cuando nos excedamos de la ltima posicin
//de la EEPROM, cuando lleguemos al mximo 1024 empezaremos de nuevo
if (posicionActual == 1024)
posicionActual = 0;
//esperamos un segundo
delay(1000);
}

En ambos casos usamos la librera EEPROM.h, necesaria para acceso a la memoria

EEPROM de Arduino.

Cmo ampliar las posibilidades de almacenamiento de

Arduino
Cmo hemos indicado, las diferentes memorias de los chips de Arduino (Flash, SRAM y
EEPROM) son demasiado limitadas para determinadas funcionalidades. Por ejemplo, si

conectamos una cmara de fotos o de vdeo a Arduino y queremos guardar capturas de

fotos o vdeos no nos servirn estas memorias.

Ampliar con memoria EEPROM externa

Una posibilidad para ampliar la capacidad de memoria de Arduino es usar memoria

EEPROM externa, adquiriendo este tipo de memoria (que no es muy cara) podremos
disponer de ms memoria EEPROM para nuestro programa. Este tipo de memoria es no
voltil. Por ejemplo, una EEPROM 24LC64 puede costar unos 4 euros y tiene 64K de
tamao:

Obviamente, este tipo de memorias EEPROM no tienen un gran tamao, por ello, no sern
tiles para proyectos con grandes requerimientos de espacio.
Por supuesto existen libreras para trabajar con estas tarjetas en Arduino.

Ampliar memoria con SD Card

Si vamos a desarrollar un proyecto hardware con Arduino que tenga grandes requerimientos
de espacio (Megas, Gigas), por ejemplo si queremos trabajar con audio, vdeo, fotos,
almacenamiento de datos, etc., la mejor opcin es utilizar algn tipo de medio de
almacenamiento removible. La mayora de los microcontroladores tienen una capacidad de
memoria interna extremadamente limitada, como ya hemos comentado.

Para conseguir este almacenamiento extra utilizaremos las tarjetas flash (SD, microSD).
Ests tarjetas permiten almacenar varios GBytes de datos en un espacio muy reducido.
En la imagen mostramos un mdulo SD Card para Arduino, acoplable directamente:

En este otro ejemplo mostramos una SD Card para Arduino que tenemos que conectar
manualmente, como se muestra en la imagen:

Por supuesto existen libreras para trabajar con estas tarjetas en Arduino.
***************************************************************

Cmo Usar La Memoria EEPROM De Arduino

Posted on 21 noviembre, 2014 Under Tutoriales de Arduino 9 Comments

Por si todava no lo sabas, te dir que tu Arduino dispone de una memoria EEPROM, es
decir, una memoria no voltil (como la de un disco duro) en la que puedes almacenar datos
sin preocuparte de perderlos cuando le quites la alimentacin a tu Arduino. En este post
aprenders cmo usar la memoria EEPROM de Arduino para reutilizar los datos
importantes, recuperar la configuracin de tu Arduino o incluso pasar datos de un
sketch a otro.
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 lstima ya que, con
unas cuantas lneas de cdigo y por menos de 1kB de aumento en el tamao del sketch,
puedes tener a tu disposicin un recurso realmente interesante.
Utilizar la EEPROM de tu placa es especialmente til a la hora de guardar la
configuracin de tu Arduino (como por ejemplo las direcciones MAC e IP que aprendiste
a usar en este artculo) pero su uso va mucho ms all. Si quieres calibrar un sensor (por
ejemplo una LDR) para fijar sus valores lmite, no tienes por qu utilizar un cdigo que
siempre calibre el sistema al iniciarse (en el setup), puedes implementar un cdigo que
calibre y guarde los datos en la memoria EEPROM y, una vez los hayas guardado,
utilizarlos en otro sketch. Gracias a ello ahorrars espacio en tu microcontrolador y te
asegurars de que esos datos no dependen del da 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 da).

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 ms informacin sobre las caractersticas de las distintas placas de Arduino

puedes hacerlo a travs 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 fcilmente utilizando la librera

EEPROM.h (podrs 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 tendrs desde la
direccin 0 hasta la 999 y podrs utilizar valores de 0 a 255. En caso de que quieras guardar
valores mayores tendrs 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 cmo se hace.

//Se incluye la librera EEPROM

#include <EEPROM.h>
//Se crea una variable con el valor de la posicin 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 informacin a guardar en un byte.
byte Informacion = B11001;// La "B" indica que el formato es binario
//Tambin es posible almacenar la informacin leda a travs de un
//sensor. Hay que tener en cuenta que el valor mximo 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 precisin.
// 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 direccin ");
Serial.print(Direccion);
Serial.print(" se encuentra la informacin: ");
Serial.print(Val1, DEC);// DEC para datos en decimal.
delay(100);

Serial.print("En la direccin ");

Serial.print(Direccion+1);
Serial.print(" se encuentra la informacin: ");
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 ms
significativo y el menos significativo, esto es, el que est ms a la izquierda y
el que est ms a la derecha. Si el elemento que quieres gestionar est
compuesto solamente por un par de bytes, puedes utilizar estas instrucciones
para separar fcilmente 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 informacin.
byte L;
byte H;
//Se almacenan los bytes ms 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);

************************************************************************

Guardando datos en Arduino utilizando la memoria

EEPROM
Los que han utilizado Arduino se habrn dado cuenta que cuando se reinicia el micro
controlador utilizando el botn reset o bien, encendiendo y apagando el Arduino, el
programa que est colocado la memoria se reiniciar y no ser posible utilizar cualquier
dato que se haya tenido antes del reinicio. Si se tiene por ejemplo los datos de un sensor,
todo lo que se haya ledo se perder en el reinicio.
Se dice que la memoria de Arduino, donde se almacena el cdigo es una memoria voltil,
cuyo contenido se borra cuando se interrumpe el flujo elctrico. Sin embargo, Arduino al

igual que muchos otros micro controladores posee una memoria no voltil, con un esacio de
almacenamiento ms reducido que la memoria voltil, pero an as muy til para nuestros
propsitos.
Me estoy refiriendo a la memoria EEPROM (Electrically Erasable Programmable ReadOnly Memory, o ROM programable y borrada elctricamente).
Casi todos los modelos de Arduino tienen una EEPROM disponible, con diferentes
capacidades dependiendo del modelo.

La informacin que se guarde en la memoria EEPROM podr ser recuperada an despus

de reiniciarse el micro controlador.
Para lograr esto Arduino incluye la librera EEPROM que viene junto con Arduino IDE en
el paquete que se descarga directamente desde la pgina oficial de Arduino.
Consta bsicamente de dos mtodos:

read()

write()

Con el mtodo read() se lee los valores que se hayan guardado en determinada posicin de
memoria, mientras que con el mtodo write() se guarda la informacin en las posiciones de
memoria.
Las posiciones de memoria son el equivalentes a casillas donde se guarda la informacin.
La cantidad de casillas disponibles depende del modelo. La cantidad de bytes equivale a
la cantidad de casillas, por lo que un modelo de 512 bytes tendr disponibles 512 casillas
disponibles para guardar datos.
Para escribir datos se utiliza:
write(posicin, valor)
Ejemplo:
#include &lt;EEPROM.h&gt; //Se implementa la librera EEPROM
void setup()
{
for (int i = 0; i &lt; 512; i++)
EEPROM.write(i, i);
}
void loop()
{
}

Para leer los datos se utiliza:

read(posicin)
Ejemplo:
#include &lt;EEPROM.h&gt;
// empieza en el primer byte (direccin 0) de la EEPROM
int direccion = 0;
byte valor;
void setup()
{
Serial.begin(9600);
}

void loop()
{
while (direccin&gt;=0){
// Lee un byte de cada direccion de la EEPROM
valor = EEPROM.read(direccion);
Serial.print(direccion);
Serial.print("t");
Serial.print(valor, DEC);
Serial.println();
// incrementa "direccion" en 1 para avanzar a la siguiente direccin de la
EEPROM
direccion = direccion++;
// Solamente hay 512 bytes de EEPROM, desde 0 hasta 511
// Si estamos en la direccion 512, volvemos a la direccin 0
if (direccion == 512){
direccion = -1;
}
delay(500);
}
}

-------------------------------------------------------------------------------------------------------------

http://www.ajpdsoft.com/modules.php?name=News&file=article&sid=571
http://panamahitek.com/guardando-datos-en-arduino-utilizando-la-memoriaeeprom/
http://www.educachip.com/como-usar-la-memoria-eeprom-de-arduino/
http://www.opiron.com/portfolio/como-gestionar-memoria-eeprom-de-arduino