Netduino impiegare la memoria 24LC256 

Come usare la memoria 24LC256 con Netduino

dopo aver scritto l’articolo sull’utilizzo della memoria 24LC256 utilizzando una scheda Arduino ho realizzato questo piccolo tutorial per tutti gli utenti che possiedono una scheda Netduino.
La parte teorica e lo schema elettrico del circuito rimangono invariati, l’unica ovvia differenza è la scrittura del codice che in questo caso si basa sul linguaggio C#.

Questo è il codice:

[csharp]
//buffer per memorizzare indirizzi
//e dati
Byte[] tx_write = new Byte[3];
Byte[] tx_read = new Byte[2];
Byte[] rx_data = new Byte[1];

Int16 indirizzo = 0;
Byte data = 0;
Int32 ciclo = 0;

//creo un oggetto per usare il led onboard
OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);

//accendo il led onboard
led.Write(true);

//Configurazione contenente l’indirizzo della memoria 24LC256
//e la frequenza del bus i2c
I2CDevice.Configuration cnf = new I2CDevice.Configuration(0x50, 100);

//Creo un oggetto per eseguire le richieste di lettura e scrittura
I2CDevice mem24LC256 = new I2CDevice(cnf);

//creo un oggetto I2CReadTransaction che viene associato al buffer rx_data
//il buffer tx viene utilizzato per contenere i dati letti dalla memoria 24LC256
I2CDevice.I2CReadTransaction[] rt_data = new
I2CDevice.I2CReadTransaction[] { I2CDevice.CreateReadTransaction(rx_data) };

//creo un oggetto I2CWriteTransaction che viene associato al buffere tx_write
//il buffer tx viene utilizzato per spedire i due byte dell’indirizzo della
//locazione di memoria che vogliamo utilizzare e il byte contenente il dato
//da memorizzare nella memoria
I2CDevice.I2CWriteTransaction[] wt_write = new
I2CDevice.I2CWriteTransaction[] { I2CDevice.CreateWriteTransaction(tx_write) };

//creo un oggetto I2CWriteTransaction che viene associato al buffere tx_read
//il buffer tx_read viene utilizzato per selezionare la locazione di memoria
//da cui vogliamo leggere il contenuto
I2CDevice.I2CWriteTransaction[] wt_read = new
I2CDevice.I2CWriteTransaction[] { I2CDevice.CreateWriteTransaction(tx_read) };

//info di debug
Debug.Print("START Scrittura");

//eseguo un ciclo per memorizzare dati in tutti e 32KB
for(ciclo = 0; ciclo < 32000; ciclo++)
{
//compongo il buffer con l’indirizzo di memoria
//che voglio utilizzare ed il dato che voglio
//scrivere al suo interno
tx_write[0] = (Byte)((indirizzo >> 8) & 0xff);
tx_write[1] = (Byte)(indirizzo & 0xff);
tx_write[2] = data;

//eseguo il comando
mem24LC256.Execute(wt_write, 10);

//incremento il valore di data e lo resetto
//quando raggiunge il valore 255
data++;

if (data == 255)
data = 0;

//incremento il valore della
//locazione di memoria da usare
indirizzo++;

}

Debug.Print("Fine Scrittura");

//attendo 1 secondo
Thread.Sleep(1000);

Debug.Print("Inizio lettura");

//resetto il valore dell’indirizzo
indirizzo = 0;

for (ciclo = 0; ciclo < 32000; ciclo++)
{
//utilizzo il buffer tx_read per caricare
//l’indirizzo della locazione di memoria da dove
//leggere i dati
tx_read[0] = (Byte)((indirizzo >> 8) & 0xff);
tx_read[1] = (Byte)(indirizzo & 0xff);

//eseguo il comando
mem24LC256.Execute(wt_read, 10);

//attendo 5 ms
Thread.Sleep(5);

//ora eseguo il comando per leggere i dati dalla
//locazione di memoria precedentemente selezionata
//il dato letto viene memorizzato nelbuffer rx_data
mem24LC256.Execute(rt_data, 10);

//printo l’indirizzo della locazione di memoria corrente
//ed il suo contenuto
Debug.Print(indirizzo.ToString() + ":" + rx_data[0].ToString());

//incremento il valore della
//locazione di memoria da usare
indirizzo++;
}

Debug.Print("Fine lettura");

//spengo il led onboard a fine lettura
led.Write(false);

[/csharp]

Il codice è ricco di commenti che spiegano cosa eseguono le istruzioni!