Arduino SPI Tutorial: Master och slav SPI kommunikation mellan två Arduino

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. Seriell kommunikation ä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 denna handledning 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 kommer en Arduino att fungera som mästare och en annan kommer att fungera som slav, två lysdioder och tryckknappar kommer att anslutas till båda Arduino. För att demonstrera SPI-kommunikation kommer vi att styra huvudsidan ledd av 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änssnittet hittades av Motorola 1970. SPI har en fullduplexanslutning, vilket innebär att data skickas och tas emot samtidigt. Det är en mästare kan skicka data till en slav och en slav kan skicka data till befälhavaren samtidigt. SPI är synkron seriell kommunikation innebär att klockan krävs för kommunikationsändamål.

SPI-kommunikation förklaras tidigare i andra mikrokontroller:

  • SPI-kommunikation med PIC-mikrokontroller PIC16F877A
  • gränssnitt 3.5 tums pekskärm TFT LCD med Raspberry Pi
  • programmering avr microcontroller med SPI stift
  • gränssnitt Nokia 5110 grafisk LCD med Arduino

arbeta med SPI

a SPI har en master / slav kommunikation med hjälp av fyra rader. En SPI kan bara ha en mästare och kan ha flera slavar. En mästare är vanligtvis en mikrokontroller och slavarna kan vara en mikrokontroller, sensorer, ADC, DAC, LCD etc.

nedan är blockschemat representation av SPI Master med enda Slav.

SPI kommunikationskrets mellan en master och slav

SPI har följande fyra rader MISO, MOSI, SS och CLK

  • MISO (Master In Slave Out) – Slavlinjen för att skicka data till master.
  • MOSI (Master Out Slave In) – huvudlinjen för att skicka data till kringutrustning.
  • SCK (Serial Clock) – klockpulserna som synkroniserar dataöverföring genererad av befälhavaren.
  • SS (Slave Select) – Master kan använda denna pin-kod för att aktivera och inaktivera specifika enheter.

SPI Master med flera slavar

SPI-kommunikation

för att starta kommunikationen mellan master och slave måste vi ställa in den önskade enhetens slave Select (SS) – pin till låg, 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 i master. Som du kan se i bilden ovan finns det fyra slavar där SCLK, MISO, MOSI är vanliga anslutna till master och SS för varje slav är ansluten separat till enskilda SS-stift (SS1, SS2, SS3) av master. Genom att ställa in den nödvändiga SS-stiftet lågt kan en mästare kommunicera med den slaven.

SPI stift i Arduino UNO

bilden nedan visar SPI stift närvarande Arduino UNO (i röd ruta).

SPI Pins in Arduino UNO

SPI Line

Pin in Arduino

MOSI

11 or ICSP-4

MISO

12 or ICSP-1

SCK

13 or ICSP-3

SS

använda SPI i Arduino

innan du börjar programmera för SPI-kommunikation mellan två Arduinos. Vi behöver lära oss om Arduino SPI-biblioteket som används i Arduino IDE.

biblioteket < SPI.h > ingår i programmet för användning av följande funktioner för SPI-kommunikation.

1. SPI.börja ()

använd: för att initiera 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 (divider)

använd: för att ställa in SPI-klockdelaren 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 (handler)

användning: Denna funktion anropas när en slavenhet tar emot data från master.

4. SPI.överföring (val)

använd: Denna funktion används för att samtidigt skicka och ta emot data mellan master och slave.

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 fästa med en LED & en tryckknapp separat. Master LED kan styras med slav Arduinos tryckknapp och slav Arduinos LED kan styras av master Arduinos Tryckknapp med hjälp av 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.2 k (2)
  • Breadboard
  • anslutningstrådar

Arduino SPI kommunikation Kretsdiagram

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 förbli detsamma förutom pin-numret. Du måste kontrollera pinout av Arduino nano eller mega att hitta Arduino nano SPI stift och Arduino Mega stift, när du har gjort att allt annat kommer att vara densamma.

kretsschema för SPI-kommunikation mellan två Arduinos

Jag har byggt den ovan visade kretsen över en brödbräda, du kan se kretsuppsättningen som jag använde för testning nedan.

kretsschema för SPI-kommunikation mellan två Arduinos

hur man programmerar Arduino för SPI-kommunikation:

denna handledning har två program ett för master Arduino och andra för slav Arduino. Kompletta program för båda sidor ges i slutet av projektet.

Arduino SPI Master programmering förklaring

1. Först och främst måste vi inkludera SPI-biblioteket för att använda SPI-kommunikationsfunktioner.

#include<SPI.h> 

2. I void setup ()

  • Vi startar seriell kommunikation med baudhastighet 115200.
Serial.begin(115200); 
  • fäst LED till stift 7 och tryckknapp till stift 2 och ställ in dessa stift utgång och ingång respektive.
pinMode(ipbutton,INPUT); pinMode(LED,OUTPUT); 
  • nästa börjar vi SPI-kommunikationen
SPI.begin(); 
  • nästa ställer vi in Klockadivider för SPI-kommunikation. Här har vi satt divider 8.
SPI.setClockDivider(SPI_CLOCK_DIV8); 
  • ställ sedan in SS-stiftet högt eftersom vi inte startade någon överföring till slav arduino.
digitalWrite(SS,HIGH); 

3. I void loop ():

  • vi läser statusen för tryckknappstiftet som är anslutet till pin2 (Master Arduino) för att skicka detta värde till slaven Arduino.
buttonvalue = digitalRead(ipbutton); 
  • ange logik för inställning av x-värde (ska skickas till slav) beroende på inmatning från pin 2
 if(buttonvalue == HIGH) { x = 1; } else { x = 0; }
  • innan vi skickar värdet måste vi sänka slavvalsvärdet för att börja överföringen till slav från master.
digitalWrite(SS, LOW); 
  • här kommer det viktiga steget, i följande uttalande skickar vi tryckknappvärdet lagrat i Mastersend variabel till slave arduino och får också värde från slave som kommer att lagras i Mastereceive variabel.
Mastereceive=SPI.transfer(Mastersend); 
  • efter det beroende på Masteceive-värdet slår vi på eller stänger av Master Arduino-lysdioden.
 if(Mastereceive == 1) { digitalWrite(LED,HIGH); //Sets pin 7 HIGH Serial.println("Master LED ON"); } else { digitalWrite(LED,LOW); //Sets pin 7 LOW Serial.println("Master LED OFF"); }

Obs: vi använder seriell.println () för att visa resultatet i seriell Motor av Arduino IDE. Kontrollera videon i slutet.

Arduino SPI Slavprogrammering förklaring

1. Först och främst måste vi inkludera SPI-biblioteket för att använda SPI-kommunikationsfunktioner.

#include<SPI.h> 

2. I void setup ()

  • Vi startar seriell kommunikation med baudhastighet 115200.
Serial.begin(115200); 
  • fäst LED till stift 7 och tryckknapp till pin2 och ställ in dessa stift utgång och ingång respektive.
pinMode(ipbutton,INPUT); pinMode(LED,OUTPUT); 
  • Det viktiga steget här är följande uttalanden
pinMode(MISO,OUTPUT); 

ovanstående uttalande sätter MISO som utgång (måste skicka data till Master in). Så data skickas via MISO av Slav Arduino.

  • slå Nu på SPI i slavläge genom att använda SPI Control Register
SPCR |= _BV(SPE); 
  • slå sedan på interrupt för SPI-kommunikation. Om en data tas emot från master anropas avbrotts rutin och det mottagna värdet tas från SPDR (SPI data Register)
SPI.attachInterrupt(); 
  • värdet från master tas från SPDR och lagras i Slavereceived variabel. Detta sker i följande avbrott rutin funktion.
ISR (SPI_STC_vect){ Slavereceived = SPDR; received = true; }

3. Nästa I void loop () ställer vi in Slave arduino LED för att slå på eller av beroende på Slavereceived-värdet.

 if (Slavereceived==1) { digitalWrite(LEDpin,HIGH); //Sets pin 7 as HIGH LED ON Serial.println("Slave LED ON"); }else { digitalWrite(LEDpin,LOW); //Sets pin 7 as LOW LED OFF Serial.println("Slave LED OFF"); }
  • nästa läser vi status för Slav Arduino tryckknapp och lagra värdet i Slavesend för att skicka värdet till Master Arduino genom att ge värde till SPDR register.
 buttonvalue = digitalRead(buttonpin); if (buttonvalue == HIGH) { x=1; }else { x=0; } Slavesend=x; SPDR = Slavesend; 

Obs: vi använder seriell.println () för att visa resultatet i seriell Motor av 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 tryckknappen på huvudsidan trycks in tänds den vita lysdioden på slavsidan.

hur man använder SPI i Arduino: kommunikation mellan två Arduino-kort

Lämna ett svar

Din e-postadress kommer inte publiceras. Obligatoriska fält är märkta *