EEPROM una memoria non volatile
L’ EEPROM è un tipo di memoria non volatile che consente di scrivere e cancellare i dati utilizzando una tensione elettrica.
Possono essere riscritte un numero limitato di volte, di solito tra 100.000 e 1.000.000 volte, a seconda del dispositivo, per questo motivo è consigliabile evitare scritture a loop.
Sono comunemente utilizzati in sistemi embedded in cui è necessario memorizzare piccole quantità di dati e dove non è necessario aggiornarli frequentemente.
L’EEPROM è stata sviluppata come sostituto delle memorie EPROM e PROM, entrambe con limitazioni.
La PROM può essere scritta una sola volta, mentre, EPROM può essere riutilizzata, ma per essere cancellata deve essere esposta alla luce ultravioletta e questo processo richiede diverse ore.
L’EEPROM, ha risolto molti delle problematiche delle memorie EPROM e PROM.
La EEPROM può essere cancellata e riscritta in modo elettrico e il processo è relativamente veloce.
Inoltre, i chip EEPROM sono piccoli, a basso consumo e possono essere integrati in una varietà di dispositivi, come i microcontrollori.
Sul microcontrollore ESP32 non è stata integrata una memoria EEPROM ma c’è un emulatore di EEPROM che consente di memorizzare i dati in una sezione specifica della memoria flash che funge da EEPROM virtuale.
Pertanto, è possibile utilizzarla nei nostri progetti per memorizzare variabili che devono essere uttilizzate anche dopo un riavvio del sistema, per esempio variabili di configurazione.
È importante notare che anche la memoria EEPROM emulata sull’ ESP32 ha un numero limitato di cicli di scrittura, poiché utilizza parte della memoria FLASH che ha anch’essa un numero limitato di scritture.
La memoria interna, EEPROM emulata, può memorizzare 512 valori compresi tra 0 e 255 oppure 128 indirizzi IP.
Utilizzo della libreria EEPROM per la scrittura e lettura di dati sull’ESP32
In questo sketch si utilizza la libreria EEPROM per scrivere e leggere dati dalla memoria EEPROM dell’ESP32.
#include <EEPROM.h>
#define EEPROM_SIZE 12
void setup() {
Serial.begin(115200);
//Inizializziamo l'EEPROM
EEPROM.begin(EEPROM_SIZE);
//Write data
int address = 0;
int data = 18;
EEPROM.write(address, data);
address += sizeof(data);
float param = 26.5;
EEPROM.writeFloat(address, param);/
EEPROM.commit();
address = 0;
int lettura;
lettura = EEPROM.read(address);
Serial.print("leggi = ");
Serial.println(lettura);
address += sizeof(lettura);
float variabile_float;
EEPROM.get(address, variabile_float);
Serial.print("Read param = ");
Serial.println(variabile_float);
EEPROM.end();
}
void loop() {}
Codice completo, di seguito descrivo le principali istruzioni.
#define EEPROM_SIZE 12
E’ una direttiva del preprocessore che definisce una costante chiamata “EEPROM_SIZE” con un valore di 12.
Questa costante viene utilizzata per specificare la dimensione della memoria EEPROM che verrà utilizzata nello sketch.
Ciò significa che la quantità massima di dati che possono essere memorizzati nella EEPROM è 12 byte.
EEPROM.begin(EEPROM_SIZE);
Questa funzione inizializza la memoria EEPROM con la dimensione specificata (in questo caso la dimensione è definita dalla costante EEPROM_SIZE = 12) e la prepara per le operazioni di lettura e scrittura.
Deve essere richiamata prima di poter utilizzare qualsiasi altra funzione EEPROM.
EEPROM.write(address, data);
Il comando “EEPROM.write (address, data)” scrive il valore contenuto nella variabile data all’indirizzo specificato dalla variabile address.
address += sizeof(data);
Questa riga di codice aumenta il valore della variabile “address” della dimensione della variabile “data”. La funzione “sizeof” restituisce la dimensione in byte della variabile specificata.
In questo caso, la dimensione della variabile “data” viene aggiunta al valore corrente della variabile “address” per spostare l’indirizzo di memoria alla posizione successiva per la scrittura o lettura nella memoria EEPROM.
EEPROM.writeFloat(address, param);
Questa riga di codice scrive un valore a virgola mobile della variabile “param” nell’indirizzo che abbiamo calcolato nell’istruzione precedente.
La scrittura di un valore a virgola mobile richiede più byte rispetto ai valori interi, quindi la funzione “EEPROM.writeFloat” è stata scritta per memorizzare correttamente i dati nella memoria.
EEPROM.commit();
La funzione “EEPROM.commit()” scrive i dati dal registro temporaneo alla memoria EEPROM vera e propria, garantendo che i dati non vengano persi anche se l’ESP32 verrà spento.
EEPROM.get(address, variabile_float);
La funzione “EEPROM.get” legge il valore memorizzato nell’indirizzo specificato e lo assegna alla variabile “variabile_float”.
Questa funzione è simile alla funzione “EEPROM.read” ma con la differenza che “EEPROM.get” permette di leggere più byte contemporaneamente, poiché in questo caso dobbiamo leggere un valore float.
EEPROM.end();
Cancella semplicemente la cache locale.
Conclusioni
Se hai domande o curiosità riguardo al codice o al post, non esitare a contattarci tramite il modulo di contatto sottostante. Saremo felici di aiutarti!
