Raspberry Pi, Arduino Sériové Komunikace – Vše, co Potřebujete Vědět,

BY admin
|

V tomto tutoriálu vám ukážu jak pro komunikaci mezi Raspberry Pi a Arduino desky přes Sériové komunikace.

nejprve rychle vysvětlím, co je sériová komunikace. Pak uvidíte, jak nastavit hardware a software, a my se ponoříme do kódu Pythonu (Cpp pro Arduino). Nejprve základní příklad, což vede k úplnější aplikaci pomocí Raspberry Pi, Arduino, a další elektronická zařízení.

tento tutoriál bude pracovat s deskou Raspberry Pi 4 (a starší: 3B, 3B+) a jakoukoli deskou Arduino. Budu používat většinou Arduino Uno, ale poskytne více podrobností o rozdílech mezi deskami Arduino, pokud jde o sériovou komunikaci.

při práci s elektronickými zařízeními je komunikace klíčová. Každé zařízení – kromě toho, že dělá dobře to, co má dělat-musí být schopno jasně komunikovat s ostatními zařízeními. To je jedna z nejdůležitějších věcí, na které je třeba pracovat, aby se přešlo z velmi základní aplikace na složitější.

Obsah

Co je Sériové komunikace (UART)

Sériové komunikace je jen způsob, jak přenášet data. Data budou odeslána postupně, jeden bit najednou (1 byte = 8 bitů), na rozdíl od paralelní komunikace, kde je odesláno mnoho bitů současně.

protokol UART

konkrétněji, když používáte Serial s Arduino a Raspberry Pi, používáte protokol UART. UART znamená „Univerzální asynchronní příjem a přenos“.

učíte se, jak používat Raspberry Pi k vytváření vlastních projektů?

podívejte se na Raspberry Pi pro začátečníky a učit se krok za krokem.

v Podstatě je to asynchronní multi-master protokol založen na Sériové komunikaci, která vám umožní komunikovat mezi 2 desky. Buďte ujištěni, existují knihovny, které pro vás zpracují všechny nízké vrstvy.

Multi-master znamená, že všechna připojená zařízení budou moci odesílat data, když chtějí. To je jeden z hlavních rozdílů s protokoly master-slaves, kde pouze hlavní zařízení může zahájit komunikaci. Obvykle budete používat jiné protokoly, jako jsou I2C a SPI, když potřebujete konfigurace master-slaves: například když máte jednu desku Arduino a více senzorů nebo akčních členů.

deska Arduino Uno má jeden UART, který můžete použít buď pomocí kabelu USB, nebo z kolíků RX/TX (nepoužívejte jej současně s oběma). Některé desky mají více dostupných UART. Například Arduino Mega má různé Seriály (Seriál, Serial1, Serial2, Serial3) a Arduino Zero má nativní USB port (použití SerialUSB místo Sériové).

na Raspberry Pi můžete připojit mnoho sériových zařízení na porty USB. Každý z nich bude mít jiný název zařízení (uvidíme, jak je najít později v tomto tutoriálu). Můžete také použít GPIO (RX0 / TX0) pro další UART.

pravděpodobně již znáte sériovou komunikaci

určitě jste již mnohokrát použili sériovou komunikaci. Jsem si jistý, že již znáte sériovou knihovnu Arduino, která vám umožní zaznamenat, co se děje ve vašem kódu, a získat Uživatelský vstup. Když používáte Sériový monitor, studna, v podstatě vaše Arduino IDE zahájí sériovou komunikaci s Arduino. Můžete přijímat a odesílat data přímo ze sériového monitoru.

to, co zde uděláme, je téměř stejné, kromě toho, že místo vašeho Arduino IDE bude druhou stranou sériové komunikace deska Raspberry Pi. Budeme muset udělat nějaké nastavení a napsat nějaký kód, aby to fungovalo. Poté si Raspberry Pi I Arduino budou moci navzájem posílat zprávy.

podívejme se nyní, jak fyzicky propojit 2 desky dohromady.

nastavení Hardwaru pro Sériovou komunikaci

Existují 2 způsoby, jak připojit vaše Raspberry Pi a Arduino pro Sériovou komunikaci.

sériové přes USB

nejjednodušší způsob je použít USB kabel mezi oběma deskami.

na straně Raspberry Pi je vše, co potřebujete, jednoduchý konektor USB. Můžete si vybrat některý ze 4 portů USB dostupných na desce.

pro Arduino použijete port USB, který používáte k nahrání kódu z počítače (s Arduino IDE) na vaši desku. Zde bude konektor USB záviset na verzi, kterou máte. U desek jako Arduino Uno a Mega se konektor bude lišit od Arduino Nano a od Arduino Zero.

pro tento příklad jsem použil desku Arduino Uno.

jak vidíte, je to nejjednodušší hardwarové připojení, které můžete vytvořit mezi Raspberry Pi a Arduino.

Poznámka: nejprve budete muset připojit Arduino k počítači, takže můžete nahrát kód do desky. Poté připojte kabel USB k Raspberry Pi. Raspberry Pi bude napájet Arduino pomocí tohoto kabelu.

sériové přes GPIO

Chcete-li vytvořit sériové připojení, můžete také použít obyčejné vodiče mezi GPIO Raspberry Pi a piny Arduino.

v závislosti na desce Arduino budete možná muset použít řadič úrovně napětí. Raspberry Pi pracuje na 3.3 V. pro desky Arduino, jako je Due, 101, bude to v pořádku, protože také používají 3.3 V.

Ale pro mnoho Arduino, jako je Uno, Mega, Leonardo, Nano, a mnoho dalších, deska je v provozu na 5V. Proto, budete potřebovat 3.3 V/5V level-shifter k ochraně Raspberry Pi při připojení RX a TX (více info na piny Raspberry Pi a Arduino Uno kolíky).

pro zbytek tohoto tutoriálu použijeme nastavení pomocí kabelu USB. To bude snazší spravovat a pokud nemáte dobrý důvod ne příliš, měli byste raději používat kabel USB místo prostých GPIO pro sériovou komunikaci.

Raspberry Pi nastavení softwaru

nepotřebujete žádné speciální nastavení pro Arduino. Jen se ujistěte, že jste si stáhli a nainstalovali Arduino IDE.

nyní je na vašem Raspberry Pi zapotřebí několik věcí, aby komunikace fungovala.

Připojte se k Raspberry Pi, buď přes ssh, nebo pomocí pluginu obrazovka + myš+klávesnice a otevřete terminál. Pokud jste na svém Pi ještě nenainstalovali operační systém, můžete Raspbian nebo Ubuntu nainstalovat velmi snadno na SD kartu.

Detekovat desky Arduino

Při připojení Arduino s USB kabelem, měli byste vidět, že se objeví jako /dev/ttyACM0, nebo /dev/ttyUSB0 (někdy číslo může být různé, například /dev/ttyACM1).

jednoduše spusťte ls /dev/tty* a měli byste to vidět. V tomto okamžiku, pokud si nejste jisti, které zařízení je deska Arduino, jednoduše odpojte desku (vyjměte kabel USB) a znovu spusťte ls /dev/tty*. Tímto způsobem snadno zjistíte název sériového zařízení Vašeho Arduina.

hardwarová oprávnění pro Serial

můžete také přidat uživatele do skupiny dialout, abyste se vyhnuli chybám, jako jsou: serial.serialutil.SerialException: nelze otevřít port /dev/ttyACM0: Permission denied: ‚/dev/ttyACM0‘

$ sudo adduser your_username dialout

To bude ujistěte se, že máte přístup k Sériové zařízení (/dev/ttyACMx, /dev/ttyUSBx, …).

Poté, co jste sami přidali do skupiny dialout, budete muset restartovat Pi (nebo alespoň odhlášení/přihlášení) použít změny – dozvědět se více o Raspberry Pi hardware oprávnění.

nainstalujte Python Serial library na Raspberry Pi

abyste mohli používat sériové rozhraní s Pythonem, musíte nainstalovat knihovnu.

pro tento tutoriál použijeme knihovnu pySerial (dokumentace pro Python 3). Chcete-li jej nainstalovat:

python3 -m pip install pyserial

tato knihovna Python je dobře známá a používá se v mnoha aplikacích.

při instalaci, pokud se zobrazí chyba, například „/ usr / bin / python3: žádný modul s názvem pip“, musíte nejprve nainstalovat pip s sudo apt install python3-pip.

jednoduchá sériová komunikace z Arduina do Raspberry Pi

začněme velmi jednoduchým programem.

Arduino kód

Nahrajte tento kód z počítače do Arduina pomocí Arduino IDE.

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

nejprve inicializujeme sériovou komunikaci a zvolíme přenosovou rychlost, zde 9600. 9600 je běžně používaná přenosová rychlost a také docela nízká. Ve svých budoucích aplikacích můžete bez problémů použít přenosovou rychlost 57600 nebo dokonce 115200. V tomto tutoriálu budeme pokračovat s 9600.

každou sekundu donutíme Arduino poslat řetězec se sériovým.println (). funkce println () přidá na konec řetězce znak nového řádku ‚\n‘.

můžete otevřít Sériový monitor a zobrazit řetězec v počítači.

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)

takže, co dělá tento kód?

#!/usr/bin/env python3import serial

nejprve importujeme sériovou knihovnu, kterou jsme dříve nainstalovali.

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

sériová komunikace je inicializována voláním serial.Serial () spolu s několika parametry:

  • Název sériového zařízení pro Arduino: obvykle ‚/dev/ttyACM0‘, ‚/dev/ttyUSB0‘ nebo podobně.
  • přenosová rychlost: tento parametr je velmi důležitý. Musíte použít stejnou přenosovou rychlost jako ta, kterou jste použili na Arduino, jinak vše, co budete číst a psát, bude odpadky. Takže si vybereme 9600, jako jsme to udělali v náčrtu Arduino.
  • timeout: toto je časový limit pro operace čtení. Zde jsme ji nastavili na 1 sekundu. To znamená, že když čteme ze seriálu, program nebude navždy uvíznut, pokud data nepřicházejí. Po 1 sekundě nebo čtení, pokud nejsou přijaty všechny bajty, funkce vrátí již přijaté bajty.

so, serial.Serial () vrací objekt, který můžete použít pro všechny sériové operace. Uložíme jej do proměnné „ser“.

 ser.flush()

pak použijeme funkci flush (). To bude flush žádné vstupní a výstupní buffer, tak to bude vyhnout se přijímání nebo odesílání divný/není vhodné/není kompletní údaje na začátku komunikace.

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

V nekonečné smyčce (myslím smyčky() funkce v Arduino sketch), zkontrolujeme, jestli některá data je k dispozici s in_waiting atribut (nedávejte závorka, to není funkce). Pokud ano, můžeme číst data.

funkce readline () bude číst všechny bajty, dokud nebude detekován znak nového řádku.

kdybychom právě vytiskli to, co jsme obdrželi, viděli bychom b ‚ Hello z Arduina!n‘. Při čtení ze serialu obdržíte bajty a musíte tyto bajty převést (dekódovat) do příslušného datového typu. Takže používáme decode (‚utf-8‘) – můžete také použít decode (‚ascii‘) – dekódovat přijatá data do řetězce.

nakonec je funkce rstrip() specifická pro řetězce, umožňuje odstranit všechny koncové znaky(nový řádek, návrat vozíku). Tímto způsobem můžeme odstranit ‚\r ‚ a ‚\n ‚ a získat správný řetězec.

poznámka: zde pokaždé čteme kompletní řádek. Pokud chcete číst určité množství bajtů – jeden nebo více-použijte funkci čtení (size=1).

testování sériové komunikace

nyní odpojte desku Arduino od počítače a připojte ji k desce Raspberry Pi.

Arduino kód je již spuštěn, jakmile je zapnutý.

na Raspberry Pi proveďte spustitelný soubor Python a spusťte jej.

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

funguje to! Řetězec odeslaný Arduino každou sekundu se zobrazí na terminálu Raspberry Pi.

obousměrná sériová komunikace mezi Raspberry Pi a Arduino

udělejme věci trochu zajímavější. Viděli jste, jak odesílat data z Arduina do Raspberry Pi. V této části uvidíte, jak mluvit z Raspberry Pi na Arduino. Tak budete mít obě strany komunikace a budete moci vytvářet programy, které čekají na navzájem vstup.

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

zde zkontrolujeme, zda Arduino přijalo data se sériovým.dostupný(). Tím získáte počet bajtů, které již byly přijaty a uloženy v vyrovnávací paměti pro příjem.

pokud některá data dorazila, použijeme Serial.readStringUntil () se znakem newline ‚\n ‚ pro získání dalšího řádku. To je podobné funkci readline (). Všechny bajty přijaté do ‚\n ‚ jsou automaticky převedeny a přidány do objektu Arduino String.

poté pouze vytiskneme data, která jsme obdrželi, s dalším textem.

Poznámka: Pokud chcete číst bajty jeden po druhém, můžete tak učinit se sériovým.funkce čtení (). Pak budete muset převést tento(ty) byte (y) v případě potřeby: int, String, atd.

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)

použijte funkci pyserial write () pro odesílání dat do Arduina. Zde můžete vidět, že jsem přidal ‚b‘ před řetězec poslat. Tím se kóduje řetězec na bajty, protože bajty můžete odesílat pouze sériově. Všechna data, která nejsou bajtovým nebo bajtovým polem, musí být před odesláním převedena. Pokud se pokusíte odeslat takový řetězec, dostanete tuto chybu „TypeError: řetězce unicode nejsou podporovány, zakódujte do bajtů:“ Dobrý den od Raspberry Pi!'“

Poznámka: místo ser.write(b"Hello from Raspberry Pi!\n") jste mohli napsat ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) nebo ser.write("Hello from Raspberry Pi!\n".encode('ascii')). Tohle udělá to samé. Funkce encode () vezme řetězec a zakóduje jej pro sériové.

také přidáváme nový znak ‚\n‘, protože se očekává, že Arduino ukončí čtení sériovým.čtení až do (‚\n‘).

pak uděláme to samé jako předtím: přečteme řádek, dekódujeme jej na řetězec a odstraníme jakýkoli koncový znak. Nepoužíváme ser.in_waiting zde, protože pro tuto konkrétní aplikaci víme, že Arduino pošle zpět některá data hned poté, co obdrží řetězec. Taky, máme 1 druhý časový limit, abychom se vyhnuli uvíznutí na tomto řádku.

nakonec vytiskneme přijatý řetězec a počkáme 1 sekundu s časem.sleep() před odesláním dalšího řetězce přes Serial.

testování obousměrné sériové komunikace

na Raspberry Pi, aby váš Python soubor spustitelný a spusťte jej.

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

úspěch! Arduino obdržel řetězec, a poslal ho zpět s několika dalšími slovy. Pak Raspberry Pi obdržel a vytiskl Poslední řetězec.

Raspberry Pi, Arduino Sériové komunikace: příklad Použití

Nyní, když víte, jak nastavit vaše Arduino a Raspberry Pi pro Sériovou komunikaci, a psát programy mluvit mezi každé desce, pojďme vytvořit složitější aplikace.

v této aplikaci budou k desce Arduino připojeny 4 LED diody a jedno tlačítko.

Raspberry Pi a Arduino bude připojen pomocí kabelu USB a použití Sériové komunikace, mluvit k sobě navzájem.

zde je výsledek, který chceme získat:

  • po stisknutí tlačítka odešle Arduino upozornění na Raspberry Pi (jednoduchý bajt).
  • Raspberry Pi pak vypočítá náhodné celé číslo mezi 1 a 4 a odešle jej do Arduina.
  • Arduino zapne LED související s tímto číslem a vypne ostatní LED.

to vám umožní procvičit komunikaci a synchronizaci úkolů mezi Arduino a Raspberry Pi.

pokud jste dorazili na tento bod tutoriálu (Gratulujeme!) Doporučuji vám, abyste se pokusili napsat kód sami, než si přečtete kód, který jsem uvedl níže. Taky, není tam jen jeden možný kód pro splnění těchto požadavků, takže váš kód se může lišit od mého, je to naprosto v pořádku. Můžete získat pomoc ze sériového odkazu Arduino a odkazu PYSERIAL API.

Schémata

Aby tento obvod:

  • Připojení 4 Led kolíky 9-12. Přidejte 220 ohmový odpor pro každou LED mezi delší nohu a digitální kolík. Kratší noha je spojena se zemí.
  • Přidejte tlačítko s 10kOhm rezistorem připojeným k zemi(pull-down rezistor). Jedna strana tlačítka je připojena na 5V, druhá na digitální pin 5 pro čtení.
  • nezapomeňte vytvořit společný základ mezi všemi komponenty: deskou Arduino, 4 LED diodami a tlačítkem. Nepřidávejte žádné napájení, pokud jste alespoň správně nepřipojili důvody.
  • Připojte Arduino a Raspberry Pi pomocí kabelu USB pro sériovou komunikaci (kabel USB již řídí uzemnění mezi 2 deskami).

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

ve funkci setup() inicializujeme režimy pinů pro všechny 4 LED diody a tlačítko. Také se ujistíme, že jsou všechny LED diody vypnuty.

pak ve smyčce() děláme 2 věci: manipulaci s tlačítkem a správu 4 LED. Obě akce se provádějí jeden po druhém, ale jsou zpracovány velmi rychle, takže je to, jako by se děly ve stejnou dobu. To je případ multitaskingu programu Arduino.

první akce: manipulace s tlačítkem.

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;

musíme tlačítko Zrušit, abychom se vyhnuli nežádoucím hodnotám. Když zjistíme, že je tlačítko stisknuto, můžeme poslat Některá data do Raspberry Pi sériově.

Zde jsem použil seriál.funkce write (): odešle bajt nebo řadu bajtů. To se liší od sériového.tisk (), díky kterému bude výstup pěkný na sériovém monitoru. Jak mluvíme s jiným strojem a ne s člověkem, s tím není problém.

číslo, které zde posíláme, je 18. Toto je jen náhodné číslo, které spojíme se stavem „tlačítko bylo stisknuto“, takže když Raspberry Pi obdrží číslo, zkontroluje, zda se rovná 18. Můžete si představit posílání různých akcí nebo zpráv prostřednictvím sériového, pomocí různých čísel.

Poznámka: obvykle můžete také použít Arduino přerušení vědět, kdy bylo stisknuto tlačítko. Pokud tak učiníte, nepoužívejte sériovou knihovnu v přerušení. Pokud absolutně musíte použít přerušení, nastavte příznak uvnitř přerušení (jednoduchá booleovská proměnná) a použijte sériové uvnitř funkce loop ().

a druhá akce: správa 4 LED.

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

nejprve zkontrolujeme, zda Arduino přijalo některá data z Raspberry Pi přes sériovou komunikaci.

pokud ano, čteme další bajt se sériovým.přečíst(). Zde si můžete všimnout malého triku, který se skládá z odečtení „0“, které převede znak na číslo, které představuje-v tomto případě celé číslo.

poté je to docela jednoduché. Vypneme všechny LED diody a poté zapneme pouze LED spojené s číslem: 1, 2, 3 nebo 4. V případě, že je odeslána nesprávná hodnota, nebude zapnuta žádná LED.

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

nejprve přidáme jeden importní řádek: Python random library.

v nekonečné smyčce („while True“) jsme nejprve přečetli jeden bajt ze sériového. Časový limit je nastaven na 1 sekundu. Pokud po jedné sekundě nic nepřijme, funkce čtení() vrátí b“.

takže zkontrolujeme, zda to, co jsme obdrželi, je prostě prázdné (b“) nebo zda tam opravdu něco bylo. V tomto druhém případě převedeme data, která jsme obdrželi, na celé číslo, abychom je mohli použít v kódu. K tomu používáme funkci int.from_bytes (), který dekóduje b‘ 0x12 ‚ (hexadecimální reprezentace 18 je 0x12) na 18.

jak vidíte, zkontrolujeme, zda je číslo 18, abychom mohli pokračovat v akci. Pokud máte k dispozici různé příkazy, je vhodné použít pro každý příkaz jiné číslo.

zvolíme náhodné číslo mezi 1 a 4, abychom určili, která LED vedla k zapnutí. Pak jej pošleme pomocí funkce pyserial write (). Poslat int přes Serial, musíme nejprve převést jako řetězec s str(), a pak zakódovat s encode(‚utf-8‘).

testování aplikace

nyní můžete připojit Arduino k Raspberry Pi pomocí kabelu USB. Raspberry Pi pak dodá energii jak pro Arduino, tak pro 4 LED diody.

pokud máte k Arduinu připojeno mnoho věcí, možná budete chtít přidat externí napájecí zdroj do konektoru napájení Arduino. Například, pokud chcete použít krokový motor, Raspberry Pi nikdy nebude mít dostatek proudu pro sebe + Arduino + motor. V tomto případě se 4 LED diodami je to v pořádku.

spusťte skript Python a stiskněte tlačítko. Uvidíte protokol a jedna z LED diod na Arduinu bude zapnuta.

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

při každém stisknutí tlačítka:

  • Arduino to detekuje a pošle 18 na Raspberry Pi.
  • Raspberry Pi obdrží některá data ze seriálu. Zkontroluje, zda se číslo rovná 18. Pokud ano, je zvoleno náhodné číslo (mezi 1-4). Raspberry Pi pošle toto číslo Arduino.
  • Arduino obdrží toto číslo a napájení na přidružené LED.

Poznámka: tato aplikace rychleji a s méně kódu, můžete také zvolit použít Firmata protokolu, například pyFirmata knihovna na Raspberry a StandarfFirmata knihovna na Arduino. Podívejte se na tyto výukové programy a dozvíte se více.

Závěr

V tomto kurzu jste se naučili, jak komunikovat mezi Raspberry Pi a Arduino přes Sériový.

nyní, v reálném životě, bude to pro vás užitečné? Odpověď je ano, a docela často.

Raspberry Pi je skvělé pro mít hodně výpočetního výkonu vložené do vaší aplikace. Můžete spustit kompletní software v mnoha jazycích, webové servery, robotické aplikace, atd. Raspberry Pi má určitě některé GPIO, které můžete použít,ale nejsou tak dobré jako Arduino. Také máte více šancí vypálit Pi, pokud uděláte něco špatného s hardwarem.

Arduino je vhodnější přímo rukojeti hardware, senzory a aktuátory: IMU, servomotory, krokové motory, nic, která vyžaduje více energie, atd. – více informací o tom, kdy použít Arduino vs Raspberry Pi.

celkově vzato mohou desky 2 dokonale spolupracovat: Raspberry Pi jako „mozek“ aplikace a Arduino jako „svaly“se sériovou komunikací, která je přiměje, aby spolu mluvili.