Controllo
di apparecchiature con VB (seconda parte)
a cura di Antonio Giuliana
(requisiti: conoscenza generica VB e VC,
elementi di elettronica digitale, programmazione dei microprocessori Microchip)
|
(precedente) |
|
Pilotiamo due display |
|
Il protocollo usato per l'attivazione delle uscite si basa su tre segnali, DATA, STROBE e CLOCK assegnati, rispettivamente, ai bit D0, D1 e D2 in uscita dalla porta parallela (pin 2, 3 e 4). Il protocollo usato per pilotare i registri, è derivabile dalla seguente temporizzazione dei segnali |
 |
 o, meglio,
dalla relativa tabella (a fianco), da cui, in poche parole, si deduce
che i bit presenti all'ingresso D sono trasferiti sequenzialmente ad ogni
impulso di CLOCK positivo alle uscite dei flip-flop interni e da questi
trasferiti alle uscite parallele dell'integrato tramite un impulso positivo
all'ingresso di STROBE. |
|
Il programma provvede ad accettare il valore, inviarlo al circuito
e visualizzarlo su form. |
|
Come gestire n ingressi |
 |
Come
primo esempio, cercheremo di pilotare due display a 7 segmenti (quelli
utilizzati in molti apparecchi elettronici come radiosveglie e tv) per
visualizzare un numero.
Un display
a LED ad anodo comune, visto da dietro, presenta i terminali disposti
come nella figura a fianco
Il programma
di controllo provvede ad inviare i bit, secondo i seguenti passi:|
da cui si comprende che il segnale PL (Parallel Load), attivo quando posto a zero, è utilizzato per caricare gli 8 bit dall'esterno all'interno del registro dell'integrato e che ogni segnale di clock (Clock Pulse, CP oppure CK) permette di presentare gli 8 bit in sequenza su una sola uscita. I bit in uscita sono nell'ordine MSB...LSB (il circuito è mostrato accanto) e vengono sfruttati i segnali D0, D1 e BUSY della porta parallela (rispettivamente PL, CK e DOUT degli integrati). |
 |
 |
|
|
Il programma di controllo (I74165.EXE) provvede ad ottenere i bit dall'interfaccia e presentarli, secondo i seguenti passi:
Il programma provvede a leggere il valore dal circuito e visualizzarlo su form. |
|
Anche in questo caso è possibile espandere il circuito aggiungendo un integrato per ogni 8 ingressi richiesti e anche in questo caso, le linee usate per pilotarlo rimangono sempre le stesse. È necessario modificare la routine di ingresso dei dati per adattarla al numero di ingressi di cui il circuito dispone. Un'altra tecnica per tre display |
 |
|
Mentre il circuito integrato è pilotato dai soliti segnali di controllo (DATA, CLOCK e STROBE) attraverso le linee D0, D1 e D2, i singoli transistor che accendono e spengono i display sono pilotati dai segnali D3, D4 e D5. Notare che i display sono accesi quando il segnale corrispondente è a 0, spenti se è a 1 (la logica negata è determinata dal fatto che i transistor sono dei PNP). |
|
|
|
Per avere molte uscite |
|
|
 |
Il
programma che pilota il circuito provvede ad accendere in sequenza i
3 display in base ad un evento controllato da un timer. Il software
di prova (MPR4094.EXE) permette di sfruttare il display come uno di
quei contatori presenti in vari negozi per gestire il turno di vendita
(naturalmente i pulsanti di controllo, che sono su un form, possono
essere collegati fisicamente al dispositivo). Un pulsante serve per
aumentare il numero, uno per metterlo a zero e un altro per diminuirlo.
Il
primo impulso è di sincronizzazione e prevede il bit dei dati
a 1, seguono 34 impulsi per i dati che sono inseriti in un registro
interno. All'arrivo del 36° impulso, i dati sono portati all'esterno
in blocco. Il circuito è semplice in quanto il circuito integrato
svolge la maggior parte delle funzioni. Dato l'alto numero di collegamenti,
è bene però porre attenzione durante la realizzazione
pratica.|
Questo circuito, adeguatamente pilotato dal software di cui si dirà in seguito, provvede a mostrare su 4 display l'ora corrente (ore/minuti). I due LED centrali lampeggiano per scandire i secondi mentre il tasto serve a mostrare la data attuale (giorno/mese). Notare come le linee della porta parallela impiegate siano soltanto due per pilotare i display e una terza per richiedere la visualizzazione della data. Naturalmente il tasto potrebbe essere completamente sostituito da una funzione analoga svolta da un pulsante sul form. La foto accanto (sebbene non molto definita) mostra un esempio di come sia possibile realizzare il circuito utilizzando una scheda per prototipi |
 |
 |
Il cuore del programma (5450.EXE) è sicuramente costituito da
una coppia di sub che pilotano il circuito integrato. Queste sono la Write5450 e la ClockPulse |
Private Sub Write5450(ByVal v As String)
Dim ix As Integer
With IO
.BitSet PAR1, DATA
ClockPulse
For ix = 1 To 34
If Mid(v, ix, 1) = "1" Then
.BitSet PAR1, DATA
Else
.BitReset PAR1, DATA
End If
ClockPulse
Next ix
ClockPulse
End With
End Sub
Private Sub ClockPulse()
With IO
.BitSet PAR1, CLOCK
.BitReset PAR1, CLOCK
End With
End Sub
|
|
La ClockPulse emette un impulso positivo sul terminale CLOCK del dispositivo (collegato alla linea D0 della porta parallela) ponendo la linea prima a 1 e poi a 0. La ClockPulse viene utilizzata dalla Write5450 inizialmente per emettere il bit di sincronizzazione sul terminale DATA (collegato alla linea D1 della porta parallela) ponendolo uguale a 1. In seguito sono emessi i 34 bit di dati (ognuno seguito da un impulso di clock) e, al termine, un ulteriore impulso di clock utilizzato dall'integrato per caricare il gruppo di bit ricevuti nel registro collegato alle uscite (segnale di LOAD interno). Notare che il segmento del display (ovvero il LED) viene acceso quando il bit passato è uguale a 1; l'integrato provvede a negare ogni bit in modo da collegare a massa i LED e accenderli. Il test sul pulsante per visualizzare la data viene fatto all'interno dell'evento timer. |
|
Come si può notare dallo schema, la comunicazione avviene tramite
4 linee dati sincronizzate da alcuni segnali di controllo che sono forniti
dal PC al display. Il display può essere montato facilmente come
mostrato in questa foto |
|
|
|
Il protocollo I2C La comunicazione avviene, essenzialmente, tra un dispositivo detto master e uno o più dispositivi detti slave. La comunicazione viene gestita dal master (che inizia e conclude lo scambio di dati) il quale contatta uno (ed uno solo) dei dispositivi slave che risponde adeguatamente. Tutti i dispositivi sono disposti su un unico bus fatto dai due segnali di cui si diceva (SCL per il clock e SDA per i dati); tutti gli slave 'ascoltano' le comunicazioni del master, anche se uno solo può rispondere. Questo significa che i dispositivi slave devono essere, in qualche modo, definiti in maniera univoca nella 'rete' e, allo scopo, ognuno di essi detiene un 'indirizzo'. Il master, quindi, quando vuole comunicare con uno slave, deve prima comunicarne sul bus l'indirizzo; solo se il dispositivo slave conferma la sua presenza, il master può inviare o richiedere dati. I due segnali possono essere bidirezionali, ma per i nostri scopi,
è sufficiente che la linea SCK possa essere solo di uscita. Le
due linee devono essere collegate normalmente all'alimentazione positiva
tramite due resistenze di pull-up. Lo schema a blocchi che segue, mostra
come è possibile realizzare un circuito che utilizza il protocollo
I2C |
|
Il protocollo I2C prevede che il dispositivo master inizi
la comunicazione generando una condizione detta di start e la
concluda con una condizione di stop. Tra i bit di start e di stop si svolge tutto lo scambio
dati tra master e slave. I dati vengono scambiati byte
per byte, impostando sulla linea SDA il valore logico del singolo bit
e, per ogni bit, inviando un impulso positivo sulla linea SCL. Dopo
l'ottavo bit, il master rilascia la linea dei dati e invia un ulteriore
impulso sulla linea SCL; durante tale lasso di tempo, il dispositivo
slave deve porre il bit SDA a livello logico basso per indicare
che la trasmissione è avvenuta correttamente e subito dopo rilasciare
la linea SDA. Questo nono bit viene denominato Ack bit (acknowledge
bit, bit di riconoscimento) e il seguente diagramma ne mostra il
funzionamento È importante capire che il bit di Ack deve essere generato dal dispositivo che riceve i dati; nel caso in cui sia il dispositivo slave a ricevere il byte (di comando o dato) è lo slave a generare il bit di Ack alla fine di ogni byte; nel caso sia il master a ricevere dei dati dallo slave, allora è il master a dover generare il bit di Ack alla fine del byte. Il primo byte trasmesso dal master subito dopo il bit di start è un byte di controllo e il significato dei suoi bit è il seguente: |
Usiamo un display LCD
Il programma
di controllo (LCD.EXE) ammette due linee di testo da 16 caratteri da
trasmettere al display. Con un ulteriore tasto, tramite il transistor
(collegato alla linea D0 della porta parallela) è possibile accendere
la retroilluminazione del display (se prevista nel modello prescelto);
a tale scopo è necessario portare tale linea a livello logico
zero. Il display accetta comandi e dati in due modalità: tramite
il bus parallelo a 8 bit o nella modalità a 4 bit; quest'ultima
è più semplice da gestire a livello hardware, anche se
un po' più complessa a livello software. Il controller HD44780
(un chip SMD da 80 piedini, attualmente non più prodotto dalla
Hitachi, ma compatibile con altri chip in commercio) offre funzionalità
molto complesse i cui dettagli possono essere ottenuti consultandone
il datasheet (vedere bibliografia). Attenzione al fatto che la piedinatura
mostrata nel circuito elettrico si riferisce ai display reperibili in
commercio (di diverse marche e modelli) comunque compatibili con il
controller HD44780; questi display, in genere, si interfacciano al mondo
esterno tramite 16 contatti.
Quando
il bus è in condizione di riposo (ovvero, quando nessuna comunicazione
avviene tra master e slave) i due segnali sono a livello
logico alto. Lo start viene generato quando la linea SDA va a
livello logico basso mentre la linea SCL è a livello logico alto;
lo stop viene riconosciuto quando la linea SDA va a livello logico
alto mentre la linea SCL è anch'essa a livello logico alto. Le
due condizioni sono mostrate dal diagramma accanto
| dal bit 7 al bit 4 | sono quattro bit che identificano il tipo di slave device utilizzato; è un valore assegnato in fabbrica e non dipende dal fabbricante del dispositivo ma solo dal tipo. Ad esempio, le EEPROM seriali del tipo 24Cxx sono identificate dai bit 1010. Questo valore si ottiene dal datasheet del dispositivo e fa parte dell'indirizzo a 7 bit che identifica univocamente il dispositivo sul bus; |
| dal bit 3 al bit 1 | questi tre bit sono associati, rispettivamente, ai valori logici presenti sui piedini A2, A1 e A0 del dispositivo slave. Essi, insieme ai quattro precedenti, fanno parte dell'indirizzo a 7 bit che identifica univocamente il dispositivo sul bus. Questo fatto significa, ad esempio per le EEPROM seriali del tipo 24Cxx, che è possibile montarne al massimo 8 sul singolo bus. Essendo fissi i primi 4 bit infatti, si potrà variare solamente la configurazione di questi 3 bit; |
| bit 0 | con questo bit (R/W) il master indica che vuole effettuare un'operazione di lettura (bit=1) o un'operazione di scrittura (bit=0) rispetto al device slave. |
|
Lo schema a blocchi che segue mostra come possa essere realizzato un corretto
indirizzamento di alcuni dispositivi slave per comunicare con un dispositivo
master utilizzando il bus I2C.
|
 |
In questo modo, sul bus, rispondono dei dispositivi slave ai seguenti indirizzi (tutti diversi):
in cui i primi 4 bit sono caratteristici del dispositivo (1010 per le 24Cxx e 0100 per i PCF8574) mentre i tre restanti sono cablati tramite i pin A2, A1 e A0 di ogni dispositivo. Naturalmente, nel nostro caso, il dispositivo master sarà il PC e il bus I2C sarà collegato alla porta parallela. |
|
Alcuni circuiti con dispositivi I2C Noi utilizzeremo il PCF8574 (indirizzo di base 0100) collegato alla porta parallela semplicemente alla linea D0 per il segnale di clock (SCL) e alla BUSY per il segnale dati (SDA) che deve essere di tipo bidirezionale. Il circuito mostra il collegamento tra la parallela e il circuito integrato tramite il bus I2C Le funzioni svolte da questo circuito sono semplici. I quattro pulsanti visibili in basso controllano l'accensione dei rispettivi LED collegati in alto e pilotati direttamente dall'integrato. Come si può vedere, le linee sono di input e di output e il collegamento alla porta parallela avviene tramite due fili necessari per il protocollo I2C. |
Il primo di questi circuiti impiega un PCF8574 (vedere datasheet in |
Il timer utilizzato nel programma (I2CBUS.EXE) per dialogare con l'integrato, esegue il seguente codice ' Read Input
I2CStart
I2CWriteByte &H40 ' Addr W
I2CNAck
I2CStart
I2CWriteByte &H41 ' Addr R
I2CNAck
byr = I2CReadByte \ &H10
I2CAck
I2CStop
' Write output
I2CStart
I2CWriteByte &H40 ' Addr W
I2CNAck
I2CWriteByte (&HF0 Or byr)
I2CNAck
I2CStop
che, periodicamente legge il dato proveniente dal nibble alto e lo scrive nel nibble basso. Durante l'operazione di scrittura è necessario scrivere il valore logico 1 in tutte le linee utilizzate come ingressi. Notare la sequenza usata per la lettura del byte e quella per la scrittura. In questo caso la gestione è molto semplice in quanto le informazioni scambiate si riducono ad un byte; per questo motivo esaminiamo il circuito che segue che utilizza un altro device di tipo I2C: una EEPROM di tipo 24C32. Questa EEPROM e altre simili sono molto diffuse in parecchie apparecchiature elettroniche di largo consumo e sono pilotabili tramite bus I2C. La 24C32, in particolare, è una memoria non volatile (ovvero, conserva le informazioni anche in assenza di alimentazione), programmabile elettricamente (non deve essere cancellata con raggi ultravioletti) e capace di memorizzare 32 Kbit (cioè 4 KByte). Le operazioni di lettura/scrittura, nel rispetto del protocollo I2C,
sono effettuate utilizzando una sequenza ben precisa. La 24C32 permette
di leggere/scrivere sia singole locazioni di memoria, sia pagine di
32 byte. L'operazione di scrittura è effettuata secondo la seguente
temporizzazione |
|
in cui si possono notare (in neretto i bit trasmessi dallo slave in risposta al master):
Esiste una sola limitazione: l'indirizzo di partenza fornito per scrivere i 32 byte, deve essere un multiplo di 32. Per la lettura, il protocollo prevede qualche passo in più. Dopo i primi 7 passi, infatti, è necessario fornire un nuovo bit di start (restart condition) e il byte di controllo con il bit di lettura/scrittura a 1 (lettura); in seguito, sarà possibile leggere dallo slave fino a 32 byte di dati (a partire dal primo indirizzo fornito). La temporizzazione è la seguente 
|
|
Quando sono letti i byte dall'EEPROM, il segnale di ack deve essere
fornito dal master (che in questo momento sta ricevendo); quando il
master non vorrà ulteriori byte, fornirà un segnale di
No Ack (ack negato) e un bit di stop per concludere la trasmissione. Per questo circuito, che conclude questa puntata, ho pensato di realizzare un programma più complesso rispetto ad un semplice dimostrativo di test. Anche se è migliorabile, ho scritto un programma abbastanza completo che permette di leggere/scrivere l'EEPROM, controllarne il contenuto e leggere/scrivere il contenuto su disco in formato .HEX o .BIN (standard per questo tipo di dispositivi). Con questo programma, che costituisce il cuore di un completo software per un programmatore di EEPROM seriali, tramite i tasti Legge e Scrive è possibile leggere dalla memoria e scriverci e con i tasti Apre e Salva si può leggere i dati da file (un .HEX o un .BIN) e scriverli. Il programma può essere ampliato aggiungendo una funzione di verifica, il supporto per altri tipi di EEPROM I2C e un aiuto in linea. Facendo queste e altre modifiche è possibile realizzare un dispositivo veramente utile. La gestione del dialogo con la memoria tramite bus I2C non differisce molto da quello che si svolge con il PCF8574 tanto che alcune funzioni di base (Start, Stop, Ack, Nack) sono comuni ai due programmi di gestione. Per maggiori dettagli è comunque sempre meglio consultare il datasheet (vedere bibliografia) della EEPROM 24C32.  |
|
Conclusioni Come promesso, nella prossima parte cominceremo a lavorare con i microcontrollori della serie PIC (Arizona Microchip) che interfacceremo al PC; scriveremo i programmi per il microcontrollore (rigorosamente in assembler) e per il PC (naturalmente in VB) in modo che dialoghino per ottenere quello che vogliamo. Bibliografia
FeedBack |
Il
circuito è molto semplice in quanto non è necessario utilizzare
l'alimentatore. Dato il bassissimo assorbimento dell'EEPROM infatti,
è possibile alimentarla tramite uno dei pin di uscita della porta
parallela che sarà impostato al valore logico 1 alla partenza
del programma di gestione. In questo caso, l'alimentazione viene prelevata
dalla linea D1 (pin 3). Naturalmente è diverso il discorso se
sono impiegati più chip sul bus I2C (o dei LED), nel qual caso
diventa necessario utilizzare l'alimentatore.