- Vad är SPI-kommunikationsprotokoll?
- Hur fungerar SPI-protokollet?
- Skillnad mellan I2C och SPI-kommunikation
- SPI med PIC16F877A med XC8 Compiler:
- SPI Header File Förklaring:
- Huvudprogram Förklaring:
- Simulera PIC med SPI debugger:
PIC Microcontrollers är en kraftfull plattform som tillhandahålls av mikrochip för inbäddade projekt. dess mångsidiga natur har gjort det möjligt för den att hitta vägar till många applikationer och har ännu inte vuxit mycket. Om du har följt våra PIC-självstudier skulle du ha lagt märke till att vi redan har täckt ett brett utbud av självstudier om PIC-mikrokontroller från och med de grundläggande. I samma flöde fortsätter vi att lära oss vilka kommunikationsprotokoll som finns tillgängliga med PIC och hur man använder dem. Vi har redan täckt I2C med PIC Microcontroller.
I det stora systemet med inbäddade applikationer kan ingen mikrokontroller utföra alla aktiviteter på egen hand. Vid någon tidpunkt måste den kommunicera med andra enheter för att dela information, det finns många olika typer av kommunikationsprotokoll för att dela informationen, men de mest använda är USART, IIC, SPI och CAN. Varje kommunikationsprotokoll har sina egna fördelar och nackdelar. Låt oss fokusera på SPI-protokollet för nu eftersom det är vad vi ska lära oss i denna handledning.
Vad är SPI-kommunikationsprotokoll?
Termen SPI står för ” Serial Peripheral Interface ”. Det är ett vanligt kommunikationsprotokoll som används för att skicka data mellan två mikrokontroller eller för att läsa / skriva data från en sensor till en mikrokontroller. Den används också för att kommunicera med SD-kort, skiftregister, displaykontroller och mycket mer.
Hur fungerar SPI-protokollet?
SPI-kommunikationen är synkron kommunikation, vilket innebär att den fungerar med hjälp av en klocksignal som delas mellan de två enheterna som utbyter data. Det är också en full duplexkommunikation eftersom den kan skicka och ta emot data med en separat buss. Den SPI kommunikation kräver 5 trådar för att fungera. En enkel SPI-kommunikationskrets mellan en master och slav visas nedan
De fem ledningarna som krävs för kommunikationen är SCK (Serial Clock), MOSI (Master Out Slave In), MISO (Master In Slave Out) och SS (Slave Select). SPI-kommunikationen sker alltid endast mellan en mästare och slav. En mästare kan ha flera slavar anslutna till den. Befälhavaren ansvarar för att generera klockpulsen och samma delas med alla slavar. All kommunikation kan också initieras endast av mästaren.
SCK-stiftet (aka SCL-seriell klocka) delar klocksignalen som genereras av mästaren med slavarna. MOSI-stiftet (aka SDA –Serial Data Out) används för att skicka data från mastern till salven. MISO-stiftet (aka SDI - Serial Data In) används för att få data från salven till mastern. Du kan också följa pilmarkeringen i figuren ovan för att förstå data / signalens rörelse. Slutligen används SS-stiftet (även kallat CS –Chip select) när det är mer än en slavmodul ansluten till mastern. Denna kan användas för att välja önskad slav. En provkrets där mer än en slav är ansluten till mastern för SPI-kommunikation visas i kretsen nedan.
Skillnad mellan I2C och SPI-kommunikation
Vi har redan lärt oss I2C-kommunikation med PIC och därför måste vi känna till hur I2C fungerar och var vi kan använda dem som att I2C kan användas för att gränssnitt RTC-modul. Men nu, varför behöver vi SPI-protokoll när vi redan har I2C. Anledningen är att både I2C- och SPI-kommunikation är fördelar på sitt eget sätt och därför är applikationsspecifikt.
I en utsträckning kan I2C-kommunikationen anses ha några fördelar jämfört med SPI-kommunikation eftersom I2C använder mindre antal stift och det blir väldigt praktiskt när det finns ett stort antal slavar anslutna till bussen. Men nackdelen med I2C är att den har samma buss för att skicka och ta emot data och därför är den relativt långsam. Så det är enbart baserat på ansökan för att välja mellan SPI och I2C-protokoll för ditt projekt.
SPI med PIC16F877A med XC8 Compiler:
Tillräckligt med grunderna, låt oss nu lära oss hur vi kan använda SPI-kommunikation på PIC16F877A mikrokontroller med hjälp av kompilatorn MPLABX IDE och XC8. Innan vi börjar göra det klart att denna handledning bara talar om SPI i PIC16F877a med hjälp av XC8-kompilator, kommer processen att vara densamma för andra mikrokontroller men små förändringar kan krävas. Kom också ihåg att för avancerade mikrokontroller som PIC18F-serien kan kompilatorn själv ha något inbyggt bibliotek för att använda SPI-funktionerna, men för PIC16F877A finns inget sådant så låt oss bygga ett på egen hand. Biblioteket som förklaras här kommer att ges som en rubrikfil för nedladdning längst ner som kan användas för PIC16F877A för att kommunicera med andra SPI-enheter.
I denna handledning kommer vi att skriva ett litet program som använder SPI-kommunikation för att skriva och läsa data från SPI-bussen. Vi kommer sedan att verifiera detsamma med hjälp av Proteus-simulering. All kod relaterad till SPI-register kommer att göras i rubrikfilen PIC16f877a_SPI.h. På så sätt kan vi använda den här huvudfilen i alla kommande projekt där SPI-kommunikation krävs. Och inuti huvudprogrammet använder vi bara funktionerna från huvudfilen. Den fullständiga koden tillsammans med rubrikfilen kan laddas ner härifrån.
SPI Header File Förklaring:
Inne i rubrikfilen måste vi initiera SPI-kommunikationen för PIC16F877a. Som alltid är det bästa stället att börja PIC16F877A-databladet. De register som styr SPI-kommunikationen för PIC16F8777a är SSPSTAT och SSPCON- registret. Du kan tala om dem på sidorna 74 och 75 i databladet.
Det finns många parametrar som måste väljas när SPI-kommunikationen initieras. Det vanligaste alternativet är att klockfrekvensen kommer att ställas in på Fosc / 4 och kommer att göras i mitten och klockan kommer att ställas in som låg i idealläge. Så vi använder också samma konfiguration för vår rubrikfil, du kan enkelt ändra dem genom att ändra respektive bitar.
SPI_Initialize_Master ()
SPI initialiserar Master-funktionen används för att starta SPI-kommunikationen som master. Inuti denna funktion ställer vi in respektive stift RC5 och RC3 som utgångsstift. Sedan konfigurerar vi SSPTAT och SSPCON-registret för att aktivera SPI-kommunikationen
ogiltig SPI_Initialize_Master () { TRISC5 = 0; // SSPSTAT = 0b00000000; // sid 74/234 SSPCON = 0b00100000; // sid 75/234 TRISC3 = 0; // Ange som utgång för slavläge }
SPI_Initialize_Slave ()
Denna funktion används för att ställa in mikrokontrollern för att fungera i slavläge för SPI-kommunikation. Under slavläge ska stift RC5 ställas in som utgång och stift RC3 bör ställas in som ingång. SSPSTAT och SSPCON ställs in på samma sätt för både slaven och mästaren.
ogiltig SPI_Initialize_Slave () { TRISC5 = 0; // SDO-stift ska deklareras som utdata SSPSTAT = 0b00000000; // sid 74/234 SSPCON = 0b00100000; // sid 75/234 TRISC3 = 1; // Ställ in som ut för huvudläge }
SPI_Write (char inkommande)
SPI-skrivfunktionen används för att skriva data till SPI-bussen. Den får informationen från användaren via variabeln inkommande och använder den sedan för att överföra till buffertregistret. SSPBUF rensas i den efterföljande klockpulsen och data skickas in i bussen bit för bit.
ogiltigt SPI_Write (char inkommande) { SSPBUF = inkommande; // Skriv användardata i buffert }
SPI_Ready2Read ()
SPI ready to Read-funktionen används för att kontrollera om data i SPI-bussen tas emot helt och om de kan läsas. SSPSTAT-registret har en bit som heter BF som kommer att ställas in när data har mottagits fullständigt, så vi kontrollerar om den här biten är inställd om den inte är inställd måste vi vänta tills den blir inställd på att läsa något från SPI-bussen.
osignerad SPI_Ready2Read () { om (SSPSTAT & 0b00000001) returnerar 1; annars returnerar 0; }
SPI_Read ()
SPI Read används för att läsa in data från SPI-bussen till mikrokontrollern. Data som finns i SPI-bussen kommer att lagras i SSPBUF, vi måste vänta tills fullständiga data lagras i bufferten och sedan kan vi läsa den i en variabel. Vi kontrollerar BF-biten i SSPSTAT-registret innan vi läser bufferten för att säkerställa att datamottagningen är komplett.
char SPI_Read () // Läs mottagen data { while (! SSPSTATbits.BF); // Håll tills BF-bit är inställd för att säkerställa att den fullständiga datan är läsretur (SSPBUF); // returnera läsdata }
Huvudprogram Förklaring:
Funktionerna som förklaras i avsnittet ovan kommer att finnas i sidhuvudfilen och de kan kallas till huvudc-filen. Så låt oss skriva ett litet program för att kontrollera om SPI-kommunikationen fungerar. Vi skriver bara några data i SPI-bussen och använder proteussimuleringen för att kontrollera om samma data tas emot i SPI-felsökaren.
Som alltid börja programmet genom att ställa in konfigurationsbitarna och då är det mycket viktigt att lägga till rubrikfilen som vi just förklarade i programmet som visas nedan
#omfatta
Om du har öppnat programmet från zip-filen som laddats ner ovan kommer huvudfilen som standard att finnas i huvudfilkatalogen för din projektfil. Annars måste du lägga till rubrikfilen manuellt inuti ditt projekt, när du har lagt till dina projektfiler ser ut så här nedan
Inuti huvudfilen måste vi initialisera PIC som Master för SPI-kommunikation och sedan inuti en oändlig stund-loop kommer vi att skriva slumpmässigt tre hex-värden i SPI-bussen för att kontrollera om vi får samma under simuleringen.
ogiltigt huvud () { SPI_Initialize_Master (); medan (1) { SPI_Write (0X0A); __fördröja_ms (100); SPI_Write (0X0F); __fördröja_ms (100); SPI_Write (0X15); __fördröja_ms (100); } }
Observera att de slumpmässiga värdena som används i programmet är 0A, 0F och 15 och att de är hex-värden så vi borde se detsamma under simuleringen. Det är det som koden är klar, detta är bara ett exempel men vi kan använda samma metod för att kommunicera med annan MCU eller med andra sensormoduler som arbetar på SPI-protokoll.
Simulera PIC med SPI debugger:
Nu när vårt program är klart kan vi kompilera det och sedan fortsätta med simulering. Proteus har en trevlig praktisk funktion som heter SPI debugger , som kan användas för att övervaka data över en SPI-buss. Så vi använder samma och bygger en krets som visas nedan.
Eftersom det bara finns en SPI-enhet i simuleringen använder vi inte SS-stiftet och när den inte används ska den jordas som visas ovan. Ladda bara hex-filen i PIC16F877A mikrokontroller och klicka på play-knappen för att simulera vårt program. När simuleringen startar får du ett popup-fönster som visar data i SPI-bussen enligt nedan
Låt oss titta närmare på informationen som kommer in och kontrollera om den är densamma som den som vi skrev i vårt program.
Uppgifterna tas emot i samma ordning som vi skrev i vårt program och samma är markerad för dig. Du kan också prova att simulera ett program för att kommunicera med två PIC-mikrokontroller med hjälp av SPI- protokollet. Du måste programmera en PIC som master och den andra som slav. Alla nödvändiga rubrikfiler för detta ändamål finns redan i rubrikfilen.
Detta är bara en glimt av vad SPI kan göra, det kan också läsa och skriva data till flera enheter. Vi kommer att täcka mer om SPI i våra kommande handledning genom att koppla ihop olika moduler som fungerar med SPI-protokoll.
Hoppas att du förstod projektet och lärde dig något användbart av det. Om du är osäker kan du lägga upp dem i kommentarfältet nedan eller använda forumen för teknisk hjälp.
Komplett huvudkod har angivits nedan; du kan hämta headerfiler med all kod härifrån