Usando la memoria EEPROM
Para acceder a la memoria EEPROM se utiliza una de las librerías AVR que vienen con el software Arduino. Lo primero es escribir esta línea al principio del código
#include <avr/eeprom.h>
Si esta línea encabeza el código entonces estarán disponibles las dos funciones necesarias para ‘escribir a’ y ‘leer desde’ la memoria EEPROM:
eeprom_write_byte(direccion, valor_escrito);
lectura = eeprom_read_byte(direccion);
Las palabras en itálica deberán ser reemplazadas así:
direccion Deberá ser un número entre 0 y 511 y corresponde a la dirección del byte donde se almacenará la información. Con la función eeprom_write_byte() puede escribirse al tiempo solo 1 de cualquiera de los 512 bytes.
valor_escrito Esta es la información que se guardará en la memoria EEPROM. Puede ser un caracter o un número pero lo importante es que no supere el límite de un byte de capacidad.
La idea es que se escoge una determinada dirección en la memoria EEPROM para guardar un dato. De esa manera podrá luego obtenerse ese dato si se consulta la misma dirección con la función eeprom_read_byte(). En el ejemplo de arriba ese valor se está guardando en la variable “lectura”.
Estas funciones pueden ser llamadas desde el setup() o el loop() según se considere necesario. Si se necesita guardar más de un dato consecutivamente pueden recorrerse las direcciones desde 0 hasta 511, e incluso si ese dato ocupa menos de un byte puede utilizarse lógica binaria para que en cada byte quepa más de un dato.
derivaTron con memoria
Un ejemplo con bastante pedido: cómo hacer para que el derivaTron guarde un registro de las jugadas.
// librería
#include <avr/eeprom.h>
//declaración de variables
unsigned int registro;
// el termino unsigned permite usar el rango
// de los enteros (int) sin los negativos
// adicione otras variables que su código use
// por ejemplo
byte caminoSiguiente;
boolean tomaDecision;
void setup(){
// aparte de otras instrucciones que necesite // para iniciar su programa tomaDecision = false; registro = 0;
}
void loop(){
// se creo una variable booleana tomaDecision
// pensando en que hay que garantizar que
// solo se escriba la memoria 1 vez por cada
// toma de decisión del camino a seguir
// recuerde que solo hay 512 casillas
// segun el sensor que use para decidir que hay
// que escoger un camino habria que correr esto
// tomaDecision = true;
if (tomaDecision == true){
// acá iría el codigo para mostrar vías aleatorias
// supongamos que sería
caminoSiguiente = random(3);
// esto guardaría la decisión en memoria
// si todavia quedan registros para usar
if (registro < 512){
eeprom_write_byte((unsigned char*)registro, caminoSiguiente);
registro++;
}
// y finalmente se evita que se guarde más
// de la necesaria. Por lo menos hasta que
// un sensor vuelva a operar una nueva decisión
tomaDecision = false;
}
// luego podría hacer otra cosa con la decisión
// tomada :: prender leds, producir sonidos, etc.
}
Podrían leerse los datos en el mismo programa pero aquí simplemente creamos otro programa para leerlos más tarde. Este se podría subir reemplazando el anterior pero los datos guardados seguirían en la EEPROM:
// librería
#include <avr/eeprom.h> unsigned int registro; int lectura;
void setup(){
Serial.begin(19200); registro = 0;
}
void loop(){
if (registro < 512){
lectura = eeprom_read_byte((unsigned char*)registro);
Serial.println(lectura, DEC);
registro++;
}
}