Se la EEPROM viene usata solo per salvare dei preset da un menù prima di arrivare a otre centomila scritture di una cella sicuramente “muore” prima Arduino perché ci vogliono moltissimi anni prima di arrivare alla fine della vita utile della EEPROM
Facendo un semplice conto, anche ipotizzando di cambiare 10 volte al giorno i vari preset e usare l’impianto tutti i giorni occorrono 10000 giorni per arrivare al limite minimo garantito di scritture, ovvero più di 27 anni.
Tra parentesi non è che a 100000 scritture la EEPROM cessa di funzionare, semplicemente è un valore minimo garantito, la durata reale è maggiore e comunque si perdono solo poche celle per volta e non tutte assieme.
Altamente consigliato l’utilizzo del metodo update, messo a disposizione dalle avrlibc, che invece di scrivere incondizionatamente le celle EEPROM prima verifica il contenuto con il valore fornito e scrive solo se è differente, cosa che permette di usare una semplice funzione di aggiornamento della EEPROM ogni volta che si esce dal menù senza scrivere necessariamente tutte le celle interessate anche se non è necessario.
Codice di esempio per la gestione delle EEPROM con la creazione delle variabili da memorizzare, lettura, scrittura delle stesse tramite metodo update.
#include <avr/eeprom.h>
/************** AvrLibc EEMEM function *****************
uint8_t eeprom_read_byte (const uint8_t *__p) __ATTR_PURE__
uint16_t eeprom_read_word (const uint16_t *__p) __ATTR_PURE__
uint32_t eeprom_read_dword (const uint32_t *__p) __ATTR_PURE__
float eeprom_read_float (const float *__p) __ATTR_PURE__
void eeprom_read_block (void *__dst, const void *__src, size_t __n)
void eeprom_write_byte (uint8_t *__p, uint8_t __value)
void eeprom_write_word (uint16_t *__p, uint16_t __value)
void eeprom_write_dword (uint32_t *__p, uint32_t __value)
void eeprom_write_float (float *__p, float __value)
void eeprom_write_block (const void *__src, void *__dst, size_t __n)
void eeprom_update_byte (uint8_t *__p, uint8_t __value)
void eeprom_update_word (uint16_t *__p, uint16_t __value)
void eeprom_update_dword (uint32_t *__p, uint32_t __value)
void eeprom_update_float (float *__p, float __value)
void eeprom_update_block (const void *__src, void *__dst, size_t __n)
*********************************************************/
/* non modificare assolutamente l'ordine dei parametri */
// dichiarazioni EEMEM preset
unsigned int EEMEM orario_1_EEP; // orario 1
unsigned int EEMEM orario_2_EEP; // orario 1
unsigned int EEMEM orario_3_EEP; // orario 1
unsigned int EEMEM orario_4_EEP; // orario 1
unsigned int EEMEM temp_EEP; // temperatura
// legge preset da EEPROM
void Read_Preset()
{
Ton_1 = eeprom_read_word(&orario_1_EEP);
Toff_1 = eeprom_read_word(&orario_2_EEP);
Ton_2 = eeprom_read_word(&orario_3_EEP);
Toff_2 = eeprom_read_word(&orario_4_EEP);
temp_preset = eeprom_read_word(&temp_EEP);
}
// scrive preset su EEPROM
void Write_Preset()
{
eeprom_update_word(&orario_1_EEP, Ton_1);
eeprom_update_word(&orario_2_EEP, Toff_1);
eeprom_update_word(&orario_3_EEP, Ton_2);
eeprom_update_word(&orario_4_EEP, Toff_2);
eeprom_update_word(&temp_EEP, temp_preset);
}
La nota “/* non modificare assolutamente l’ordine dei parametri */” è una warning relativa al fatto che una volta inizializzata la EEPROM se si modifica l’ordine di dichiarazione delle variabili i loro valori poi risultano falsati, questo perché cambiano gli address fisici della EEPROM utilizzati dal codice, sono gestiti in automatico dalle relative funzioni delle avrlibc.
Se è necessario modificare le variabili, o il loro ordine, la EEPROM deve essere nuovamente inizializzata con gli eventuali valori di default.
… per quanto riguarda la gestione circolare delle celle (se ho capito cosa si intende ma penso di sì), dovrei mettere in piedi un algoritmo che determini da solo un “offset” per la gestione delle celle ma che dopo sia in grado anche di utilizzarlo per le letture, giusto? Cioè mi spiego: supponiamo di scrivere i primi X indirizzi, poi in lettura devo andare da 0 a X, la volta successiva da X+1 a X*2 ma questo offset poi lo devo utilizzare anche in lettura, giusto? Cioè dovrei memorizzarmelo da qualche parte, right?
