Seleccionar página

Cómo Usar La Memoria EEPROM De Arduino

por | Nov 21, 2014 | Tutoriales de Arduino

Memoria EEPROM de Arduino
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.

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.

Memoria EEPROM de las Placas Arduino

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 &lt; 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;&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 &gt; 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;&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 =&gt; 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.

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 en los comentarios. Intentaré responderte lo antes posible… Un abrazo smile

Enrique Romero,

Autor del post.

¿No quieres perderte nada? ¡Suscríbete!

78 Comentarios

  1. Hola a todos, en el siguiente mensaje, intentaré explicar un fallo que se produce en arduino cuando tienes conectada una pantalla LCD.
    Para poner en situación, utilizo Arduino Mega + Ramps 1.4 para manejar una impresora 3D, y al conectar la LCD, cuando modificas el firmware a través del USB y el IDE de arduino, cargas el código y sube correctamente, pero esos cambios no se guardan en la memoria FLASH donde Arduino guarda el Sketch. Cuando haces funcionar la impresora 3D, los valores modificados en el código no se aprecian por que no se han guardado. Se debe entonces acceder al código desde la LCD, modificarlo y guardarlo. De esta forma si se guardan.

    Supongo que al acceder al código desde el USB y tener conectada la LCD se almacenan en la SRAM en lugar de en la FLASH o en la EEPROM y por eso se pierden los cambios.

    Mi pregunta es: ¿Donde guarda arduino el programa(sketch) al cargarlo desde el USB y donde se guarda a través de la LCD?

    Espero que puedan ayudarme y al resto de usuarios que también hemos sufrido de este fallo en la comunicación de arduino y sus memorias.

    Un saludo a todos.

    Responder
    • Buenas Álvaro,

      ¿Has probado a programarlo por ISCP?

      Un saludo, Enrique.

      Responder
  2. hola enrique espero me ayudes compre unos lylipad arduino y de los 4 todos traen el blink grabado menos uno que creo no tiene nada grabado que tengo que hacer para grabar el blink en ese que biene sin memoria?
    mi otro problema es que no soy capaz de subir ningun sketch a los demas lylipad uso un ftdi pero nada tambien probe con un arduino sacando el integrado y nada no se donde fallo
    salu2

    Responder
    • Buenas Tazma,

      Puede ser que no tengan cargado el bootloader (programa que hace que los microcontroladores entiendan el lenguaje Arduino). Puedes quemarlo con un Arduino estándar (es uno de los programas que viene por defecto en la IDE de Arduino).

      Un saludo, Enrique.

      Responder
      • hola para no liarla que tengo que ir a eeprom y grabar ???

        gracias por reesponder

      • Buenas Tazma,

        Para escribir en la EEPROM basta con que hagas el sketch en la IDE de Arduino. Él se encarga del resto. smile

        Un saludo, Enrique.

  3. Hola Enrique

    Las instrucciones para escribir datos en la EEPROM tienen que ir forzosamente en el “Setup Void”? O es posible realizar dicha escritura de datos en el “Void Loop”?

    Responder
    • Puedes ponerlo donde quieras Jesús.

      Incluso puedes hacer un módulo y llamarlo desde el setup o el loop.

      Un saludo, Enrique.

      Responder
      • Muchas gracias Enrique.

        Saludos, feliz año smile

  4. Hola Enrrique primero que nada agradezco que escribes en tu pagina a sido de mucho apoyo para diferentes proyectos, pero en esta búsqueda de resolver mi duda me ha llevado hasta aquí quiero que un led quede encendido durante hora recibiendo un string, con un celular S.O. android ya puedo mandar un string sin problema y declaro mi salida a un led pero después de unos segundos aproximadamente 40 me apaga el LED el arduino, sin que yo diga una instrucción contraria que puedo hacer?

    Responder
    • Buenas Álvaro,

      Parece que el reloj que rige tu programa no funciona como debería. Podría estar relacionado con el cristal de cuarzo o con los registros del timer.

      Si no quieres complicarte mucho lo más sencillo es que aumentes el tiempo de espera para apagar el LED.

      Un saludo, Enrique.

      Responder
      • Ok muchas gracias Enrique probare con otro arduino, ya que necesito estar monitoreando la entrada constantemente.

  5. Como puedo borrar la memoria eeprom de un arduino uno

    Responder
    • Buenas Zkato,

      Vale con que sobre escribas los valores que te interesen.

      Un saludo, Enrique.

      Responder
  6. Hola Enrique. Podría usarse para memorizar el circuito de un laberinto, y luego(en la segunda vuelta) ir directamente hacia la solución evitando dar rodeos? De qué forma podríamos implementar esa idea aprovechando el espacio de la eprom?
    Muchas gracias.

    Responder
    • Buenas Santiago,

      Puedes utilizar un bit para indicar giro a derecha o izquierda y un byte (o los bits que necesites) para indicar el tiempo hasta el siguiente giro. Ésto solo te vale si el vehículo se mueve a velocidad constante, claro.

      Un saludo, Enrique.

      Responder
      • Gracias por la respuesta, un saludo!

      • Gracias a ti por pasarte por el blog, Santiago. smile

  7. Hola Enrique a ver si me podes ayudar, quisiera usar la eeprom para almacenar y modificar datos del web server como por ej: User/password y datos del ethernet shield como ser: IP, GATEWAY, MASK. Podrias darme una mano? Gracias!

    Responder
    • Buenas Fernando,

      Puedes almacenarlos como lo harías con cualquier otro dato. ¿Dónde tienes el fallo exactamente?

      Un saludo, Enrique.

      Responder
  8. hola como hago si quiero guardar en mi arduino uno un valor del sensor de temperatura y además uno de humedad…porque si uso un solo byte pierdo precisión y no sería la idea en mi proyecto.

    Responder
    • Buenas Nahuel,

      Un byte puede almacenar información realmente grande y esos parámetros no suelen requerir demasiada precisión. En cualquier caso, puedes utilizar más de un byte o variables “unsigned” para ganar algo más de precisión en caso de que no vayas a utilizar valores negativos.

      Un saludo, Enrique.

      Responder
  9. Hola Enrique,

    Muy buena información, pero en “Información Adicional: Trabajando Con Texto” no tienes ejemplos explícitos de como hacerlo. Estoy realizando una alarma con datos string que tienen un tamaño de 7 byte:
    ( alarmString = “0”+(String)aHora + “:” + “0” + (String)aMinutos + “: “+ “00”;) y no he podido lograr almacenar estos datos en la eeprom.
    Tu colaboracion seria de gran ayuda!!
    Gracias

    Responder
    • Buenas Guido,

      ¿Has pensado en utilizar código ASCII? A lo mejor así te resulta más sencillo.

      Un saludo, Enrique.

      Responder
  10. Hola Enrique, te hago la misma consulta que michel ferrari, esperamos alguna ayuda, saludos de parte de Dario desde Argentina.

    Responder
    • Buenas Dario,

      Si el valor es demasiado grande para la memoria puedes probar a escribirlo en otros formatos (como hexadecimal).

      Un saludo, Enrique.

      Responder
  11. Enrique :
    Me podrias decir como hago para usar la eepro con una vector ,necesito armar un vector que indique distisntas fallas y la hora en que ocurrieron .quera evitar colocar un sd
    desde ya muchas gracias
    saludos

    Responder
    • Buenas Damian,

      Puedes usar el vector dentro del código estándar y luego almacenarlo.

      Un saludo, Enrique.

      Responder
  12. Hola, una preguntota, Necesito guardar datos que son leídos desde lilypad main board en una memoria sd, pero no encuentro la forma de comunicarlo con el (lc) lector que contiene a esta tarjeta sd. Alguna propuesta?

    Responder
    • Buenas Ana,

      Puede que este link te sirva de utilidad. Va sobre cómo utilizar las tarjetas SD con Arduino.

      Un saludo, Enrique.

      Responder
      • Hola Enrique tengo un problema con el arduin uno me manda error de la libreria de EEPRON que no valido gracias

      • Buenas Juan Carlos,

        Es probable que hayas escrito algo mal :/. Repásalo porque podría ser cualquier tontería. smile

        Un saludo, Enrique.

  13. saludos Enrique. tengo una duda y quiero saber si alguien me puede ayudar. tengo un proyecto con ethernet y tarjetas RFID. con la placa ethernet y un arduino mega 2560. y cuando me paso de los 31.776 byte el programa se me queda como colgado y se me ejecuta una sola funcion y si acaso. y no entiendo por que si tiene 256 KB con 8 KB de uso del bootloader. el programa carga sin error por favor si alguien sabe ayuda.

    Responder
    • Buenas Herwin,

      Puede ser que cuando intentas cargar el programa lo hagas como si estuvieras cargando una placa UNO.

      Un saludo, Enrique.

      Responder
  14. Hola que tal, gracias por tu espacio ya que me ha sido de ayuda en mis proyectos.
    Quiero pedirte una sugerencia de como puedo trabajar con números negativos, he intentado guardar el valor entero “-1” en algún lugar de memoria EEPROM, pero al momento de leerlo me regresa el valor 254 por lo que puedo deducir que utiliza complemento a 1 o a 2(no recuerdo muy bien cual es) para guardar el valor, pero al momento de leerlo de la EEPROM está el problemas.

    Responder
    • Buenas Lalo,

      Puedes utilizar el bit más significativo de tu grupo de bits para establecer si el número que va detrás es positivo o negativo.

      Un saludo, Enrique.

      Responder
  15. Buenas Enrique,
    vuelvo por aquí ya que por navidad dejé algo aparcado el tema.
    He probado a hacerlo con el doble reset y no lo consigo. El problema es que no dispongo de otro arduino por eso no he podido hacer la prueba que me comentas…
    no sé si, antes de probar con otro arduino (tiene que ser el UNO o Nano?) habría alguna otra opción que pudiera probar.
    gracias!

    Responder
    • Por cierto, se me ha olvidado poner.
      He hecho la prueba con un display alfanumérico que tenga un contador (minutos/segundos). Si le quito la alimentación, el contador vuelve a empezar de cero (no guarda el valor). debería seguir contando, ¿no?
      con el tema de la tira me pasa lo mismo.
      gracias!

      Responder
      • Buenas de nuevo,

        No sé si te estoy entendiendo pero si no almacenas la información y luego se la pasas al display, éste “no tiene memoria” y mostrará lo que esté ejecutando Arduino en cada momento.

        Un saludo.

    • Buenas Cris,

      Si no recuerdo mal el problema que tenías era con el bootloader, ¿Verdad? Puedes cargarlo tanto con una UNO como con un Nano (yo suelo utilizar el Nano por comodidad pero es indiferente).

      Si no dispones de otro Arduino, yo pensaría en hacerme de un Nano, los puedes comprar por menos de 5€ y te ahorrará bastante tiempo y bastantes problemas tanto para cargar el bootloader como para hacer pruebas sin alterar el circuito de tu Arduino principal.

      Un saludo, Enrique.

      Responder
  16. Buenas,
    Tengo un Arduino Pro Micro alimentado por una fuente externa, unos pulsadores y una tira de led conectada a ella.
    Para cargar el programa conecto el microusb y descargo el programa.
    Si, toco los pulsadores, la tira de led varía OK.
    Si desconecto el cable microsub y toco los pulsadores, la tira de led varía OK (gracias a la alimentación externa).
    Pero, si quito la alimentación externa del arduino/tira y vuelvo a conectar (un corte de luz, por ejemplo), tengo que volver a conectar el arduino al pc para volver a descargar el programa. La tira de led “se vuelve loca” y no varía y parece que el programa tampoco se ha guardado.

    Al guna idea de por qué sucede ésto?
    gracias!

    Responder
    • Buenas Cris,

      Podría ser un problema del Bootloader, que no cargue bien el programa en tu Arduino. Te lo digo porque alguna vez he tenido problemas de ese tipo al cargar programas desde ISCP.

      Un saludo, Enrique.

      Responder
      • Gracias por tu respuesta Enrique.
        Y…. ¿cómo podría solucionarlo? …Gracias!

      • Buenas de nuevo Cris,

        Yo suelo cargarlo utilizando otro Arduino. Tienes el programa en la misma IDE de Arduino.

        Un saludo, Enrique.

      • Buenas Enrique.
        He estado buscando y he visto esto:
        https://learn.sparkfun.com/tutorials/pro-micro–fio-v3-hookup-guide/troubleshooting-and-faq

        por lo que entiendo, teniendo el arduino conectado por USB al PC, debo conectar un cable entre GND y RST y hacer un “interruptor” (conectarlos durante 8 segundos y desconectarlos).
        Una vez hecho esto, cargar el programa “normal”. con qué programador?
        o hay que hacer algo más? gracias

      • Buenas otra vez, smile

        Hay varias formas de llevarlo a cabo (de hecho llevo bastante tiempo queriendo hacer un post al respecto). Como te he comentado, creo que lo más simple es cargar el bootloader utilizando otro Arduino (yo uso un Nano), cargando el programa que puedes encontrar en la IDE (en la pestaña de Herramientas > Quemar Bootloader).

        Prueba si quieres la opción que tienes ahí y si no pues la que te comento.

        Un saludo, Enrique.

  17. excelente pagina ….. una pregunta de que manera puedo reservar segmentos de memora para poder guardar varias posiciones de diferentes servomotores…?

    Responder
    • Buenas Xavier,

      Puedes utilizar las posiciones de los diferentes bits y asignarles posiciones a grupos de 2, 3, etc.

      Un saludo, Enrique.

      Responder
  18. hola, muy buenos el post ademas que explica bien para entender facilmente, tengo una pregunta he leido en otros post acerca de las veces que se puede escribir sobre la EPROM dicen que son como 100.000 veces, acerca de esto en el primer codigo vas a estar sensando continuamente lo cual significa que se va a estar reescribiendo el valor del sensor o estoy mal? necesito mas acerca de este tema puedes guiarme?? Gracias

    Responder
    • Buenas Nelson,

      La verdad es que no he entendido muy bien la pregunta uneasy

      Un saludo, Enrique.

      Responder
  19. muy buen post me a servido de mucho pero tengo una duda que no e podido resolver. como se cuantos espacion de la memoria necesito para guardar un numero que puede ir desde cero hasta 9,999,999, o de 500 hasta 7000. ojala me puedas ayudar gracias.

    Responder
    • Buenas Iván,

      Cualquiera de esos números te cabe en 24 bits. Si quieres saber exactamente el valor que tendrá de forma rápida, puedes utilizar conversores online de decimal a binario.

      Un saludo, Enrique.

      Responder
  20. hola buenas bigsmile tengo una duda fijate que estoy trabajando en un proyecto para graduacion y me eh puesto a hacer una persiana que suba con un servo cuando la luz en una LDR sea poca… y cuando sea mas baje la persiana…
    mi pregunta es que no hayo como meter la LDR… si me podrias ayudar
    y tambien que pensando que lo que haria es escribir en la eeprom luego leer y depende de el estado luego volveria a escribir para ver el estado de la persiana. entonces la EEPROM. en pocas palabras me terminaria la eeprom?? es otra pregunta :v gracias de ante mano si me podrias ayudar

    Responder
    • Buenas Ezequiel,

      Para incorporar las LDR a tu proyecto te ayudará echarle una ojeada a este otro post.

      Respecto a la EEPROM, seguramente no necesites utilizarla en tu proyecto si tu Arduino va a estar siempre encendido y, en cualquier caso, al escribir en la EEPROM puedes hacerlo en la misma zona de memoria que estabas utilizando, es decir, puedes sobreescribir los datos (ya que lo único que te interesa es el último estado de la persiana).

      Un saludo, Enrique.

      Responder
  21. muy bien todo .
    tengo una duda no se si me puedas ayudar – ojala si.. estoy haciendo un cuenta kilometros la cuestion es que solo me es necesario guardas los kilometros recorridos hasta un instante antes de que se corte la corriente al arduino . ¿como puedo hacer para solo guardar el ultimo dato y sobreescribirlo en el anterior?

    Responder
    • Buenas,

      Puedes guardar los datos en memoria volátil mientras se está ejecutando el programa e ir pasándolos a la EEPROM (ir actualizándolos) cada cierto tiempo.

      Un saludo, Enrique.

      Responder
  22. Hola, amigo muy buen tutorial la verdad me esta ayudando mucho pero tengo muchisimas dudas que no se si tu me podrias ayudar a solucionar, bueno pues son las siguientes, en la escuela me dejaron realizar un sistema minimo con el micro 8051 utilizando el arduino (mega en este caso) para pode accesar a la memoria Ram y EEprom del sistema ya sea para leer datos o escribir en las diferentes direcciones de estas, mi problema es que no se de que forma debo utilizar los datos o cual sera la forma en este caso para leer/escribir, de antemano muchas gracias!!!

    Responder
    • Buenas,

      Puedes hacerte una mejor idea del tratamiento de los datos echándole una ojeada a las librerías.

      Un saludo, Enrique.

      Responder
  23. Hola Enrique, muy buen post tiene cosas interesantes, gracias por compartir. Tengo un problema con la EEPROM del arduino uno, he almacenado los valores máximos y mínimos de temperatura, estoy reescribiendo en la misma posición los valores (por un tiempo funcionaba perfectamente), pero últimamente se han visto afectados. Mi pregunta es cuando reescribo en la EEPROM debo limpiarla (clear) o sólo escribir el nuevo valor?

    Gracias de antemano

    PD: He reescrito el valor sin limpiar la EEPROM y los valores fluctúan entre 15 y 35

    Responder
    • Buenas Jhon,

      La verdad es que me parece un poco raro. Nunca he tenido ese problema. En principio, con sobreescribirlos bastaría, pero puede ser que escribas valores que no rellenen todos los bits que estás leyendo y eso produzca las variaciones. Prueba limpiando la memoria y me cuentas.

      Un saludo, Enrique.

      Responder
  24. Hola buenas, gracias por tomarte el tiempo en explicar esto de la memoria eeprom, pero me surgieron dos dudas, una de ellas, se puede volver a guardar un dato en el mismo espacio? (la memoria en ese caso seria ilimitada?). Otra duda, si solo se pueden guardar valores entre 0 y 255, Si tengo una varia tipo int que puede llegar a un máximo de 3000, puedo dividirla por 100 y despues guardarla?, y al momento de leerla solo la multiplico por 100 para obtener el valor.

    Un saludo desde Valdivia/Chile. Gracias

    Responder
    • Buenas Víctor,

      Si almacenas información en el mismo espacio la sobrescribes, perdiendo lo que tenías inicialmente.

      Si tienes un valor demasiado grande como para almacenarlo, puedes utilizar esa técnica. Sin embargo, estarás perdiendo resolución y no valdría para almacenar, por ejemplo, texto.

      Un saludo, Enrique.

      Responder
  25. Hola Enrique.
    Comentarte que tienes una pequeña errata en la explicación.
    Una variable de tipo “int” no tiene un rango de 0 a 1024 valores como dices tú, si no que tiene un rango de 0 a 4294967296 valores. Esto se produce porque no es 255 x 4, sino 2 ^ 32 (que sería 255 ^ 4).
    Cabe añadir que el último bit se utiliza para indicar el signo, con lo cuál, en rango efectivo de una variable int va desde -4294967298 a 2147483647.
    siendo el bit más significativo, el indicador del signo

    Responder
    • Carlos, en el texto aludido: “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 ” parece obvio que se refiere a la precisión del ADC ligado a la entrada analógica para la medida del valor entregado por el sensor.
      El valor maximo del anterior adc de 10 bits todos sabemos que es 1023 o 3FFH tambien 11 1111 1111B que corresponden a 1024 intervalos de digitalización aludidos en el comentario.
      Saludos y felicidades por el blog Enrique.

      Responder
  26. Hola Enrique, sabes que tu post casi me sirve a la perfeccion…y digo casi porque se distingue un poco de lo que yo quiero hacer. Yo necesito escribir en la EEPROM dos variables de tipo int pero en el VOID LOOP, y luego de un apagado retomarlas ahi tambien. Son dos valores, maximo y minimo de temperatura que le doy con un teclado matricial al Arduino.
    Mi pregunta es, puedo leer y escribir en el VOID LOOP a la vez?, y se que esto es importante porque la memoria EEPROM no tiene que ser leida mas que lo necesario, sino la pierdo como sabras. Y si es que puedo, me indicas aproximadamente como seria o donde puedo encontrar info.
    Muchas gracias. Sos muy solidario compartiendo esto.

    Responder
    • Buenas,

      Puedes leer y escribir secuencialmente, es decir, primero lees y si no es la información que te interesa la puedes reescribir.

      Un saludo, Enrique.

      PD: Si no te importa, envíame el código al correo. Es demasiado largo para aceptarlo como comentario :S

      Responder
  27. Estimado Enrique
    Te agradezco que compartas tus conocimientos sobre esta plataforma para quienes estamos iniciándonos a explorarlo. Yo ando con un proyecto en mente, quiero hacer un despertador. Mi problema es guardar la hora en la que se va activar el buzz. ya que debo guardar tanto la hora, min y seg.
    Se me está haciendo algo complicado, si pudieras orientarme un poco te lo agradecerìa.
    de antemano gracias por tu tiempo

    Saludos

    Responder
    • Buenas Manuel,

      Antes que nada disculpa la tardanza en contestar. ¿Estás utilizando el módulo de reloj?

      Un saludo, Enrique.

      Responder
  28. disculpa, aunque no va tanto al caso, quisiera saber si en arduino se pueden usar bytes para usar puertos completos, es decir, en lugar de declarar pin 2, salida, pin3, salida, pin4 salida….poder usar puerto 1, salida (que comprenda desde el pin 0 hasta el pin 7) o algo parecido se puede hacer?

    Responder
    • Buenas Uriel,

      La verdad es que no lo he hecho nunca pero si no se puede hacer seguro que se puede simular ese comportamiento.

      Un saludo, Enrique.

      Responder
  29. Hola Enrique. Primero, felicitarte por los tutoriales que publicas, que tienen un nivel bastante aceptable, y me han servido de mucho ya que llevo poco tiempo desde que al leer acerca de los artículos para Arduino de Banggood me decidí a comprarles y ahora cada vez que necesito algo es uno de los primeros sitios que consulto. Me gusta que intentas mostrar la lógica de las cosas y no te limites a dar la típica “receta” que tanto abunda en otros sitios.. En este tutorial, muy interesante también, solo advertirte de un posible error -digo posible porque no lo he comprobado, podría hacerse con un bucle a ver hasta donde llega- . El error es que un kB, informáticamente hablando, son 1024 bytes, no 1000 como pones en el texto.
    Por lo demás, de 10…
    Saludos.

    Responder
    • Buenas Ekaitz,

      Como bien dices, en este caso habría que considerar 1024. Es un error que cometo a veces porque según dónde lo mires un kB son 1000 bytes o 1024 bytes. Te dejo un link por si te interesa comprobarlo.

      Un saludo, Enrique.

      Responder
      • No, si no me hacía falta el enlace (prefiero utilizar también en informática los términos en castellano antes que usar barbarismos, que tanto abundan). Digo que cabía la posibilidad (improbable) de las 1000 posiciones de memoria que decías, pero con un bucle que fuera escribiendo y leyendo desde la posición cero hasta la 1023, se podría salir de dudas. Quizá un día de esto lo haga para ir practicando.
        Y si, llevas razón en cuanto a la frecuente confusión entre kilos en el sistema métrico y “kilos informáticos”. Sobre todo a la hora de comprar un disco duro o un lapiz USB o cualquier cosa de esas, donde haya muchos…

  30. Hola Enrique/Oscar, muy buenos los comentarios de ambos.
    El post original me sirvio para aprender la raiz de los movimientos de bits que no lo entendia, y creo que entender la base de las cosas es lo mas importante de todo, mas alla de que despues lo uses o no.
    Ya habia leido que resultaba util la nueva libreria de EEPROM porque tenia la funcion update, get y put, que entre otras cosas sirven para no escribir un dato en un destino que ya contenía el mismo dato, y por lo tanto no acortar la vida de la EEPROM sin sentido, y el get y put para trabajar con objetos completos como menciona muy bien Oscar. Asique por el comentario de Oscar me decidi al upgrade de mi IDE, y leyendo la libreria resulta que la funcion put, ademas utiliza update, asique cierra por todos lados.

    Seguramente no les aclare nada que no sepan, simplemente queria compartir con ustedes estos comentarios en forma de agradecimiento por el post y comentarios de ustedes.

    Saludos desde Argentina.

    Responder
    • Muchas gracias por dejar tu comentario y dar tu opinión, Adrián.

      Un saludo, Enrique.

      Responder
  31. Hola.
    Antes de nada, felicitarte Enrique por esta web: los tutoriales son muy claros y se nota que lo haces con mucho mimo. ¡Muchas gracias!
    Y lo segundo…hace pocos días que ha salido una nueva versión del IDE (la 1.6.x) de Arduino que incluye en la librería EEPROM unos métodos nuevos que facilitan mucho la lectura y escritura de datos que ocupan más de un byte. La verdad es que vale la pena usarlos porque así no hay que estar jugando a nivel de bits. Aquí está la referencia: http://arduino.cc/en/Reference/EEPROM
    Venga, hasta luego

    Responder
    • Buenas Oscar,

      Me alegro de que te guste la web. smile

      La verdad es que no había mirado la nueva versión de esa librería. Me parece estupendo que se lo hayan currado porque la verdad es que era un poco engorroso trabajar a nivel de bit. Gran aporte. smile

      Un saludo, Enrique.

      Responder
    • Hola Oscar !!! Usted podria ayudarme con el codigo ? Me gustaria almacenar un numero como 10.000 en la eeprom, pero no se como lo hacer… usted podria escrevir un codigo para que yo cepa como hacer ? Perdoname la ortografia. Gracias !!!

      Responder

Enviar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Cómo Usar La Memoria EEPROM De Arduino was last modified: diciembre 14th, 2016 by Enrique
Share This

¿Me ayudas?

Hey! Espero que te esté gustando el artículo. ¿Me ayudarías compartiéndolo con tus amigos? Un pequeño paso para ti, un gran paso para EducaChip. :) ¡Gracias!