Raspberry Pi Arduino Serial Communication – tot ce trebuie să știți

BY admin
|

în acest tutorial vă voi arăta cum să comunicați între un Raspberry Pi și o placă Arduino prin comunicare serială.

în primul rând, voi explica rapid ce este comunicarea serială. Apoi, veți vedea cum să vă configurați hardware-ul și software-ul și ne vom scufunda în codul Python (Cpp pentru Arduino). Un exemplu de bază la început, care duce la o aplicație mai completă folosind un Raspberry Pi, un Arduino și alte dispozitive electronice.

acest tutorial va funcționa cu o placă Raspberry Pi 4 (și mai devreme: 3B, 3b+) și orice placă Arduino. Voi folosi cea mai mare parte Arduino Uno, dar va oferi mai multe detalii despre diferențele dintre plăcile Arduino atunci când vine vorba de comunicarea serială.

când lucrați cu dispozitive electronice, comunicarea este esențială. Fiecare dispozitiv – pe lângă faptul că face bine ceea ce ar trebui să facă – trebuie să poată comunica clar cu alte dispozitive. Acesta este unul dintre cele mai importante lucruri la care trebuie să lucrați pentru a trece de la o aplicație foarte de bază la altele mai complexe.

cuprins

ce este comunicarea serială (cu UART)

comunicarea serială este pur și simplu o modalitate de a transfera date. Datele vor fi trimise secvențial, câte un bit la un moment dat (1 octet = 8 biți), contrar comunicării paralele, unde mulți biți sunt trimiși în același timp.

protocolul UART

mai precis, atunci când utilizați Serial cu Arduino și Raspberry Pi, utilizați protocolul UART. UART înseamnă „recepție și transmisie asincronă universală”.

înveți cum să folosești Raspberry Pi pentru a-ți construi propriile proiecte?

verificați Raspberry Pi pentru începători și învățați pas cu pas.

practic este un protocol multi-master asincron bazat pe comunicarea serială, care vă va permite să comunicați între cele 2 plăci. Fii liniștit, există biblioteci care se vor ocupa de toate straturile joase pentru tine.

multi-master înseamnă că toate dispozitivele conectate vor fi libere să trimită date atunci când doresc. Aceasta este una dintre principalele diferențe cu protocoalele master-slave, unde numai dispozitivul master poate iniția o comunicare. De obicei, veți utiliza alte protocoale, cum ar fi I2C și SPI, atunci când aveți nevoie de configurații master-slave: de exemplu, atunci când aveți o placă Arduino și mai mulți senzori sau actuatori.

placa Arduino Uno are un UART pe care îl puteți utiliza fie cu un cablu USB, fie de la pinii RX/TX (nu îl utilizați cu ambele în același timp). Unele placi au mai multe UARTs disponibile. De exemplu, Arduino Mega are seriale diferite (Serial, Serial1, Serial2, Serial3) și Arduino Zero are doar un port USB nativ (utilizați SerialUSB în loc de Serial).

pe Raspberry Pi, puteți conecta multe dispozitive seriale pe porturile USB. Fiecare va avea un nume de dispozitiv diferit (vom vedea cum să le găsim mai târziu în acest tutorial). De asemenea, puteți utiliza GPIOs (RX0/TX0) pentru un UART suplimentar.

probabil știți deja comunicarea serială

Cu siguranță ați folosit deja comunicarea serială de multe ori. Sunt sigur că știți deja Biblioteca Serial Arduino, care vă permite să vă conectați ceea ce se întâmplă în codul dvs. și de a lua de intrare de utilizator. Când utilizați monitorul Serial, Ei bine, practic Arduino IDE inițiază o comunicare serială cu Arduino. Puteți primi și trimite date direct de pe monitorul Serial.

ceea ce vom face aici este aproape la fel, cu excepția faptului că în loc de IDE Arduino, cealaltă parte a comunicării Seriale va fi o placă Raspberry Pi. Va trebui să facem niște setări și să scriem un cod ca să funcționeze. Apoi, atât Raspberry Pi, cât și Arduino își vor putea trimite mesaje reciproc.

să vedem acum cum să conectăm fizic cele 2 plăci împreună.

configurare Hardware pentru comunicare serială

există 2 moduri de a conecta Raspberry Pi și Arduino pentru comunicare serială.

Serial prin USB

cel mai simplu mod este să utilizați un cablu USB între ambele plăci.

pe partea Raspberry Pi, un conector USB simplu este tot ce aveți nevoie. Puteți alege oricare dintre cele 4 porturi USB disponibile pe placă.

pentru Arduino, veți utiliza portul USB pe care îl utilizați pentru a încărca codul de pe computer (cu Arduino IDE) pe placa dvs. Aici conectorul USB va depinde de versiunea pe care o aveți. Pentru plăci precum Arduino Uno și Mega, conectorul va fi diferit de Arduino Nano și de Arduino Zero.

pentru acest exemplu am folosit o placă Arduino Uno.

după cum puteți vedea, este cea mai simplă conexiune hardware pe care o puteți face între Raspberry Pi și Arduino.

notă: mai întâi va trebui să vă conectați Arduino la computer, astfel încât să puteți încărca codul în placă. După aceea, conectați cablul USB la Raspberry Pi. Raspberry Pi va alimenta Arduino prin acest cablu.

Serial prin GPIOs

pentru a realiza o conexiune serială, puteți utiliza, de asemenea, fire simple între Raspberry Pi GPIOs și pinii Arduino.

în funcție de placa Arduino, este posibil să fie nevoie să utilizați un schimbător de nivel de tensiune. Raspberry Pi funcționează la 3.3 V. pentru plăcile Arduino precum Due, 101, va fi bine, deoarece folosesc și 3.3 V.

dar, pentru mulți Arduino, cum ar fi Uno, Mega, Leonardo, Nano și multe altele, placa funcționează la 5V. astfel, aveți nevoie de un schimbător de nivel de 3,3 V/5V pentru a proteja Raspberry Pi atunci când conectați RX și TX (mai multe informații despre pinii Raspberry Pi și pinii Arduino Uno).

pentru restul acestui tutorial vom folosi configurarea cu cablul USB. Acest lucru va fi mai ușor de gestionat și, dacă nu aveți un motiv bun, nu prea, ar trebui să preferați să utilizați cablul USB în loc de gpios simplu pentru comunicarea serială.

Raspberry Pi software setup

nu aveți nevoie de nici o configurare specială pentru Arduino. Doar asigurați-vă că ați descărcat și instalat IDE Arduino.

acum, pe Raspberry Pi, sunt necesare câteva lucruri pentru a face comunicarea să funcționeze.

Conectați-vă la Raspberry Pi, fie prin ssh, fie prin pluginul ecran+mouse+tastatură și deschideți un terminal. Dacă nu ați instalat încă un sistem de operare pe Pi, puteți instala Raspbian sau Ubuntu foarte ușor pe un card SD.

detectați placa Arduino

când conectați Arduino cu un cablu USB, ar trebui să vedeți că apare ca /dev/ttyACM0 sau /dev/ttyUSB0 (uneori numărul poate fi diferit, de exemplu /dev/ttyACM1).

pur și simplu rulați ls /dev/tty* și ar trebui să-l vedeți. În acest moment, dacă nu sunteți sigur ce dispozitiv Este placa Arduino, pur și simplu deconectați placa (scoateți cablul USB) și rulați din nou ls /dev/tty*. În acest fel, veți observa cu ușurință numele dispozitivului serial al Arduino.

permisiuni Hardware pentru Serial

de asemenea, poate doriți să adăugați utilizatorul la grupul dialout, pentru a evita erori, cum ar fi: serial.serialutil.SerialException: nu s-a putut deschide portul / dev / ttyACM0: Permisiune refuzată: ‘/ dev / ttyACM0’

$ sudo adduser your_username dialout

acest lucru vă va asigura că aveți acces la dispozitive seriale (/dev/ttyACMx, /dev/ttyUSBx, …).

după ce v – ați adăugat la grupul dialout, trebuie să reporniți Pi-ul (sau cel puțin logout/login) pentru a aplica modificarea-aflați mai multe despre permisiunile hardware Raspberry Pi.

instalați Python Serial library pe Raspberry Pi

trebuie să instalați o bibliotecă pentru a putea utiliza interfața serială cu Python.

pentru acest tutorial vom folosi biblioteca pySerial (documentație pentru Python 3). Pentru a-l instala:

python3 -m pip install pyserial

această bibliotecă Python este bine-cunoscut și utilizat într-o mulțime de aplicații.

când instalați, dacă primiți o eroare precum „/usr/bin/python3: niciun modul numit pip”, atunci trebuie să instalați mai întâi pip cu sudo apt install python3-pip.

comunicare serială simplă de la Arduino la Raspberry Pi

să începem cu un program foarte simplu.

cod Arduino

încărcați acest cod de pe computer pe Arduino, utilizând IDE-ul Arduino.

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

mai întâi, inițializăm comunicarea serială și alegem o rată de transfer, aici 9600. 9600 este o rată de transfer frecvent utilizată și, de asemenea, una destul de scăzută. În aplicațiile viitoare puteți utiliza o rată baud de 57600 sau chiar 115200 fără nicio problemă. Pentru acest tutorial vom continua cu 9600.

în fiecare secundă facem Arduino trimite un șir cu Serial.println (). funcția println () va adăuga un caracter newline ‘\n’ la sfârșitul șirului.

puteți deschide monitorul Serial pentru a vedea șirul de pe computer.

Raspberry Pi cod Python 

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

deci, ce face acest cod?

#!/usr/bin/env python3import serial

mai întâi, importăm biblioteca serială pe care am instalat-o anterior.

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

comunicarea serială este inițializată apelând serial.Serial() împreună cu câțiva parametri:

  • numele dispozitivului Serial pentru Arduino: de obicei ‘/dev/ttyACM0’, ‘/dev/ttyUSB0’ sau similar.
  • rata de transfer: acest parametru este foarte important. Trebuie să utilizați aceeași rată de transfer ca cea pe care ați folosit-o pe Arduino, altfel tot ceea ce veți citi și scrie va fi gunoi. Deci, alegem 9600 așa cum am făcut în schița Arduino.
  • timeout: acesta este un timeout pentru operațiile de citire. Aici L-am setat la 1 secundă. Înseamnă că atunci când citim din Serial, programul nu va fi blocat pentru totdeauna dacă datele nu vin. După 1 secundă sau citire, dacă nu sunt primiți toți octeții, funcția va returna octeții deja primiți.

deci, serial.Serial () returnează un obiect pe care îl puteți utiliza pentru toate operațiile seriale. Îl stocăm în variabila ‘ser’.

 ser.flush()

apoi folosim funcția flush (). Acest lucru va spăla orice tampon de intrare și ieșire, astfel încât va evita primirea sau trimiterea de date ciudate/nu utile/nu complete la începutul comunicării.

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

într-o buclă infinită (gândiți-vă la funcția loop() din schița Arduino), verificăm dacă unele date sunt disponibile cu atributul in_waiting (nu puneți paranteze, aceasta nu este o funcție). Dacă da, putem citi datele.

funcția readline() va citi toți octeții până când este detectat un caracter newline.

dacă am imprima doar ceea ce am primit, am vedea b ‘ Hello de la Arduino!\r \ n’. Primiți octeți când citiți din Serial și trebuie să convertiți (decodificați) acei octeți în tipul de date corespunzător. Deci, folosim decode (‘utf-8’) – puteți utiliza și decode (‘ascii’) – pentru a decoda datele primite într-un șir.

în cele din urmă, funcția rstrip() este specifică șirurilor, vă permite să eliminați orice caractere finale (linie nouă, retur de transport). În acest fel putem elimina ‘\r’ și ‘\n’ și a obține un șir propriu-zis.

notă: aici citim o linie completă de fiecare dată. Dacă doriți să citiți o anumită cantitate de octeți – unul sau mai mulți – utilizați funcția read(size=1).

testarea comunicării seriale

acum, deconectați placa Arduino de la computer și conectați-o la placa Raspberry Pi.

codul Arduino este deja în funcțiune, de îndată ce este alimentat.

pe Raspberry Pi, faceți fișierul Python executabil și lansați-l.

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

funcționează! Șirul trimis de Arduino în fiecare secundă este afișat pe Terminalul Raspberry Pi.

comunicare serială bidirecțională între Raspberry Pi și Arduino

să facem lucrurile puțin mai interesante. Ați văzut cum să trimiteți date de la Arduino la Raspberry Pi. În această parte veți vedea cum să vorbiți de la Raspberry Pi la Arduino. Astfel, veți avea ambele părți ale Comunicării și veți putea crea programe care așteaptă intrarea celuilalt.

cod Arduino 

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

aici verificăm dacă Arduino a primit date cu Serial.disponibil (). Acest lucru vă va oferi numărul de octeți deja sosiți și stocați în bufferul de primire.

dacă au sosit unele date, folosim Serial.readStringUntil () cu un caracter newline ‘\n’ pentru a obține următoarea linie. Acest lucru este similar cu funcția readline (). Toți octeții primiți până la’ \N ‘ sunt convertiți automat și adăugați într-un obiect Arduino String.

apoi, vom imprima doar înapoi datele pe care le-am primit, cu o bucată suplimentară de text.

Notă: Dacă doriți să citiți octeți unul câte unul, puteți face acest lucru cu Serial.citește () funcție. Apoi, va trebui să convertiți acest(acele) octet(e) dacă este necesar: int, String etc.

Raspberry Pi cod Python 

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

utilizați funcția pyserial write() pentru a trimite date către Arduino. Aici puteți vedea că am adăugat un ‘ b ‘ înainte de șir pentru a trimite. Aceasta va codifica șirul în octeți, deoarece puteți trimite octeți numai prin Serial. Orice date care nu este un octet sau matrice octet trebuie să fie convertite înainte de a fi trimise. Dacă încercați doar să trimiteți șirul așa, veți primi această eroare „TypeError: șirurile unicode nu sunt acceptate, vă rugăm să codificați la octeți:” Bună ziua de la Raspberry Pi!”

notă: în loc de ser.write(b"Hello from Raspberry Pi!\n") ați fi putut scrie ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) sau ser.write("Hello from Raspberry Pi!\n".encode('ascii')). Acest lucru va face același lucru. Funcția encode () va lua șirul și îl va codifica pentru Serial.

de asemenea, adăugăm un caracter newline ‘\n’ pentru că este de așteptat ca Arduino să-și încheie citirea cu Serial.readStringUntil (‘\n’).

apoi, facem același lucru ca înainte: citim o linie, o decodăm în șir și eliminăm orice caracter final. Nu folosim ser.in_waiting aici, deoarece pentru această aplicație specifică știm că Arduino va trimite înapoi unele date imediat după ce a primit șirul. De asemenea, avem un timeout de 1 secundă pentru a evita blocarea pe această linie.

în cele din urmă, tipărim șirul primit și așteptăm 1 secundă cu timpul.sleep () înainte de a trimite șirul următor peste Serial.

testarea comunicației seriale bidirecționale

pe Raspberry Pi, faceți fișierul Python executabil și lansați-l.

$ 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 a primit șirul și l-a trimis înapoi cu câteva cuvinte. Apoi Raspberry Pi a primit și a tipărit șirul final.

Raspberry Pi Arduino Serial communication: exemplu de aplicație

acum, că știți cum să configurați Arduino și Raspberry Pi pentru comunicare serială și să scrieți programe pentru a vorbi între fiecare placă, să creăm o aplicație mai complexă.

în această aplicație, 4 LED-uri și un buton vor fi conectate la placa Arduino.

Raspberry Pi și Arduino vor fi conectate cu un cablu USB și vor folosi comunicarea serială pentru a vorbi între ele.

iată rezultatul pe care vrem să-l obținem:

  • când este apăsat butonul, Arduino va trimite o notificare către Raspberry Pi (un octet simplu).
  • Raspberry Pi va calcula apoi un număr întreg aleatoriu între 1 și 4 și îl va trimite la Arduino.
  • Arduino va porni LED-ul legat de acest număr și va opri celelalte LED-uri.

acest lucru vă va face să practicați comunicarea și sincronizarea sarcinilor între Arduino și Raspberry Pi.

daca ati ajuns la acest punct al tutorialului (felicitari!) Vă încurajez să încercați să scrieți codul de unul singur înainte de a citi codul pe care l-am furnizat mai jos. De asemenea, nu există doar un singur cod posibil pentru a îndeplini aceste cerințe, astfel încât codul dvs. ar putea fi diferit de al meu, este total OK. Puteți obține ajutor de la Arduino Serial reference și pyserial API reference.

scheme

pentru a face acest circuit:

  • conectați 4 LED-uri la pinii 9-12. Adăugați un rezistor de 220 ohmi pentru fiecare LED între piciorul mai lung și știftul digital. Piciorul mai scurt este conectat la sol.
  • adăugați un buton cu un rezistor de 10kohm conectat la masă (rezistor pull-down). O parte a butonului este conectată la 5V, cealaltă la pinul digital 5 pentru citire.
  • nu uitați să faceți un teren comun între toate componentele: placa Arduino, cele 4 LED-uri și butonul de apăsare. Nu adăugați nicio sursă de alimentare dacă nu ați conectat cel puțin corect motivele.
  • conectați Arduino și Raspberry Pi printr-un cablu USB, pentru comunicarea serială (cablul USB gestionează deja conexiunea la masă între cele 2 plăci).

cod Arduino 

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

în funcția setup() inițializăm modurile pin pentru toate cele 4 LED-uri și butonul de apăsare. De asemenea, ne asigurăm că toate LED-urile sunt oprite.

apoi în buclă() facem 2 lucruri: manipularea butonului și gestionarea celor 4 LED-uri. Ambele acțiuni se fac una câte una, dar sunt gestionate foarte repede, așa că este ca și cum s-ar întâmpla în același timp. Acesta este un caz de multitasking un program Arduino.

prima acțiune: Manevrarea butonului.

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;

trebuie să debunce butonul pentru a evita valorile nedorite. Când aflăm că butonul este apăsat, putem trimite câteva date către Raspberry Pi prin Serial.

aici am folosit serialul.scrie () funcție: trimite un octet sau o serie de octeți. Acest lucru este diferit de Serial.imprimare() care va face frumos de ieșire pentru a vedea pe monitorul Serial. În timp ce vorbim cu o altă mașină și nu cu un om, nici o problemă cu asta.

Numărul pe care îl trimitem aici este 18. Acesta este doar un număr aleatoriu pe care îl vom asocia cu starea „butonul a fost apăsat”, așa că atunci când Raspberry Pi va primi un număr, va verifica dacă este egal cu 18. Vă puteți imagina trimiterea de acțiuni sau mesaje diferite prin Serial, folosind numere diferite.

notă: de obicei, puteți utiliza, de asemenea, Arduino întrerupe să știe când un buton a fost apăsat. Dacă faceți acest lucru, nu utilizați Biblioteca Serial în întrerupere. Dacă trebuie să utilizați absolut întreruperi, setați un steag în interiorul întreruperii (o variabilă booleană simplă) și utilizați Serial în interiorul funcției loop ().

și a doua acțiune: gestionarea celor 4 LED-uri.

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

mai întâi verificăm dacă Arduino a primit unele date de la Raspberry Pi prin comunicarea serială.

dacă da, citim următorul octet cu Serial.citește (). Aici puteți observa un mic truc, constând în scăderea cu ‘0’, care va converti caracterul la numărul pe care îl reprezintă – în acest caz un număr întreg.

după aceea este destul de simplu. Oprim toate LED-urile și apoi pornim doar LED-ul asociat cu numărul: 1, 2, 3 sau 4. În cazul în care este trimisă o valoare greșită, niciun LED nu va fi pornit.

Raspberry Pi cod Python 

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

mai întâi adăugăm o linie de import: Biblioteca aleatoare Python.

în bucla infinită („în timp ce este adevărat”), citim mai întâi un octet din Serial. Timpul de expirare este setat la 1 secundă. Dacă nu se primește nimic după o secundă, funcția read() va returna b”.

deci, verificăm dacă ceea ce am primit este pur și simplu gol (b”) sau dacă a existat cu adevărat ceva. În acest din urmă caz, convertim datele pe care le-am primit într-un număr întreg, astfel încât să le putem folosi în cod. Pentru aceasta folosim funcția int.from_bytes (), care va decoda b’0x12′ (reprezentarea hexazecimală a lui 18 este 0x12) la 18.

după cum puteți vedea, verificăm dacă numărul este 18 pentru a continua acțiunea. Dacă aveți comenzi diferite de gestionat, utilizarea unui număr diferit pentru fiecare comandă este o bună practică.

alegem un număr aleatoriu între 1 și 4 pentru a determina care a dus la pornire. Apoi îl trimitem cu funcția pyserial write (). Pentru a trimite un int prin Serial, îl convertim mai întâi ca un șir cu str(), apoi îl codificăm cu encode(‘utf-8’).

testarea aplicației

acum Puteți conecta Arduino la Raspberry Pi folosind cablul USB. Raspberry Pi va furniza apoi puterea atât pentru Arduino, cât și pentru cele 4 LED-uri.

dacă aveți multe lucruri conectate la Arduino, poate doriți să adăugați o sursă de alimentare externă pe conectorul sursei de alimentare Arduino. De exemplu, dacă doriți să utilizați un motor pas cu pas, Raspberry Pi nu va avea niciodată suficient curent pentru sine + Arduino + motorul. În acest caz, cu 4 LED-uri este în regulă.

rulați scriptul Python și apăsați butonul de apăsare. Veți vedea un jurnal și unul dintre LED-urile de pe Arduino va fi pornit.

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

de fiecare dată când apăsați butonul:

  • Arduino îl va detecta și va trimite 18 la Raspberry Pi.
  • Raspberry Pi va primi unele date de la Serial. Se va verifica dacă numărul egal cu 18. Dacă da, este ales un număr aleatoriu (între 1-4). Raspberry Pi va trimite acest număr la Arduino.
  • Arduino va primi acest număr și putere pe LED-ul asociat.

Notă: Pentru a face această aplicație mai rapid și cu mai puțin cod, puteți alege, de asemenea, să utilizați protocolul Firmata, cu, de exemplu, biblioteca pyFirmata pe zmeură și Biblioteca Standardffirmata pe Arduino. Consultați aceste tutoriale pentru a afla mai multe.

concluzie

în acest tutorial ați învățat cum să comunicați între placa Raspberry Pi și Arduino prin Serial.

acum, în viața reală, vă va fi util acest lucru? Răspunsul este da, și destul de des.

Raspberry Pi este excelent pentru a avea multă putere de calcul încorporată în aplicația dvs. Puteți rula software-uri complete în mai multe limbi, servere web, aplicații de robotică etc. Raspberry Pi are cu siguranță câteva GPIOs pe care le puteți folosi, dar nu sunt la fel de bune ca cele Arduino. De asemenea, aveți mai multe șanse să vă ardeți Pi dacă faceți ceva în neregulă cu hardware-ul.

Arduino este mai potrivit pentru a manipula direct senzorii hardware și actuatoarele: IMU, Servomotoare, Motoare pas cu pas, ORICE necesită mai multă putere etc. – mai multe informații despre când să utilizați Arduino vs Raspberry Pi.

în ansamblu, cele 2 plăci pot funcționa perfect împreună: Raspberry Pi ca „creier” al aplicației și Arduino ca „mușchi”, cu o comunicare serială pentru a-i face să vorbească între ei.