Questo è il primo dei due capitoli in cui inizieremo a indagare sul bus dati SPI e su come possiamo controllare i dispositivi che lo utilizzano con i nostri sistemi Arduino.
Il bus SPI può sembrare un’interfaccia complessa da padroneggiare, tuttavia con qualche breve studio di questa spiegazione ed esempi pratici diventerai presto un master bus! Per fare ciò impareremo la teoria necessaria e quindi la applicheremo controllando una varietà di dispositivi. In questo tutorial le cose saranno mantenute il più semplice possibile.
Ma prima di tutto, che cos’è? E qualche teoria SP
SPI è l’acronimo di “Serial Peripheral Interface”. È un bus dati seriale sincrono-i dati possono viaggiare in entrambe le direzioni contemporaneamente, al contrario (ad esempio) del bus I2C che non può farlo. Per consentire la trasmissione sincrona dei dati, il bus SPI utilizza quattro fili. Sono chiamati:
- MOSI – Master-out, Slave-in. Questa linea trasporta i dati dal nostro Arduino al dispositivo SPI-controllato (s);
- MISO – Master-in, Slave out. Questa linea trasporta i dati dal dispositivo controllato da SPI all’Arduino;
- SS-Slave-selezionare. Questa linea dice al dispositivo sul bus che vogliamo comunicare con esso. Ogni dispositivo SPI ha bisogno di una linea SS unica all’Arduino;
- SCK – Serial clock.
All’interno di questi tutorial consideriamo la scheda Arduino come master e i dispositivi SPI come slave. Sulle nostre schede Arduino Uno e compatibili i pin utilizzati sono:
- SS-digital 10. È possibile utilizzare altri pin digitali, ma 10 è generalmente il valore predefinito in quanto è accanto agli altri pin SPI;
- MOSI-digital 11;
- MISO-digital 12;
- SCK – digital 13;
Arduino Mega utenti-MISO è 50, MOSI è 51, SCK è 52 e SS è di solito 53. Se si utilizza un Arduino Leonardo, i pin SPI sono sui pin di intestazione ICSP. Vedi qui per maggiori informazioni. È possibile controllare uno o più dispositivi con il bus SPI. Ad esempio, per un dispositivo il cablaggio sarebbe:
I dati viaggiano avanti e indietro lungo le linee MOSI e MISO tra il nostro Arduino e il dispositivo SPI. Questo può accadere solo quando la linea SS è impostata su BASSA. In altre parole, per comunicare con un particolare dispositivo SPI sul bus, impostiamo la linea SS su quel dispositivo su LOW, quindi comunichiamo con esso, quindi impostiamo la linea su HIGH. Se abbiamo due o più dispositivi SPI sul bus, il cablaggio sarebbe simile al seguente:
Si noti come ci sono due linee SS – abbiamo bisogno di uno per ogni dispositivo SPI sul bus. È possibile utilizzare qualsiasi pin di uscita digitale libero sul vostro Arduino come una linea SS. Basta ricordarsi di avere tutte le linee SS alta tranne che per la linea collegata al dispositivo SPI che si desidera utilizzare al momento.
I dati vengono inviati al dispositivo SPI in forma di byte. Dovresti sapere ormai che otto bit fanno un byte, quindi rappresentano un numero binario con un valore compreso tra zero e 255.
Quando comunichiamo con i nostri dispositivi SPI, dobbiamo sapere in che modo il dispositivo si occupa dei dati – MSB o LSB prima. MSB (bit più significativo) è il lato sinistro del numero binario e LSB (bit meno significativo) è il lato destro del numero. Cioè:
Oltre a inviare valori numerici lungo il bus SPI, i numeri binari possono anche rappresentare comandi. È possibile rappresentare otto impostazioni on/off utilizzando un byte di dati, quindi i parametri di un dispositivo possono essere impostati inviando un byte di dati. Questi parametri variano con ogni dispositivo e dovrebbero essere illustrati nella scheda tecnica del dispositivo particolare. Ad esempio, un potenziometro digitale IC con sei pot:
Questo dispositivo richiede due byte di dati. Il byte ADDR indica al dispositivo quale dei sei potenziometri controllare (numerati da 0 a 5) e il byte DATI è il valore del potenziometro (0~255). Possiamo usare numeri interi per rappresentare questi due valori. Ad esempio, per impostare il potenziometro numero due a 125, invieremo 2 quindi 125 al dispositivo.
Come inviare i dati ai dispositivi SPI nei nostri schizzi?
Prima di tutto, dobbiamo usare la libreria SPI. È incluso con l’installazione IDE Arduino predefinita, quindi metti quanto segue all’inizio del tuo schizzo:
#include "SPI.h"
Avanti, in void.setup () dichiara quali pin verranno utilizzati per SS e li imposta come OUTPUT. Ad esempio,
pinMode(ss, OUTPUT);
dove ss è stato precedentemente dichiarato come un numero intero di valore dieci. Ora, per attivare il bus SPI:
SPI.begin();
e, infine, abbiamo bisogno di dire ai schizzo che modo per inviare i dati, MSB o LSB prima utilizzando
SPI.setBitOrder(MSBFIRST);
o
SPI.setBitOrder(LSBFIRST);
Quando è il momento di inviare dati attraverso il bus SPI per il nostro dispositivo, tre cose devono accadere. Innanzitutto, impostare il pin digitale con SS su basso:
digitalWrite(SS, LOW);
Quindi invia i dati in byte, un byte alla volta usando:
SPI.transfer(value);
Il valore può essere un numero intero / byte compreso tra zero e 255. Infine, al termine dell’invio dei dati al dispositivo, terminare la trasmissione impostando SS high:
digitalWrite(ss, HIGH);
L’invio dei dati è abbastanza semplice. Generalmente la parte più difficile per le persone è interpretare la scheda tecnica del dispositivo per capire come i comandi e i dati devono essere strutturati per la trasmissione. Ma con un po ‘ di pratica, questi piccoli ostacoli possono essere superati.
Ora per alcuni esempi pratici!
È ora di salire sul bus SPI e controllare alcuni dispositivi. Seguendo gli esempi qui sotto, si dovrebbe ottenere una comprensione pratica di come il bus SPI e dispositivi possono essere utilizzati con le nostre schede Arduino.
MCP4162 Esempio
Il nostro primo esempio utilizzerà una parte semplice ma interessante – un potenziometro digitale (ne abbiamo usato anche uno nel tutorial I2C). Questa volta abbiamo un Microchip MCP4162-serie 10k reostato:
Ecco la scheda tecnica per la vostra lettura. Per controllarlo dobbiamo inviare due byte di dati: il primo byte è il byte di controllo, e per fortuna per questo esempio è sempre zero (poiché l’indirizzo per il valore del tergicristallo è 00h ). Il secondo byte è il valore per impostare il tergicristallo, che controlla la resistenza. Quindi, per impostare il tergicristallo abbiamo bisogno di fare tre cose, il nostro sketch…
in Primo luogo, impostare il SS (slave select) linea di basso:
digitalWrite(10, LOW);
Poi inviare i due byte di dati:
SPI.transfer(0); // command byteSPI.transfer(value); // wiper value
Infine la SS riga in alto:
digitalWrite(10, HIGH);
fatto Facilmente. La connessione alla nostra scheda Arduino è molto semplice – considera la piedinatura MCP4162:
Vdd si collega a 5V, Vss a GND, CS a digital 10, SCK a digital 13, SDI a digital 11 e SDO a digital 12. Ora passiamo attraverso i valori disponibili del MCP4162 nel seguente schizzo:
/* SPI bus demo using a Microchip MCP4162 digital potentiometer */#include "SPI.h" // necessary libraryint ss=10; // using digital pin 10 for SPI slave selectint del=200; // used for various delaysvoid setup(){ pinMode(ss, OUTPUT); // we use this for SS pin SPI.begin(); // wake up the SPI bus. SPI.setBitOrder(MSBFIRST); // our MCP4162 requires data to be sent MSB (most significant byte) first}void setValue(int value){ digitalWrite(ss, LOW); SPI.transfer(0); // send command byte SPI.transfer(value); // send value (0~255) digitalWrite(ss, HIGH);}void loop(){ for (int a=0; a<256; a++) { setValue(a); delay(del); } for (int a=255; a>=0; --a) { setValue(a); delay(del); }}
Ora per vedere i risultati dello schizzo. Nel seguente video clip, a corriamo attraverso il campo di resistenza e misuriamo il valore del reostato con un multimetro:
Prima di andare avanti, se i potenziometri digitali sono nuovi per te, considera la lettura di questa breve guida scritta da Microchip sulle differenze tra potenziometri meccanici e digitali.
Un altro esempio:
In questo esempio utilizzeremo il potenziometro digitale a quattro canali Analog Devices AD5204 (scheda tecnica.PDF). Esso contiene quattro 10 k ohm potenziometri lineari, e ogni potenziometro è regolabile per una delle 256 posizioni.
Le impostazioni sono volatili, il che significa che non vengono ricordate quando l’alimentazione è spenta. Pertanto, quando viene applicata l’alimentazione, i potenziometri sono tutti preimpostati al centro della scala. Il nostro esempio è l’esempio di montaggio superficiale SOIC-24, tuttavia è anche prodotto in formato DIP.
Per rendere la vita più facile può essere saldato su una scheda di sblocco SOIC che lo converte in un pacchetto foro passante:
In questo esempio, controlleremo la luminosità di quattro LED. Il cablaggio è molto semplice. I pinout sono nella scheda tecnica.
E lo sketch:
#include <SPI.h> // necessary libraryint ss=10; // using digital pin 10 for SPI slave selectint del=5; // used for fading delayvoid setup(){ pinMode(ss, OUTPUT); // we use this for SS pin SPI.begin(); // wake up the SPI bus. SPI.setBitOrder(MSBFIRST); // our AD5204 requires data to be sent MSB (most significant byte) first. See data sheet page 5 allOff(); // we do this as pot memories are volatile}void allOff()// sets all potentiometers to minimum value{ for (int z=0; z<4; z++) { setPot(z,0); }}void allOn()// sets all potentiometers to maximum value{ for (int z=0; z<4; z++) { setPot(z,255); }}void setPot(int pot, int level)// sets potentiometer 'pot' to level 'level'{ digitalWrite(ss, LOW); SPI.transfer(pot); SPI.transfer(level); digitalWrite(ss, HIGH);}void blinkAll(int count){ for (int z=0; zvoid indFade(){ for (int a=0; a<4; a++) { for (int l=0; l<255; l++) { setPot(a,l); delay(del); } for (int l=255; l>=0; --l) { setPot(a,l); delay(del); } }}void allFade(int count){ for (int a=0; a<count; a++)="" {="" for="" (int="" l="0;" l<255;="" l++)="" setpot(0,l);="" setpot(1,l);="" setpot(2,l);="" setpot(3,l);="" delay(del);="" }="">=0; --l) { setPot(0,l); setPot(1,l); setPot(2,l); setPot(3,l); delay(del); } }}void loop(){ blinkAll(3); delay(1000); indFade(); allFade(3);}
Le funzioni allOff() e allOn() vengono utilizzate per impostare i potenziometri rispettivamente al minimo e al massimo. Usiamo allOff () all’inizio dello schizzo per spegnere i LED. Ciò è necessario in quanto all’accensione i tergicristalli sono generalmente impostati a metà strada.
Inoltre li usiamo nella funzione blinkAll () per blink lampeggiare i LED. La funzione setPot () accetta un numero di tergicristallo (0~3) e un valore per impostare tale tergicristallo (0~255). Infine la funzione indFade () fa un bel lavoro di sbiadire ogni LED acceso e spento in ordine – causando un effetto molto simile alla modulazione di larghezza di impulso.
Infine, eccolo in azione:
Quindi eccolo lì – si spera un’introduzione facile da capire al mondo del bus SPI e come controllare i dispositivi all’interno. Come sempre, ora spetta a voi e la vostra immaginazione per trovare qualcosa da controllare o arrivare fino ad altri imbrogli. Nel prossimo articolo SPI vedremo la lettura e la scrittura dei dati tramite il bus SPI.
Questo post portato a voi da pmdway.com-tutto per i produttori e gli appassionati di elettronica, con consegna gratuita in tutto il mondo.
Per tenersi aggiornati con i nuovi messaggi a tronixstuff.com, si prega di iscriversi alla mailing list nella casella a destra, o seguici su Twitter @ tronixstuff.