seriële mededeling van Raspberry Pi Arduino-alles wat u moet weten

BY admin
|

In deze tutorial zal ik u laten zien hoe u tussen een Raspberry Pi en een Arduino-bord via seriële mededeling communiceert.

eerst zal ik snel uitleggen wat seriële communicatie is. Dan zul je zien hoe je je hardware en software instelt, en we duiken in de Python code (Cpp voor Arduino). Een basisvoorbeeld in eerste instantie, wat leidt tot een meer complete toepassing met behulp van een Raspberry Pi, een Arduino, en andere elektronische apparaten.

deze tutorial zal werken met een Raspberry Pi 4 (en eerder: 3B, 3B+) bord, en elk Arduino bord. Ik zal hoofdzakelijk Arduino Uno gebruiken maar zal meer details over de verschillen tussen arduinoraad geven wanneer het over periodieke mededeling komt.

bij het werken met elektronische apparaten is communicatie de sleutel. Elk apparaat-naast goed doen wat het hoort te doen – moet in staat zijn om duidelijk te communiceren met andere apparaten. Dat is een van de belangrijkste dingen om aan te werken om over te schakelen van een zeer basic applicatie naar meer complexe.

inhoudsopgave:

Wat is seriële communicatie (met UART)

seriële communicatie is gewoon een manier om gegevens over te dragen. De gegevens worden opeenvolgend, bit per keer verzonden (1 byte = 8 bits), in tegenstelling tot parallelle communicatie, waarbij veel bits tegelijkertijd worden verzonden.

UART-protocol

meer specifiek, wanneer u Serial gebruikt met Arduino en Raspberry Pi, gebruikt u het UART-protocol. UART betekent “Universele asynchrone ontvangst en transmissie”.

u leert Raspberry Pi gebruiken om uw eigen projecten te bouwen?

bekijk Raspberry Pi voor Beginners en leer stap voor stap.

in principe is het een asynchrone multi-master protocol gebaseerd op de seriële communicatie, waardoor je kunt communiceren tussen de 2 boards. Wees gerust, er zijn bibliotheken die alle lage lagen voor je afhandelen.

Multi-master betekent dat alle aangesloten apparaten vrij zijn om gegevens te verzenden wanneer ze dat willen. Dit is een van de belangrijkste verschillen met master-slaves protocollen, waar alleen het master apparaat een communicatie kan initiëren. Meestal gebruik je andere protocollen zoals I2C en SPI wanneer je master-slaves configuraties nodig hebt: bijvoorbeeld wanneer je één Arduino board en meerdere sensoren of actuatoren hebt.

het Arduino Uno-bord heeft één UART die u kunt gebruiken met een USB-kabel of met de RX/TX-pinnen (gebruik het niet met beide tegelijk). Sommige boards hebben meer UARTs beschikbaar. De Arduino Mega heeft bijvoorbeeld verschillende Serials (serieel, Serial1, Serial2, Serial3) en de Arduino Zero heeft alleen een native USB-poort (gebruik SerialUSB in plaats van Serial3).

op de Raspberry Pi kunt u veel seriële apparaten aansluiten op de USB-poorten. Elk zal een andere apparaatnaam hebben (we zullen zien hoe je ze later in deze tutorial kunt vinden). U kunt ook de GPIOs (RX0/TX0) gebruiken voor een extra UART.

u kent waarschijnlijk al seriële communicatie

u hebt zeker al vele malen seriële communicatie gebruikt. Ik weet zeker dat u de seriële bibliotheek van Arduino al kent, waarmee u kunt loggen wat er in uw code gebeurt en gebruikersinvoer krijgt. Wanneer u de periodieke monitor gebruikt, goed, in principe initieert uw Arduino IDE een periodieke mededeling met uw Arduino. U kunt gegevens rechtstreeks van de seriële monitor ontvangen en verzenden.

wat we hier doen is bijna hetzelfde, behalve dat in plaats van je Arduino IDE, de andere kant van de seriële communicatie een Raspberry Pi bord zal zijn. We moeten wat setup doen en wat code schrijven om het te laten werken. Dan, zowel Raspberry Pi en Arduino zal zitten kundig voor het verzenden van berichten naar elkaar.

laten we nu eens kijken hoe je de 2 borden fysiek met elkaar verbindt.

Hardware setup voor seriële communicatie

er zijn 2 manieren om uw Raspberry Pi en Arduino te verbinden voor seriële communicatie.

serieel via USB

de makkelijkste manier is om een USB-kabel tussen beide bord te gebruiken.

aan de Raspberry Pi-zijde is een eenvoudige USB-aansluiting voldoende. U kunt kiezen uit een van de 4 USB-poorten beschikbaar op het bord.

Voor Arduino gebruikt u de USB-poort die u gebruikt om code van uw computer (met de Arduino IDE) naar uw bord te uploaden. Hier hangt de USB-connector af van welke versie je hebt. Voor raad zoals Arduino Uno en Mega, zal de schakelaar van Arduino Nano, en van Arduino nul verschillen.

voor dit voorbeeld heb ik een Arduino Uno board gebruikt.

zoals u kunt zien, is het de eenvoudigste hardware verbinding die u kunt maken tussen Raspberry Pi en Arduino.

Noot: u moet eerst uw Arduino aansluiten op uw computer, zodat u de code in het bord kunt uploaden. Daarna, sluit de USB-kabel aan op de Raspberry Pi. De Raspberry Pi zal de Arduino via deze kabel van stroom voorzien.

serieel via GPIOs

om een seriële verbinding te maken kunt u ook gewone draden gebruiken tussen de Raspberry Pi GPIOs en de Arduino pinnen.

afhankelijk van je Arduino board moet je misschien een spanningsniveauverschuiver gebruiken. Raspberry Pi werkt bij 3.3 V. Voor Arduino-raad zoals wegens, 101, zal het fijn zijn omdat zij ook 3.3 V. gebruiken.

maar voor vele Arduino, zoals Uno, Mega, Leonardo, Nano, en nog veel meer, werkt de Raad bij 5V. aldus, hebt u een 3.3 V/5V niveau-shifter nodig om Framboos Pi te beschermen wanneer het verbinden van RX en TX (meer informatie over Raspberry Pi-spelden en Arduino Uno-spelden).

voor de rest van deze handleiding gebruiken we de instellingen met de USB-kabel. Dit zal gemakkelijker te beheren en tenzij je een goede reden niet te, je moet de voorkeur geven aan het gebruik van de USB-kabel in plaats van gewone gpios voor seriële communicatie.

Raspberry Pi Software setup

u hebt geen speciale setup nodig voor Arduino. Zorg ervoor dat u de Arduino IDE hebt gedownload en geïnstalleerd.

op uw Raspberry Pi zijn een paar dingen nodig om de communicatie te laten werken.

maak verbinding met uw Raspberry Pi, hetzij via ssh, hetzij via een plugin een scherm+muis+toetsenbord, en open een terminal. Als u nog geen besturingssysteem op uw Pi hebt geïnstalleerd, kunt u Raspbian of Ubuntu heel gemakkelijk op een SD-kaart installeren.

Detecteer het Arduino bord

wanneer u de Arduino aansluit met een USB-kabel, ziet u het verschijnen als /dev/ttyACM0, of /dev/ttyUSB0 (soms kan het nummer anders zijn, bijvoorbeeld /dev/ttyACM1).

voer gewoon ls /dev/tty* uit en je zou het moeten zien. Als u op dit punt niet zeker weet welk apparaat het Arduino-bord is, koppelt u het bord eenvoudig los (verwijder de USB-kabel) en voert u ls /dev/tty* opnieuw uit. Op deze manier vindt u gemakkelijk de seriële apparaatnaam van uw Arduino.

Hardwaremachtigingen voor Serial

ook kunt u uw Gebruiker toevoegen aan de dialooggroep, om fouten zoals: serial te voorkomen.serialutil.SerialException: kan port / dev/ttyACM0 niet openen: Toegang geweigerd: ‘/ dev/ttyACM0’

$ sudo adduser your_username dialout

dit zorgt ervoor dat je toegang hebt tot seriële apparaten (/dev/ttyACMx, /dev/ttyUSBx, …).

nadat u uzelf aan de dialoutgroep hebt toegevoegd, moet u uw Pi opnieuw opstarten (of in ieder geval uitloggen/inloggen) om de wijziging toe te passen – meer informatie over Raspberry Pi-hardwaremachtigingen.

seriële Python-bibliotheek installeren op Raspberry Pi

u moet een bibliotheek installeren om de seriële interface met Python te kunnen gebruiken.

voor deze tutorial gebruiken we de pyserial library (documentatie voor Python 3). Om het te installeren:

python3 -m pip install pyserial

deze Python bibliotheek is bekend en wordt gebruikt in veel toepassingen.

bij het installeren, als u een fout krijgt zoals “/usr/bin/python3: No module named pip”, dan moet u pip eerst installeren met sudo apt install python3-pip.

eenvoudige seriële communicatie van Arduino naar Raspberry Pi

laten we beginnen met een heel eenvoudig programma.

Arduino code

Upload deze code van uw computer naar uw Arduino met behulp van de Arduino IDE.

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

eerst initialiseren we de seriële communicatie en kiezen we een baudrate, hier 9600. 9600 is een veelgebruikte baudrate, en ook een vrij lage. In uw toekomstige toepassingen kunt u zonder problemen een baudrate van 57600 of zelfs 115200 gebruiken. Voor deze tutorial gaan we verder met 9600.

elke seconde sturen we de Arduino een tekenreeks met serieel.println (). de functie println () voegt een nieuw regelteken ‘\n’ toe aan het einde van de tekenreeks.

u kunt de seriële monitor openen om de tekenreeks op uw computer te zien.

Raspberry Pi Python code 

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

dus, wat doet deze code?

#!/usr/bin/env python3import serial

eerst importeren we de seriële bibliotheek die we eerder hebben geïnstalleerd.

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

de seriële communicatie wordt geïnitialiseerd door serial aan te roepen.Serial () samen met een paar parameters:

  • seriële apparaatnaam voor Arduino: meestal ‘/ dev/ttyACM0’, ‘/dev / ttyUSB0’, of iets dergelijks.
  • baudrate :deze parameter is zeer belangrijk. Je moet dezelfde baudrate gebruiken als degene die je op Arduino hebt gebruikt, anders zal alles wat je leest en schrijft vuilnis zijn. Zo, kiezen wij 9600 zoals wij in de Arduino schets deden.
  • time-out: Dit is een time-out voor leesbewerkingen. Hier zetten we het op 1 seconde. Het betekent dat wanneer we lezen van Serial, het programma zal niet voor altijd vast te zitten als de gegevens niet komt. Na 1 tweede of lezing, als niet alle bytes worden ontvangen, zal de functie de reeds ontvangen bytes teruggeven.

So, serial.Serial () geeft een object terug dat je kunt gebruiken voor al je seriële bewerkingen. We slaan het op in de ‘ser’ variabele.

 ser.flush()

dan gebruiken we de flush() functie. Dit zal elke input en output buffer spoelen, dus het zal voorkomen dat het ontvangen of verzenden van vreemde/niet Nuttige / niet volledige gegevens aan het begin van de communicatie.

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

in een oneindige lus (denk aan de functie loop() in de Arduino-schets), controleren we of er gegevens beschikbaar zijn met het attribuut in_waiting (plaats geen haakjes, dit is geen functie). Zo ja, dan kunnen we de gegevens lezen.

de functie readline () zal alle bytes lezen totdat een newline teken wordt gedetecteerd.

als we gewoon zouden printen wat we kregen, zouden we b ‘ Hello van Arduino zien!\r \ n’. U ontvangt bytes wanneer u van serieel leest, en u moet die bytes omzetten (decoderen) in het aangewezen gegevenstype. We gebruiken dus decode (‘utf-8’) – Je kunt ook decode (‘ascii’) gebruiken – om de ontvangen gegevens te decoderen naar een string.

tenslotte is de functie rstrip () specifiek voor tekenreeksen. Hiermee kunt u alle achterliggende tekens verwijderen (newline, carriage return). Op deze manier kunnen we de ‘\r’ en ‘\n’ verwijderen en een juiste string krijgen.

opmerking: hier lezen we elke keer een volledige regel. Als u een bepaalde hoeveelheid bytes wilt lezen – één of meer – gebruik dan de functie lezen(size=1).

seriële communicatie testen

verwijder nu uw Arduino-bord van uw computer en sluit het aan op uw Raspberry Pi-bord.

de Arduino-code draait al, zodra deze is ingeschakeld.

op de Raspberry Pi, maak het Python-bestand uitvoerbaar en start het.

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

het werkt! De string verzonden door Arduino elke seconde wordt weergegeven op de Raspberry Pi terminal.

bidirectionele seriële communicatie tussen Raspberry Pi en Arduino

laten we het wat interessanter maken. Je hebt gezien hoe om gegevens te verzenden van Arduino naar Raspberry Pi. In dit deel zie je hoe je van Raspberry Pi naar Arduino kunt praten. Zo heb je beide kanten van de communicatie en kun je programma ‘ s maken die op elkaars input wachten.

Arduino code 

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

hier controleren we of de Arduino gegevens heeft ontvangen met seriële.beschikbaar(). Dit geeft je het aantal bytes dat al is aangekomen en opgeslagen in de ontvangbuffer.

als sommige gegevens zijn aangekomen, gebruiken we serieel.readStringUntil () met een newline teken ‘\n’ om de volgende regel te krijgen. Dit is vergelijkbaar met de functie readline (). Alle Ontvangen bytes tot ‘\n ‘ worden automatisch geconverteerd en toegevoegd in een Arduino String object.

vervolgens printen we de ontvangen gegevens terug, met een extra stukje tekst.

Opmerking: Als u bytes één voor één wilt lezen, kunt u dit doen met de serie.read () functie. Dan zul je deze(die) byte(s) moeten converteren indien nodig: int, String, etc.

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)

gebruik de pyserial functie write () om gegevens naar de Arduino te sturen. Hier kun je zien dat ik een ‘b’ heb toegevoegd voor de tekenreeks om te verzenden. Dit zal de string coderen naar bytes, omdat je alleen bytes kunt verzenden via serieel. Alle gegevens die geen byte of byte array zijn, moeten worden geconverteerd voordat ze worden verzonden. Als je gewoon probeert om de string als dat te sturen, krijg je deze fout “TypeError: unicode strings worden niet ondersteund, gelieve te coderen naar bytes:’ Hallo van Raspberry Pi!'”

opmerking: in plaats van ser.write(b"Hello from Raspberry Pi!\n") had u ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) of ser.write("Hello from Raspberry Pi!\n".encode('ascii'))kunnen schrijven. Dit zal hetzelfde doen. De functie encode() neemt de string en codeert deze voor serieel.

ook voegen we een newline teken ‘\n’ toe omdat dat is wat de Arduino verwacht zijn lezing te beëindigen met serieel.readStringUntil (‘\n’).

dan doen we hetzelfde als voorheen: we lezen een regel, decoderen deze naar een tekenreeks en verwijderen elk volgend teken. We gebruiken de ser niet.in_waiting hier, want voor deze specifieke toepassing weten we dat de Arduino enkele gegevens terug zal sturen net nadat het de string heeft ontvangen. Ook, we hebben een 1 seconde time-out om te voorkomen dat vast te zitten op deze lijn.

tenslotte printen we de ontvangen tekenreeks en wachten we 1 seconde met de tijd.sleep () voor het verzenden van de volgende string over Serial.

bidirectionele seriële communicatie testen

op uw Raspberry Pi, maak uw Python-bestand uitvoerbaar en start het.

$ 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! De Arduino ontving de snaar, en stuurde het terug met een paar woorden. Vervolgens de Raspberry Pi ontvangen en afgedrukt de laatste snaar.

Raspberry Pi seriële communicatie Arduino: Toepassingsvoorbeeld

Nu u weet hoe u uw Arduino en Raspberry Pi voor seriële communicatie kunt instellen en programma ‘ s kunt schrijven om tussen elk bord te praten, maken we een complexere toepassing.

in deze applicatie worden 4 LEDs en één drukknop aangesloten op het Arduino bord.

de Raspberry Pi en Arduino worden aangesloten met een USB-kabel en gebruiken seriële communicatie om met elkaar te praten.

Dit is het resultaat dat we willen krijgen:

  • wanneer de drukknop wordt ingedrukt, stuurt de Arduino een melding naar de Raspberry Pi (Een eenvoudige byte).
  • de Raspberry Pi zal dan berekenen een willekeurig geheel getal tussen 1 en 4, en stuur het naar de Arduino.
  • de Arduino schakelt de LED in met betrekking tot dit nummer en schakelt de andere LED ‘ s uit.

hierdoor kunt u oefenen op de communicatie en synchronisatie van taken tussen Arduino en Raspberry Pi.

als u op dit punt van de tutorial bent aangekomen (gefeliciteerd!) Ik moedig u aan om te proberen om de code te schrijven door jezelf voordat u de code die ik hieronder heb verstrekt lezen. Ook, Er is niet alleen een mogelijke code om aan deze eisen te voldoen, dus uw code kan anders zijn dan de mijne, het is helemaal OK. U kunt hulp van de seriële verwijzing van Arduino en de verwijzing van pySerial API krijgen.

schema

om dit circuit te maken:

  • Sluit 4 LED ‘ s aan op pinnen 9-12. Voeg een weerstand van 220 Ohm toe voor elke LED tussen het langere been en de digitale pin. Het kortere been is verbonden met de grond.
  • voeg een drukknop toe met een 10kOhm weerstand aangesloten op de grond (pull-down weerstand). De ene kant van de knoop wordt verbonden met 5V, de andere aan digitale speld 5 voor lezing.
  • vergeet niet om een gemeenschappelijke basis te maken tussen alle componenten: het Arduino bord, de 4 LEDs en de drukknop. Voeg geen stroomtoevoer toe als u het terrein niet op zijn minst correct hebt aangesloten.
  • sluit de Arduino en Raspberry Pi aan via een USB-kabel, voor de seriële communicatie (de USB-kabel beheert al de grondverbinding tussen uw 2 borden).

Arduino code 

#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; } }}

in de functie setup() initialiseren we de pin modi voor alle 4 LEDs en de drukknop. We zorgen er ook voor dat alle LED ‘ s uitgeschakeld zijn.

vervolgens doen we in de loop() 2 dingen: de drukknop bedienen en de 4 LEDs beheren. Beide acties worden één voor één gedaan, maar ze worden heel snel afgehandeld, dus het is net alsof ze tegelijkertijd gebeuren. Dat is een geval van multitasken van een Arduino programma.

eerste actie: bediening van de drukknop.

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;

we moeten de knop ontkoppelen om ongewenste waarden te voorkomen. Wanneer we erachter komen dat de knop wordt ingedrukt, kunnen we wat gegevens verzenden naar de Raspberry Pi via seriële.

hier heb ik de serie gebruikt.write () functie: het stuurt een byte of reeks bytes. Dit is anders dan serieel.print () wat de uitvoer leuk maakt om te zien op de seriële monitor. Als we met een andere machine praten en niet met een mens, is dat geen probleem.

het nummer dat we hier sturen is 18. Dit is gewoon een willekeurig nummer dat we zullen associëren met de staat “knop is ingedrukt”, dus wanneer de Raspberry Pi ontvangt een nummer, het zal controleren of het gelijk is aan 18. U kunt zich voorstellen dat u verschillende acties of berichten via seriële, met behulp van verschillende nummers.

opmerking: meestal kunt u ook Arduino interrupts gebruiken om te weten wanneer een knop is ingedrukt. Als je dat doet, gebruik dan niet de seriële bibliotheek in de interrupt. Als je absoluut interrupts moet gebruiken, zet dan een vlag in de interrupt (een eenvoudige Booleaanse variabele), en gebruik Serial binnen je loop() functie.

en de tweede actie: beheer van de 4 LEDs.

 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; } }

eerst controleren we of de Arduino enkele gegevens van de Raspberry Pi over de seriële communicatie heeft ontvangen.

zo ja, dan lezen we de volgende byte met serieel.lezen(). Hier ziet u een kleine truc, bestaande uit aftrekken met ‘0’, die het karakter zal omzetten naar het nummer dat het vertegenwoordigt – in dit geval een geheel getal.

daarna is het vrij eenvoudig. We zetten alle LED ‘ s uit en zetten dan alleen de LED aan die geassocieerd is met het nummer: 1, 2, 3 of 4. In het geval dat een verkeerde waarde wordt verzonden, geen LED zal worden ingeschakeld.

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'))

eerst voegen we een importregel toe: de Python willekeurige bibliotheek.

in de oneindige lus (“while True”) lezen we eerst één byte uit serieel. De time-out is ingesteld op 1 seconde. Als er na één seconde niets wordt ontvangen, geeft de read() functie b”Terug.

dus we controleren of wat we hebben ontvangen gewoon leeg is (b”) of dat er echt iets was. In dit laatste geval zetten we de gegevens die we hebben ontvangen om naar een geheel getal zodat we deze kunnen gebruiken in de code. Daarvoor gebruiken we de functie int.from_bytes (), die zal decoderen b’ 0x12 ‘ (de hexadecimale representatie van 18 is 0x12) tot 18.

zoals u kunt zien controleren we of het nummer 18 is om de actie voort te zetten. Als je verschillende commando ‘ s hebt, is het een goede gewoonte om voor elk commando een ander nummer te gebruiken.

we kiezen een willekeurig getal tussen 1 en 4 om te bepalen welke leidde tot inschakelen. Dan sturen we het met de pyserial write() functie. Om een Int via Serial te verzenden, converteren we het eerst als een string met str (), en coderen het dan met encode(‘utf-8’).

het testen van de toepassing

nu kunt u de Arduino aansluiten op de Raspberry Pi met behulp van de USB-kabel. De Raspberry Pi zal dan leveren de macht voor zowel de Arduino en de 4 LEDs.

Als u veel dingen op uw Arduino hebt aangesloten, wilt u misschien een externe voeding op de Arduino-voedingsconnector toevoegen. Bijvoorbeeld, als u een stappenmotor wilt gebruiken, zal de Raspberry Pi nooit genoeg stroom voor zichzelf + de Arduino + de motor hebben. In dit geval, met 4 LEDs is dat OK.

Voer uw Python-script uit en druk op de drukknop. U zult een logboek zien en één van de LEIDENE op de Arduino zal worden aangezet.

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

elke keer dat u op de knop drukt:

  • de Arduino detecteert het en stuurt 18 naar de Raspberry Pi.
  • de Raspberry Pi ontvangt enkele gegevens van seriële. Het zal controleren of het nummer gelijk is aan 18. Zo ja, dan wordt een willekeurig getal (tussen 1-4) gekozen. De Raspberry Pi stuurt dit nummer naar de Arduino.
  • de Arduino ontvangt dit nummer en de stroom op de bijbehorende LED.

OPMERKING: Om deze toepassing sneller en met minder code te doen, kunt u er ook voor kiezen om het Firmata-protocol te gebruiken, met bijvoorbeeld de pyFirmata-bibliotheek op Raspberry en de StandarfFirmata-bibliotheek op Arduino. Bekijk deze tutorials voor meer informatie.

conclusie

In deze tutorial heeft u geleerd hoe u kunt communiceren tussen uw Raspberry Pi en Arduino board via seriële.

nu, in het echte leven, zal dit nuttig zijn voor u? Het antwoord is ja, en vrij vaak.

de Raspberry Pi is geweldig voor het hebben van veel rekenkracht ingebed in uw toepassing. U kunt complete software draaien in vele talen, webservers, robotica toepassingen, enz. De Raspberry Pi heeft zeker een aantal GPIO ‘ s die u kunt gebruiken, maar ze zijn niet zo goed als de Arduino degenen. Ook heb je meer kansen om je Pi te branden als je iets verkeerd doet met hardware.

de Arduino is meer geschikt voor het direct verwerken van hardwaresensoren en actuatoren: IMU, servomotoren, stappenmotoren, alles wat meer vermogen vereist, enz. – meer informatie over wanneer te gebruiken Arduino vs Raspberry Pi.

al met al kunnen de 2 boards perfect samenwerken: de Raspberry Pi als het “brein” van de applicatie, en de Arduino als de “spieren”, met een seriële communicatie om ze met elkaar te laten praten.