EEPROM

La EEPROM es una memoria no volátil que dispone el microcontrolador de Arduino que nos permite guardar datos para poder recuperar en caso de pérdida de alimentación de nuestro dispositivo.

La gran desventaja que tiene la EEPROM es que tiene un número limitado de escrituras, por lo que debemos calcular cuántas veces se va a escribir en ella para calcular su vida útil con nuestro programa. Además la velocidad de lectura y escritura en inferior que en la SRAM y Flash.

Más información en: http://en.wikipedia.org/wiki/EEPROM

Las celdas de memoria de una EEPROM están constituidas por un transistor MOS, que tiene una compuerta flotante (estructura SAMOS), su estado normal está cortado y la salida proporciona un 1 lógico.

Aunque una EEPROM puede ser leída un número ilimitado de veces, sólo puede ser borrada y reprogramada entre 100.000 y un millón de veces.

Además de la memoria EEPROM integrada en el chip del microcontrolador, hay disponibles memorias EEPROM externas. Estos dispositivos suelen comunicarse mediante protocolos como I²C, SPI y Microwire.

La memoria flash es una forma avanzada de EEPROM.

La librería EEPROM nos permite leer y escribir bytes de la EEPROM de Arduino. La EEPROM en cada MCU tiene un tamaño diferente, en nuestro caso con el Arduino UNO es de 1024 bytes. Esta librería solo me permite leer y escribir a nivel de byte, por lo que si quiero guardar variables cuyo tamaño sea mayor de 1 byte, deberemos hacer operaciones.

Librería http://arduino.cc/en/Reference/EEPROM

• read() – Lee un byte de la EEPROM. http://arduino.cc/en/Reference/EEPROMRead
• write() – Escribe un byte de la EEPROM.  http://arduino.cc/en/Reference/EEPROMWrite
• update() – Escribe un byte de la EEPROM, el valor solo es escrito si es diferente al almacenado. https://www.arduino.cc/en/Reference/EEPROMUpdate
• get() – Lee cualquier tipo de dato u objeto de la EEPROM. https://www.arduino.cc/en/Reference/EEPROMGet
• put() –  Escribe cualquier tipo de dato u objeto de la EEPROM. https://www.arduino.cc/en/Reference/EEPROMPut
• EEPROM[ ] – Este operador permite usar el identificador ‘EEPROM’ como un array. Las celdas de la EEPROM pueden leerse y escribirse con este método. https://www.arduino.cc/en/Reference/EEPROMObject

Una EEPROM tarda unos 3,3 ms en completar una escritura y para Arduino se ha especificado una vida de 100000 ciclos de escritura/borrado.

Tutorial lectura EEPROM: http://en.wikipedia.org/wiki/EEPROM

Tutorial escritura EEPROM: http://arduino.cc/en/Tutorial/EEPROMWrite

Tutorial limpiado EEPROM: http://arduino.cc/en/Tutorial/EEPROMClear

Para grabar estructuras de datos en la EEPROM de una forma muy sencilla podemos usar EEPROMAnything.h. http://playground.arduino.cc/Code/EEPROMWriteAnything

AVR Libc dispone de métodos de la librería <avr/eeprom.h> para manejar la EEPROM: http://www.atmel.com/webdoc/AVRLibcReferenceManual/group__avr__eeprom.html

La librería EEPROMex es una extensión de la librería EEPROM que amplía sus funcionalidades:

• http://playground.arduino.cc/Code/EEPROMex
• http://thijs.elenbaas.net/2012/07/extended-eeprom-library-for-arduino
• https://github.com/thijse/Arduino-EEPROMEx

El acceso entre la EEPROM y la CPU se hace mediante los registros:

• EEPROM Address Registers: EEARH y EEARL
• EEPROM Data Register: EEDR
• EEPROM Control Register: EECR

Más información en la página 36 del http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf

Cosas a tener en cuenta con la EEPROM: https://engineerzero.wordpress.com/2013/07/11/five-things-to-remember-pun-about-arduino-eeprom/

• Los datos deben guardarse en formato byte para ser usados
• EEPROM puede los datos de configuración de usuario
• Dañar la EEPROM no es un problema grave
• Dañar la EEPROM puede ser un problema si no se tiene cuidado
• Dañar la EEPROM no es el fin del mundo

Muy buen tutorial de Luis Llamas: https://www.luisllamas.es/guardar-variables-entre-reinicios-con-arduino-y-la-memoria-no-volatil-eeprom/

Un uso típico con la EEPROM es crear un firmware único muchos dispositivos y guardar las variables de cada dispositivo en la EEPROM, por ejemplo la IP, MAC, identificador, número de sondas conectadas, etc… De esta forma con un único firmware único que en el setup() lee la configuración de la EEPROM, se personaliza el comportamiento de cada dispositvo.

Comprobación de EEPROM no corrompida: https://www.arduino.cc/en/Tutorial/EEPROMCrc

La verificación por redundancia cíclica (CRC) es un código de detección de errores usado frecuentemente en redes digitales y en dispositivos de almacenamiento para detectar cambios accidentales en los datos. https://es.wikipedia.org/wiki/Verificaci%C3%B3n_de_redundancia_c%C3%ADclica

Calculo CRC: http://www.lammertbies.nl/comm/info/crc-calculation.html

Sketch para grabar en la EEPROM en diferentes celdas y no machacar una misma zona de memoria, comprobando el nivel de desgaste de las celdas de la EEPROM: http://blog.blinkenlight.net/experiments/counting-resets/wear-leveling/

EEPROM Externa

Para proteger un arduino que queremos comercializar y que no se pueda replicar el programa en otros microcontroladores Atmel.

Un ejemplo es usar una EEPROM externa usado como “mochila” donde guardamos un número único. Este mismo módulo lo podríamos usar como contador o con otras funcionalidades.

• EEPROM externa : http://datasheets.maximintegrated.com/en/ds/DS2430A.pdf
• Como trabajar con ella: http://playground.arduino.cc/Learning/OneWire

Práctica: Volcado EEPROM

Si estamos depurando un proyecto de Arduino usando EEPROM, es posible que queramos ver la EEPROM para entender lo que está pasando.

Si tenemos un programador ISP como el USBtinyISP de Adafruit, siempre se puede utilizar avrdude para volcar la EEPROM a un archivo. Por ejemplo, el siguiente código crea un archivo denominado e2data.ee con contenido de EEPROM.

 
$ avrdude -p m328p -c usbtiny -P usb -U eeprom:r:e2data.ee:r

Otra opción es usar un sketch que nos saque por el puerto serie el contenido de la EEPROM.

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_Avanzado_2017/tree/master/Ejercicio23-leeEEPROM

Práctica: Termómetro con Máximas y Mínimas.

Partiendo del ejercicio https://aprendiendoarduino.wordpress.com/2017/06/24/ejemplo-sensor-de-temperatura/ hacer que guarde los valores máximos y mínimos en las direcciones de memoria 100 y 200 respectivamente.

Para recuperarlo pulsar en el monitor serie M para máximo y m para mínimo. Para inicializar los valores de max y min pulsar R.

Como las temperaturas máximas y mínimas son de tipo float, usar los métodos:

• get() https://www.arduino.cc/en/Reference/EEPROMGetz
• put() https://www.arduino.cc/en/Reference/EEPROMPut

Uso sensor tmp36: http://www.prometec.net/sensor-tmp36/

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_Avanzado_2017/tree/master/Ejercicio24-Temperatura_Max_Min