- Hva er SPI Communication Protocol?
- Hvordan fungerer SPI-protokollen?
- Forskjellen mellom I2C og SPI-kommunikasjon
- SPI med PIC16F877A ved bruk av XC8 Compiler:
- SPI Header File Forklaring:
- Hovedprogram Forklaring:
- Simulering av PIC med SPI-feilsøkingsprogram:
PIC Microcontrollers er en kraftig plattform levert av mikrochip for innebygde prosjekter; dens allsidige natur har gjort det mulig å finne veier til mange applikasjoner og er ennå ikke til å vokse mye. Hvis du har fulgt PIC-opplæringen, ville du ha lagt merke til at vi allerede har dekket et bredt spekter av opplæringsprogrammer om PIC-mikrokontroller, helt fra det grunnleggende. I samme flyt fortsetter vi med å lære kommunikasjonsprotokollene som er tilgjengelige med PIC og hvordan du bruker dem. Vi har allerede dekket I2C med PIC Microcontroller.
I det enorme systemet med innebygde applikasjoner kan ingen mikrokontroller utføre alle aktivitetene av seg selv. På et tidspunkt av tiden må den kommunisere til andre enheter for å dele informasjon, det er mange forskjellige typer kommunikasjonsprotokoller for å dele denne informasjonen, men de mest brukte er USART, IIC, SPI og CAN. Hver kommunikasjonsprotokoll har sin egen fordel og ulempe. La oss fokusere på SPI-protokollen for nå, siden det er det vi skal lære i denne opplæringen.
Hva er SPI Communication Protocol?
Begrepet SPI står for " Serial Peripheral Interface ". Det er en vanlig kommunikasjonsprotokoll som brukes til å sende data mellom to mikrokontrollere eller til å lese / skrive data fra en sensor til en mikrokontroller. Den brukes også til å kommunisere med SD-kort, skiftregister, skjermkontroller og mye mer.
Hvordan fungerer SPI-protokollen?
SPI-kommunikasjonen er synkron kommunikasjon, noe som betyr at den fungerer ved hjelp av et kloksignal som deles mellom de to enhetene som utveksler dataene. Også en full-dupleks kommunikasjon fordi den kan sende og motta data ved hjelp av en egen buss. Den SPI kommunikasjon krever 5 ledninger for å fungere. En enkel SPI-kommunikasjonskrets mellom en master og slave er vist nedenfor
De fem ledningene som kreves for kommunikasjonen er SCK (Serial Clock), MOSI (Master Out Slave In), MISO (Master In Slave Out) og SS (Slave Select). SPI-kommunikasjonen foregår alltid bare mellom en mester og slave. En mester kan ha flere slaver koblet til den. Mesteren er ansvarlig for å generere klokkepulsen, og den samme deles med alle slaver. Også all kommunikasjon kan bare initieres av mesteren.
SCK-pinnen (aka SCL-seriell klokke) deler kloksignalet som genereres av mesteren med slaverne. MOSI-pinnen (aka SDA –Serial Data Out) brukes til å sende dataene fra mesteren til salven. MISO-pinnen (aka SDI - Serial Data In) brukes til å få dataene fra salven til mesteren. Du kan også følge pilmerket i figuren ovenfor for å forstå bevegelsen av data / signal. Til slutt brukes SS-pinnen (aka CS –Chip select) når det er mer enn en slave-modul tilkoblet masteren. Denne kan brukes til å velge ønsket slave. En prøvekrets der mer enn en slave er koblet til masteren for SPI-kommunikasjon, er vist i kretsen nedenfor.
Forskjellen mellom I2C og SPI-kommunikasjon
Vi har allerede lært I2C-kommunikasjon med PIC, og derfor må vi være kjent med hvordan I2C fungerer, og hvor vi kan bruke dem som I2C kan brukes til å grensesnitt RTC-modul. Men nå, hvorfor trenger vi SPI-protokoll når vi allerede har I2C. Årsaken er at både I2C og SPI-kommunikasjon er fordeler på sine egne måter og derfor er applikasjonsspesifikk.
I en grad kan I2C-kommunikasjonen anses å ha noen fordeler i forhold til SPI-kommunikasjon fordi I2C bruker mindre antall pin og det blir veldig nyttig når det er et stort antall slaver koblet til bussen. Men ulempen med I2C er at den har samme buss for sending og mottak av data, og derfor er den relativt treg. Så det er bare basert på applikasjon for å bestemme mellom SPI og I2C-protokollen for prosjektet ditt.
SPI med PIC16F877A ved bruk av XC8 Compiler:
Nok av det grunnleggende, la oss nå lære hvordan vi kan bruke SPI-kommunikasjon på PIC16F877A- mikrokontrolleren ved hjelp av kompilatoren MPLABX IDE og XC8. Før vi begynner å gjøre det klart at denne opplæringen bare snakker om SPI i PIC16F877a ved bruk av XC8-kompilator, vil prosessen være den samme for andre mikrokontrollere, men små endringer kan være nødvendig. Husk også at for avanserte mikrokontrollere som PIC18F-serien, kan kompilatoren selv ha noe bibliotek innebygd for å bruke SPI-funksjonene, men for PIC16F877A eksisterer ingenting som det, så la oss bygge et på egen hånd. Biblioteket som er forklart her vil bli gitt som en headerfil for nedlasting nederst, som kan brukes til PIC16F877A til å kommunisere med andre SPI-enheter.
I denne opplæringen vil vi skrive et lite program som bruker SPI-kommunikasjon til å skrive og lese data fra SPI-bussen. Vi vil deretter verifisere det samme ved hjelp av Proteus-simulering. All koden relatert til SPI-registre vil bli laget i toppfilen kalt PIC16f877a_SPI.h. På denne måten kan vi bruke denne headerfilen i alle våre kommende prosjekter der SPI-kommunikasjon er nødvendig. Og inne i hovedprogrammet vil vi bare bruke funksjonene fra toppfilen. Den komplette koden sammen med toppfilen kan lastes ned herfra.
SPI Header File Forklaring:
Inne i toppfilen må vi initialisere SPI-kommunikasjonen for PIC16F877a. Som alltid er det beste stedet å starte PIC16F877A-databladet. Registerene som styrer SPI-kommunikasjonen for PIC16F8777a er SSPSTAT og SSPCON- registeret. Du kan om dem på side 74 og 75 i databladet.
Det er mange parametere som må velges mens du initialiserer SPI-kommunikasjonen. Det mest brukte alternativet er at klokkefrekvensen vil bli satt til Fosc / 4 og vil bli gjort i midten, og klokken vil bli satt til lav i ideell tilstand. Så vi bruker også den samme konfigurasjonen for headerfilen vår, du kan enkelt endre dem ved å endre de respektive bitene.
SPI_Initialize_Master ()
SPI initialiser Master-funksjonen brukes til å starte SPI-kommunikasjonen som master. Inne i denne funksjonen setter vi de respektive pinnene RC5 og RC3 som utgangspinner. Deretter konfigurerer vi SSPTAT og SSPCON-registeret for å slå på SPI-kommunikasjonen
ugyldig SPI_Initialize_Master () { TRISC5 = 0; // SSPSTAT = 0b00000000; // s. 74/234 SSPCON = 0b00100000; // sg 75/234 TRISC3 = 0; // sett som utgang for slavemodus }
SPI_Initialize_Slave ()
Denne funksjonen brukes til å stille mikrokontrolleren til å fungere i slave-modus for SPI-kommunikasjon. Under slave-modus skal pinnen RC5 settes som utgang og pinnen RC3 skal settes som inngang. SSPSTAT og SSPCON er satt på samme måte for både slave og master.
ugyldig SPI_Initialize_Slave () { TRISC5 = 0; // SDO-pinne skal deklareres som utgang SSPSTAT = 0b00000000; // s. 74/234 SSPCON = 0b00100000; // sg 75/234 TRISC3 = 1; // Sett som ut for hovedmodus }
SPI_Write (innkommende tegn)
SPI Write-funksjonen brukes til å skrive data inn i SPI-bussen. Den får informasjonen fra brukeren gjennom variabelen innkommende og bruker den til å overføre til bufferregisteret. SSPBUF vil bli slettet i den påfølgende klokkepulsen, og dataene blir sendt inn i bussen bit for bit.
ugyldig SPI_Write (char innkommende) { SSPBUF = innkommende; // Skriv brukeroppgitte data i buffer }
SPI_Ready2Read ()
SPI ready to Read-funksjonen brukes til å kontrollere om dataene i SPI-bussen mottas fullstendig og om de kan leses. SSPSTAT-registeret har en bit som heter BF som vil stille når dataene er mottatt helt, så vi sjekker om denne biten er satt hvis den ikke er satt, så må vi vente til den blir satt til å lese noe fra SPI-bussen.
usignert SPI_Ready2Read () { hvis (SSPSTAT & 0b00000001) returnerer 1; ellers returnere 0; }
SPI_Read ()
SPI Read brukes til å lese dataene fra SPI-bussen inn i mikrokontrolleren. Dataene som er til stede i SPI-bussen blir lagret i SSPBUF, vi må vente til de fullstendige dataene er lagret i bufferen, og så kan vi lese dem inn i en variabel. Vi sjekker BF-biten i SSPSTAT-registeret før vi leser bufferen for å sikre at datamottaket er komplett.
char SPI_Read () // Les mottatte data { while (! SSPSTATbits.BF); // Hold til BF-bit er satt, for å sikre at de fullstendige dataene leses tilbake (SSPBUF); // returner lesedataene }
Hovedprogram Forklaring:
Funksjonene som er forklart i avsnittet ovenfor, vil være i toppfilen, og de kan kalles inn i hoved-c-filen. Så la oss skrive et lite program for å sjekke om SPI-kommunikasjonen fungerer. Vi vil bare skrive få data inn i SPI-bussen og bruke proteus-simuleringen for å sjekke om de samme dataene mottas i SPI-feilsøkingsprogrammet.
Som alltid begynner programmet med å sette konfigurasjonsbiter, og det er veldig viktig å legge til headerfilen som vi nettopp forklarte i programmet som vist nedenfor
#inkludere
Hvis du har åpnet programmet fra zip-filen som er lastet ned ovenfor, vil toppfilen som standard være tilstede i toppfilkatalogen til prosjektfilen din. Ellers må du legge til toppteksten manuelt i prosjektet ditt, når prosjektfilene dine er lagt til, vil de se slik ut nedenfor
Inne i hovedfilen må vi initialisere PIC som Master for SPI-kommunikasjon og deretter inne i en uendelig mens loop vil vi skrive tilfeldige tre hexverdier i SPI-bussen for å sjekke om vi mottar det samme under simuleringen.
ugyldig hoved () { SPI_Initialize_Master (); mens (1) { SPI_Write (0X0A); __forsink_ms (100); SPI_Write (0X0F); __forsink_ms (100); SPI_Write (0X15); __forsink_ms (100); } }
Legg merke til at de tilfeldige verdiene som brukes i programmet er 0A, 0F og 15, og at de er heksverdier, så vi skal se det samme under simuleringen. Det er det koden er ferdig, dette er bare et utvalg, men vi kan bruke den samme metoden for å kommunisere med annen MCU eller med andre sensormoduler som fungerer på SPI-protokoll.
Simulering av PIC med SPI-feilsøkingsprogram:
Nå som programmet vårt er klart, kan vi kompilere det og deretter fortsette med simulering. Proteus har en fin hendig funksjon kalt SPI debugger , som kan brukes til å overvåke dataene over en SPI-buss. Så vi bruker det samme og bygger en krets som vist nedenfor.
Siden det bare er en SPI-enhet i simuleringen, bruker vi ikke SS-pinnen, og når den ikke brukes, bør den jordes som vist ovenfor. Bare last inn hex-filen i PIC16F877A mikrokontroller og klikk på avspillingsknappen for å simulere programmet vårt. Når simuleringen starter, vil du få et popup-vindu som viser dataene i SPI-bussen som vist nedenfor
La oss se nærmere på dataene som kommer inn og sjekke om de er de samme som vi skrev i programmet vårt.
Dataene mottas i samme rekkefølge som vi skrev i programmet vårt, og det samme er uthevet for deg. Du kan også prøve å simulere et program for å kommunisere med to PIC-mikrokontrollere ved hjelp av SPI- protokoll. Du må programmere en PIC som master og den andre som slave. Alle nødvendige headerfiler for dette formålet er allerede gitt i headerfilen.
Dette er bare et glimt av hva SPI kan gjøre, det kan også lese og skrive data til flere enheter. Vi vil dekke mer om SPI i de kommende opplæringsprogrammene våre ved å grense forskjellige moduler som fungerer med SPI-protokollen.
Håper du forsto prosjektet og lærte noe nyttig av det. Hvis du er i tvil, legg dem inn i kommentarfeltet nedenfor, eller bruk forumene for teknisk hjelp.
Komplett hovedkode er gitt nedenfor; du kan laste ned headerfiler med all koden herfra