- Hva er SPI?
- Arbeid med SPI
- SPI Pins i Arduino UNO
- Bruker SPI i Arduino
- Komponenter som kreves for Arduino SPI-kommunikasjon
- Arduino SPI kommunikasjonskretsdiagram
- Slik programmerer du Arduino for SPI-kommunikasjon:
- Arduino SPI Master Programming Forklaring
- Arduino SPI Slave Programming Forklaring
- Hvordan fungerer SPI på Arduino? - La oss teste det!
En mikrokontroller bruker mange forskjellige protokoller for å kommunisere med forskjellige sensorer og moduler. Det er mange forskjellige typer kommunikasjonsprotokoller for trådløs og kablet kommunikasjon, og den mest brukte kommunikasjonsteknikken er seriell kommunikasjon. Seriell kommunikasjon er prosessen med å sende data en bit av gangen, sekvensielt, over en kommunikasjonskanal eller buss. Det er mange typer seriell kommunikasjon som UART, CAN, USB, I2C og SPI-kommunikasjon.
I denne opplæringen lærer vi om SPI-protokollen og hvordan du bruker den i Arduino. Vi vil bruke SPI Protocol for kommunikasjon mellom to Arduinos. Her vil en Arduino fungere som mester og en annen vil fungere som slave, to lysdioder og trykknapper vil være koblet til begge Arduino. For å demonstrere SPI-kommunikasjon, vil vi kontrollere lysdioden på hovedsiden ved å trykke på knappen på slave-siden og omvendt ved hjelp av SPI Serial Communication Protocol.
Hva er SPI?
SPI (Serial Peripheral Interface) er en seriell kommunikasjonsprotokoll. SPI-grensesnitt ble funnet av Motorola i 1970. SPI har en full-dupleks-forbindelse, noe som betyr at dataene blir sendt og mottatt samtidig. Det vil si at en mester kan sende data til en slave og en slave kan sende data til mesteren samtidig. SPI er synkron seriell kommunikasjon betyr at klokken er nødvendig for kommunikasjonsformål.
SPI-kommunikasjon er tidligere forklart i andre mikrokontrollere:
- SPI Kommunikasjon med PIC Microcontroller PIC16F877A
- Grensesnitt 3,5 tommers berøringsskjerm TFT LCD med Raspberry Pi
- Programmering av AVR-mikrokontroller med SPI-pinner
- Grensesnitt Nokia 5110 Grafisk LCD med Arduino
Arbeid med SPI
Et SPI har en master / slave-kommunikasjon ved å bruke fire linjer. Et SPI kan bare ha en mester og kan ha flere slaver. En mester er vanligvis en mikrokontroller og slavene kan være en mikrokontroller, sensorer, ADC, DAC, LCD etc.
Nedenfor er blokkdiagramrepresentasjonen av SPI Master med Single Slave.
SPI har følgende MISO, MOSI, SS og CLK linjer
- MISO (Master in Slave Out) - Slave-linjen for å sende data til mesteren.
- MOSI (Master Out Slave In) - Masterlinjen for sending av data til eksterne enheter.
- SCK (Serial Clock) - Klokkepulsene som synkroniserer dataoverføring generert av masteren.
- SS (Slave Select) –Master kan bruke denne pinnen til å aktivere og deaktivere bestemte enheter.
SPI Master med flere slaver
For å starte kommunikasjonen mellom master og slave må vi sette den nødvendige enhetens Slave Select (SS) -pinne til LAV, slik at den kan kommunisere med masteren. Når det er høyt, ignorerer det mesteren. Dette lar deg ha flere SPI-enheter som deler de samme MISO-, MOSI- og CLK-linjene. Som du kan se i bildet ovenfor, er det fire slaver der SCLK, MISO, MOSI er vanlig koblet til master og SS til hver slave er koblet separat til individuelle SS-pinner (SS1, SS2, SS3) til master. Ved å sette den nødvendige SS-pinnen LAV kan en mester kommunisere med den slaven.
SPI Pins i Arduino UNO
Bildet nedenfor viser SPI-pinnene som er tilstede Arduino UNO (i rød boks).
|
SPI Line |
Fest i Arduino |
|
MOSI |
11 eller ICSP-4 |
|
MISO |
12 eller ICSP-1 |
|
SCK |
13 eller ICSP-3 |
|
SS |
10 |
Bruker SPI i Arduino
Før du begynner å programmere for SPI-kommunikasjon mellom to Arduinos. Vi må lære om Arduino SPI-biblioteket som brukes i Arduino IDE.
Biblioteket
1. SPI.begin ()
BRUK: Å initialisere SPI-bussen ved å sette SCK, MOSI og SS til utganger, trekke SCK og MOSI lavt og SS høyt.
2. SPI.setClockDivider (skillelinje)
BRUK: Å stille SPI-klokkeinndelingen i forhold til systemklokken. De tilgjengelige delene er 2, 4, 8, 16, 32, 64 eller 128.
Skillevegger:
- SPI_CLOCK_DIV2
- SPI_CLOCK_DIV4
- SPI_CLOCK_DIV8
- SPI_CLOCK_DIV16
- SPI_CLOCK_DIV32
- SPI_CLOCK_DIV64
- SPI_CLOCK_DIV128
3. SPI.attachInterrupt (behandler)
BRUK: Denne funksjonen kalles når en slaveenhet mottar data fra masteren.
4. SPI.transfer (val)
BRUK: Denne funksjonen brukes til samtidig sending og mottak av data mellom master og slave.
Så la oss starte med praktisk demonstrasjon av SPI-protokollen i Arduino. I denne opplæringen vil vi bruke to arduino som master og andre som slave. Begge Arduino er festet med en LED og en trykknapp separat. Master LED kan styres ved hjelp av slave Arduinos trykknapp og slave Arduinos LED kan styres av master Arduinos trykknapp ved hjelp av SPI-kommunikasjonsprotokoll som er tilstede i arduino.
Komponenter som kreves for Arduino SPI-kommunikasjon
- Arduino UNO (2)
- LED (2)
- Trykknapp (2)
- Motstand 10k (2)
- Motstand 2.2k (2)
- Brettbrett
- Koble ledninger
Arduino SPI kommunikasjonskretsdiagram
Nedenfor kretsskjema viser hvordan du bruker SPI på Arduino UNO, men du kan følge den samme prosedyren for Arduino Mega SPI-kommunikasjon eller Arduino nano SPI-kommunikasjon. Nesten alt vil være det samme bortsett fra pin-nummeret. Du må sjekke pinout av Arduino nano eller mega for å finne Arduino nano SPI pins og Arduino Mega pins, når du har gjort at alt annet vil være det samme.
Jeg har bygget den ovennevnte kretsen over et brødbord, du kan se kretsoppsettet som jeg brukte til testing nedenfor.
Slik programmerer du Arduino for SPI-kommunikasjon:
Denne opplæringen har to programmer, ett for master Arduino og et annet for slave Arduino. Komplette programmer for begge sider er gitt på slutten av dette prosjektet.
Arduino SPI Master Programming Forklaring
1. Først og fremst må vi inkludere SPI-biblioteket for bruk av SPI-kommunikasjonsfunksjoner.
#inkludere
2. I ugyldig oppsett ()
- Vi starter seriekommunikasjon med baudrate 115200.
Serial.begin (115200);
- Fest LED på pinne 7 og trykknapp på pinne 2 og sett pinnene henholdsvis UTGANG og INNGANG.
pinMode (ipbutton, INPUT); pinMode (LED, OUTPUT);
- Deretter begynner vi SPI-kommunikasjonen
SPI.begin ();
- Deretter setter vi Clockdivider for SPI-kommunikasjon. Her har vi satt skillelinje 8.
SPI.setClockDivider (SPI_CLOCK_DIV8);
- Sett deretter SS-pinnen HØYT siden vi ikke startet noen overføring til slave arduino.
digitalWrite (SS, HIGH);
3. I ugyldig sløyfe ():
- Vi leser statusen til trykknappstiften som er koblet til pin2 (Master Arduino) for å sende denne verdien til slaven Arduino.
buttonvalue = digitalRead (ipbutton);
- Still inn logikk for innstilling av x-verdi (skal sendes til slave) avhengig av inngang fra pin 2
hvis (knappverdi == HØY) { x = 1; } annet { x = 0; }
- Før du sender verdien, må vi LAVE slavevalgverdien for å starte overføringen til slave fra master.
digitalWrite (SS, LOW);
- Her kommer det viktige trinnet, i følgende uttalelse sender vi trykknappverdien lagret i Mastersend- variabelen til slave arduino og mottar også verdi fra slave som vil bli lagret i Mastereceive- variabel.
Mastereceive = SPI.transfer (Mastersend);
- Etter det, avhengig av Mastereceive- verdien, vil vi slå Master Arduino LED PÅ eller AV.
hvis (Mastereceive == 1) { digitalWrite (LED, HIGH); // Setter pin 7 HIGH Serial.println ("Master LED ON"); } annet { digitalWrite (LED, LAV); // Setter pin 7 LOW Serial.println ("Master LED OFF"); }
Merk: Vi bruker serial.println () for å se resultatet i Serial Motor av Arduino IDE. Sjekk videoen på slutten.
Arduino SPI Slave Programming Forklaring
1. Først og fremst må vi inkludere SPI-biblioteket for bruk av SPI-kommunikasjonsfunksjoner.
#inkludere
2. I ugyldig oppsett ()
- Vi starter seriekommunikasjon med baudrate 115200.
Serial.begin (115200);
- Fest LED til pin 7 og trykknapp for pin2, og sett disse pinnene henholdsvis OUTPUT og INPUT.
pinMode (ipbutton, INPUT); pinMode (LED, OUTPUT);
- Det viktige trinnet her er følgende utsagn
pinMode (MISO, OUTPUT);
Ovennevnte uttalelse setter MISO som OUTPUT (Må sende data til Master IN). Så data sendes via MISO fra Slave Arduino.
- Slå nå på SPI i slave-modus ved å bruke SPI Control Register
SPCR - = _BV (SPE);
- Slå deretter PÅ avbrudd for SPI-kommunikasjon. Hvis data mottas fra master, kalles Interrupt Routine og den mottatte verdien hentes fra SPDR (SPI data Register)
SPI.attachInterrupt ();
- Verdien fra master er hentet fra SPDR og lagret i slavereceived variable. Dette skjer i følgende avbryt rutinefunksjon.
ISR (SPI_STC_vect) { Slavereceived = SPDR; mottatt = sant; }
3. Neste i ugyldig sløyfe () setter vi Slave arduino-lysdioden til å slå PÅ eller AV, avhengig av den slaver mottatt verdien.
hvis (Slavereceived == 1) { digitalWrite (LEDpin, HIGH); // Setter pin 7 som HIGH LED ON Serial.println ("Slave LED ON"); } annet { digitalWrite (LEDpin, LOW); // Setter pin 7 som LOW LED OFF Serial.println ("Slave LED OFF"); }
- Deretter leser vi statusen til Slave Arduino trykknapp og lagrer verdien i Slavesend for å sende verdien til Master Arduino ved å gi verdi til SPDR-registeret.
buttonvalue = digitalRead (buttonpin); hvis (knappverdi == HØY) {x = 1; } annet {x = 0; } Slavesend = x; SPDR = Slavesend;
Merk: Vi bruker serial.println () for å se resultatet i Serial Motor av Arduino IDE. Sjekk videoen på slutten.
Hvordan fungerer SPI på Arduino? - La oss teste det!
Nedenfor er bildet av det endelige oppsettet for SPI-kommunikasjon mellom to Arduino-brett.
Når du trykker på trykknappen på hovedsiden, slås den hvite lysdioden på slavesiden PÅ.
Og når du trykker på trykknappen på slave-siden, slås den røde LED-en på mastersiden PÅ.
Du kan sjekke ut videoen nedenfor for å se demonstrasjonen av Arduino SPI-kommunikasjon. Hvis du har spørsmål, kan du legge dem igjen i kommentarfeltet og bruke forumene våre.