Interfaccia periferica seriale in Arduino

Arduino è una scheda di sviluppo elettronica che funziona utilizzando un microcontrollore. Elabora le istruzioni e genera l'output desiderato. La comunicazione gioca un ruolo importante durante l'elaborazione del codice Arduino. Per farlo Arduino ha più protocolli di comunicazione come USART, I2C e SPI. Per saperne di più sui protocolli di comunicazione in dettaglio clicca qui. Oggi discuteremo di come viene utilizzato SPI (interfaccia periferica seriale).

Interfaccia periferica seriale (SPI)

L'interfaccia periferica seriale (SPI) è un protocollo di dati seriali sincroni utilizzato dai microcontrollori Arduino per scopi di comunicazione con uno o più dispositivi periferici rapidamente su brevi distanze. Può anche essere utilizzato per la comunicazione tra due microcontrollori.

SPI è una comunicazione duplex completa, il che significa che può inviare e leggere i dati allo stesso tempo. Tra tutti e tre i protocolli di comunicazione (USART, SPI e I2C) in Arduino SPI è più veloce. SPI ha applicazioni in cui è richiesta una velocità dati elevata come visualizzare il testo su schermate o la scrittura di dati sulla scheda SD.

SPI funziona usando quattro righe:

• SCK: Segnale di orologio che sincronizza il trasferimento di dati tra dispositivi master e slave.
• MISO: (Master in Slave Out) o Miso è una riga di dati per lo slave che può inviare i dati al master.
• MOSI: (Master Out Slave In) o MOSI è una linea di dati per il master per inviare dati a dispositivi slave e periferiche.
• SS: (Slave Select) È la linea utilizzata da Master per selezionare un dispositivo slave specifico. Informa un dispositivo slave a cui verranno inviati o ricevuti i dati.

Aggiornamento: Secondo la documentazione ufficiale di Arduino SPI in Arduino non supporta più queste terminologie. La tabella seguente mostra le nuove terminologie:

Pinout SPI in Arduino Uno

Il protocollo SPI è supportato da più schede Arduino qui abbiamo discusso del supporto Arduino Uno per SPI. Di seguito sono riportati i pin utilizzati da Arduino Uno per la comunicazione periferica seriale.

SPI nella configurazione di maestro slave

Collegare un dispositivo principale a Single Slave è semplice dobbiamo solo collegarli con lo stesso pin. Una volta che sia il dispositivo master e slave è collegato come mostrato nell'immagine in basso. Innanzitutto, dobbiamo impostare le SS (Slave Select Line) sul dispositivo master per essere basso. Rimarrà basso durante la trasmissione dei dati. La linea SS bassa prepara lo slave per inviare o ricevere dati. Una volta che le SS sono basse, il dispositivo può inviare dati utilizzando la linea MOSI e può produrre segnali di clock per la comunicazione sincrona utilizzando il pin SCLK.

SPI in configurazione slave multipla single master

SPI supporta anche più dispositivi slave, una linea SS (Slave Select) separata viene utilizzata per ogni singolo slave. A differenza del singolo slave qui master ha bisogno di una linea SS separata per ogni slave. Funzionamento della configurazione di dispositivi slave singoli e multipli è in qualche modo simile. Dispositivo master tirare la linea SS di Slave particolare a basso che informa il dispositivo slave che Master invierà o riceverà dati da quello slave.

La seguente immagine illustra la configurazione del dispositivo più slave singolo master.

La configurazione della catena Daisy è un altro modo per collegare più dispositivi slave. Laddove il master non ha bisogno di più linee ss per ogni slave in effetti una singola linea SS è collegata al primo dispositivo slave. Una volta che il dispositivo principale tira la linea SS a bassa, invia segnali a tutti i dispositivi slave per essere pronti per la comunicazione su MOSI PIN. Quindi il dispositivo principale inviare dati al pin MOSI del primo dispositivo slave.

Allo stesso tempo, il maestro invia un segnale di clock sul pin SCK. I dati vengono inviati da uno schiavo ad altri e il pin SS è impostato come basso durante questa durata. Il master dovrebbe inviare un segnale di clock sufficiente per raggiungerlo fino all'ultimo dispositivo slave. I dati ricevuti da un particolare dispositivo slave saranno ricevuti da master sul suo pin di miso.

La seguente immagine illustra la configurazione della catena Daisy.

Come programmare Arduino per la comunicazione SPI

Ora prenderemo due tavole di Arduino e passeremo una corda da una scheda Arduino che è maestro al secondo Arduino che agisce da schiavo. Ricorda di aprire due finestre separate di Arduino IDE prima di caricare il codice, altrimenti esiste un'alta possibilità di caricare lo stesso codice in entrambi i.

Prima di caricare il codice selezionare la porta COM in cui è connesso Arduino. Entrambi gli Arduino dovrebbero essere collegati in porte COM separate.

Circuito

Collegare due schede Arduino come mostrate nel circuito sotto. Assicurati di collegare entrambe le schede a GND e collegare tutti gli altri quattro pin SPI dal pin da 10 a 13 di entrambi gli Arduino.

Hardware

Di seguito è riportata l'immagine hardware di due schede Arduino collegate al PC utilizzando il cavo USB.

Codice principale

/*Master Arduino Code*/
#include /*libreria SPI inclusa* /
void setup ()
Seriale.Inizia (115200); /*Tasso di baud definito per la comunicazione seriale*/
DigitalWrite (SS, High); /*(Ss) slave select riga disabilitato*/
Sp.inizio(); /*La comunicazione SPI inizia*/
Sp.setClockDivider (SPI_Clock_div8); /*Clock diviso per 8*/

void loop ()
char char_str; /*Variabile definita per inviare dati*/
DigitalWrite (SS, basso); /*(Ss) slave select abilitato*/
per (const char * p = "linuxhint.Com \ r "; char_str =*p; p ++) /*stringa di prova inviata* /
Sp.trasferimento (char_str); /*SPI Transfer Begin*/
Seriale.print (char_str); /*Stringa è stampata*/

DigitalWrite (SS, High);
ritardo (2000);

Qui nel codice sopra prima abbiamo incluso la libreria SPI per la comunicazione. Successivamente, abbiamo iniziato definendo la frequenza di baud per visualizzare l'output sulla riga di selezione slave monitor seriale utilizzando la scrittura digitale. Per iniziare la comunicazione SPI Sp.inizio() si usa.

In loop parte del codice una variabile char è definita per archiviare la stringa che invieremo Slave Arduino. Successivamente una stringa “Linuxhint.Com " è definito che viene trasferimento in slave arduino usando la SPI.trasferimento(). Per vedere la stringa di input sul monitor seriale Seriale.stampa() viene utilizzata la funzione.

Codice degli schiavi

/*Codice Arduino Slave*/
#include /*libreria SPI inclusa* /
Char Buffer [50]; /*Buffer definito per archiviare la stringa ricevuta da master*/
indice byte volatile; /*Salva dati stringa*/
Processo booleano volatile;
void setup ()
Seriale.Inizia (115200);
pinMode (miso, output); /*Miso impostato come output per inviare dati a master*/
SPCR | = _bv (SPE); /*SPI in modalità slave attiva*/
indice = 0; /*Buffer vuoto*/
processo = false;
Sp.attackInterrupt (); /*attiva interrupt*/

ISR (SPI_STC_VECT) /*SPI Interrupt Routine* /
byte char_str = spdr; /*Leggi il byte dal registro dei dati SPI*/
if (indice < sizeof buffer)
Buffer [indice ++] = char_str; /*dati salvati nell'indice del buff dell'array*/
if (char_str == '\ r') /*Controlla la stringa alla fine* /
processo = true;


void loop ()
if (processo)
processo = false; /*Ripristino del processo*/
Seriale.println (buffer); /*Array ricevuto stampato su monitor seriale*/
indice = 0; /*Pulsante di ripristino a zero*/

Il codice sopra viene caricato su Slave Arduino dove abbiamo iniziato definendo tre variabili buffer, indice ed processo. La variabile buffer memorizzerà la stringa di input dal maestro Arduino mentre l'indice cercherà l'indice di elementi all'interno della stringa e una volta stampata tutta la stringa, il processo fermerà il programma e si ripristinerà a zero. Dopo di che di nuovo Slave inizierà a ricevere dati da Master Arduino e sarà stampato su Serial Monitor.

Produzione

L'output può essere visto in due diverse finestre dell'IDE Arduino. L'uscita di Arduino sia master e schiavo è stampata su monitor seriale.

Conclusione

L'interfaccia periferica seriale è un importante protocollo di comunicazione utilizzato nella programmazione Arduino che aiuta gli utenti a controllare più dispositivi utilizzando una singola scheda Arduino. SPI è più veloce del protocollo USART e I2C. Può essere implementato in due diverse configurazioni single master con singolo slave o più schiavi. Questo articolo fornisce un'idea di come Arduino può essere connesso per la comunicazione SPI.