Biblioteca EEPROM

Cuando a una placa Arduino se le interrumpe la alimentación eléctrica o bien cuando se activa el pulsador de reset, el programa de la memoria se reiniciará y se perderán todos los datos que tuviera antes del reinicio. La memoria del Arduino, donde se almacena el código se dice que es volátil, cuyo contenido se borra cuando de corta la alimentación a la placa. Sin embargo, Arduino, como muchos otros microcontroladores, tiene una memoria no volátil, con un espacio más reducido que la memoria volátil, pero que resulta útil en ciertos casos.

Esta memoria no volátil es la llamada EEPROM (Electrically Erasable Programmable Read-Only Memory, o ROM programable y borrable eléctricamente).
Casi todos los modelos de Arduino tienen una EEPROM disponible con diferente capacidad según el tipo de placa.

 
Placa EEPROM
Arduino UNO 1 Kb
Arduino Leonardo 1 Kb
Arduino Due No tiene
Arduino Yun 1 Kb
Arduino Mega 4 Kb
Arduino Micro 1 Kb
Arduino Lilypad 1 Kb
Arduino Nano 512 Bytes
Arduino Pro Mini 512 Bytes
Arduino Pro 512 Bytes
Arduino Mini 1 Kb
Arduino Fio 1 Kb

 
La información que se guarde en la memoria EEPROM puede recuperarse en cualquier momento, incluso después de haben reiniciado la placa o tras un corte de alimentación. Para esto Arduino posee la biblioteca EEPROM que cuenta con los siguientes métodos:
 
  • read(): Lee un byte de la EEPROM. Las ubicaciones que nunca han sido escritas tienen el valor de 255.
    • Sintaxis: EEPROM.read(address)
    • Parámetros
      • address : La ubicación a leer, empezando desde 0 (int)
    • Retornos: El valor almacenado en esa ubicación (byte)

    Ejemplo

    // Este programa lee los datos de la EEPROM desde la ubicacion 0
    // hasta la ubicacion 512, despues vuelve a cero y comienza una nueva lectura

    #include <EEPROM.h>
    int a = 0;
    int value;

    void setup()
    {
    Serial.begin(9600);
    }

    void loop()
    {
    value = EEPROM.read(a);

    Serial.print(a);
    Serial.print("\t");
    Serial.print(value);
    Serial.println();

    a = a + 1;

    if (a == 512)
    a = 0;

    delay(500);
    }
    ____________________________________________________________________
  • write() : Escribe un byte en la EEPROM.
    • Sintaxis: EEPROM.write(address, value)
    • Parámetros:
      • address:  La ubicación donde escribir dichos datos, desde 0 (int)
      • value: El valor a escribir, de 0 a 255 (byte)
    • Retornos: Ninguno
    • Nota: Una escritura en la EEPROM tarda 3,3 milisegundos en completarse. La EEPRON tiene una vida de aproximadamente 100.000 ciclos de escritura/borrado de datos. Tenga en cuenta con que frecuencia se escribe en ella.
    Ejemplo
    // Este programa escribe escribe un cero en las posiciones de
    // memoria de la 0 a la 255
    #include <EEPROM.h>

    void setup()
    {
      for (int i = 0; i < 255; i++)
        EEPROM.write (i, i);
    }

    void loop()
    {
    }
    ____________________________________________________________________
  • update: Escribe un byte en la EEPROM. El valor se escribe sólo si difiere del que ya se guardan en la misma dirección.
    • Sintaxis: EEPROM.update (address, value)
    • Parámetros:
      • address:  La ubicación donde escribir dichos datos, desde 0 (int)
      • value: El valor a escribir, de 0 a 255 (byte)
    • Retornos: Ninguno
    • Nota: El uso de esta función puede ahorrar ciclos de vida de la EEPROM si los datos escritos no cambian con frecuencia.

    Ejemplo
    #include <EEPROM.h>
    
    void setup()
    {
      for (int i = 0; i < 255; i++) {
        // esto hace lo mismo que EEPROM.write(i, i)
        EEPROM.update(i, i);
      }
      for (int i = 0; i < 255; i++) {
        // escribe el valo "12" en la celfa 3 solo la primera vez
        // no escribira en la celda las restantes 254 veces
        EEPROM.update(3, 12);
      }
    }
    
    void loop()
    {
    }
    ___________________________________________________________________
    
  • get(): Lee cualquier tipo de datos o un objeto de la EEPROM.
    • Sintaxis: EEPROM.get(address, data)
    • Parámetros:
       
      • address: La ubicación a leer, empezando desde 0 (int)
      • data: los datos a leer, puede ser un tipo primitivo (por ejemplo. float) o una estructura personalizada.
    • Retornos: Una referencia a los datos que se pasan.

    Ejemplo
    #include <EEPROM.h>
    
    struct MyObject{
      float field1;
      byte field2;
      char name[10];
    };
    
    void setup(){
    
      float f = 0.00f;   //Variable para almacenar los datos leidos de la EEPROM.
      int eeAddress = 0; //Direccion de la EEPROM para empezar a leer
      Serial.begin( 9600 );
      while (!Serial) {
        ; // espera a que el puerto serie este conectado. Solo necesario para el Leonardo
      }
      Serial.print( "Leido un float de la EEPROM: " );
    
      //Obtiene los datos float de la EEPROM en la ubicacion 'eeAddress'
      EEPROM.get( eeAddress, f );
      Serial.println( f, 3 );  //Esto imprime 'ovf, nan' si los datos de la EEPROM no es un float valido.
    
      // get() se puede usar tambien con estructuras personalizadas. 
      eeAddress = sizeof(float); //Move address to the next byte after float 'f'.
      MyObject customVar; //Variable para almacenar el objeto personalizado leido en la EEPROM.
      EEPROM.get( eeAddress, customVar );
    
      Serial.println( "Leido un objeto personlixado de la EEPROM: " );
      Serial.println( customVar.field1 );
      Serial.println( customVar.field2 );
      Serial.println( customVar.name );
    }
    
    void loop(){ /* Bucle vacio */ }
    ___________________________________________________________________
  • put(): Escribe cualquier tipo de datos o un objeto de la EEPROM.
    • Sintaxis: EEPROM.put(address, data)
    • Parámetros:  
      • address: La ubicación a escribir, empezando desde 0 (int)
      • data: los datos a escribir, puede ser un tipo primitivo (por ejemplo. float) o una estructura personalizada.
    • Retornos: Una referencia a los datos que se pasan.
    • Nota: Esta función utiliza EEPROM.update() para realizar la escritura, por lo que no se vuelven a escribir los datos si estos no han cambiado.
    Ejemplo

    /***
        Ejemplo de EEPROM.put().
    
        Esto muestra como usar el metodo EEPROM.put().
        Además, este programa restablecerá los datos de EEPROM para el 
        programa de ejemplo de EEPROM.get()
    
        Tenga en cuenta, que a diferencia de la versión EEPROM.write () de un solo byte, 
        el método put utilizará la semántica de actualización. Como en un byte solo se 
        escribirá en la memoria EEPROM si los datos son en realidad diferentes.
    
        Escrito por Christopher Andrews 2015
        Publicado bajo livensia MITe.
    ***/
    
    #include <EEPROM.h>
    
    struct MyObject {
      float field1;
      byte field2;
      char name[12];
    };
    
    void setup() {
    
      Serial.begin(9600);
      while (!Serial) {
        ; // // espera a que el puerto serie se abra. Necesario para el puerto USB nativo solamente
      }
    
      float f = 123.456f;  //Variable a almacenar en la EEPROM.
      int eeAddress = 0;   //Ubicacion en la queremos poner los datos.
    
    
      //Una sola llamada, primero con la direccion y segundo el objeto.
      EEPROM.put(eeAddress, f);
    
      Serial.println("Escrito un tipo de datos float!");
    
      /**  Put está diseñado también para su uso con estructuras personalizados **/
    
      //Datos a almacenar.
      MyObject customVar = {
        3.14f,
        65,
        "Trabajando!"
      };
    
      eeAddress += sizeof(float); //Cambia la dirección al siguiente byte después de float 'f'.
    
      EEPROM.put(eeAddress, customVar);
      Serial.print("Escrito un tipo de datos personalizado!"); 
      Serial.print("Ver el programa ejemplo EEPROM.get para ver cómo se pueden recuperar los valores!");
    }
    
    void loop() {
      /* Bucle vacio */
    }
    
    __________________________________________________________________
  • EEPROM[ ]: Este operador permite utilizar el identificador `EEPROM` como una matriz. Las celdas de la EPROM pueden leerse y escribirse directamente utilizando este método.
    • Sintaxis: EEPROM[address]
    • Parámetros:
      • address: la dirección
    • Retornos: Una referencia a la célula de la EEPROM.
  • Ejemplo

    #include <EEPROM.h>
    
    void setup(){
    
      unsigned char val;
    
      //Lee la primera celda de la EEPROM.
    
      val = EEPROM[ 0 ];
    
      //Escribe la primera celda de la EEPROM.
    
      EEPROM[ 0 ] = val;
    
      //Compara los contenidos
    
      if( val == EEPROM[ 0 ] ){
        //Hacer algo...
      }
    }
    
    void loop(){ /* Bucle vacio */ }
    ___________________________________________________________________

No hay comentarios:

Publicar un comentario