Raspberry Pi Arduino soros kommunikáció-minden, amit tudnod kell

ebben az oktatóanyagban megmutatom, hogyan kell kommunikálni a Raspberry Pi és az Arduino fórumon keresztül soros kommunikáció.

először is gyorsan elmagyarázom, mi a soros kommunikáció. Ezután megtudhatja, hogyan állíthatja be a hardvert és a szoftvert, és belemerülünk a Python kódba (Cpp az Arduino számára). Először egy alapvető példa, amely egy teljesebb alkalmazáshoz vezet Raspberry Pi, Arduino és más elektronikus eszközök használatával.

ez az oktatóanyag Raspberry Pi 4 (és korábbi: 3b, 3b+) táblával és bármilyen Arduino táblával fog működni. Leginkább az Arduino Uno-t fogom használni, de további részleteket fogok adni az Arduino táblák közötti különbségekről, amikor a Soros kommunikációról van szó.

amikor elektronikus eszközökkel dolgozik, a kommunikáció kulcsfontosságú. Minden eszköznek – amellett, hogy jól csinálja, amit tennie kell-képesnek kell lennie arra, hogy egyértelműen kommunikáljon más eszközökkel. Ez az egyik legfontosabb dolog, amin dolgozni kell annak érdekében, hogy egy nagyon alapvető alkalmazásról bonyolultabb alkalmazásokra váltsunk.

mi a soros kommunikáció (UART-val)

A soros kommunikáció egyszerűen az adatátvitel egyik módja. Az adatokat egymás után, egy bitenként (1 byte = 8 Bit) küldjük el, ellentétben a párhuzamos kommunikációval, ahol sok bitet küldünk egyszerre.

UART protokoll

pontosabban, ha Serial-t használ az Arduino és a Raspberry Pi használatával, akkor az UART protokollt használja. Az UART jelentése “univerzális aszinkron vétel és átvitel”.

megtanulod, hogyan kell használni a Raspberry Pi-t saját projektek készítéséhez?

nézd meg a Raspberry Pi-t kezdőknek és tanulj lépésről lépésre.

alapvetően ez egy aszinkron multi-master protokoll, amely a Soros kommunikáción alapul, amely lehetővé teszi a 2 tábla közötti kommunikációt. Nyugodjon meg, vannak olyan könyvtárak, amelyek az összes alacsony réteget kezelik az Ön számára.

A Multi-master azt jelenti, hogy minden csatlakoztatott eszköz szabadon küldhet adatokat, amikor csak akar. Ez az egyik fő különbség a master-slave protokollokkal szemben, ahol csak a master eszköz kezdeményezhet kommunikációt. Általában más protokollokat, például az I2C-t és az SPI-t használ, amikor master-slave konfigurációkra van szüksége: például ha van egy Arduino tábla és több érzékelő vagy működtető.

az Arduino Uno kártyán van egy UART, amelyet USB-kábellel vagy az RX/TX csapokból használhat (ne használja egyszerre mindkettővel). Néhány táblán több Elérhető UART van. Például az Arduino Mega különböző sorozatokkal rendelkezik (Serial, Serial1, Serial2, Serial3), az Arduino Zero pedig csak natív USB porttal rendelkezik (serial helyett SerialUSB-t használjon).

A Raspberry Pi-n számos soros eszközt csatlakoztathat az USB-portokhoz. Mindegyiknek más lesz az eszköz neve (később ebben az oktatóanyagban meglátjuk, hogyan találjuk meg őket). Ön is használja a GPIOs (RX0/TX0) egy további UART.

valószínűleg már ismeri a soros kommunikációt

bizonyára már sokszor használta a soros kommunikációt. Biztos vagyok benne, hogy már ismeri az Arduino Soros könyvtárat, amely lehetővé teszi, hogy naplózhassa, mi történik a kódjában, és felhasználói bemenetet kapjon. Amikor a Soros monitort használja, nos, alapvetően az Arduino IDE soros kommunikációt kezdeményez az Arduino – val. Az adatokat közvetlenül a Soros monitorról fogadhatja és küldheti.

amit itt csinálunk, majdnem ugyanaz, azzal a különbséggel, hogy az Arduino IDE helyett a soros kommunikáció másik oldala Raspberry Pi tábla lesz. Be kell állítanunk és írnunk kell egy kódot, hogy működjön. Ezután mind a Raspberry Pi, mind az Arduino képes lesz üzeneteket küldeni egymásnak.

nézzük meg, hogyan lehet fizikailag összekapcsolni a 2 táblát.

Hardverbeállítás soros kommunikációhoz

A Raspberry Pi és az Arduino soros kommunikációhoz 2 módon csatlakoztatható.

soros USB-n keresztül

a legegyszerűbb módszer USB-kábel használata mindkét kártya között.

A Raspberry Pi oldalán csak egy egyszerű USB-csatlakozóra van szüksége. A táblán Elérhető 4 USB port közül választhat.

az Arduino esetében az USB portot fogja használni, amellyel kódot tölt fel a számítógépéről (az Arduino IDE-vel) a táblára. Itt az USB-csatlakozó attól függ, hogy melyik verziója van. Az olyan táblák esetében, mint az Arduino Uno és a Mega, a csatlakozó eltér az Arduino Nano-tól és az Arduino Zero-tól.

ebben a példában egy Arduino Uno táblát használtam.

mint látható, ez a legegyszerűbb hardver kapcsolat, amelyet a Raspberry Pi és az Arduino között lehet létrehozni.

Megjegyzés: először csatlakoztatnia kell az Arduino-t a számítógépéhez, így feltöltheti a kódot a táblára. Ezután csatlakoztassa az USB kábelt a Raspberry Pi-hez. A Raspberry Pi ezen a kábelen keresztül táplálja az Arduino-t.

Soros Via GPIOs

soros kapcsolat létrehozásához sima vezetékeket is használhat a Raspberry Pi GPIO és az Arduino csapok között.

az Arduino táblától függően előfordulhat, hogy feszültségszint-váltót kell használnia. A Raspberry Pi 3, 3 V-on működik. az Arduino táblákhoz, mint például a Due, 101, rendben lesz, mert 3, 3 V-ot is használnak.

de sok Arduino, mint például az Uno, Mega, Leonardo, Nano, és még sok más, a tábla működik 5V. így szükség van egy 3.3 V/5V szintváltó, hogy megvédje a Raspberry Pi csatlakoztatásakor RX és TX (További információ a Raspberry Pi Csapok és Arduino Uno csapok).

az oktatóanyag további részében a telepítést az USB kábellel fogjuk használni. Ezt könnyebb kezelni, és ha nincs jó oka, akkor inkább az USB-kábelt használja a sima GPIO helyett a soros kommunikációhoz.

Raspberry Pi szoftver beállítása

nem kell semmilyen speciális beállítás Arduino. Csak győződjön meg róla, hogy letöltötte és telepítette az Arduino IDE-t.

most, a Raspberry Pi-n, néhány dologra van szükség a kommunikáció működéséhez.

csatlakozzon a Raspberry Pi-hez ssh-n keresztül, vagy plugin segítségével egy képernyő+egér+billentyűzet, és nyisson meg egy terminált. Ha még nem telepített operációs rendszert a Pi-re, akkor a Raspbian vagy az Ubuntu nagyon egyszerűen telepíthető SD-kártyára.

az Arduino kártya észlelése

amikor az Arduino-t USB-kábellel csatlakoztatja, látnia kell, hogy /dev/ttyACM0 vagy /dev/ttyUSB0 néven jelenik meg (néha a szám eltérő lehet, például /dev/ttyACM1).

egyszerűen futtassa a ls /dev/tty* parancsot, és látnia kell. Ezen a ponton, ha nem biztos abban, hogy melyik eszköz az Arduino kártya, egyszerűen húzza ki a kártyát (távolítsa el az USB kábelt), és futtassa újra a ls /dev/tty* parancsot. Így könnyen észreveheti az Arduino soros eszköz nevét.

hardver engedélyek Soros

is érdemes felvenni a felhasználót a dialout csoport, hogy elkerüljék a hibákat, mint például: Soros.serialutil.SerialException: nem sikerült megnyitni a /dev/ttyACM0 portot: engedély megtagadva: ‘/dev / ttyACM0’

$ sudo adduser your_username dialout

ez biztosítja, hogy hozzáférjen a Soros eszközökhöz (/dev/ttyACMx, /dev/ttyUSBx, …).

miután felvette magát a dialout csoportba, újra kell indítania a Pi – t (vagy legalább a kijelentkezést/bejelentkezést) a módosítás alkalmazásához-tudjon meg többet a Raspberry Pi hardverengedélyeiről.

telepítse a Python Soros könyvtárat a Raspberry Pi-re

telepítenie kell egy könyvtárat, hogy képes legyen használni a Soros felületet a Pythonnal.

ehhez az oktatóanyaghoz a pySerial könyvtárat (a Python 3 dokumentációját) fogjuk használni. Telepíteni:

python3 -m pip install pyserial

ez a Python könyvtár jól ismert és sok alkalmazásban használatos.

telepítéskor, ha olyan hibát kap, mint a “/usr/bin/python3: nincs pip nevű modul”, akkor először a pip-et kell telepítenie sudo apt install python3-pip.

egyszerű soros kommunikáció az Arduino-tól a Raspberry Pi-ig

kezdjük egy nagyon egyszerű programmal.

Arduino kód

töltse fel ezt a kódot a számítógépről az Arduino-ra az Arduino IDE használatával.

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

először inicializáljuk a soros kommunikációt, és itt választunk egy adatátviteli sebességet, 9600. A 9600 egy általánosan használt átviteli sebesség, és egy nagyon alacsony. A jövőbeni alkalmazásokban probléma nélkül használhatja az 57600 vagy akár 115200 adatátviteli sebességet. Ehhez az oktatóanyaghoz folytatjuk a 9600-at.

minden másodpercben arra késztetjük az Arduino-t, hogy Soros karakterláncot küldjön.println (). a println () függvény egy ‘\n’ újsor karaktert ad a karakterlánc végéhez.

megnyithatja a Soros monitort, hogy megnézze a karakterláncot a számítógépen.

Raspberry Pi Python kód

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

Szóval, mit csinál ez a kód?

#!/usr/bin/env python3import serial

először importáljuk a korábban telepített soros könyvtárat.

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

A soros kommunikáció soros hívással inicializálódik.Soros () néhány paraméterrel együtt:

• az Arduino soros eszköz neve: általában ‘/ dev/ttyACM0’, ‘/dev / ttyUSB0’ vagy hasonló.
• átviteli sebesség: ez a paraméter nagyon fontos. Ugyanazt az adatátviteli sebességet kell használnia, mint amit az Arduino-n használt, különben minden, amit olvasni és írni fog, szemét lesz. Tehát a 9600-at választjuk, mint az Arduino vázlatban.
• időtúllépés: ez az olvasási műveletek időtúllépése. Itt állítottuk be 1 másodpercre. Ez azt jelenti, hogy amikor sorozatból olvasunk, a program nem fog örökre elakadni, ha az adatok nem jönnek. 1 másodperc vagy olvasás után, ha nem minden bájt érkezik, a funkció visszaadja a már fogadott bájtokat.

tehát soros.A Serial() egy olyan objektumot ad vissza, amelyet az összes Soros művelethez használhat. A ‘ser’ változóban tároljuk.

 ser.flush()

ezután a flush() függvényt használjuk. Ez minden bemeneti és kimeneti puffert átöblít, így elkerüli a furcsa/nem hasznos/nem teljes adatok fogadását vagy küldését a kommunikáció elején.

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

végtelen hurokban (gondoljunk az Arduino vázlat hurok() függvényére) ellenőrizzük, hogy vannak-e adatok az in_waiting attribútummal (ne tegyünk zárójelet, ez nem függvény). Ha igen, el tudjuk olvasni az adatokat.

a readline() függvény az összes bájtot beolvassa, amíg új sor karaktert nem észlel.

ha csak nyomtatott, amit kaptunk látnánk b ‘ Helloban Arduino!\ r \ n’. A Soros olvasáskor bájtokat kap, és ezeket a bájtokat a megfelelő adattípusba kell konvertálni (dekódolni). Tehát a dekódolást(‘utf-8’) használjuk – a dekódolást(‘ascii’) is használhatjuk – a kapott adatok karakterláncba történő dekódolásához.

végül az rstrip () függvény a karakterláncokra jellemző, lehetővé teszi a hátsó karakterek eltávolítását (újsor, kocsi visszatérés). Így eltávolíthatjuk a ‘\ r ‘- t és’ \n ‘ – t, és megkaphatjuk a megfelelő karakterláncot.

megjegyzés: itt minden alkalommal egy teljes sort olvasunk. Ha bizonyos mennyiségű bájtot szeretne olvasni – egy vagy több – használja az olvasás(Méret=1) funkciót.

soros kommunikáció tesztelése

most húzza ki az Arduino kártyát a számítógépről, és csatlakoztassa a Raspberry Pi kártyához.

az Arduino kód már fut, amint be van kapcsolva.

A Raspberry Pi, hogy a Python fájl futtatható, és indítsa el.

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

működik! Az Arduino által Másodpercenként küldött karakterlánc megjelenik a Raspberry Pi terminálon.

kétirányú soros kommunikáció a Raspberry Pi és az Arduino között

tegyük egy kicsit érdekesebbé a dolgokat. Látta, hogyan lehet adatokat küldeni az Arduino-tól a Raspberry Pi-hez. Ebben a részben megtudhatja, hogyan kell beszélni a Raspberry Pi-től az Arduino-ig. Így lesz mindkét oldalán a kommunikáció, és akkor képes lesz arra, hogy hozzon létre programokat, amelyek várják egymás bemenet.

Arduino kód

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

itt ellenőrizzük, hogy az Arduino soros adatokat kapott-e.elérhető (). Ez megadja a már beérkezett és a vételi pufferben tárolt bájtok számát.

ha néhány adat megérkezett, akkor Soros.readStringUntil () egy új sor karakter ‘\n’, hogy a következő sorban. Ez hasonló a readline () függvényhez. A ‘\n’ – ig fogadott összes bájt automatikusan átalakul és hozzáadódik egy Arduino karakterlánc objektumhoz.

ezután csak kinyomtatjuk a kapott adatokat egy további szöveggel.

Megjegyzés: Ha egyesével szeretné olvasni a bájtokat, akkor ezt a sorozattal teheti meg.read () függvény. Ezután szükség esetén konvertálnia kell ezt(azokat) bájt(oka) t: int, String stb.

Raspberry Pi Python kód

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

használja a pyserial függvény write() adatokat küldeni az Arduino. Itt láthatja, hogy hozzáadtam egy ‘b’ – t a küldendő karakterlánc előtt. Ez bájtokra kódolja a karakterláncot, mert csak Soros úton küldhet bájtokat. Minden olyan adatot, amely nem bájt vagy bájt tömb, az elküldés előtt konvertálni kell. Ha csak így próbálja elküldeni a karakterláncot, akkor ezt a hibát kapja: “TypeError: az unicode karakterláncok nem támogatottak, kérjük, kódolja bájtokba:” Hello a Raspberry Pi-től!'”

megjegyzés: a ser.write(b"Hello from Raspberry Pi!\n") helyett írhattál volna ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) vagy ser.write("Hello from Raspberry Pi!\n".encode('ascii')). Ez ugyanezt fogja tenni. A kódolás() függvény fogja a karakterláncot, és Sorosnak kódolja.

ezenkívül hozzáadunk egy új sor karaktert ‘\n ‘ mert ez az, amit az Arduino várhatóan befejezi az olvasást Soros.readStringUntil(‘\n’).

ezután ugyanazt tesszük, mint korábban: elolvasunk egy sort, dekódoljuk karakterláncnak, és eltávolítunk minden záró karaktert. Nem használjuk a ser-t.in_waiting itt, mert erre a konkrét alkalmazásra tudjuk, hogy az Arduino néhány adatot küld vissza, miután megkapta a karakterláncot. Szintén, van egy 1 második időtúllépés, hogy elkerüljük, hogy beragadjunk ezen a vonalon.

végül kinyomtatjuk a kapott karakterláncot, és 1 másodpercet várunk az idővel.sleep() a következő karakterlánc soros küldése előtt.

tesztelése kétirányú soros kommunikáció

A Raspberry Pi, hogy a Python fájl futtatható, és indítsa el.

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

siker! Az Arduino megkapta a madzagot,és még néhány szóval visszaküldte. Ezután a Raspberry Pi megkapta és kinyomtatta a végső karakterláncot.

Raspberry Pi Arduino soros kommunikáció: Alkalmazási példa

most, hogy tudja, hogyan kell beállítani az Arduino és a Raspberry Pi soros kommunikációt, és írjon programokat az egyes táblák közötti beszélgetéshez, hozzunk létre egy összetettebb alkalmazást.

ebben az alkalmazásban 4 LED és egy nyomógomb csatlakozik az Arduino táblához.

A Raspberry Pi és az Arduino USB kábellel csatlakozik, és soros kommunikációt használ egymással.

itt van az eredmény, amit szeretnénk kapni:

• a nyomógomb megnyomásakor az Arduino értesítést küld a Raspberry Pi-nek (egy egyszerű bájt).
• a Raspberry Pi kiszámít egy véletlenszerű egész számot 1 és 4 között, és elküldi az Arduino-nak.
• az Arduino bekapcsolja az ehhez a számhoz tartozó LED-et, a többi LED-et pedig kikapcsolja.

ez teszi a gyakorlatban a kommunikáció és szinkronizálás feladatok között Arduino és Raspberry Pi.

Ha megérkezett ezen a ponton a bemutató (gratula!) Azt javasoljuk,hogy próbálja meg írni a kódot egyedül, mielőtt elolvassa a kódot, amit alább. Szintén, nem csak egy lehetséges kód felel meg ezeknek a követelményeknek, így a kódod eltérhet az enyémtől, teljesen rendben van. Segítséget kaphat az Arduino Soros referenciától és a pySerial API referenciától.

vázlatrajz

ahhoz, hogy ezt az áramkört:

• csatlakoztasson 4 LED-et a 9-12-es csapokhoz. Adjon hozzá egy 220 ohmos ellenállást minden LED-hez a hosszabb láb és a digitális csap között. A rövidebb láb a talajhoz van csatlakoztatva.
• adjon hozzá egy nyomógombot a földhöz csatlakoztatott 10kOhm ellenállással (lehúzó ellenállás). A gomb egyik oldala 5 V-ra van csatlakoztatva, a másik az 5 digitális tűhöz az olvasáshoz.
• ne felejtsen el közös alapot teremteni az összes alkatrész között: az Arduino tábla, a 4 LED és a nyomógomb. Ne adjon hozzá tápegységet, ha legalább nem csatlakoztatta megfelelően az alapot.
• csatlakoztassa az Arduino-t és a Raspberry Pi-t USB-kábelen keresztül a soros kommunikációhoz (az USB-kábel már kezeli a 2 kártya közötti földi kapcsolatot).

Arduino kód

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

a setup() funkcióban inicializáljuk a pin módokat mind a 4 LED-hez és a nyomógombhoz. Azt is biztosítjuk, hogy az összes LED ki van kapcsolva.

ezután a hurokban () 2 dolgot csinálunk: a nyomógomb kezelése és a 4 LED kezelése. Mindkét műveletet egyenként hajtják végre, de nagyon gyorsan kezelik őket, így olyan, mintha egyszerre történnének. Ez egy Arduino program multitasking esete.

első művelet: a nyomógomb kezelése.

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;

le kell tiltanunk a gombot a nem kívánt értékek elkerülése érdekében. Amikor megtudjuk, hogy megnyomja a gombot, néhány adatot Soros úton küldhetünk a Raspberry Pi-nek.

itt használtam a sorozatot.write () függvény: bájtot vagy bájtsorozatot küld. Ez különbözik a sorozattól.print (), amely lehetővé teszi a kimenet szép látni a Soros monitor. Mivel egy másik géphez beszélünk, nem pedig emberhez, ezzel nincs probléma.

az itt küldött szám 18. Ez csak egy véletlen szám, amelyet a “gomb megnyomása” állapothoz társítunk, tehát amikor a Raspberry Pi számot kap, ellenőrizni fogja, hogy egyenlő-e 18-mal. Elképzelheti, hogy különböző műveleteket vagy üzeneteket küld Soros úton, különböző számok használatával.

Megjegyzés: általában az Arduino megszakításokat is használhatja, hogy megtudja, mikor nyomtak meg egy gombot. Ha így tesz, ne használja a Soros könyvtárat a megszakításban. Ha feltétlenül interrupts-t kell használnod, akkor állíts be egy zászlót a interrupt-ban (egy egyszerű logikai változó), és használd a Soros belül a loop() függvényt.

és a második művelet: a 4 LED kezelése.

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

először ellenőrizzük, hogy az Arduino kapott-e néhány adatot a Raspberry Pi-től a soros kommunikáció során.

ha igen, akkor a következő bájtot sorozatszámmal olvassuk.olvas (). Itt észrevehet egy kis trükköt, amely a ‘0’ – val történő kivonásból áll, amely átalakítja a karaktert az általa képviselt számra-ebben az esetben egész számra.

ezután nagyon egyszerű. Kikapcsoljuk az összes LED-et, majd csak a számhoz társított LED-et kapcsoljuk be: 1, 2, 3 vagy 4. Abban az esetben, ha rossz értéket küld, a LED nem kapcsol be.

Raspberry Pi Python kód

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

először egy import Sort adunk hozzá: a Python véletlenszerű könyvtárat.

a végtelen hurokban (“míg igaz”) először egy bájtot olvasunk a sorozatból. Az időtúllépés 1 másodpercre van beállítva. Ha egy másodperc múlva semmi sem érkezik, a read () függvény visszatér b”.

tehát ellenőrizzük, hogy az, amit kaptunk, egyszerűen üres-e (b”), vagy valóban volt-e valami. Ez utóbbi esetben a kapott adatokat egész számra konvertáljuk, így felhasználhatjuk a kódban. Ehhez használjuk az int funkciót.from_bytes (), amely dekódolja a b’ 0x12 ‘ – t (a 18 hexadecimális ábrázolása 0x12) 18-ra.

mint látható, ellenőrizzük, hogy a szám 18-e a művelet folytatásához. Ha különböző parancsokat kell kezelnie, akkor az egyes parancsokhoz eltérő szám használata jó gyakorlat.

kiválasztunk egy véletlen számot 1 és 4 között, hogy meghatározzuk, melyik vezetett a bekapcsoláshoz. Ezután elküldjük a pySerial write () függvénnyel. Az int Soros küldéséhez először stringként konvertáljuk str(), majd kódoljuk encode(‘utf-8’).

az alkalmazás tesztelése

most csatlakoztathatja az Arduino-t a Raspberry Pi-hez az USB-kábel segítségével. A Raspberry Pi ezután mind az Arduino, mind a 4 LED tápellátását biztosítja.

ha sok dolog van csatlakoztatva az Arduino – hoz, érdemes külső tápegységet hozzáadni az Arduino tápegység csatlakozójához. Például, ha léptetőmotort szeretne használni, akkor a Raspberry Pi-nek soha nem lesz elegendő áram önmagához + az Arduino + a motorhoz. Ebben az esetben 4 LED-del ez rendben van.

futtassa a Python szkriptet, majd nyomja meg a nyomógombot. Látni fog egy naplót, és az Arduino egyik LED-je bekapcsol.

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

minden alkalommal, amikor megnyomja a gombot:

• az Arduino felismeri, és 18-at küld a Raspberry Pi-nek.
• a Raspberry Pi kap néhány adatot a sorozatból. Ez ellenőrzi, hogy a szám egyenlő 18. Ha igen, véletlen számot (1-4 között) választunk. A Raspberry Pi elküldi ezt a számot az Arduino-nak.
• az Arduino megkapja ezt a számot és bekapcsolja a hozzá tartozó LED-et.

Megjegyzés: Az alkalmazás gyorsabb és kevesebb kóddal történő elvégzéséhez a Firmata protokollt is használhatja, például a Pyfirmata könyvtárat a Raspberry-n és a StandarfFirmata könyvtárat az Arduino-n. Nézze meg ezeket az oktatóanyagokat, hogy többet megtudjon.

következtetés

ebben az oktatóanyagban megtanulta, hogyan kell kommunikálni a Raspberry Pi és az Arduino tábla között Soros úton.

most, a való életben, ez hasznos lesz számodra? A válasz igen, és elég gyakran.

A Raspberry Pi kiválóan alkalmas sok számítási teljesítmény beágyazására az alkalmazásba. Teljes szoftvereket futtathat számos nyelven, webszervereket, robotikai alkalmazásokat stb. A Raspberry Pi-nek minden bizonnyal van néhány GPIO-ja, amelyeket használhat, de ezek nem olyan jók, mint az Arduino-k. Ezenkívül több esélye van arra, hogy megégesse a Pi-t, ha valami rosszat csinál a hardverrel.

az Arduino alkalmasabb a hardverérzékelők és működtetők közvetlen kezelésére: IMU, szervomotorok, léptetőmotorok, bármi, ami nagyobb energiát igényel stb. – További információ arról, hogy mikor kell használni az Arduino vs Raspberry Pi-t.

összességében a 2 tábla tökéletesen működhet együtt: a Raspberry Pi az alkalmazás “agya”, az Arduino pedig az “izmok”, Soros kommunikációval, hogy egymással beszéljenek.