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.

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!

The post Netduino impiegare la memoria 24LC256 appeared first on Esperimenti con logiche programmabili.

Il limite di memoria di una scheda Arduino può essere superato utilizzando delle memorie esterne che permettono di aggiungere capacità di memorizzazione per tutte quelle applicazioni che richiedono la registrazione di dati. Possiamo scegliere tantissimi tipi di memorie a seconda del tipo di interfaccia (I2C, SPI, parallela…) e dalla loro capacità.

Per questo tutorial ho scelto una comunissima EEPROM Seriale prodotta da Microchip, la 24LC256. Questa memoria può essere collegata alle schede Arduino tramite bus I2C e offre 256 Kbits di memoria (32KB). La pin function della memoria è rappresentata in figura:

i pin A0, A1, A2 permettono di specificare l’indirizzo del dispositivo sul bus I2C, i pin Vcc e Vss sono rispettivamente l’alimentazione (5Vdc) e la massa (Gnd), il pin WP (Write Protect) abilita (se collegato a Gnd) o disabilita (se collegato a Vcc) la scrittura della EEPROM, i pin SCL e SDA sono relativi al collegamento I2C.

secondo il datasheet del produttore possiamo riassumere alcune caratteristiche fondamentali:

Per questo tutorial ho utilizzato una Arduino Leonardo. La figura seguente mostra i collegamenti del circuito.

Nello schema possiamo osservare che i pin A0, A1, A2 sono connessi a massa. Questi pin permettono di personalizzare l’indirizzo del dispositivo all’interno del bus I2C. Nel data sheet verifichiamo come viene formato il control byte address:

i 4 bit più significativi sono preimpostati (Control Code) mentre i bit A0, A1 e A2 sono personalizzabili da noi. Il bit meno significativo R/W, serve per selezionare una operazione di scrittura o una operazione di lettura.
Avendo a massa i pin A0, A1 e A2 i campi Chip Select Bits sono a zero. L’indirizzo del dispositivo è quindi il seguente:

in esadecimale otteniamo il valore:

0x50

Per poter eseguire operazioni di scrittura e lettura della memoria EEPROM del 24LC256, è necessario inviare, oltre al Control Byte (che specifica l’indirizzo del dispositivo nel busI2C), altri due byte che indicano l’indirizzo della locazione di memoria EEPROM del 24LC256 che vogliamo scrivere o leggere:

il dispositivo 24LC256 possiede 256Kbit di memoria, quindi le locazioni di memoria che possiamo scrivere e leggere sono 32000 byte (256000 / 8).
Avendo a disposizione 2 byte per selezionare l’indirizzo (Address High Byte e Address Low Byte) possiamo utilizzare una variabile int (formata appunto da 2 Byte) che impiegheremmo per specificare il valore dell’indirizzo della locazione di memoria (da 0 a 31999).

La libreria Wire non permette comunque di passare un valore intero perciò potremmo semplicemente effettuare una operazione bitwise per dividere la variabile intera in due byte. Fortunatamente esistono già delle funzioni che semplificano questa operazione, highByte e lowByte.

Il codice di esempio seguente permette di scrivere tutti i  32000 byte della mem0rie a di eseguire una lettura degli stessi:

#include <Wire.h>

int indirizzo = 0;
int data = 0;
int ciclo = 0;
void setup()
{
  //init seriale
  Serial.begin(9600);
  //per la Arduino Leonardo devo
  //attendere l'inizializzazione del modulo
  while (!Serial)
  {
    ;
  }

  //attendo ulteriori 5 secondi
  //prima di inviare un dato sulla seriale
  delay(5000);
  //invio un messaggio al serial monitor
  Serial.println("Start");
  //inizializzo la porta I2C della Arduino
  Wire.begin();
}

void loop()
{
  //avviso dell'inizio della
  //scrittura dei dati sulla seriale
  Serial.println("Inizio Scrittura");
  //init variabile
  indirizzo = 0;
  //eseguo ciclicamente la scrittura di
  //tutte e 32000 locazioni di memoria
  for (ciclo = 0; ciclo & lt; 32000; ciclo++)
  {
    //invio il control byte specificando
    //una richiesta di scrittura
    Wire.beginTransmission(0x50);
    //invio due byte contenenti l'indirizzo della
    //locazione di memoria che voglio scrivere un byte
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));
    //scrivo un byte nella locazione di memoria
    //precedentemente selezionata
    Wire.write(byte(data));
    //fine trasmissione
    Wire.endTransmission();
    //incrementa il valore di data
    data++;
    //quando la variabile data arriva a 255
    //resetto il suo valore a zero
    if (data == 255)
      data = 0;

    //incrementa il valore dell'indirizzo
    indirizzo++;
    //attendi 5ms per poter terminare le operazioni di
    //scrittura sulla memoria
    delay(5);
  }

  //avvisami quando la scrittura di 32000 byte
  //è terminata
  Serial.println("Fine Scrittura");
  //attendi 1/2 secondo
  delay(500);
  //avvisami dell'inizio della lettura
  Serial.println("Inizio lettura");

  //init variabile
  indirizzo = 0;
  for (ciclo = 0; ciclo & lt; 32000; ciclo++)
  {
    //invio il control byte specificando
    //una richiesta di scrittura
    Wire.beginTransmission(0x50);
    //invio due byte per selezionare la locazione
    //di memoria da leggere
    Wire.write(highByte(indirizzo));
    Wire.write(lowByte(indirizzo));
    Wire.endTransmission();
    //incremento la variabile indirizzo
    indirizzo++;
    //richiedo un byte al 24LC256
    Wire.requestFrom(0x50, 1);
    //attendo la disponibilità di dati sul bus i2c

    while (Wire.available())
    {
      Serial.print(ciclo);
      Serial.print(": ");
      //leggo dal bus il dato relativo alla
      //locazione di memoria precedentemente specificata
      byte c = Wire.read();
      //invio il dato al serial monitor
      Serial.println(c);
    }
  }
  delay(1000);
}

la scrittura di 32000 byte richiederà qualche minuto poiché il codice impiega circa 5ms per scrivere un byte (32000 * 0.005 => 160 secondi). La lettura invece risulta più fluida ed è anche influenzata dalla velocità della seriale, che per questo esempio è impostata a 9600bps.

The post 24LC256 utilizzare una memoria seriale su bus I2C appeared first on Esperimenti con logiche programmabili.

Nel precedente articolo abbiamo imparato a gestire i quattro ingressi analogici del dispositivo PCF8591P. In questo tutorial impareremo a utilizzare la porta DAC (Digital to Analog Converter) per creare una tensione continua partendo da un dato digitale.

Lo schema elettrico rimane pressoché invariato. L’unica modifica riguarda l’eliminazione dei collegamenti sui pin analogici AIN ed il collegamento al pin AOUT di un diodo led rosso da 3mm e di una resistenza (R) da 100Ohm:

L’indirizzo del PCF8591P sul bus I2C non viene modificato, rispetto all’articolo precedente, dato che i pin A0, A1 e A2 sono collegati a massa.
Possiamo sempre gestire l’acquisizione dai pin ADC (AIN0, AIN1, AIN2, AIN3), una funzione non esclude l’altra.

La risoluzione del convertitore digitale analogico è di 8bit quindi i valori possibili possono essere espressi con 256 valori digitali (da 0 a 255). Il valore di tensione associato per ogni valore digitali dipende dalla tensione presente sul pinVref e sul pin AGnd secondo questo grafico:

Nel circuito precedente il pin14 VRef è collegato alla 5Vdc mentre il pin13 Agnd è collegato a massa. Quindi per conoscere il valore di tensione associato alla variazione di un singolo bit possiamo eseguire questo calcolo:

tensione_rif/bit_totali = (Vref-Agnd) / 256 => (5-0)/256 => 19,5 mVdc per variazione d bit

ad esempio se caricassi sul DAC data register il valore decimale 127 otterrei in uscita dal pin15 del PCF8591 la tensione di:

Vout = ValDAC * ValStep => 127 * 19.5mVdc => 2.47Vdc

Cambiando il valore di Vref, ad esempio portandolo a 3.3Vdc otteniamo delle variazioni di tensione per bit più piccole. Questa scelta dipende dal tipo di progetto che vogliamo realizzare.

Per attivare la porta DAC del PCF8591P dobbiamo settare al livello alto il bit7 (Analog Output Enable Flag) del registro Control Byte.

La sequenza di byte da inviare al PCF8591P segue lo schema rappresentato nella figura seguente:

ovvero, dopo aver ‘selezionato’ sul bus I2C il dispositivo tramite il suo indirizzo, inviamo il byte di configurazione e successivamente il byte contenente il valore digitale che verrà poi convertito in segnale analogico.

Passando al codice di esempio ho realizzato uno sketch che ha il compito di  far variare la tensione sul pin15 da 5Vdc sino a scendere gradualmente a 0Vdc per poi ritornare, sempre gradualmente, a 5Vdc, ottenendo un effetto fade sul diodo led collegato come da schema:

#include <Wire.h>
byte ciclo=0;

void setup()
{
 //inizializzo la libreria Wire come Master
 Wire.begin();
}

void loop()
{
 for(ciclo = 255; ciclo > 0; ciclo--)
 {
  Wire.beginTransmission(0x48);
  //invio un byte
  Wire.write(byte(0x40));
  Wire.write(byte(ciclo));
  //fine trasmissione
  Wire.endTransmission();
  delay(10);
 }
 
 for(ciclo = 0; ciclo < 255; ciclo++)
 {
  Wire.beginTransmission(0x48);
  //invio un byte
  Wire.write(byte(0x40));
  Wire.write(byte(ciclo));
  //fine trasmissione
  Wire.endTransmission();
  delay(10);
 }
}

The post Usare la porta DAC del PCF8591P appeared first on Esperimenti con logiche programmabili.

L’integrato PCF8591 prodotto da NXP dispone di 4 ingressi analogici con risoluzione di 8 bit e di una uscita analogica sempre ad 8 bit. La sua gestione avviene tramite bus I2C, permettendo così il collegamento nel bus di diversi integrati (per un massimo di 127 unità). Avendo una gestione software semplice ed un costo intorno ai 3€ viene impiegato in diversi shield Arduino per aumentare il numero di porte ADC, inoltre la presenza di una uscita analogica programmabile (DAC) permette di generare segnali utili in diversi progetti e applicazioni.

Nella figura seguente viene mostrato lo schema a blocchi del PCF8591:

Per specificare l’indirizzo del dispositivo all’interno del bus I2C vengono impiegati i pin A0, A1 e A2. La scelta del canale ADC che vogliamo impiegare avviene tramite il registro control byte, configurabile via software come anche la gestione dell’uscita analogica, che in questo tutorial non verrà trattata.

Il circuito di esempio che  utilizza un integrato PCF8591P ed un Arduino UNO, di seguito lo schema:

I pin A0, A1,e A2 sono collegati a massa, quindi il loro valore logico è pari a zero. Sul datasheet del componente possiamo dedurre quale sarà l’indirizzo sul bus I2C seguendo questa tabella:

i quattro bit piu significativi sono fissi e non possono essere cambiati, mentre i tre bit meno significativi sono appunto collegati ai pin A0 A1 e A2. Nello schema essendo collegati a massa, otterremo l’indirizzo del dispositivo che  corrisponderà, al valore binario seguente:

0b1001000

che convertito in esadecimale diventa:

0x48

Una volta stabilito l’indirizzo, è necessario configurare il dispositivo tramite il registro ‘control byte’. Questo registro permette di scegliere il canale analogico da rendere attivo per l’acquisizione (bit 0 e bit 1 A/D Channell Number) e la configurazione degli ingressi analogici (bit4 e bit5 Analog Input Programming).
Le informazioni di questo registro sono riassunte in questo schema, presente nel datasheet:

Tralasciamo il bit per l’uscita analogica (bit6) e il bit  auto increment (bit2), assegnandoli il valore logico zero.
I valori da assegnare al control byte per selezionare i diversi ingressi analogici in configurazione four single-ended inputs (bit4 e bit5 a zero) dovranno essere:

0b00000000 -> 0x00 -> attiva l’ingrasso analogico AIN0
0b00000001 -> 0x01 -> attiva l’ingrasso analogico AIN1
0b00000010 -> 0x02 -> attiva l’ingrasso analogico AIN2
0b00000011 -> 0x03 -> attiva l’ingrasso analogico AIN3

La sequenza di byte da inviare è la seguente:

quindi tramite le dovute istruzioni, invieremo sul bus I2C un primo byte contenente l’indirizzo del dispositivo e un secondo byte riguardante la configurazione interna del dispositivo.
L’integrato PCF8591 è così pronto ad acquisire ed inviare il dato sul canale I2C.
Il codice seguente permette di acquisire un dato analogico sul pin AIN0 e sul pin AIN1 del dispositivo e di inviarlo al serial monitor dell’ IDE Arduino:

//libreria I2C
#include <Wire.h>

void setup()
{
 //inizializzo la libreria Wire
 Wire.begin();
 //init seiale
 Serial.begin(9600);
 //avviso che il programma è avviato
 Serial.println("START");
}

void loop()
{
 //avvio una richiesta di scrittura al
 //dispositivo con indirizzo 0x48
 Wire.beginTransmission(0x48);
 //invio il byte di configurazione
 //in questo caso abilito il canale analogico AIN0
 Wire.write(byte(0x00));
 //fine trasmissione
 Wire.endTransmission();
 //richiedo un byte allo slave che ha indirizzo 0x48
 Wire.requestFrom(0x48, 1);
 //attendo la disponibilità di dati sul bus i2c
 while(Wire.available())
 {
  //leggo il byte che mi invia il PCD8591
  byte c = Wire.read();
  //invio il dato al serial monitor
  Serial.println(c);
 }
 //pausa 10 millis
 delay(10);
 //avvio una richiesta di scrittura al
 //dispositivo con indirizzo 0x48
 Wire.beginTransmission(0x48);
 //invio il byte di configurazione
 //in questo caso abilito il canale analogico AIN01
 Wire.write(byte(0x01));
 //fine trasmissione
 Wire.endTransmission();
 //richiedo un byte allo slave che ha indirizzo 0x04
 Wire.requestFrom(0x48, 1);
 //attendo la disponibilità di dati sul bus i2c
 while(Wire.available())
 {
  //leggo dal bus il dato relativo alla
  //conversione a/d sul pin AIN01
  byte c = Wire.read();
  //invio il dato al pc
  Serial.println(c);
 }
 //esegui il codice ogni secondo
 delay(1000);
}

Sinteticamente viene prima configurato, tramite il ‘control byte’, il dispositivo PCF8591 e successivamente viene avviata una richiesta di lettura dal dispositivo. Per eseguire la lettura dei quattro, è necessario eseguire quattro configurazioni e quattro letture.

The post Come usare l’integrato PCF8591 appeared first on Esperimenti con logiche programmabili.

Una caratteristica che reputo molto interessante è la possibilità di espandere Arduino tramite l’uso di shield. La maggior parte di queste schede aggiuntive sono però progettate per compiere una funzione specifica, non programmabile.
Esistono alcuni metodi che permettono di comunicare con altri dispositivi utilizzando come canale di trasmissione dati i protocolli seriali (I2C, SPI o RS232). Questo rende possibile demandare ad una scheda slave funzioni di elaborazione gravose, che non vogliamo far eseguire alla scheda master. Ho realizzato questo piccolo tutorial usando il bus I2C per creare uno scambio dati tra un Arduino ed un chip ATmega328 standalone.

Il bus I2C, basandosi su due fili, non permette la comunicazione contemporanea tra Master e Slave. Lo scambio dati deve essere gestito dal Master tramite gli indirizzi (univoci) degli slave. Il flusso può essere sintetizzato in questo modo

1. Il Master invia sul bus un bit di start
2. Il Master invia sul bus l’indirizzo dello slave con cui vuole comunicare
3. Il Master decide se scrivere o leggere dal dispositivo
4. Lo Slave legge o scrive in base alla richiesta del Master

La libreria Wire dispone di tutte le funzioni necessarie alla realizzazione Master-Slave tra due schede Arduino. Lo schema del circuito che ho realizzato è visibile nella figura seguente.

Come detto precedentemente lo schema si basa su Arduino Uno impiegato come Master e con un ATmega328 impiegato come slave.

Il codice permette di inviare un dato numerico allo slave, che provvederà ad incrementarlo per poi rispedirlo al Master.

[c]
//MASTER
#include <Wire.h>

byte x = 0;
byte num = 0;

void setup()
{
//inizializzo la libreria Wire come Master
Wire.begin();

//init seiale
Serial.begin(9600);
//avviso che il programma è avviato
Serial.println("START");

}

void loop()
{
//invio sul bus I2C un byte al device
//che ha come indirizzo il valore 0x04
//start trasmissione
Wire.beginTransmission(0x04);
//invio un byte
Wire.write(x);
//fine trasmissione
Wire.endTransmission();

delayMicroseconds(500);

//richiedo un byte allo slave che ha indirizzo 0x04
Wire.requestFrom(0x04, 1);

//attendo la disponibilità di dati sul bus i2c
while(Wire.available())
{
//quando è presente un dato avvia
//la lettura
num = Wire.read();
}

//incrementa il valore del byte
x++;

//verifico che il byte letto dallo slave sia stato
//incrementato
if(num != x)
Serial.println("ERRORE");

delay(5);

}

[/c]

Il codice seguente è relativo allo Slave

[c]
//SLAVE
#include <Wire.h>

byte x = 0;

void setup()
{
//inizializzo la libreria
//imposto l’indirizzo dello slave
Wire.begin(0x04);

//eventi per la ricezione del dato
//e per la richiesta del dato
Wire.onReceive(receiveEvent);
Wire.onRequest(requestEvent);
}

void loop()
{
//esegui qualcosa
delay(1000);
}

void receiveEvent(int data)
{
//questo evento viene generato quando sul bus
//è presente un dato da leggere

//eseguo la lettura
x = Wire.read();

//elaboro il dato letto
x++;
}

void requestEvent()
{
//questo evento viene generato quando il master
//richiede ad uno specifico slave
//una richiesta di dati

//spedisco il dato al Master
Wire.write(x);

}

[/c]

I commenti presenti nel codice permettono di capire ciò che avviene tra i due dispositivi.

Di seguito uno screenshot dei dati scambiati sul bus

Di seguito invece la trasmissione del Master

The post Comunicazione tra Arduino tramite I2C appeared first on Esperimenti con logiche programmabili.

Il mondo dell’elettronica, come sapiamo, è composto da migliaia di componenti che svolgono funzioni dedicate, come un sensore di temperatura, oppure sono capaci di gestire diverse operazioni come nel caso dei microcontrollori.
La tecnologia analogica ha pian piano lasciato il posto a quella digitale e i componenti hanno iniziato a colloquiare tra loro utilizzando vari protocolli di comunicazione (insieme di regole che determinano il funzionamento della comunicazione).
Oggi, la maggior parte dei circuiti utilizza un microcontrollore, il cui compito è quello di gestire il circuito ed i componenti ad esso collegato.
Nel caso di sistemi complessi i componenti che creano il circuito sono diversi e possono saturare la capacità fisica di collegamento del microcontrollore, come nel caso proposto in figura.

Ben presto si è capito che per snellire questo tipo di circuiti era necessario creare un meccanismo capace di ottimizzare l’interconnessione tra componenti e microcontrollore. Il sistema più efficace è certamente quello di adottare un bus di collegamento, che permette lo scambio di dati, tra componenti e microcontrollore, utilizzando pochi fili comuni.
La figura seguente mostra un esempio di bus dove diversi componenti sono interconnessi utilizzando solo 2 fili. Il microcontrollore in questo caso deve gestire la comunicazione utilizzando un protocollo comune a tutti i componenti.
Diverse aziende svilupparono dei protocolli che col tempo sono divenuti degli standard, in questo modo componenti e microcontrollori hanno iniziato a scambiarsi dati in modo semplice ed efficiente.

La Philips negli anni ’80 sviluppò il Bus I2C (Inter Integrated Circuit pronunciato i-quadro-ci o i-due-ci), un protocollo seriale che usa due fili per instaurare la comunicazione con i componenti.

Tipicamente questo protocollo richiede un master (il microcontrollore che gestisce la comunicazione), e uno o più componenti slave (sensori, ADC, DAC, memorie ecc… che inviano i dati al microcontrollore).
Gli slave vengono identificati nel bus tramite un indirizzo univoco. Il master invia sulla linea l’indirizzo dello slave con cui vuole instaurare la comunicazione.
E’ possibile un sistema con più master (multimaster) ma la comunicazione deve sempre essere gestita da un master alla volta.

Il bus I2C permette di collegare agli stessi due fili ben 112 dispositivi. La velocità di comunicazione non è elevatissima e puoi variare, tipicamente, da un minimo di 10Kbits/s fino a 400Kbits/s (sviluppi successivi del bus I2c hanno permesso velocità fino a 3.4Mbits/S e interconnessioni di 1024 componenti).

I segnali presenti sui fili sono chiamati SDA (Signal DAta) per il trasferimento dei dati e SCL (Serial Clock Line) per la sincronizzazione della linea. In figura è rappresentato il diagramma dei segnali:

Il master deve eseguire, per avviare la comunicazione, una commutazione della linea SDA dallo stato alto allo stato basso, quando il segnale SCL è alto (vedi riquadro Start).
Successivamente il master può inviare dati sulla linea SDA.
Quando il segnale SCL è basso il master inizia a scrivere il valore del bit (1 o 0); quando il segnale SCL è alto, il bit è stabile e può essere letto dallo slave (riquadro BIT1).Questo procedimento si ripete per tutti i bit (Riquadro BIT2 e BIT N).
Quando tutti i bit sono stati inviati, la comunicazione termina quando il master riporta la linea SDA a livello alto in concomitanza del livello alto della linea SCL (riquadro Stop).

Questo esempio spiega il comportamento tipico dei segnali sul bus.

La comunicazione tra master e slave è risulta nella pratica più complessa di quanto espresso precedentemente. Per capire meglio è utile analizzare un esempio reale, perciò ho realizzato un semplice circuito che impiega un Pic 16F876 e un sensore di temperatura digitale MCP9803 che colloquiano utilizzando il bus I2C.

Lo schema elettrico è il seguente:

Il circuito utilizza un microcontrollore per comunicare con il sensore di temperatura MCP9803. I dati acquisiti vengono acquisiti e inviati tramite la porta UART del pic al pc. Il Max233 converte i segnali TTL in segnali RS232.

Partiamo con lo studio del datasheet del sensore MCP9803. Le caratteristiche principali sono riassunte nella tanella seguente:

Il pin 1 (SDA) del sensore è collegato direttamente al pin 15 del pic (SDA), mentre il pin 2 (SCLK) del sensore è collegato al pin 14 del pic (SCL).

I pin 5, 6, 7 del sensore (A0, A1, A2) permettono di definire l’indirizzo del dispositivo all’interno del bus. Sul datasheet possiamo leggere come viene impostato:

Per comporre l’indirizzo sono necessari 7 bit. Nei modelli 9800/xxxx gli indirizzi sono predefiniti, mentre nell’MCP9803 i bit A3, A4, A5, A6 sono scelti dalla casa costruttrice e i bit A0, A1, A2 sono impostabili dall’utente.

Nel circuito in questione, i pin A0, A1, A2 sono collegati a massa, quindi a valore logico 0, di conseguenza l’indirizzo del nostro sensore è 1001000 (0x48 in esadecimale).

Bene ora l’MCP9803 può essere identificato dal pic usando l’indirizzo a 7 bit.

Scorrendo il datasheet, andiamo nella sezione register:

Il sensore ha un registro che permette di accedere ai vari registri interni, come ad esempio il Configuration Register dove possiamo cambiare la risoluzione del convertitore digitale. Vedremmo poi come cambiare la risoluzione da 9bit (valore di default) a 12bit.
Quello che ci serve ora è leggere il dato del ‘Temperature Register’. Per selezionarlo è sufficiente porre il bit0(P0) e il bit1(P1) a 0 (Questo registro è a 0 per default ma eseguiamo comunque l’operazione ai fini didattici).

Ora studiamo la sezione dove è illustrata la sequenza di comunicazione tra il master ed il sensore MCP9803.

Si inizia con il comando di start (SDA va basso quando SCLK è alto – vedi box rosso ‘S’) poi il master scrive i 7 bit dell’indirizzo dello slave (1001000) più un bit che definisce se vogliamo leggere o scrivere nei registri dello slave (Se questo bit è a 1 leggeremo i dati dallo slave se è a 0 scriveremo i dati nello slave).
Questa informazione del bit che definisce la lettura o la scrittura è presente in questa sezione del datasheet.

Il master invia il seguente valore binario 10010000 (0x90 in esadecimale) per scrivere sullo slave.
Dopo l’invio del byte sul bus I2C, lo slave risponde con un acknowledges (pone la linea SDA bassa quando il SCLK è alto).
Ora il master invia un secondo byte per scrivere sul register point il valore necessario a selezionare il registro Temperature Regiser (Bito e Bit1 a 0). Il sensore risponde con un altro acknowledges.

Adesso che abbiamo impostato il sensore, per leggere dal registro contenente il dato della temperatura, possiamo avviare l’operazione di lettura.
Controlliamo ancora il datasheet  e appuriamo che il dato della temperatura è espresso con due byte.

L’operazione per leggere due byte consecutivi dal registro selezionato è rappresentata in figura:

Inviamo un comando si Start, poi l’indirizzo dello slave (0x48) ed il bit di selezione lettura/Scrittura impostato a 1(lettura). Il valore binario risultante è 10010001 (0x91 in esadecimale).

Il sensore risponde con un acknowledges. Il master esegue la lettura del primo byte, invia un acknowledges, legge il secondo byte ed invia un not acknowledges (indica allo slave la fine della lettura).
Il master termina la comunicazione inviando un comando di stop (riquadro P).

Il codice che permette al pic di eseguire tutte queste operazioni è stato scritto utilizzando MikroC Pro della Mikroelektronika. Il linguaggio, basato sulla sintassi del C, risulta molto semplice e facile da scrivere.
Inoltre sono disponibili molte librerie che svolgono molte operazioni tra le quali quella relativa all’uso del bus I2C.

Il codice caricato sul pic16F876 è il seguente:

unsigned short Primo_Byte = 0;
unsigned short Secondo_Byte = 0;

void main()
{
//inizializzo la porta UART
//a 9600bps
UART1_Init(9600);
//Inizializzo la porta I2C
//con una velocità di 400Khz
I2C1_Init(400000);

//Attendo 100 millisecondi
Delay_ms(100);

//invio uno Start sul bus I2C
I2C1_Start();
//Invio l'indirizzo 1001000
//setto il bit per la scrittura
I2C1_Wr(0x90); //10010000
//scrivo sul Register point il valore 0
//per accedere al Temperature Register
I2C1_Wr(0x00);

//ciclo infinito per leggere
//continuamente la temperatura
while (1)
{
//invio uno Start sul bus I2C
I2C1_Start();

//Invio l'indirizzo 1001000
//setto il bit per la scrittura
I2C1_Wr(0x91); //10010001
//leggo il primo Byte ed invio un acknowledge
Primo_Byte = I2C1_Rd(1);
//leggo il primo Byte ed invio un NOT acknowledge
Secondo_Byte = I2C1_Rd(0);
//Invio uno stop sul bus I2C
I2C1_Stop();

//Invio sulla seriale i dati letti dal sensore
UART1_Write(Primo_Byte);
UART1_Write(Secondo_Byte);

//attendo 2 secondi tra una lettura e la
//sucessiva
Delay_ms(2000);

}
}

Il pic acquisisce il segnale ed invia i dati grezzi al pc che dovrà interpretarli ed elaborarli secondo la formula presente nel datasheet:

dove Code è il dato grezzo letto dal sensore, mentre n dipende dal valore di risoluzione del convertitore (-1 per 9bit di risoluzione, -2 per 10bit di risoluzione, -3 per 11bit di risoluzione e -4 per 12bit di risoluzione).

Il datasheet mostra una tabella di esempio che possiamo usare per capire come avviene questo calcolo:

L’esempio con 9bit di risoluzione e una temperatura ambiente di 125°C produce un valore binario formato da 9bit, suddivisi in due byte, il primo con valore binario di 01111101 e il secondo con valore binario 00000000 (vedi riquadri 1° Byte e 2° Byte). Questi due byte devono essere uniti per formare un valore intero.
Il primo byte è quello più significativo mentre il secondo è quello meno significativo, quindi uniamo il bit del secondo byte al primo:

01111101 + 0 = 011111010 => 0xFA (esadeciale) => 250 (Decimale)

Ora applichiamo la formula per calcolare la temperatura

250 * 2^-1 = 250 * 0.5 = 125°C

Nella seconda parte illustrerò come acquisire i dati inviati dal pic con la seriale e come cambiare la risoluzione di campionamento da 9bit a 12bit.

Come sempre aspetto i vostri suggerimenti.

The post Protocollo I2C e sensore di temperatura MCP9803 (1°parte) appeared first on Esperimenti con logiche programmabili.