Seriell perifert grensesnitt i Arduino

Arduino er et elektronisk utviklingsbrett som kjører ved hjelp av en mikrokontroller. IT behandler instruksjoner og genererer ønsket utgang. Kommunikasjon spiller en stor rolle mens du behandler Arduino -kode. For å gjøre det har Arduino flere kommunikasjonsprotokoller som USAart, I2C og SPI. For å lese mer om kommunikasjonsprotokoller i detalj, klikk her. I dag skal vi diskutere hvordan SPI (seriell perifert grensesnitt) brukes i Arduino.

Seriell perifert grensesnitt (SPI)

Seriell perifert grensesnitt (SPI) er en synkron seriell dataprotokoll brukt av Arduino mikrokontrollere for kommunikasjonsformål med en eller flere perifere enheter raskt over korte avstander. Det kan også brukes til kommunikasjon mellom to mikrokontrollere.

SPI er en full duplekskommunikasjon som betyr at den kan sende og lese data samtidig. Blant alle tre kommunikasjonsprotokoller (USAT, SPI og I2C) i Arduino SPI er raskest. SPI har applikasjoner der det kreves høy datahastighet, for eksempel å vise tekst på skjermer eller skrive data på SD -kort.

SPI fungerer med fire linjer:

• SCK: Klokkesignal som synkroniserer dataoverføring mellom master- og slaveenheter.
• Miso: (Mester i slave ut) eller miso er en datalinje for slave som kan sende data tilbake til Master.
• Mosi: (Master out slave inn) eller MOSI er en datalinje for master å sende data til slaveenheter og periferiutstyr.
• Ss: (Slave Select) Det er linjen som brukes av Master for å velge en spesifikk slaveenhet. Den informerer slaveenhet om hvilke data som skal sendes eller mottas.

Oppdater: I henhold til Arduino Official Documentation SPI i Arduino støtter ikke lenger disse terminologiene. Under tabellen viser de nye terminologiene:

Spi pinout i arduino uno

SPI -protokoll støttes av flere Arduino -tavler her diskuterte vi Arduino Uno -støtte for SPI. Følgende er pinnene som brukes av Arduino Uno for seriell perifer kommunikasjon.

SPI i Master Slave Configuration

Å koble en masterenhet til en enkelt slave er enkelt, vi må bare koble dem begge med samme pin. Når både master- og slaveenhet er koblet som vist i bildet nedenfor. Først må vi stille inn SS (slavens utvalgte linje) på masterenhet for å være lav. Det vil forbli lavt under dataoverføringen. Lav SS -linje Forbered slave til å sende eller motta data. Når SS er lav master, kan enheten sende data ved hjelp av MOSI -linjen og kan produsere klokkesignaler for synkron kommunikasjon ved hjelp av SCLK -pinnen.

SPI i single master multiple slavekonfigurasjon

SPI støtter også flere slaveenheter, en egen SS (Slave Select) -linje brukes for hver eneste slave. I motsetning til en enkelt slave her, trenger mester en egen SS -linje for hver slave. Arbeid av enkelt- og flere slaveenhetskonfigurasjon er på en eller annen måte lik. Master Device Trekk SS -linjen til bestemt slave til lav som informerer slaveenhet om at master kommer til å sende eller motta data fra den slaven.

Følgende bilde illustrerer en enkelt master flere slaveenhetskonfigurasjon.

Daisy Chain Configuration er en annen måte å koble til flere slaveenheter. Hvor mester ikke trenger flere SS -linje for hver slave, er faktisk en enkelt SS -linje koblet til første slaveenhet. Når hovedenheten trekker SS -linjen til lav, sender den signaler til alle slaveenheter for å være klar for kommunikasjon på MOSI PIN -koden. Deretter Master Device Send data til MOSI PIN -koden til den første slaveenheten.

Samtidig sender mesteren et klokkesignal på SCK -pinnen. Data sendes fra en slave til andre og SS PIN er satt like lav i denne varigheten. Master skal sende nok klokkesignal for å nå det til siste slaveenhet. Data mottatt fra bestemt slaveenhet vil bli mottatt av Master på Miso Pin.

Følgende bilde illustrerer Daisy Chain -konfigurasjonen.

Hvordan programmere Arduino for SPI -kommunikasjon

Nå tar vi to Arduino -tavler og passerer en streng fra ett Arduino -brett som er mester til andre Arduino som opptrer som slave. Husk å åpne to separate vinduer av Arduino IDE før du laster opp kode ellers er det stor sjanse for å laste opp den samme koden i begge Arduino.

Før du laster opp kode, velg COM -porten som Arduino er tilkoblet. Begge Arduino skal kobles til på separate COM -porter.

Krets

Koble to Arduino -brett som vist i nedenfor kretsen. Sørg for å koble begge brettene til GND og koble alle andre fire SPI -pins fra pinne 10 til 13 av begge Arduino.

Maskinvare

Nedenfor er maskinvarebildet av to Arduino -tavler koblet til PC -en ved hjelp av USB -kabelen.

Master Code

/*Master Arduino -kode*/
#include /*spi -bibliotek inkludert* /
void setup ()
Serie.Begin (115200); /*Baudfrekvens definert for seriell kommunikasjon*/
DigitalWrite (SS, High); /*(SS) Slave Select Line deaktivert*/
Spi.begynne(); /*SPI -kommunikasjon begynner*/
Spi.setClockDivider (spi_clock_div8); /*Klokke delt med 8*/

void loop ()
char char_str; /*Variabel definert for å sende data*/
DigitalWrite (SS, lav); /*(SS) Slave Select Aktivert*/
for (const char * p = "linuxhint.Com \ r "; char_str =*p; p ++) /*teststreng sendt* /
Spi.overføring (char_str); /*SPI -overføring begynner*/
Serie.print (char_str); /*Streng skrives ut*/

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

Her i koden ovenfor først inkluderte vi SPI -bibliotek for kommunikasjon. Deretter startet vi med å definere baudfrekvens for å se utdata på seriell monitor slavelinje er deaktivert ved hjelp av digital skriving. For å begynne SPI -kommunikasjon Spi.begynne() benyttes.

I sløyfe er en del av koden en røyevariabel definert for å lagre strengen som vi skal sende slave Arduino. Neste en streng “Linuxhint.Com ” er definert som overføres til slave Arduino ved hjelp av SPI.overføre(). For å se inngangsstrengen på seriemonitoren Serie.skrive ut() funksjon brukes.

Slavekode

/*Slave Arduino -kode*/
#include /*spi -bibliotek inkludert* /
char buffer [50]; /*Buffer definert for å lagre mottatt streng fra master*/
flyktig byteindeks; /*Lagre strengdata*/
flyktig boolsk prosess;
void setup ()
Serie.Begin (115200);
pinmode (miso, output); /*Miso satt som utdata for å sende data til master*/
Spcr | = _bv (spe); /*SPI i slavemodus aktiv*/
indeks = 0; /*Buffer tom*/
prosess = falsk;
Spi.vedlegginrupt (); /*slå på avbrudd*/

ISR (SPI_STC_VECT) /*SPI Interrupt Rutine* /
byte char_str = spdr; /*Les byte fra SPI Data Register*/
hvis (indeks < sizeof buffer)
buffer [indeks ++] = char_str; /*Data lagret i indeks for array buff*/
if (char_str == '\ r') /*sjekk for streng for å avslutte* /
prosess = sant;


void loop ()
if (prosess)
prosess = falsk; /*Prosess tilbakestilling*/
Serie.println (buffer); /*Mottatt matrise trykt på seriell skjerm*/
indeks = 0; /*Tilbakestill knapp til null*/

Over koden lastes opp til slave Arduino der vi startet med å definere tre variabler buffer, indeks og prosess. Buffervariabel vil lagre inngangsstrengen fra Master Arduino mens indeksen vil se etter indeksen for elementer inne i strengen, og når all strengen er skrevet ut, vil prosessen stoppe programmet og tilbakestilles til null. Deretter vil slave igjen begynne å motta data fra Master Arduino og vil bli skrevet ut på seriell skjerm.

Produksjon

Utgang kan sees i to forskjellige vinduer av Arduino IDE. Utgang fra både mester og slave Arduino er skrevet ut på seriemonitor.

Konklusjon

Seriell perifert grensesnitt er en viktig kommunikasjonsprotokoll som brukes i Arduino -programmering som hjelper brukere til å kontrollere flere enheter ved hjelp av et enkelt Arduino -kort. SPI er raskere enn USAT og I2C -protokollen. Det kan implementeres i to forskjellige konfigurasjoner enkeltmester med enkelt slave eller flere slaver. Denne artikkelen gir et innblikk i hvordan Arduino kan kobles til for SPI -kommunikasjon.