Introduksjon til bit banging: spi kommunikasjon via bit banging

Kommunikasjonsgrensesnitt er en av faktorene som vurderes når du velger en mikrokontroller som skal brukes til et prosjekt. Designeren sørger for at mikrokontrolleren som velges har alle grensesnittene som kreves for å kommunisere med alle de andre komponentene som skal brukes til produktet. Eksistensen av noen av disse grensesnittene som SPI og I2C på mikrokontroller øker alltid kostnadene for slike mikrokontrollere, og avhengig av BOM-budsjettet kan det gjøre at en ønsket mikrokontroller ikke er rimelig. I situasjoner som disse kommer teknikkene som Bit Banging inn for å spille.

Hva er Bit Banging?

Bit banging er en teknikk for seriell kommunikasjon der hele kommunikasjonsprosessen håndteres via programvare i stedet for dedikert maskinvare. For å overføre data innebærer teknikken bruk av programvare for å kode dataene i signaler og pulser som brukes til å manipulere tilstanden til en I / O-pinne til en mikrokontroller som fungerer som Tx-pinnen for å sende data til målenheten. For å motta data, involverer teknikken sampling av tilstanden til Rx-pinnen etter bestemte intervaller som bestemmes av kommunikasjonsoverføringshastigheten. Programvaren setter alle parameterne som trengs for å oppnå denne kommunikasjonen, inkludert synkronisering, timing, nivåer osv., Som vanligvis bestemmes av dedikert maskinvare når bit banging ikke brukes.

Når skal du bruke Bit Banging

Bit-Banging brukes vanligvis i situasjoner der en mikrokontroller med det nødvendige grensesnittet ikke er tilgjengelig, eller når det kan være for dyrt å bytte til en mikrokontroller med ønsket grensesnitt. Det gir dermed en billig måte å gjøre det mulig for den samme enheten å kommunisere ved hjelp av flere protokoller. En mikrokontroller som tidligere kun er aktivert for UART-kommunikasjon, kan utstyres for å kommunisere ved hjelp av SPI og 12C via bit-smell.

Algoritme for seriell kommunikasjon via Bit Banging

Selv om koden for å implementere bitebinging kan variere på tvers av forskjellige mikrokontrollere, og kan også variere for forskjellige serielle protokoller, men prosedyren / algoritmen for implementering av bitebinging er den samme på alle plattformer.

For å sende data for eksempel brukes pseudokoden nedenfor;

1. Start
2. Send startbit
3. Vent til timingen samsvarer med mottakerens overføringshastighet
4. Send databit
5. Vent til varigheten samsvarer med mottakerens baudrate igjen
6. Sjekk om alle databitene er sendt. Hvis nei, gå til 4. Hvis ja, gå til 7
7. Send stopp bit
8. Stoppe

Mottak av data har en tendens til å være litt mer kompleks, vanligvis brukes et avbrudd for å bestemme når data er tilgjengelige på mottakerpinnen. Dette bidrar til å sikre at mikrokontrolleren ikke kaster bort for mye prosessorkraft. Selv om visse implementeringer bruker noen av mikrokontrollers I / O-pinner, er sjansen for støy og feil, hvis ikke sannsynligvis håndtert, høyere. Algoritmen for å motta data ved hjelp av avbrudd er forklart nedenfor.

1. Start
2. Aktiver avbrudd på Rx-pin
3. Når avbrudd utløses, skaff startbit
4. Vent på timing i henhold til overføringshastigheten
5. Les Rx-pinnen
6. Gjenta fra 4 til alle data er mottatt
7. Vent på timing i henhold til overføringshastigheten
8. Se etter stoppbit
9. Stoppe

Litt smell over SPI

Som nevnt ovenfor, fungerer bit banging for forskjellige protokoller annerledes, og det er derfor viktig å lese om hver protokoll, å forstå datainnramming og klokke før du prøver å implementere. Tar vi SPI-modus 1 som et eksempel, er klokkens basisverdi alltid 0 og data blir alltid sendt eller mottatt på den stigende kanten av klokken. Tidsdiagrammet for kommunikasjonsprotokollen SPI Mode 1 er vist nedenfor.

For å implementere dette kan følgende algoritme brukes;

1. Start
2. Sett SS-pinnen lav for å begynne kommunikasjonen
3. Sett pinnen for Master Out Slave In (MOSI) til den første biten av dataene som skal sendes
4. Sett klokken (SCK) høyt slik at data overføres av mesteren og mottas av slaven
5. Les tilstanden til Master in Slave Out (MISO) for å motta den første biten av data fra slave
6. Still SCK Low, slik at data kan sendes til neste stigende kant
7. Gå til 2 til alle databiter er overført.
8. Sett SS-pinnen High for å stoppe overføringen.
9. Stoppe

Eksempel på Bit Banging: SPI-kommunikasjon i Arduino

Som et eksempel, la oss implementere algoritmen for SPI-kommunikasjon via bit banging i Arduino for å vise hvordan data kan bit-banges over SPI ved hjelp av koden nedenfor.

Vi starter med å erklære at pinnene til Arduino skal brukes.

const int SSPin = 11; const int SCKPin = 10; const int MISOPin = 9; const int MOSIPin = 8; byte sendData = 64; // Verdien som skal sendes byte slaveData = 0; // for lagring av verdien som sendes av slaven

Deretter går vi til tomt oppsett () -funksjonen der tilstanden til pinnene blir deklarert. Bare MISO-pinnen (Master in Slave out) blir erklært som en inngang, siden den er den eneste pinnen som mottar data. Alle andre pinner er erklært som utdata. Etter at pin-modus er erklært, er SS-pinnen satt til HIGH. Årsaken til dette er å sikre at prosessen er feilfri, og kommunikasjonen starter bare når den er satt til lav.

ugyldig oppsett () { pinMode (MISOPin, INPUT); pinMode (SSPin, OUTPUT); pinMode (SCKPin, OUTPUT); pinMode (MOSIPin, OUTPUT); digitalWrite (SSPin, HIGH); }

Deretter starter vi løkken for å sende data. Merk at denne sløyfen fortsetter å sende dataene gjentatte ganger.

Vi starter sløyfen med å skrive SS-pinnen lav, for å starte begynnelsen på kommunikasjonen, og ringe til bitbangdata- funksjonen som bryter de forhåndsdefinerte dataene i biter og sender. Når dette er gjort, skriver vi deretter SS-pinnen HIGH for å indikere slutten på dataoverføringen.

void loop () { digitalWrite (SSPin, LOW); // SS lav slaveData = bitBangData (sendData); // dataoverføring digitalWrite (SSPin, HIGH); // SS høyt igjen }

Den bitbangdata () funksjon er skrevet under. Funksjonen tar inn dataene som skal sendes, og deler dem opp i biter og sender dem ved å løpe over koden for overføring som angitt i trinn 7 i algoritmen.

byte bitBangData (byte _send) // Denne funksjonen overfører dataene via bitbanging { byte _receive = 0; for (int i = 0; i <8; i ++) // 8 bits i en byte { digitalWrite (MOSIPin, bitRead (_send, i)); // Sett MOSI digitalWrite (SCKPin, HIGH); // SCK high bitWrite (_receive, i, digitalRead (MISOPin)); // Capture MISO digitalWrite (SCKPin, LOW); // SCK low } return _receive; // Returner de mottatte dataene }

Ulemper ved Bit Banging

Å vedta bit banging bør imidlertid være en gjennomtenkt beslutning, da det er flere ulemper med bit banging som kan gjøre det ikke pålitelig for implementering i visse løsninger. Bit banging øker strømforbruket av mikrokontrolleren på grunn av den høye prosessorkraften som forbrukes av prosessen. Sammenlignet med dedikert maskinvare, oppstår flere kommunikasjonsfeil som glitches og jitters når bit banging brukes, spesielt når datakommunikasjon utføres av mikrokontrolleren samtidig som andre oppgaver. Kommunikasjon via bit banging skjer med en brøkdel av hastigheten som den oppstår når dedikert maskinvare brukes. Dette kan være viktig i visse applikasjoner, og kan gjøre litt smell til et "ikke så bra" valg.

Bit banging brukes til alle typer seriell kommunikasjon inkludert; RS-232, asynkron seriell kommunikasjon, UART, SPI og I2C.

UART via litt smell i Arduino

En av de populære implementeringene av bit banging er Arduino Software Serial Library som gjør det mulig for Arduino å kommunisere over UART uten å bruke de dedikerte UART-pinnene for maskinvare (D0 og D1). Dette gir stor fleksibilitet ettersom brukere kan koble til så mange serielle enheter som antall pinner på Arduino-kortet kan støtte.