- Vad är SPI?
- Arbeta med SPI
- SPI-stift i Arduino UNO
- Använda SPI i Arduino
- Komponenter som krävs för Arduino SPI-kommunikation
- Arduino SPI-kommunikationskretsschema
- Hur man programmerar Arduino för SPI-kommunikation:
- Arduino SPI Master Programming Förklaring
- Arduino SPI Slave Programming Förklaring
- Hur fungerar SPI på Arduino? - Låt oss testa det!
En mikrokontroller använder många olika protokoll för att kommunicera med olika sensorer och moduler. Det finns många olika typer av kommunikationsprotokoll för trådlös och trådbunden kommunikation, och den vanligaste kommunikationstekniken är Seriell kommunikation. Seriekommunikation är processen att skicka data en bit i taget, sekventiellt, över en kommunikationskanal eller buss. Det finns många typer av seriell kommunikation som UART, CAN, USB, I2C och SPI-kommunikation.
I den här handledningen lär vi oss om SPI-protokollet och hur man använder det i Arduino. Vi kommer att använda SPI-protokoll för kommunikation mellan två Arduinos. Här fungerar en Arduino som Master och en annan som Slave, två lysdioder och tryckknappar kommer att anslutas till båda Arduino. För att demonstrera SPI-kommunikation kommer vi att styra lysdioden på huvudsidan med tryckknappen på slavsidan och vice versa med hjälp av SPI Serial Communication Protocol.
Vad är SPI?
SPI (Serial Peripheral Interface) är ett seriellt kommunikationsprotokoll. SPI-gränssnitt hittades av Motorola 1970. SPI har en full-duplex-anslutning, vilket innebär att data skickas och tas emot samtidigt. Det vill säga en master kan skicka data till en slav och en slav kan skicka data till master samtidigt. SPI är synkron seriell kommunikation betyder att klockan krävs för kommunikationsändamål.
SPI-kommunikation har tidigare förklarats i andra mikrokontroller:
- SPI-kommunikation med PIC-mikrokontroller PIC16F877A
- Gränssnitt 3,5 tums pekskärm TFT LCD med Raspberry Pi
- Programmering av AVR-mikrokontroller med SPI-stift
- Gränssnitt Nokia 5110 Grafisk LCD med Arduino
Arbeta med SPI
Ett SPI har en master / slavkommunikation med fyra rader. Ett SPI kan bara ha en master och kan ha flera slavar. En mästare är vanligtvis en mikrokontroller och slavarna kan vara en mikrokontroller, sensorer, ADC, DAC, LCD etc.
Nedan visas blockdiagrammet av SPI Master med Single Slave.
SPI har följande fyra rader MISO, MOSI, SS och CLK
- MISO (Master in Slave Out) - Slavlinjen för att skicka data till mastern.
- MOSI (Master Out Slave In) - Huvudlinjen för att skicka data till kringutrustningen.
- SCK (Serial Clock) - Klockpulserna som synkroniserar dataöverföring genererad av mastern.
- SS (Slave Select) –Master kan använda denna stift för att aktivera och inaktivera specifika enheter.
SPI Master med flera slavar
För att starta kommunikationen mellan master och slave måste vi ställa in den önskade enhetens Slave Select-stift (SS) på LOW, så att den kan kommunicera med master. När det är högt ignorerar det mästaren. Detta gör att du kan ha flera SPI-enheter som delar samma MISO-, MOSI- och CLK-linjer som master. Som du kan se i bilden ovan finns det fyra slavar där SCLK, MISO, MOSI är vanligt anslutna till master och SS för varje slav är separat ansluten till enskilda SS-stift (SS1, SS2, SS3) för master. Genom att ställa in önskad SS-stift LÅG kan en master kommunicera med den slaven.
SPI-stift i Arduino UNO
Bilden nedan visar SPI-stiften som presenterar Arduino UNO (i röd ruta).
|
SPI Line |
Stift i Arduino |
|
MOSI |
11 eller ICSP-4 |
|
MISO |
12 eller ICSP-1 |
|
SCK |
13 eller ICSP-3 |
|
SS |
10 |
Använda SPI i Arduino
Innan du börjar programmera för SPI-kommunikation mellan två Arduinos. Vi måste lära oss om Arduino SPI-biblioteket som används i Arduino IDE.
Biblioteket
1. SPI.begin ()
ANVÄNDNING: Att initialisera SPI-bussen genom att ställa in SCK, MOSI och SS till utgångar, dra SCK och MOSI lågt och SS högt.
2. SPI.setClockDivider (delare)
ANVÄNDNING: För att ställa in SPI-klockavdelaren i förhållande till systemklockan. De tillgängliga avdelarna är 2, 4, 8, 16, 32, 64 eller 128.
Avdelare:
- SPI_CLOCK_DIV2
- SPI_CLOCK_DIV4
- SPI_CLOCK_DIV8
- SPI_CLOCK_DIV16
- SPI_CLOCK_DIV32
- SPI_CLOCK_DIV64
- SPI_CLOCK_DIV128
3. SPI.attachInterrupt (hanterare)
ANVÄNDNING: Denna funktion anropas när en slavenhet tar emot data från mastern.
4. SPI.transfer (val)
ANVÄNDNING: Denna funktion används för att samtidigt skicka och ta emot data mellan master och slav.
Så nu ska vi börja med praktisk demonstration av SPI-protokollet i Arduino. I denna handledning kommer vi att använda två arduino en som mästare och andra som slav. Båda Arduino är anslutna med en LED och en tryckknapp separat. Master LED kan styras med hjälp av slav Arduinos tryckknapp och slav Arduinos LED kan styras av master Arduinos tryckknapp med SPI-kommunikationsprotokoll som finns i arduino.
Komponenter som krävs för Arduino SPI-kommunikation
- Arduino UNO (2)
- LED (2)
- Tryckknapp (2)
- Motstånd 10k (2)
- Motstånd 2.2k (2)
- Bakbord
- Anslutande ledningar
Arduino SPI-kommunikationskretsschema
Nedanstående kretsschema visar hur man använder SPI på Arduino UNO, men du kan följa samma procedur för Arduino Mega SPI-kommunikation eller Arduino nano SPI-kommunikation. Nästan allt kommer att vara detsamma förutom pin-numret. Du måste kontrollera pinout av Arduino nano eller mega för att hitta Arduino nano SPI-stift och Arduino Mega-stift, när du väl har gjort att allt annat kommer att vara detsamma.
Jag har byggt den ovan visade kretsen över ett brädbräde, du kan se kretsuppsättningen som jag använde för testning nedan.
Hur man programmerar Arduino för SPI-kommunikation:
Denna handledning har två program, ett för master Arduino och ett för slav Arduino. Kompletta program för båda sidor ges i slutet av detta projekt.
Arduino SPI Master Programming Förklaring
1. Först och främst måste vi inkludera SPI-biblioteket för att använda SPI-kommunikationsfunktioner.
#omfatta
2. I ogiltig installation ()
- Vi börjar seriekommunikation med överföringshastighet 115200.
Serial.begin (115200);
- Fäst lysdioden på stift 7 och tryckknappen på stift 2 och ställ in stiften OUTPUT respektive INPUT.
pinMode (ipbutton, INPUT); pinMode (LED, OUTPUT);
- Därefter börjar vi SPI-kommunikationen
SPI.begin ();
- Därefter ställer vi in Clockdivider för SPI-kommunikation. Här har vi ställt in avdelare 8.
SPI.setClockDivider (SPI_CLOCK_DIV8);
- Ställ sedan in SS-nålen HÖG eftersom vi inte startade någon överföring till slavarduino.
digitalWrite (SS, HIGH);
3. I ogiltig slinga ():
- Vi läser status för tryckknappsstiftet som är anslutet till pin2 (Master Arduino) för att skicka dessa värden till slaven Arduino.
buttonvalue = digitalRead (ipbutton);
- Ställ in logik för att ställa in x-värde (skickas till slav) beroende på inmatning från stift 2
om (knappvärde == HÖG) { x = 1; } annat { x = 0; }
- Innan vi skickar värdet måste vi LÅGA slavvalvärdet för att påbörja överföringen till slav från master.
digitalWrite (SS, LOW);
- Här kommer det viktiga steget, i följande uttalande skickar vi tryckknappsvärdet som är lagrat i Mastersend- variabeln till slav arduino och får också värde från slav som kommer att lagras i Mastereceive- variabeln.
Mastereceive = SPI.transfer (Mastersend);
- Efter det, beroende på Mastereceive- värdet, slår vi på eller stänger av Master Arduino LED.
if (Mastereceive == 1) { digitalWrite (LED, HIGH); // Ställer in pin 7 HIGH Serial.println ("Master LED ON"); } annat { digitalWrite (LED, LOW); // Ställer in stift 7 LOW Serial.println ("Master LED OFF"); }
Obs! Vi använder serial.println () för att visa resultatet i Serial Motor of Arduino IDE. Kontrollera videon i slutet.
Arduino SPI Slave Programming Förklaring
1. Först och främst måste vi inkludera SPI-biblioteket för att använda SPI-kommunikationsfunktioner.
#omfatta
2. I ogiltig installation ()
- Vi börjar seriekommunikation med överföringshastighet 115200.
Serial.begin (115200);
- Fäst lysdioden på stift 7 och tryckknappen på stift2 och ställ in stiften OUTPUT respektive INPUT.
pinMode (ipbutton, INPUT); pinMode (LED, OUTPUT);
- Det viktiga steget här är följande uttalanden
pinMode (MISO, OUTPUT);
Ovanstående uttalande anger MISO som OUTPUT (Måste skicka data till Master IN). Så data skickas via MISO från Slave Arduino.
- Aktivera nu SPI i slavläge med SPI Control Register
SPCR - = _BV (SPE);
- Slå sedan på PÅ-avbrott för SPI-kommunikation. Om en data tas emot från master anropas avbrottsrutinen och det mottagna värdet tas från SPDR (SPI-dataregister)
SPI.attachInterrupt ();
- Värdet från mastern hämtas från SPDR och lagras i Slavereceived variable. Detta sker i följande avbryt rutinfunktion.
ISR (SPI_STC_vect) { Slavereceived = SPDR; mottagen = sant; }
3. Därefter ställer vi in slavarduino-lysdioden på ON eller OFF beroende på det värde som mottagits av Slaver.
if (Slavereceived == 1) { digitalWrite (LEDpin, HIGH); // Ställer in stift 7 som HÖG LED PÅ Serial.println ("Slave LED ON"); } annat { digitalWrite (LEDpin, LOW); // Ställer in stift 7 som LOW LED OFF Serial.println ("Slave LED OFF"); }
- Därefter läser vi statusen för Slave Arduino-tryckknappen och lagrar värdet i Slavesend för att skicka värdet till Master Arduino genom att ge värde till SPDR-registret.
buttonvalue = digitalRead (buttonpin); om (knappvärde == HÖG) {x = 1; } annat {x = 0; } Slavesend = x; SPDR = Slavesend;
Obs! Vi använder serial.println () för att visa resultatet i Serial Motor of Arduino IDE. Kontrollera videon i slutet.
Hur fungerar SPI på Arduino? - Låt oss testa det!
Nedan är bilden av den slutliga installationen för SPI-kommunikation mellan två Arduino-kort.
När man trycker på tryckknappen på huvudsidan tänds den vita lysdioden på slavsidan.
Och när man trycker på tryckknappen på slavsidan tänds den röda lysdioden på mastersidan.
Du kan kolla in videon nedan för att se demonstrationen av Arduino SPI-kommunikation. Om du har några frågor, vänligen lämna dem i kommentarsektionen, använd våra forum.