Introduktion till bitbanging: spi-kommunikation via bitbanging

Kommunikationsgränssnitt är en av de faktorer som beaktas när man väljer en mikrokontroller som ska användas för ett projekt. Designern ser till att den mikrokontroller som väljs har alla gränssnitt som krävs för att kommunicera med alla andra komponenter som ska användas för produkten. Förekomsten av några av dessa gränssnitt som SPI och I2C på mikrokontroller ökar alltid kostnaden för sådana mikrokontroller, och beroende på BOM-budgeten kan det göra att en önskad mikrokontroller inte är överkomlig. I sådana situationer kommer teknikerna som Bit Banging att spela.

Vad är Bit Banging?

Bit banging är en teknik för seriekommunikation där hela kommunikationsprocessen hanteras via programvara istället för dedikerad hårdvara. För att överföra data innefattar tekniken användning av programvara för att koda data till signaler och pulser som används för att manipulera tillståndet för en I / O-stift hos en mikrokontroller som fungerar som Tx-stift för att skicka data till målenheten. För att ta emot data innebär tekniken att sampla tillståndet för Rx-stiftet efter vissa intervall som bestäms av kommunikations-baudhastigheten. Programvaran ställer in alla parametrar som behövs för att uppnå denna kommunikation inklusive synkronisering, timing, nivåer etc., som vanligtvis bestäms av dedikerad hårdvara när bitknäppning inte används.

När ska Bit Banging användas

Bit-Banging används vanligtvis i situationer där en mikrokontroller med det nödvändiga gränssnittet inte är tillgänglig eller när det kan vara för dyrt att byta till en mikrokontroller med önskat gränssnitt. Det ger således ett billigt sätt att göra det möjligt för samma enhet att kommunicera med flera protokoll. En mikrokontroller som tidigare endast är aktiverad för UART-kommunikation kan utrustas för att kommunicera med SPI och 12C via bitknäppning.

Algoritm för seriell kommunikation via Bit Banging

Medan koden för att implementera bitbanging kan variera mellan olika mikrokontroller och kan också variera för olika seriella protokoll, men proceduren / algoritmen för att implementera bitbinging är densamma över alla plattformar.

För att skicka data till exempel används pseudokoden nedan;

1. Start
2. Skicka startbit
3. Vänta tills tidpunkten överensstämmer med mottagarens överföringshastighet
4. Skicka databit
5. Vänta tills den överensstämmer med mottagarens baudhastighet igen
6. Kontrollera om alla databitar har skickats. Om nej, gå till 4. Om ja, gå till 7
7. Skicka stoppbit
8. Sluta

Mottagning av data tenderar att vara lite mer komplex, vanligtvis används ett avbrott för att avgöra när data är tillgängliga på mottagarstiftet. Detta hjälper till att säkerställa att mikrokontrollern inte slösar för mycket processorkraft. Även om vissa implementeringar använder någon av mikrokontrollers I / O-stift, är risken för brus och fel, om inte förmodligen hanterad, högre. Algoritmen för att ta emot data med avbrott förklaras nedan.

1. Start
2. Aktivera avbrott på Rx-stift
3. När avbrott utlöses, skaffa startbit
4. Vänta på timing enligt baudhastigheten
5. Läs Rx-stiftet
6. Upprepa från 4 tills all data har mottagits
7. Vänta på timing enligt baudhastigheten
8. Sök efter stoppbit
9. Sluta

Lite slår över SPI

Som nämnts ovan fungerar bitknäppning för olika protokoll annorlunda och det är därför viktigt att läsa om varje protokoll, förstå dataramning och klockning innan du försöker implementera. Med SPI-läge 1 som exempel är klockans basvärde alltid 0 och data skickas eller tas alltid emot på klockans stigande kant. Tidsschemat för kommunikationsprotokollet SPI Mode 1 visas nedan.

För att implementera detta kan följande algoritm användas;

1. Start
2. Ställ in SS-stiftet lågt för att börja kommunicera
3. Ställ in stiftet för Master Out Slave In (MOSI) till den första biten av data som ska skickas
4. Ställ klockstiftet (SCK) högt så att data överförs av mastern och tas emot av slaven
5. Läs tillståndet för Master in Slave Out (MISO) för att ta emot den första biten av data från slaven
6. Ställ in SCK Low så att data kan skickas vid nästa stigande kant
7. Gå till 2 tills alla databitar har överförts.
8. Ställ in SS-stiftet Högt för att stoppa överföringen.
9. Sluta

Exempel på Bit Banging: SPI-kommunikation i Arduino

Som ett exempel, låt oss implementera algoritmen för SPI-kommunikation via bitbanging i Arduino för att visa hur data kan bitbangas över SPI med hjälp av koden nedan.

Vi börjar med att förklara att Arduino-stiften ska användas.

const int SSPin = 11; const int SCKPin = 10; const int MISOPin = 9; const int MOSIPin = 8; byte sendData = 64; // Värde som ska skickas byte slaveData = 0; // för att lagra det värde som slaven skickar

Därefter går vi till tomrumsuppsättningen () där stifternas tillstånd deklareras. Endast MISO-nålen (Master in Slave out) deklareras som en ingång eftersom det är den enda nålen som tar emot data. Alla andra stift deklareras som utdata. Efter att ha förklarat stiftlägena är SS-stiftet inställt på HÖG. Anledningen till detta är att säkerställa att processen är felfri och kommunikationen startar först när den är inställd på låg.

ogiltig installation () { pinMode (MISOPin, INPUT); pinMode (SSPin, OUTPUT); pinMode (SCKPin, OUTPUT); pinMode (MOSIPin, OUTPUT); digitalWrite (SSPin, HIGH); }

Därefter startar vi slingan för att skicka data. Observera att den här slingan fortsätter att skicka data upprepade gånger.

Vi startar slingan genom att skriva SS-stiftet lågt, för att starta början av kommunikationen och anropa bitbangdatafunktionen som bryter den fördefinierade datan i bitar och skickar. Med detta gjort skriver vi sedan SS-stiftet HIGH för att indikera slutet på dataöverföringen.

void loop () { digitalWrite (SSPin, LOW); // SS låg slaveData = bitBangData (sendData); // dataöverföring digitalWrite (SSPin, HIGH); // SS hög igen }

Den bitbangdata () funktion är skriven nedan. Funktionen tar in den data som ska sändas och bryter ner den i bitar och skickar den genom att kretsa över koden för överföringen som anges i steg 7 i algoritmen.

byte bitBangData (byte _send) // Denna funktion överför data via bitbanging { byte _receive = 0; för (int i = 0; i <8; i ++) // 8 bitar i en byte { digitalWrite (MOSIPin, bitRead (_send, i)); // Ställ in MOSI digitalWrite (SCKPin, HIGH); // SCK high bitWrite (_receive, i, digitalRead (MISOPin)); // Fånga MISO digitalWrite (SCKPin, LOW); // SCK low } return _receive; // Returnera de mottagna uppgifterna }

Nackdelar med Bit Banging

Antagande av bitbanging bör dock vara ett genomtänkt beslut eftersom det finns flera nackdelar med bitbanging som kan göra det inte tillförlitligt för implementering i vissa lösningar. Bitslipning ökar strömförbrukningen av mikrokontrollern på grund av den höga processorkraften som förbrukas av processen. Jämfört med dedikerad hårdvara uppstår fler kommunikationsfel som glitches och jitters när bit banging används, särskilt när datakommunikation utförs av mikrokontrollern samtidigt som andra uppgifter. Kommunikation via bitknäppning sker med en bråkdel av den hastighet som den sker när dedikerad hårdvara används. Detta kan vara viktigt i vissa applikationer och kan göra lite smäll till ett ”inte så bra” val.

Bitbanging används för alla typer av seriell kommunikation inklusive; RS-232, asynkron seriell kommunikation, UART, SPI och I2C.

UART via bitar i Arduino

En av de populära implementeringarna av bitbanging är Arduino Software Serial Library som gör det möjligt för Arduino att kommunicera över UART utan att använda de dedikerade UART-stiften för hårdvara (D0 och D1). Detta ger stor flexibilitet eftersom användare kan ansluta så många seriella enheter som antalet stift på Arduino-kortet kan stödja.