Tutorial: usare la EEPROM di arduino

Tutte le schede Arduino sono dotate di una EEPROM, ossia una parte di memoria che non si cancella con la mancanza di alimentazione.

eeprom arduino uno

Leggendo le caratteristiche della tua scheda Arduino potrai verificare quanta memoria puoi utilizzare per memorizzare i dati da conservare.

Sul sito ufficiale arduino per ogni modello trovi una sezione dedicata alla memoria, solitamente “Memory” in cui puoi leggere qualcosa di simile:

The ATmega328 has 32 KB (with 0.5 KB used for the bootloader).
It also has 2 KB of SRAM and 1 KB of EEPROM (which can be read and written
with the EEPROM library).

La frase riportata si riferisce al modello Arduino Uno Rev.3, se non hai familiarità con l’inglese, il significato è che l’ATmega328, di cui è dotata la versione Uno di Arduino, ha:

  • 32KB (Kilo Byte) di cui 0,5 KB (512) destinati a contenere il bootloader, il sistema base che rende Arduino utilizzabile e le permette di ricevere ed eseguire i tuoi sketch;
  • 2 KB di SRAM;
  • 1KB di EEPROM ossia 1024 spazi o celle (gli addetti ai lavori mi concedano il termine) in cui puoi memorizzare e ritrovare i tuoi dati, anche dopo l’interruzione di corrente.

Alcune schede Arduino ne hanno solo 512KB (ad esempio quelle equipaggiate con l’ATmega 168), ed altre come la Mega ( equipaggiata con il miscrocontrollore ATmega 1280 o 256o) ne possiedono 4KB (4096 Byte).

Tuttavia se non ti fossero sufficenti per il tuo progetto puoi optare per un chip EEPROM esterno, pilotandolo da arduino oppure puoi utilizzare una SD shield con 2GB di memoria dati e scrivere i tuoi valori in file, rileggendo ad ogni boot i file momeorizzati.

In ciascuna cella puoi memorizzare un valore che va da 0 a 255, è un dato di tipo integer ossia un numero intero.

Per utilizzare questa memoria è a tua disposizione una libreria: EEPROM.h già presente nell’IDE Arduino e che puoi richiamarla facilmente con la linea: #include <EEPROM.h>.

La EEPROM.h ti mette a disposizione due metodi, è quindi semplicissima da utilizzare:

read( address ): con questo metodo puoi leggere il valore memorizzato nella cella indicata come address;

write( address,value ): con questo metodo puoi scrivere in una delle 512,1024,4069 celle ( address ) il valore ( value ) da memorizzare.

Semplice no ?

Ed ecco un primo sketch che ti permette di leggere da ciascuna delle celle il valore che in questo momento è impostato:

#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 == 1024)
    a = 0;

  delay(500);
}

Lo sketch è quello presentato sul sito ufficiale, avrei potuto scriverne uno io ma avrebbe fatto le stesse cose, mi sono limitato a citare quello ufficiale e modificare solo il valore delle celle da controllare, da 512 a 1024 per utilizzare tutte le celle della mia arduino.

Leggendo lo sketch:

linea 01: includi la libreria EEPROM.h con il comando #include;

linee 03-04: imposta due variabili a e value la prima utile come indice per scorrere le celle, la seconda memorizzerà i valori letti dalla EEPROM;

Nella funzione setup() inizializza la comunicazione seriale a 9600 baud, utilizzerai la comunicazione seriale per farti scrivere sul monitor seriale i valori letti, è utile soprattutto la prima volta per verificare i valori che memorizzi in una data cella;

Alla linea 13 leggi il valore della cella passata come parametro alla funzione read, nello sketch è a che alla linea 03 hai definito e impostato a 0;
linee 15-18: scrivi sul monitor seriale i valori letti, la colonna di sinistra mostra il valore dell’indice della cella, la colonna di sinistra il valore letto;
linea 20: incremente il valore di a di un punto, al prossimo ciclo loop() la linea 13 a varrà 1, al giro successivo 2, ecc… permettendoti di leggere tutte le celle della tua EEPROM;
linee 22-23: definiscono un limite di cella, per evitare errori dello sketch cercando di leggere valori di cella superiori a quelle disponibili, nell’esempio originale è impostato a 512, io ho fatto una piccola correzione per consentirti la lettura di tutte e 1024 le celle;
ricorda: se possiedi una Arduino Mega potrai impostare questo valore a 4096, inoltre le celle sono 1024 ma si parte da 0 per cui il valore di a va da 0 a 1023;
linea 25: definisce un tempo di attesa di 500 millisecondi tra una lettura e la successiva.
Eseguendo lo sketch sulla mia Arduino Uno la EEPROM riporta:
serial monitor eeprom read
Leggere dalla EEPROM è solo l’inizio, se vuoi utilizzarla in un tuo progetto dovrai scriverci prima il valore che vuoi ritrovarci, ecco lo sketch ufficiale consigliato sul sito Arduino:
#include <EEPROM.h>

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

void loop()
{
}
In questo caso gli autori non hanno voluto utilizzare la funzione loop per scrivere nella EEPROM, ma hanno utilizzato un ciclo for da 0 a 512 ( da me modidicato in un range da 0 a 1024 ) in cui per ogni cella hanno scritto il numero della cella stessa.
Apportando una ulteriore piccola modifica a questo sketch puoi scrivere e leggere nello stesso sketch i valori della tua EEPROM:
#include <EEPROM.h>

int a = 0;
int value;

void setup()
{
  Serial.begin(9600);
  for (int i = 0; i < 1024; i++)
    EEPROM.write(i, i);
}

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

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

  a = a + 1;

  if (a == 1024)
    a = 0;

  delay(500);
}
Ti racconto come è fatto solo quest’ultimo in quanto è la fusione del primo e del secondo sketch proposto:
linea 01: non è cambiata, includi sempre la libreria EEPROM.h;
linee 03-04: non sono cambiate;
linea 08: non è cambiata, inizializza la comunicazione con il monitor seriale, che utilizzerai per leggere i valori memorizzate nelle celle;
linee 09-10: imposta un ciclo da 0 a 1024 all’interno del quale utilizzando il metodo write per ogni cella memorizza un valore pari al numero della cella stessa, vedrai nella fase di lettura cosa intendo;
linee 13-28: sono invariate, servono a leggere i valori memorizzati nelle celle da 0 a 1023.
Avrai notato un piccolo errore, anche nell sketch originale, i valori memorizzabili in ciascuna cella vanno da 0 a 255 mentre con il ciclo for alla linea 09 si tenta di scrivere valori superiori per le celle da 256 a 1023, ovviamente il risultato sarà che in queste celle il valore sarà 255, il massimo valore possibile.
Ecco il risultato dello sketch eseguito sulla mia arduino:
serial monitor eeprom write e read
Alcune avvertenze:
1. per poter scrivere in ogni cella occorrono 3,3 millisecondi, per cui tienine conto quando memorizzerai i tuoi dati nella EEPROM;
2. le EEPROM possono essere scritte per un massimo di 100.000 volte, per scrittura si intende ogni volta che cambi il valore in una cella, considerando che solitamente utilizzi la EEPROM solo per memorizzare dei dati di configurazione, questo valore è decisamente elevato;
Prima di lasciarti ai tuoi esperimenti ti lascio un quesito da approfondire:
Come puoi memorizzare un valore superiore a 255? ad esempio se hai da memorizzare il valore rilevato da un potenziometro attraverso un ingresso analogico?
Esistono molti metodi tuttavia ti invito a cercare il tuo e suggerirlo a tutti noi, ovviamente utilizzando il minor numero di celle possibili.
Buon divertimento.

Prima di inserire un commento, per favore, leggi il regolamento

Permanent link to this article: https://www.mauroalfieri.it/elettronica/tutorial-usare-la-eeprom-di-arduino.html

84 pings

Skip to comment form

  1. […] al tema principale, come visto nell’articolo sulle EEPROM, ogni cella ha le dimensioni di 1 BYTE, ti serviranno quindi 2 celle per un intero a 16bit, 4 per […]

  2. […] pensato alla EEPROM presente su Arduino. Questo articolo di Mauro Alfieri spiega perfettamente il suo […]

Lascia un commento

Your email address will not be published.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.