Raspberry Pi Arduino Serial Communication – alt hvad du behøver at vide

BY admin
|

i denne tutorial vil jeg vise dig, hvordan du kommunikerer mellem en Raspberry Pi og en Arduino bord via seriel kommunikation.

først vil jeg hurtigt forklare, hvad der er seriel kommunikation. Så kan du se, hvordan du opsætter dit udstyr og program, og vi dykker ned i Python-koden (Cpp for Arduino). Et grundlæggende eksempel i starten, hvilket fører til en mere komplet applikation ved hjælp af en Raspberry Pi, en Arduino og andre elektroniske enheder.

denne tutorial vil arbejde med en Raspberry Pi 4 (og tidligere: 3B, 3B+) bord, og enhver Arduino bord. Jeg bruger mest Arduino Uno, men vil give flere detaljer om forskellene mellem Arduino-tavler, når det kommer til seriel kommunikation.

når du arbejder med elektroniske enheder, er kommunikation nøglen. Hver enhed-ud over at gøre det godt, hvad det skal gøre – skal være i stand til klart at kommunikere med andre enheder. Det er en af de vigtigste ting at arbejde på for at skifte fra en meget grundlæggende applikation til mere komplekse.

Indholdsfortegnelse

Hvad er seriel kommunikation (med UART)

seriel kommunikation er simpelthen en måde at overføre data på. Dataene sendes sekventielt, en bit ad gangen (1 byte = 8 bit), i modsætning til parallel kommunikation, hvor mange bits sendes på samme tid.

UART-protokol

mere specifikt, når du bruger seriel med Arduino og Raspberry Pi, bruger du UART-protokollen. UART betyder “universel asynkron modtagelse og Transmission”.

du lærer at bruge Raspberry Pi til at bygge dine egne projekter?

Tjek Raspberry Pi for begyndere og Lær trin for trin.

dybest set er det en asynkron multi-master-protokol baseret på den serielle kommunikation, som giver dig mulighed for at kommunikere mellem de 2 tavler. Vær beroliget, der er biblioteker, der håndterer alle de lave lag for dig.

Multi-master betyder, at alle tilsluttede enheder frit kan sende data, når de vil. Dette er en af hovedforskellen med master-slaves protokoller, hvor kun masterenheden kan starte en kommunikation. Normalt bruger du andre protokoller som I2C og SPI, når du har brug for master-slaver-konfigurationer: for eksempel når du har et Arduino-kort og flere sensorer eller aktuatorer.

Arduino Uno-kortet har en UART, som du kan bruge enten med et USB-kabel eller fra stifterne (brug det ikke med begge på samme tid). Nogle bestyrelser har mere tilgængelige UARTs. For eksempel har Arduino Mega forskellige serier (seriel, Serial1, Serial2, Serial3) og Arduino nul har kun en indbygget USB-port (brug SerialUSB i stedet for seriel).

på Raspberry Pi kan du tilslutte mange serielle enheder på USB-portene. Hver har et andet enhedsnavn (vi vil se, hvordan du finder dem senere i denne tutorial). Du kan også bruge GPIOs (RKS0/TKS0) til en ekstra UART.

du kender sandsynligvis allerede seriel kommunikation

du har bestemt allerede brugt seriel kommunikation mange gange. Jeg er sikker på, at du allerede kender Arduino Serial library, som giver dig mulighed for at logge, hvad der sker i din kode og få brugerinput. Når du bruger den serielle skærm, godt, dybest set din Arduino IDE indleder en seriel kommunikation med din Arduino. Du kan modtage og sende data direkte fra den serielle skærm.

hvad vi vil gøre her er næsten det samme, bortset fra at i stedet for din Arduino IDE, vil den anden side af den serielle kommunikation være et Raspberry Pi-bord. Vi bliver nødt til at lave nogle opsætninger og skrive noget kode for at få det til at fungere. Derefter vil både Raspberry Pi og Arduino være i stand til at sende beskeder til hinanden.

lad os nu se, hvordan man fysisk forbinder de 2 brædder sammen.

opsætning af udstyr til seriel kommunikation

der er 2 måder at forbinde din Raspberry Pi og Arduino til seriel kommunikation.

Serial via USB

den nemmeste måde er at bruge et USB-kabel mellem begge kort.

på Raspberry Pi-siden er et simpelt USB-stik alt hvad du behøver. Du kan vælge en af de 4 USB-porte, der er tilgængelige på tavlen.

for Arduino bruger du den USB-port, du bruger til at uploade kode fra din computer (med Arduino IDE) til dit bord. Her afhænger USB-stikket af hvilken version du har. For brædder som Arduino Uno og Mega vil stikket være forskelligt fra Arduino Nano og fra Arduino nul.

til dette eksempel har jeg brugt et Arduino Uno bord.

som du kan se, er det den enkleste udstyrsforbindelse, du kan oprette mellem Raspberry Pi og Arduino.

Bemærk: du skal først forbinde din Arduino til din computer, så du kan uploade koden til tavlen. Tilslut derefter USB-kablet til Raspberry Pi. Raspberry Pi vil drive Arduino via dette kabel.

Serial via GPIOs

for at oprette en seriel forbindelse kan du også bruge almindelige ledninger mellem Raspberry Pi GPIOs og Arduino-stifterne.

afhængigt af dit Arduino-kort skal du muligvis bruge en spændingsniveauskifter. Raspberry Pi fungerer ved 3.3 V. For Arduino-plader som Due, 101, vil det være fint, fordi de også bruger 3.3 V.

men for mange Arduino, såsom Uno, Mega, Leonardo, Nano og mange flere, fungerer brættet på 5V. således har du brug for en 3.3 V/5V niveauskifter for at beskytte Raspberry Pi, når du tilslutter rks og TKS (mere info om Raspberry Pi pins og Arduino Uno pins).

for resten af denne tutorial bruger vi opsætningen med USB-kablet. Dette vil være lettere at administrere, og medmindre du ikke har en god grund, bør du foretrække at bruge USB-kablet i stedet for almindelige gpios til seriel kommunikation.

opsætning af Raspberry Pi

du behøver ikke nogen speciel opsætning til Arduino. Bare sørg for at du har hentet og installeret Arduino IDE.

på din Raspberry Pi kræves der et par ting for at få kommunikationen til at fungere.

Opret forbindelse til din Raspberry Pi, enten via ssh eller ved plugin en skærm+mus+tastatur, og åbn en terminal. Hvis du endnu ikke har installeret et operativsystem på din Pi, kan du installere Raspbian eller Ubuntu meget let på et SD-kort.

registrer Arduino-kortet

når du tilslutter Arduino med et USB-kabel, skal du se det vises som /dev/ttyACM0 eller /dev/ttyUSB0 (nogle gange kan nummeret være anderledes, for eksempel /dev/ttyACM1).

Kør simpelthen ls /dev/tty* og du skal se det. På dette tidspunkt, hvis du ikke er sikker på, hvilken enhed der er Arduino-kortet, skal du blot frakoble kortet (fjern USB-kablet) og køre ls /dev/tty* igen. På denne måde vil du nemt få øje på det serielle enhedsnavn på din Arduino.

Udstyrstilladelser til seriel

du kan også tilføje din bruger til dialoutgruppen for at undgå fejl som: seriel.serialutil.Serielundtagelse: kunne ikke åbne port / dev / ttyACM0: Tilladelse nægtet: ‘/ dev / ttyACM0’

$ sudo adduser your_username dialout

dette vil sikre, at du har adgang til serielle enheder (/dev/ttyacm, /dev/ttyusbh,…).

når du har tilføjet dig selv til dialout – gruppen, skal du genstarte din Pi (eller i det mindste logge ud/logge ind) for at anvende ændringen-Lær mere om Raspberry Pi-tilladelser.

installer Python Serial library på Raspberry Pi

du skal installere et bibliotek for at kunne bruge den serielle grænseflade med Python.

til denne tutorial bruger vi pyserial-biblioteket (dokumentation til Python 3). For at installere det:

python3 -m pip install pyserial

dette Python-bibliotek er velkendt og bruges i mange applikationer.

når du installerer, hvis du får en fejl som “/usr/bin/python3: intet modul ved navn pip”, skal du først installere pip med sudo apt install python3-pip.

enkel seriel kommunikation fra Arduino til Raspberry Pi

lad os starte med et meget simpelt program.

Arduino kode

Upload denne kode fra din computer til din Arduino, ved hjælp af Arduino IDE.

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

først initialiserer vi den serielle kommunikation og vælger en baudrate, her 9600. 9600 er en almindeligt anvendt baud sats, og også en temmelig lav en. I dine fremtidige applikationer kan du bruge en baudhastighed på 57600 eller endda 115200 uden problemer. Til denne tutorial fortsætter vi med 9600.

hvert sekund får vi Arduino til at sende en streng med seriel.println (). funktionen println () tilføjer et nyt linjetegn ‘\n’ i slutningen af strengen.

du kan åbne den serielle skærm for at se strengen på din computer.

Raspberry Pi Python kode 

#!/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å hvad gør denne kode?

#!/usr/bin/env python3import serial

først importerer vi det serielle bibliotek, som vi tidligere installerede.

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

den serielle kommunikation initialiseres ved at kalde seriel.Seriel () sammen med et par parametre:

  • serielt enhedsnavn til Arduino: normalt ‘/ dev/ttyACM0’, ‘/dev / ttyUSB0’ eller lignende.
  • Baud rate: denne parameter er meget vigtig. Du skal bruge den samme baudrate som den, du brugte på Arduino, ellers vil alt, hvad du læser og skriver, være affald. Så vi vælger 9600, som vi gjorde i Arduino-skitsen.
  • timeout: dette er en timeout for læse operationer. Her sætter vi det til 1 sekund. Det betyder, at når vi læser fra seriel, vil programmet ikke sidde fast for evigt, hvis dataene ikke kommer. Efter 1 sekund eller læsning, hvis ikke alle bytes modtages, returnerer funktionen de allerede modtagne bytes.

så, seriel.Serial () returnerer et objekt, som du kan bruge til alle dine serielle handlinger. Vi gemmer det I’ ser ‘ variablen.

 ser.flush()

så bruger vi flush () – funktionen. Dette vil skylle enhver input-og outputbuffer, så det undgår at modtage eller sende underlige/ikke nyttige/ikke komplette data i begyndelsen af kommunikationen.

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

i en uendelig sløjfe (tænk på loop () – funktionen i Arduino-skitsen) kontrollerer vi, om nogle data er tilgængelige med attributten in_venter (sæt ikke parentes, dette er ikke en funktion). Hvis ja, kan vi læse dataene.

funktionen readline() læser alle bytes, indtil der registreres et nyt linjetegn.

hvis vi bare udskrev det, vi modtog, ville vi se b ‘ Hello fra Arduino!\ r \ n’. Du modtager bytes, når du læser fra seriel, og du skal konvertere (afkode) disse bytes til den relevante datatype. Så vi bruger decode (‘utf-8’) – Du kan også bruge decode (‘ascii’) – til at afkode de modtagne data til en streng.

endelig er rstrip () – funktionen specifik for strenge, det giver dig mulighed for at fjerne eventuelle efterfølgende tegn (ny linje, vognretur). På denne måde kan vi fjerne ‘\r’ og ‘\n’ og få en ordentlig streng.

Bemærk: her læser vi en komplet linje hver gang. Hvis du vil læse en vis mængde bytes – en eller flere – skal du bruge funktionen Læs(Størrelse=1).

test seriel kommunikation

tag nu dit Arduino-kort ud af din computer og tilslut det til dit Raspberry Pi-kort.

Arduino-koden kører allerede, så snart den er tændt.

på Raspberry Pi skal du gøre Python-filen eksekverbar og starte 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 virker! Strengen sendt af Arduino hvert sekund vises på Raspberry Pi-terminalen.

tovejs seriel kommunikation mellem Raspberry Pi og Arduino

lad os gøre tingene lidt mere interessante. Du har set, hvordan du sender data fra Arduino til Raspberry Pi. I denne del kan du se, hvordan man taler fra Raspberry Pi til Arduino. Således har du begge sider af kommunikationen, og du vil være i stand til at oprette programmer, der venter på hinandens input.

Arduino kode 

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

her kontrollerer vi, om Arduino har modtaget data med seriel.tilgængelig(). Dette giver dig antallet af bytes, der allerede er ankommet og gemt i modtagebufferen.

hvis nogle data er ankommet, bruger vi seriel.readstring indtil () med en ny linje tegn ‘\n’ for at få den næste linje. Dette svarer til funktionen readline (). Alle bytes modtaget indtil ‘\ n ‘ konverteres automatisk og tilføjes i et Arduino-Strengobjekt.

derefter udskriver vi bare de data, vi modtog, med et ekstra stykke tekst.

Bemærk: Hvis du vil læse bytes en efter en, kan du gøre det med serien.Læs () funktion. Så bliver du nødt til at konvertere Denne(disse) byte(r), hvis det er nødvendigt: int, String osv.

Raspberry Pi Python code 

#!/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)

brug pyserial-funktionen Skriv() til at sende data til Arduino. Her kan du se, at jeg har tilføjet en ‘b’ før strengen til at sende. Dette koder strengen til bytes, fordi du kun kan sende bytes gennem seriel. Alle data, der ikke er en byte eller byte array skal konverteres, før de sendes. Hvis du bare prøver at sende strengen Sådan, får du denne fejl ” TypeError: unicode-strenge understøttes ikke, skal du kode til bytes: ‘Hej fra Raspberry Pi!'”

Bemærk: I stedet for ser.write(b"Hello from Raspberry Pi!\n") kunne du have skrevet ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) eller ser.write("Hello from Raspberry Pi!\n".encode('ascii')). Dette vil gøre det samme. Funktionen encode () tager strengen og koder den for seriel.

vi tilføjer også et nyt linjetegn ‘\n’, fordi det er, hvad Arduino forventes at afslutte sin læsning med seriel.readstring indtil (‘\n’).

derefter gør vi det samme som vi gjorde før: vi læser en linje, afkoder den til streng og fjerner ethvert efterfølgende tegn. Vi bruger ikke ser.in_venter her, fordi for denne specifikke applikation ved vi, at Arduino vil sende nogle data tilbage lige efter at den har modtaget strengen. Vi har også en 1 anden timeout for at undgå at sidde fast på denne linje.

endelig udskriver vi den modtagne streng og venter i 1 sekund med tiden.sleep () før du sender den næste streng over seriel.

test tovejs seriel kommunikation

på din Raspberry Pi skal du gøre din Python-fil eksekverbar og starte 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!

succes! Arduino modtog strengen og sendte den tilbage med et par flere ord. Derefter modtog Raspberry Pi og trykte den endelige streng.

Raspberry Pi Arduino seriel kommunikation: Applikationseksempel

nu hvor du ved, hvordan du konfigurerer din Arduino og Raspberry Pi til seriel kommunikation og skriver programmer til at tale mellem hvert Bræt, lad os oprette en mere kompleks applikation.

i denne applikation vil 4 LED ‘ er og en trykknap blive tilsluttet Arduino-kortet.

Raspberry Pi og Arduino vil blive forbundet med et USB-kabel og bruge seriel kommunikation til at tale med hinanden.

her er resultatet, vi ønsker at få:

  • når der trykkes på trykknappen, sender Arduino en meddelelse til Raspberry Pi (en simpel byte).
  • Raspberry Pi beregner derefter et tilfældigt heltal mellem 1 og 4 og sender det til Arduino.
  • Arduino vil tænde for LED ‘ en relateret til dette nummer og slukke for de andre lysdioder.

dette vil få dig til at øve på kommunikation og synkronisering af opgaver mellem Arduino og Raspberry Pi.

hvis du ankom til dette punkt i tutorial (tillykke!) Jeg opfordrer dig til at prøve at skrive koden selv, før du læser den kode, jeg har angivet nedenfor. Der er også ikke kun en mulig kode til at opfylde disse krav, så din kode kan være forskellig fra Min, det er helt OK. Du kan få hjælp fra Arduino seriel reference og pyserial API reference.

skemaer

for at gøre dette kredsløb:

  • Tilslut 4 LED ‘ er til stifter 9-12. Tilføj en 220 Ohm modstand for hver LED mellem det længere ben og den digitale pin. Det kortere ben er forbundet med jorden.
  • Tilføj en trykknap med en 10kohm modstand forbundet til jorden (nedtrækningsmodstand). Den ene side af knappen er forbundet til 5V, den anden til digital pin 5 til læsning.
  • glem ikke at skabe en fælles grund mellem alle komponenter: Arduino-kortet, De 4 lysdioder og trykknappen. Tilføj ikke strømforsyning, hvis du i det mindste ikke har tilsluttet grunden korrekt.
  • Tilslut Arduino og Raspberry Pi via et USB-kabel til den serielle kommunikation (USB-kablet administrerer allerede jordforbindelsen mellem dine 2 kort).

Arduino-kode 

#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() initialiserer vi pin-tilstande for alle 4 lysdioder og trykknappen. Vi sørger også for, at alle led ‘ er er slukket.

så i løkken() gør vi 2 ting: håndtering af trykknappen og styring af de 4 lysdioder. Begge handlinger udføres en efter en, men de håndteres meget hurtigt, så det er ligesom om de skete på samme tid. Det er et tilfælde af multitasking af et Arduino-program.

første handling: håndtering af trykknappen.

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 skal debounce knappen for at undgå uønskede værdier. Når vi finder ud af, at der trykkes på knappen, kan vi sende nogle data til Raspberry Pi via seriel.

her har jeg brugt serien.skriv () funktion: den sender en byte eller en række bytes. Dette er forskelligt fra seriel.print (), som vil gøre output rart at se på den serielle skærm. Da vi taler med en anden maskine og ikke et menneske, er der ikke noget problem med det.

nummeret Vi sender her er 18. Dette er bare et tilfældigt tal, som vi forbinder med staten “knappen er blevet skubbet”, så når Raspberry Pi modtager et nummer, vil det kontrollere, om det er lig med 18. Du kan forestille dig at sende forskellige handlinger eller meddelelser via seriel, ved hjælp af forskellige numre.

Bemærk: normalt kan du også bruge Arduino interrupts at vide, hvornår en knap er blevet skubbet. Hvis du gør det, skal du ikke bruge Seriebiblioteket i afbrydelsen. Hvis du absolut skal bruge interrupts, skal du indstille et flag inde i interrupt (en simpel boolsk variabel) og bruge seriel inde i din loop () – funktion.

og den anden handling: styring af de 4 lysdioder.

 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 kontrollerer vi, om Arduino har modtaget nogle data fra Raspberry Pi over den serielle kommunikation.

hvis ja, læser vi den næste byte med seriel.læse(). Her kan du bemærke et lille trick, der består af at trække med ‘0’, som konverterer tegnet til det tal, det repræsenterer – i dette tilfælde et heltal.

efter det er det ret simpelt. Vi slukker for alle lysdioder, og tænd derefter kun den LED, der er knyttet til nummeret: 1, 2, 3 eller 4. Hvis der sendes en forkert værdi, tændes ingen LED.

Raspberry Pi Python code 

#!/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 tilføjer vi en importlinje: Python random library.

i den uendelige løkke (“mens det er sandt”) læser vi først en byte fra seriel. Timeout er indstillet til 1 sekund. Hvis der ikke modtages noget efter et sekund, returnerer funktionen read () B”.

så vi kontrollerer, om det, vi modtog, simpelthen er tomt (b”), eller om der virkelig var noget. I sidstnævnte tilfælde konverterer vi de data, vi modtog, til et heltal, så vi kan bruge i koden. Til det bruger vi funktionen int.from_bytes(), som vil afkode b ‘ 0h12 ‘(den seksadecimale repræsentation af 18 er 0h12) til 18.

som du kan se, kontrollerer vi, at tallet er 18 for at fortsætte handlingen. Hvis du har forskellige kommandoer at håndtere, er det en god praksis at bruge et andet nummer til hver kommando.

vi vælger et tilfældigt tal mellem 1 og 4 for at bestemme, hvilket førte til tænding. Så sender vi det med funktionen pySerial skriv (). For at sende en int via seriel konverterer vi den først som en streng med str () og koder den derefter med encode(‘utf-8’).

test af applikationen

nu kan du tilslutte Arduino til Raspberry Pi ved hjælp af USB-kablet. Raspberry Pi vil derefter levere strøm til både Arduino og 4 lysdioder.

hvis du har mange ting tilsluttet din Arduino, kan du tilføje en ekstern strømforsyning på Arduino strømforsyningsstik. For eksempel, hvis du vil bruge en trinmotor, vil Raspberry Pi aldrig have nok strøm til sig selv + Arduino + motoren. I dette tilfælde med 4 lysdioder, der er OK.

Kør dit Python script og tryk på trykknappen. Du vil se en log, og en af LED ‘ en på Arduino vil blive tændt.

$ 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.

hver gang du trykker på knappen:

  • Arduino registrerer det og sender 18 til Raspberry Pi.
  • Raspberry Pi vil modtage nogle data fra Serial. Det vil kontrollere, om antallet er lig med 18. Hvis ja, vælges et tilfældigt tal (mellem 1-4). Raspberry Pi sender dette nummer til Arduino.
  • Arduino vil modtage dette nummer og strøm på den tilhørende LED.

Bemærk: For at gøre denne applikation hurtigere og med mindre kode kan du også vælge at bruge Firmata-protokollen, med for eksempel pyFirmata-biblioteket på Raspberry og Standardffirmata-biblioteket på Arduino. Tjek disse tutorials for at lære mere.

konklusion

i denne tutorial har du lært, hvordan du kommunikerer mellem din Raspberry Pi og Arduino bord via seriel.

nu, i det virkelige liv, vil dette være nyttigt for dig? Svaret er ja, og ret ofte.

Raspberry Pi er fantastisk til at have en masse beregningskraft indlejret i din applikation. Du kan køre komplette programmer på mange sprog, internetservere, robotapplikationer osv. Raspberry Pi har bestemt nogle GPIOs, som du kan bruge, men de er ikke så gode som Arduino-dem. Du har også flere chancer for at brænde din Pi, hvis du gør noget forkert med udstyr.

Arduino er mere passende til direkte at håndtere udstyrssensorer og aktuatorer: IMU, servomotorer, stepmotorer, alt hvad der kræver mere strøm osv. – mere info om, hvornår du skal bruge Arduino vs Raspberry Pi.

alt i alt kan de 2 tavler arbejde perfekt sammen: Raspberry Pi som applikationens “hjerne” og Arduino som “muskler” med en seriel kommunikation for at få dem til at tale med hinanden.