Raspberry Pi Arduino Serial Communication-allt du behöver veta

BY admin
|

i denna handledning visar jag dig hur man kommunicerar mellan en Raspberry Pi och en Arduino-kort via seriell kommunikation.

först ska jag snabbt förklara vad som är seriell kommunikation. Då ser du hur du ställer in din hårdvara och mjukvara, och vi dyker in i Python-koden (Cpp för Arduino). Ett grundläggande exempel först, vilket leder till en mer komplett applikation med en Raspberry Pi, en Arduino och andra elektroniska enheter.

denna handledning kommer att fungera med en Raspberry Pi 4 (och tidigare: 3B, 3B+) styrelse och alla Arduino styrelse. Jag använder mestadels Arduino Uno men kommer att ge mer information om skillnaderna mellan Arduino styrelser när det gäller seriell kommunikation.

när du arbetar med elektroniska enheter är kommunikation nyckeln. Varje enhet – utöver att göra bra vad den ska göra-måste kunna kommunicera tydligt med andra enheter. Det är en av de viktigaste att arbeta med för att byta från en mycket grundläggande applikation till mer komplexa.

Innehållsförteckning

Vad är seriell kommunikation (med UART)

seriell kommunikation är helt enkelt ett sätt att överföra data. Data kommer att skickas sekventiellt, en bit i taget (1 byte = 8 bitar), i motsats till parallell kommunikation, där många bitar skickas samtidigt.

UART-protokollet

mer specifikt, när du använder Serial med Arduino och Raspberry Pi, använder du UART-protokollet. UART betyder ”Universell asynkron mottagning och överföring”.

du lär dig hur du använder Raspberry Pi för att bygga dina egna projekt?

kolla in Raspberry Pi för nybörjare och lär dig steg för steg.

i grund och botten är det ett asynkront multi-master-protokoll baserat på seriell kommunikation, vilket gör att du kan kommunicera mellan 2-korten. Var lugn, det finns bibliotek som hanterar alla låga lager åt dig.

Multi-master innebär att alla anslutna enheter är fria att skicka data när de vill. Detta är en av huvudskillnaderna med master-slaves-protokoll, där endast masternheten kan initiera en kommunikation. Vanligtvis använder du andra protokoll som I2C och SPI när du behöver master-slaves-konfigurationer: till exempel när du har ett Arduino-kort och flera sensorer eller ställdon.

Arduino Uno-kortet har en UART som du kan använda antingen med en USB-kabel eller från RX/TX-stiften (använd inte den med båda samtidigt). Vissa brädor har mer tillgängliga UARTs. Till exempel har Arduino Mega olika serier (Serial, Serial1, Serial2, Serial3) och Arduino Zero har endast en inbyggd USB-port (använd SerialUSB istället för Serial).

på Raspberry Pi kan du ansluta många seriella enheter på USB-portarna. Var och en kommer att ha ett annat enhetsnamn (vi får se hur du hittar dem senare i den här handledningen). Du kan också använda GPIOs (RX0/TX0) för en extra UART.

du vet förmodligen redan seriell kommunikation

du har säkert redan använt seriell kommunikation många gånger. Jag är säker på att du redan känner till Arduino Serial library, som låter dig logga in vad som händer i din kod och få användarinmatning. När du använder seriell bildskärm, väl, i princip din Arduino IDE initierar en seriell kommunikation med din Arduino. Du kan ta emot och skicka data direkt från seriell bildskärm.

vad vi ska göra här är nästan detsamma, förutom att istället för din Arduino IDE kommer den andra sidan av seriell kommunikation att vara ett Raspberry Pi-kort. Vi måste göra några inställningar och skriva lite kod för att få det att fungera. Då kommer både Raspberry Pi och Arduino att kunna skicka meddelanden till varandra.

Låt oss nu se hur man fysiskt kopplar samman de 2 brädorna.

Hårdvaruinställning för seriell kommunikation

det finns 2 sätt att ansluta din Raspberry Pi och Arduino för seriell kommunikation.

seriell via USB

det enklaste sättet är att använda en USB-kabel mellan båda korten.

på Raspberry Pi-sidan är en enkel USB-kontakt allt du behöver. Du kan välja någon av de 4 USB-portarna som finns på kortet.

för Arduino använder du USB-porten som du använder för att ladda upp kod från din dator (med Arduino IDE) till din styrelse. Här beror USB-kontakten på vilken version du har. För brädor som Arduino Uno och Mega kommer kontakten att skilja sig från Arduino Nano och från Arduino Zero.

för detta exempel har jag använt en Arduino Uno styrelse.

som du kan se är det den enklaste hårdvaruanslutningen du kan göra mellan Raspberry Pi och Arduino.

notera: du måste först ansluta din Arduino till din dator så att du kan ladda upp koden till brädet. Anslut sedan USB-kabeln till Raspberry Pi. Raspberry Pi kommer att driva Arduino via denna kabel.

seriell via GPIOs

för att göra en seriell anslutning kan du också använda vanliga ledningar mellan Raspberry Pi GPIOs och Arduino-stiften.

beroende på ditt Arduino-kort kan du behöva använda en spänningsnivåväxlare. Raspberry Pi arbetar vid 3.3 V. För Arduino-brädor som Due, 101, kommer det att bli bra eftersom de också använder 3.3 V.

men, för många Arduino, såsom Uno, Mega, Leonardo, Nano, och många fler, styrelsen arbetar på 5V. således, du behöver en 3.3 V/5V nivå-shifter för att skydda Raspberry Pi när du ansluter RX och TX (mer information om Raspberry Pi stift och Arduino Uno stift).

för resten av denna handledning använder vi installationen med USB-kabeln. Detta blir lättare att hantera och om du inte har en bra anledning inte heller, bör du föredra att använda USB-kabeln istället för vanliga GPIO för seriell kommunikation.

Raspberry Pi Software setup

du behöver ingen speciell inställning för Arduino. Se bara till att du har laddat ner och installerat Arduino IDE.

nu, på din Raspberry Pi, krävs några saker för att kommunikationen ska fungera.

Anslut till din Raspberry Pi, antingen via ssh eller genom plugin en skärm+mus+tangentbord och öppna en terminal. Om du inte har installerat ett operativsystem på din Pi än kan du installera Raspbian eller Ubuntu mycket enkelt på ett SD-kort.

Upptäck Arduino-kortet

när du ansluter Arduino med en USB-kabel bör du se att den visas som /dev/ttyACM0 eller /dev/ttyUSB0 (ibland kan numret vara annorlunda, till exempel /dev/ttyACM1).

kör helt enkelt ls /dev/tty* och du borde se den. Om du inte är säker på vilken enhet som är Arduino-kortet, kopplar du helt enkelt bort kortet (ta bort USB-kabeln) och kör ls /dev/tty* igen. På så sätt kan du enkelt upptäcka det seriella enhetsnamnet på din Arduino.

Maskinvarubehörigheter för Serial

du kanske också vill lägga till din användare i dialogout-gruppen för att undvika fel som: serial.serialutil.SerialException: kunde inte öppna port / dev / ttyACM0: tillstånd nekad: ’/ dev / ttyACM0’

$ sudo adduser your_username dialout

detta kommer att se till att du har tillgång till seriella enheter (/dev/ttyACMx, /dev/ttyUSBx, …).

när du har lagt till dig själv i dialogout – gruppen måste du starta om din Pi (eller åtminstone logga ut/logga in) för att tillämpa ändringen-Läs mer om Raspberry Pi-hårdvarubehörigheter.

Installera Python Serial library på Raspberry Pi

du måste installera ett bibliotek för att kunna använda det seriella gränssnittet med Python.

för denna handledning använder vi pySerial-biblioteket (dokumentation för Python 3). För att installera det:

python3 -m pip install pyserial

detta Python-bibliotek är välkänt och används i många applikationer.

när du installerar, om du får ett fel som ”/usr/bin/python3: ingen modul som heter pip”, måste du installera pip först med sudo apt install python3-pip.

enkel seriell kommunikation från Arduino till Raspberry Pi

låt oss börja med ett mycket enkelt program.

Arduino-kod

Ladda upp den här koden från din dator till din Arduino med Arduino IDE.

void setup() { Serial.begin(9600);}void loop() { Serial.println("Hello from Arduino!"); delay(1000);}

först initierar vi seriell kommunikation och väljer en överföringshastighet, här 9600. 9600 är en vanlig baudhastighet,och också en ganska låg. I dina framtida applikationer kan du använda en överföringshastighet på 57600 eller till och med 115200 utan problem. För denna handledning fortsätter vi med 9600.

varje sekund får vi Arduino att skicka en sträng med seriell.println (). funktionen println () lägger till ett nytt radtecken ’\n’ i slutet av strängen.

du kan öppna seriell bildskärm för att se strängen på din dator.

Raspberry Pi Python-kod 

#!/usr/bin/env python3import serialif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

så, vad gör den här koden?

#!/usr/bin/env python3import serial

först importerar vi det seriella biblioteket som vi tidigare installerade.

if __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)

seriell kommunikation initieras genom att anropa serial.Serial () tillsammans med några parametrar:

  • seriellt enhetsnamn för Arduino: vanligtvis ’/dev/ttyACM0’, ’/dev / ttyUSB0’ eller liknande.
  • överföringshastighet: denna parameter är mycket viktig. Du måste använda samma överföringshastighet som den du använde på Arduino, annars kommer allt du läser och skriver att vara skräp. Så vi väljer 9600 som vi gjorde i Arduino-skissen.
  • timeout: detta är en timeout för läsoperationer. Här ställer vi in det till 1 sekund. Det betyder att när vi läser från seriell, kommer programmet inte att fastna för alltid om data inte kommer. Efter 1 sekund eller läsning, om inte alla byte tas emot, returnerar funktionen de redan mottagna byte.

så, serie.Serial () returnerar ett objekt som du kan använda för alla dina seriella operationer. Vi lagrar den i variabeln ’ser’.

 ser.flush()

sedan använder vi funktionen flush (). Detta kommer att spola alla ingångs-och utgångsbuffertar, så det kommer att undvika att ta emot eller skicka konstiga/inte användbara/inte fullständiga data i början av kommunikationen.

 while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

i en oändlig slinga (tänk på loop () – funktionen i Arduino-skissen) kontrollerar vi om vissa data är tillgängliga med attributet in_waiting (lägg inte parentes, det här är inte en funktion). Om ja, kan vi läsa uppgifterna.

funktionen readline() läser alla byte tills ett nytt radtecken upptäcks.

om vi bara tryckt vad vi fick vi skulle se b ’ Hello från Arduino!\ r \ n’. Du får byte när du läser från seriell, och du måste konvertera (avkoda) dessa byte till lämplig datatyp. Så vi använder decode (’UTF-8’) – Du kan också använda decode (’ascii’) – för att avkoda mottagna data till en sträng.

slutligen är rstrip () – funktionen specifik för strängar, det låter dig ta bort eventuella efterföljande tecken (newline, vagnretur). På så sätt kan vi ta bort ’\r’ och ’\n’ och få en riktig sträng.

Obs: här läser vi en komplett rad varje gång. Om du vill läsa en viss mängd Byte – en eller flera – använd funktionen read(size=1).

testa seriell kommunikation

koppla nu ur Arduino-kortet från din dator och anslut det till ditt Raspberry Pi-kort.

Arduino-koden körs redan, så snart den är påslagen.

på Raspberry Pi, gör Python-filen körbar och starta den.

$ chmod +x receive_serial_data_from_arduino.py$ ./receive_serial_data_from_arduino.py Hello from Arduino!Hello from Arduino!Hello from Arduino!

det fungerar! Strängen som skickas av Arduino varje sekund visas på Raspberry Pi-terminalen.

dubbelriktad seriell kommunikation mellan Raspberry Pi och Arduino

Låt oss göra saker lite mer intressanta. Du har sett hur du skickar data från Arduino till Raspberry Pi. I den här delen ser du hur man pratar från Raspberry Pi till Arduino. Således har du båda sidor av kommunikationen och du kommer att kunna skapa program som väntar på varandras input.

Arduino-kod 

void setup() { Serial.begin(9600);}void loop() { if (Serial.available() > 0) { String data = Serial.readStringUntil('\n'); Serial.print("You sent me: "); Serial.println(data); }}

här kontrollerar vi om Arduino har fått data med seriell.tillgänglig(). Detta ger dig antalet byte som redan har anlänt och lagrats i mottagningsbufferten.

om vissa data har kommit, använder vi Serial.readStringUntil () med en nyrad tecken ’\n’ för att få nästa rad. Detta liknar funktionen readline (). Alla byte som mottas tills ’\n ’ konverteras automatiskt och läggs till i ett Arduino-Strängobjekt.

sedan skriver vi bara tillbaka de data vi fick, med ytterligare en textbit.

Obs: Om du vill läsa Byte en efter en kan du göra det med serien.läs () funktion. Då måste du konvertera Denna (de) byte (s) om det behövs: int, String, etc.

Raspberry Pi Python-kod 

#!/usr/bin/env python3import serialimport timeif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: ser.write(b"Hello from Raspberry Pi!\n") line = ser.readline().decode('utf-8').rstrip() print(line) time.sleep(1)

använd pySerial-funktionen Skriv() för att skicka data till Arduino. Här kan du se att jag har lagt till ett ’ b ’ innan strängen ska skickas. Detta kodar strängen till byte, eftersom du bara kan skicka byte via seriell. Alla data som inte är en byte-eller byte-array måste konverteras innan de skickas. Om du bara försöker skicka strängen så får du det här felet ”TypeError: unicode-strängar stöds inte, vänligen koda till byte:” Hej från Raspberry Pi!'”

Obs: istället för ser.write(b"Hello from Raspberry Pi!\n") kunde du ha skrivit ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) eller ser.write("Hello from Raspberry Pi!\n".encode('ascii')). Detta kommer att göra samma sak. Funktionen encode () tar strängen och kodar den för seriell.

vi lägger också till en newline-karaktär ’\n’ eftersom det är vad Arduino förväntas avsluta sin läsning med seriell.readstringfram till (’\n’).

sedan gör vi samma sak som vi gjorde tidigare: vi läser en rad, avkodar den till sträng och tar bort eventuella efterföljande tecken. Vi använder inte ser.in_waiting här, för för den här specifika applikationen vet vi att Arduino kommer att skicka tillbaka några data strax efter att den har fått strängen. Också, vi har en 1 andra timeout för att undvika att fastna på denna linje.

slutligen skriver vi ut den mottagna strängen och väntar på 1 sekund med tiden.sova () innan du skickar nästa sträng över seriell.

testa dubbelriktad seriell kommunikation

på din Raspberry Pi, gör din Python-fil körbar och starta den.

$ chmod +x bidirectional_serial_communication.py $ ./bidirectional_serial_communication.py You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!

framgång! Arduino fick strängen och skickade tillbaka den med några fler ord. Sedan fick Raspberry Pi och tryckte den sista strängen.

Raspberry Pi Arduino Serial communication: applikationsexempel

nu när du vet hur du ställer in din Arduino och Raspberry Pi för seriell kommunikation och skriver program för att prata mellan varje styrelse, låt oss skapa en mer komplex applikation.

i denna applikation kommer 4 lysdioder och en tryckknapp att anslutas till Arduino-kortet.

Raspberry Pi och Arduino kommer att anslutas med en USB-kabel och använda seriell kommunikation för att prata med varandra.

här är resultatet vi vill få:

  • när tryckknappen trycks in skickar Arduino ett meddelande till Raspberry Pi (en enkel byte).
  • Raspberry Pi beräknar sedan ett slumpmässigt heltal mellan 1 och 4 och skickar det till Arduino.
  • Arduino kommer att slå på lysdioden relaterad till detta nummer och stänga av de andra lysdioderna.

detta gör att du övar på kommunikation och synkronisering av uppgifter mellan Arduino och Raspberry Pi.

om du kom till denna punkt i handledningen (grattis!) Jag uppmuntrar dig att försöka skriva koden själv innan du läser koden jag har angett nedan. Det finns inte bara en möjlig kod för att uppfylla dessa krav, så din kod kan skilja sig från min, Det är helt OK. Du kan få hjälp från Arduino Serial reference och pySerial API reference.

scheman

för att göra denna krets:

  • Anslut 4 lysdioder till stiften 9-12. Lägg till ett 220 Ohm motstånd för varje LED mellan det längre benet och den digitala stiftet. Det kortare benet är anslutet till marken.
  • Lägg till en tryckknapp med ett 10kohm motstånd anslutet till marken (neddragningsmotstånd). Ena sidan av knappen är ansluten till 5V, den andra till digital stift 5 för läsning.
  • glöm inte att skapa en gemensam grund mellan alla komponenter: Arduino-kortet, de 4 lysdioderna och tryckknappen. Lägg inte till någon strömförsörjning om du inte åtminstone har anslutit grunderna korrekt.
  • Anslut Arduino och Raspberry Pi via en USB-kabel, för seriell kommunikation (USB-kabeln hanterar redan jordanslutningen mellan dina 2 kort).

Arduino-kod 

#define LED_1_PIN 9#define LED_2_PIN 10#define LED_3_PIN 11#define LED_4_PIN 12#define BUTTON_PIN 5byte lastButtonState = LOW;byte currentButtonState = LOW;unsigned long lastButtonDebounceTime = 0;unsigned long buttonDebounceDelay = 20;void powerOffAllLEDs(){ digitalWrite(LED_1_PIN, LOW); digitalWrite(LED_2_PIN, LOW); digitalWrite(LED_3_PIN, LOW); digitalWrite(LED_4_PIN, LOW);}void setup(){ Serial.begin(9600); pinMode(LED_1_PIN, OUTPUT); pinMode(LED_2_PIN, OUTPUT); pinMode(LED_3_PIN, OUTPUT); pinMode(LED_4_PIN, OUTPUT); pinMode(BUTTON_PIN, INPUT); powerOffAllLEDs();}void loop(){ byte readValue = digitalRead(BUTTON_PIN); if (readValue != lastButtonState) { lastButtonDebounceTime = millis(); } if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } } } lastButtonState = readValue; if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }}

i funktionen setup() initierar vi stiftlägena för alla 4 lysdioder och tryckknappen. Vi ser också till att alla lysdioder är avstängda.

sedan i slingan() gör vi 2 saker: hantering av tryckknappen och hantering av 4 lysdioder. Båda åtgärderna görs en efter en, men de hanteras mycket snabbt så det är precis som om de händer samtidigt. Det är ett fall av multitasking ett Arduino-program.

första åtgärden: hantering av tryckknappen.

byte readValue = digitalRead(BUTTON_PIN);if (readValue != lastButtonState) { lastButtonDebounceTime = millis();}if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } }}lastButtonState = readValue;

vi måste ta bort knappen för att undvika oönskade värden. När vi får reda på att knappen trycks in kan vi skicka lite data till Raspberry Pi via seriell.

Här har jag använt serien.skriv () funktion: den skickar en byte eller serie byte. Detta skiljer sig från seriell.Skriv ut () vilket gör utmatningen trevlig att se på seriell bildskärm. Eftersom vi pratar med en annan maskin och inte en människa, inga problem med det.

numret vi skickar här är 18. Detta är bara ett slumptal som vi associerar med staten ”knappen har skjutits”, så när Raspberry Pi kommer att få ett nummer kommer det att kontrollera om det är lika med 18. Du kan tänka dig att skicka olika åtgärder eller meddelanden via seriell, med olika nummer.

Obs: vanligtvis kan du också använda Arduino avbrott för att veta när en knapp har tryckts. Om du gör det, använd inte det seriella biblioteket i avbrottet. Om du absolut måste använda avbrott, sätt sedan en flagga inuti avbrottet (en enkel boolesk variabel) och använd seriell inuti din loop () – funktion.

och den andra åtgärden: hantera de 4 lysdioderna.

 if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }

först kontrollerar vi om Arduino har fått några data från Raspberry Pi över seriell kommunikation.

om ja, läser vi nästa byte med seriell.läsa(). Här kan du märka ett litet knep som består av att subtrahera med ’0’, vilket kommer att konvertera tecknet till det tal det representerar – i detta fall ett heltal.

efter det är det ganska enkelt. Vi stänger av alla lysdioder och slår sedan på endast lysdioden som är associerad med numret: 1, 2, 3 eller 4. Om ett fel värde skickas kommer ingen LED att slås på.

Raspberry Pi Python-kod 

#!/usr/bin/env python3import serialimport randomif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: number = ser.read() if number != b'': if int.from_bytes(number, byteorder='big') == 18: led_number = random.randint(1,4) print("Button has been pressed.") print("Sending number " + str(led_number) + " to Arduino.") ser.write(str(led_number).encode('utf-8'))

först lägger vi till en importlinje: Python random library.

i den oändliga slingan (”medan Sant”) läser vi först en byte från seriell. Timeout är inställd på 1 sekund. Om inget tas emot efter en sekund kommer funktionen read() att returnera b”.

så vi kontrollerar om det vi fick är helt enkelt tomt (b”) eller om det verkligen var något. I det senare fallet konverterar vi data vi fick till ett heltal så att vi kan använda i koden. För det använder vi funktionen int.from_bytes (), som avkodar b’0x12′ (den hexadecimala representationen av 18 är 0x12) till 18.

som du kan se kontrollerar vi att numret är 18 för att fortsätta åtgärden. Om du har olika kommandon att hantera är det bra att använda ett annat nummer för varje kommando.

vi väljer ett slumptal mellan 1 och 4 för att bestämma vilken LED som ska slås på. Sedan skickar vi den med pySerial write () – funktionen. För att skicka en int via seriell konverterar vi den först som en sträng med str () och kodar sedan den med encode(’utf-8’).

testa applikationen

nu kan du ansluta Arduino till Raspberry Pi med USB-kabeln. Raspberry Pi kommer sedan att leverera kraften för både Arduino och 4 lysdioder.

om du har många saker anslutna till din Arduino kanske du vill lägga till en extern strömförsörjning på Arduino-strömförsörjningskontakten. Om du till exempel vill använda en stegmotor kommer Raspberry Pi aldrig att ha tillräckligt med ström för sig själv + Arduino + motorn. I det här fallet, med 4 lysdioder som är OK.

kör ditt Python-skript och tryck på tryckknappen. Du kommer att se en logg och en av lysdioderna på Arduino kommer att slås på.

$ chmod +x arduino_raspberry_pi_leds_button.py$ ./arduino_raspberry_pi_leds_button.py Button has been pressed.Sending number 3 to Arduino.Button has been pressed.Sending number 2 to Arduino.Button has been pressed.Sending number 4 to Arduino.Button has been pressed.Sending number 1 to Arduino.Button has been pressed.Sending number 3 to Arduino.Button has been pressed.Sending number 3 to Arduino.

varje gång du trycker på knappen:

  • Arduino kommer att upptäcka det och skicka 18 till Raspberry Pi.
  • Raspberry Pi kommer att få vissa data från seriell. Det kommer att kontrollera om antalet är lika med 18. Om ja ett slumptal (mellan 1-4) väljs. Raspberry Pi skickar detta nummer till Arduino.
  • Arduino kommer att få detta nummer och slå på den tillhörande lysdioden.

Obs: För att göra denna applikation snabbare och med mindre kod kan du också välja att använda Firmata-protokollet, med till exempel pyFirmata-biblioteket på Raspberry och StandarfFirmata-biblioteket på Arduino. Kolla in dessa handledning för att lära dig mer.

slutsats

i denna handledning har du lärt dig hur du kommunicerar mellan din Raspberry Pi och Arduino board via Serial.

nu, i verkligheten, kommer det att vara användbart för dig? Svaret är ja, och ganska ofta.

Raspberry Pi är bra för att ha mycket beräkningskraft inbäddad i din applikation. Du kan köra kompletta programvaror på många språk, webbservrar,robotapplikationer etc. Raspberry Pi har verkligen Några GPIOs som du kan använda, men de är inte lika bra som Arduino. Du har också fler chanser att bränna din Pi om du gör något fel med hårdvaran.

Arduino är lämpligare att direkt hantera hårdvarusensorer och ställdon: IMU, servomotorer, stegmotorer, allt som kräver mer kraft etc. – mer information om när du ska använda Arduino vs Raspberry Pi.

sammantaget kan 2-brädorna fungera perfekt: Raspberry Pi som ”hjärnan” i applikationen och Arduino som ”musklerna”, med en seriell kommunikation för att få dem att prata med varandra.