Salvataggio dati complessi in EEprom

Illustro in questo articolo due semplici funzioni utilizzabili per salvare e recuperare da eeprom (sia interna che esterna) dati in formato “complesso”, ovvero variabili float, strutture e qualsiasi altro tipo di dato con una lunghezza superiore ad 8 bit. Le due funzioni in questione si appoggiano a funzioni “semplici” qualsiasi in grado di scrivere e leggere un dato ad 8 bit da eeprom.

Per maggiori informazioni e funzioni su come utilizzare l’ eeprom interna fate riferimento a questo articolo, per le eeprom esterne fate riferimento a quest’altro articolo.

Le due funzioni a cui ci appoggiamo sono EEPROM_WRITE che è quella in grado di scrivere su eeprom un dato ad 8 bit (ricordo che alle funzioni di scrittura va sempre passato il valore della variabile e la cella di memoria in cui scrivere) e quindi EEPROM_READ la funzione in grado di leggere il valore contenuto nel numero di cella passato come argomento. Queste due funzioni di base sono già definite nel compilatore della Hitech per l’utilizzo dell’eeprom interna. Nel caso in cui il vostro compilatore non supporti tali funzioni o avete necessità di sfruttare le routine di salvataggio dati complessi con eeprom esterne, modificate i nomi di queste due funzioni e soprattutto fate attenzione al giusto ordine degli argomenti per la funzione EEPROM_WRITE.

//*****************************************************************************
//Funzione per salvare dati complessi in EEPROM
//*****************************************************************************
void to_eeprom (void *ptr,unsigned char dim,unsigned char start_position)
{
 unsigned char k,mom;
 for (k=0;k<dim;k++)
 {
 mom = ((unsigned char*) ptr)[k];
 EEPROM_WRITE(start_position+k,mom);
 }    
 
 return;
}
//*****************************************************************************
//Funzione per recuperare dati complessi in EEPROM
//*****************************************************************************
void from_eeprom (void *ptr,unsigned char dim,unsigned char start_position)
{
 unsigned char k,mom;
 for (k=0;k<dim;k++)
 {
 mom = EEPROM_READ(start_position+k);
 ((unsigned char*) ptr)[k]=mom;
 }    
 
 return;
}
//**************************************************************************/

Il funzionamento è molto semplice: la funzione di scrittura (to_eeprom) accetta in ingresso un puntatore a void, ossia un puntatore a qualsiasi tipo di dato, viene quindi fornita la lunghezza del tipo di dato da salvare e infine il primo indirizzo in cui cominciare a salvare. All’interno della funzione, viene eseguito un cast del tipo di dati in char, il vettore passato come argomento viene quindi scansionato come fosse un array di char, ogni singolo byte viene quindi salvato con una funzione standard di scrittura.

La funzione di lettura (from_eeprom) funziona all’inverso e il primo parametro è un puntatore in cui andare a salvare i dati recuperati dall’eeprom.

Esempio di utilizzo con variabili float

Questo esempio salva la variabile float dato nell’eeprom a partire dalla locazione 0x00, una variabile float in ram occupa normalmente 4bytes:

float dato=3.141592;
to_eeprom (&dato, 4, 0x00);

Per recuperare il dato si fa in maniera analoga:

float dato;
from_eeprom (&dato, 4, 0x00);

Esempio di utilizzo con strutture

Definisco una struttura di esempio composta da un char, un float e un intero a 16bit e la salvo in eeprom a partire dall’indirizzo 0x04:

struct struttura
{
char dato1; //occupa 1 byte
float dato2; //occupa 4 byte
int dato3; //occupa 2 byte
} test_struttura; // il tipo di dato "struttura" occupa 7 byte: 1+4+2
 
to_eeprom(&test_struttura,7, 0x04);

Per recuperare la struttura:

from_eeprom(&test_struttura, 7,0x04);

Possiamo utilizzare le funzioni anche su array di strutture:

struct struttura test_array_di_strutture[5]; // questo array occupa 7*5=35 byte
to_eeprom(&test_array_di_strutture,7*5, 0x40); // scrivo a partire da 0x40
from_eeprom(&test_array_di strutture, 7*5,0x40); // leggo

Le funzioni sono state testate con Hitech-C per PIC18 ma dovrebbero funzionare correttamente con qualiasi compilatore ANSI.