Nel precedente articolo abbiamo visto come utilizzare l’integrato PCF8574AP per espandere le porte IO di Arduino. Lo stesso circuito può essere adattato anche alla scheda Netduino. Dato che ho utilizzato Arduino Leonardo, i pin SCL e SDA, relativi al bus I2C, sono dedicati, mentre Netduino rispecchia la pin function della Arduino UNO e quindi i pin SDA e SCL sono disponibili rispettivamente sui pin analogico 4 e pin analogico 5.

In definitiva, per far funzionare il circuito, dobbiamo collegare i pin secondo la tabella seguente

Per quanto riguarda il codice sorgente possiamo osservare il listato seguente che permette di accendere e spegnere i led collegati alle porte del PCF8574AP

[csharp]
//buffer per memoriaazare indirizzi
//e dati
Byte[] tx_write = new Byte[1];
Byte[] tx_read = new Byte[1];

//Configurazione contenente l’indirizzo del PCF8574AP
//e la frequenza del bus i2c
I2CDevice.Configuration cnf = new I2CDevice.Configuration(0x38, 100);

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

//creo un oggetto I2CReadTransaction che viene associato al buffer tx_read
//il buffer viene utilizzato per verificare lo stato delle porte del PCF8574AP
I2CDevice.I2CReadTransaction[] rt_data = new
I2CDevice.I2CReadTransaction[] { I2CDevice.CreateReadTransaction(tx_read) };

//creo un oggetto I2CWriteTransaction che viene associato al buffere tx_write
//il buffer tx viene utilizzato per spedire lo stato delle porte del PCF8574AP
I2CDevice.I2CWriteTransaction[] wt_write = new
I2CDevice.I2CWriteTransaction[] { I2CDevice.CreateWriteTransaction(tx_write) };

while (true)
{
//imposto tutte le porte a livello logico basso
tx_write[0] = (Byte)(0x00);
//eseguo il comando
expanderPCF8574.Execute(wt_write, 10);

Thread.Sleep(1000);

//imposto tutte le porte a livello logico alto
tx_write[0] = (Byte)(0xFF);
//eseguo il comando
expanderPCF8574.Execute(wt_write, 10);

Thread.Sleep(1000);
}
[/csharp]

Leggere lo stato delle porte

la lettura dello stato delle porte del PCF8574AP avviene eseguendo il comando relativo all’oggetto i2creadtransaction:

[csharp]
while (true)
{
//eseguo il comando
expanderPCF8574.Execute(rt_data, 10);

Debug.Print(tx_read[0].ToString());

Thread.Sleep(1000);
}
[/csharp]

Anche utilizzando Netduino i comandi da eseguire per utilizzare il PCF8574AP sono molto semplici ed intuitivi.

The post Netduino, utilizzare il PCF8574AP appeared first on Esperimenti con logiche programmabili.

Capita di trovarci a realizzare applicazioni in cui il numero dei pin digitali richiesti, supera quelli disponibili sulla scheda Arduino UNO. In questi casi potremmo utilizzare una scheda con un numero maggiore di pin IO (ad esempio la Arduino MEGA, la Arduino DUE …) o scegliere dei circuiti esterni che danno la possibilità di espandere le porte IO utilizzando una comunicazione seriale I2C o SPI.

L’integrato PCF8574AP permette di risolvere questo problema fornendo 8 porte IO che possono essere gestite utilizzando il collegamento seriale I2C. Lo schema elettrico seguente mostra come collegare il pcf8574ap alla scheda Arduino Leonardo. L’unica osservazione riguarda le uscite del PCF8574, infatti come potete osservare i led non sono collegati direttamente alle porte dell’integrato ma bensì sono collegati tramite una resistenza alla linea dei 5Vdc. Questo perché l’integrato non è in grado di fornire la corrente sufficiente per alimentare il led; è quindi necessaria una resistenza di pull-up.

Quando impostiamo, per esempio, il pin P0 al livello logico alto, otteniamo l’accensione del led perché la corrente che fluisce dall’alimentazione attraversa la resistenza e poi il led. Quando impostiamo il pin P0 al livello logico basso il led si spegne perché la corrente viene ‘assorbita’ dall’integrato. Nelle figure seguenti potete osservare quanto detto:

Il codice per testare il circuito è molto semplice e permette di accendere e spegnere i led collegati ai pin delle porte dell’integrato PCF8574AP:

[c]
#include <Wire.h>

void setup()
{
Wire.begin();
delay(1000);
}

void loop()
{
//imposto tutti i pin al livello
//logico alto
Wire.beginTransmission(0x38);
//invio un byte
Wire.write((byte)0b11111111);
//fine trasmissione
Wire.endTransmission();

delay(1000);

//imposto tutti i pin al livello
//logico basso
Wire.beginTransmission(0x38);
//invio un byte
Wire.write((byte)0b00000000);
//fine trasmissione
Wire.endTransmission();

delay(1000);
}
[/c]

Avendo espresso il valore in forma binaria riusciamo facilmente ad accendere o spegnere ogni led cambiando il valore di ogni singolo bit. Ad esempio questo codice accende e spegne solo il led sulla porta P0:

[c]
#include <Wire.h>

void setup()
{
Wire.begin();
delay(1000);
}

void loop()
{
//imposto il pin P0 al livello
//logico alto
Wire.beginTransmission(0x38);
//invio un byte
Wire.write((byte)0b00000001);
//fine trasmissione
Wire.endTransmission();

delay(1000);

//imposto il pin P0 al livello
//logico basso
Wire.beginTransmission(0x38);
//invio un byte
Wire.write((byte)0b00000000);
//fine trasmissione
Wire.endTransmission();

delay(1000);
}
[/c]

Leggere i valori in ingresso

La lettura degli ingressi avviene semplicemente effettuando una richiesta di un byte al PCF8574AP. L’integrato provvederà automaticamente, tramite la sua architettura interna, a fornire al master lo stato delle porte. Possiamo ad esempio collegare i pin da P0 a P7 a massa o alla +5Vdc e successivamente effettuare una lettura:

[c]
#include <Wire.h>

void setup()
{
Serial.begin(9600);
delay(6000);

Wire.begin();
delay(1000);
}

void loop()
{
Wire.requestFrom(0x38,1);
if(Wire.available())
{
Serial.println(Wire.read(), BIN);
}

delay(1000);
}
[/c]

il codice precedente printa in binario lo stato di ogni singola porta del PCF8574AP, ad esempio proviamo a mettere a massa i pin P0, P1, P2 e P3 e colleghiamo alla +5Vdc i pin P5, P6, P7, P8, sul serial monitor osserveremo la stringa 11110000.

Per semplicità ho utilizzato delle variabili scrivendole in binario ma nulla ci vieta di utilizzare le funzioni di bitwise per creare codice più professionale.

The post PCF8574AP come espandere porte IO appeared first on Esperimenti con logiche programmabili.

Il primo programma che possiamo creare, per iniziare a sperimentare con Netduino, è il classico esempio che permette di far lampeggiare il led di sistema, posto sulla scheda del dispositivo.
Questo programma è ormai un classico che si può trovare un po da per tutto in internet, ma nonostante ciò, anche io volevo proporvelo.

Dopo aver avviato Visual C# e creato un nuovo progetto, apriamo il file Program.cs e all’interno del blocco Main() inseriamo le seguenti righe di codice.

OutputPort ledOnBoard = new OutputPort(Pins.ONBOARD_LED, false);

while(true) //Ciclo infinito
{
//accende il led
ledOnBoard.Write(true);
//attende 500 millisecondi
Thread.Sleep(500);
//Spegne il led
ledOnBoard.Write(false);
//attende 500 millisecondi
Thread.Sleep(500);
}

queste istruzioni accendono e spengono il led ad una frequenza di mezzo secondo.
l’istruzione :

OutputPort ledOnBoard = new OutputPort(Pins.ONBOARD_LED, false);

crea un oggetto che viene usato per controllare il led onboard; il costruttore della classe OutputPort richiede l’identificativo del pin e il relativo stato iniziale. Pins.ONBOARD_LED appunto, è il led fisico posto sul dispositivo e false indica lo stato iniziale, ovvero spento.

Il cico while è infinito ed esegue ciclicamente queste istruzioni:

//accende il led
 ledOnBoard.Write(true);
//attende 500 millisecondi
Thread.Sleep(500);
//Spegne il led
ledOnBoard.Write(false);
//attende 500 millisecondi
 Thread.Sleep(500);

la funzione write() dell’oggetto non fa altro che accendere o spegnere il led a seconda del valore booleano passato come parametro.
Thread.Sleep() serve per creare un ritardo tra le istruzioni Write() per creare l’effetto intermittente, il valore passato è espresso in millisecondi.

Non ci resta che avviare il debug per eseguire la compilazione e il caricamento dell’eseguibile nel Netduino.
Il dispositivo deve essere collegato al pc tramite porta usb e Visual c# deve essere configurato per interaggire con il Netduino piuttosto che con l’emulatore.

The post Netduino far lampeggiare un led appeared first on Esperimenti con logiche programmabili.