Raspberry Pi Arduino komunikacja szeregowa-wszystko, co musisz wiedzieć

w tym samouczku pokażę Ci, jak komunikować się między Raspberry Pi A płytą Arduino za pośrednictwem komunikacji szeregowej.

najpierw szybko wyjaśnię, czym jest komunikacja szeregowa. Następnie zobaczysz, jak skonfigurować sprzęt i oprogramowanie, a my zagłębimy się w kod Pythona (Cpp dla Arduino). Podstawowy przykład na początku, co prowadzi do bardziej kompletnej aplikacji przy użyciu Raspberry Pi, Arduino, i innych urządzeń elektronicznych.

ten poradnik będzie działać z Raspberry Pi 4 (i wcześniejsze: 3B, 3B+) pokładzie, i wszelkie Arduino pokładzie. Użyję głównie Arduino Uno, ale podam więcej szczegółów na temat różnic między płytami Arduino, jeśli chodzi o komunikację szeregową.

podczas pracy z urządzeniami elektronicznymi komunikacja jest kluczowa. Każde urządzenie – oprócz tego, że robi dobrze to, co ma robić-musi być w stanie wyraźnie komunikować się z innymi urządzeniami. Jest to jedna z najważniejszych rzeczy do pracy, aby przejść z bardzo podstawowych aplikacji do bardziej złożonych.

czym jest komunikacja szeregowa (z UART)

komunikacja szeregowa jest po prostu sposobem transmisji danych. Dane będą wysyłane sekwencyjnie, jeden bit na raz (1 bajt = 8 bitów), w przeciwieństwie do komunikacji równoległej, gdzie wiele bitów jest wysyłanych w tym samym czasie.

protokół UART

mówiąc dokładniej, gdy używasz Protokołu szeregowego z Arduino i Raspberry Pi, używasz protokołu UART. UART oznacza „Uniwersalny asynchroniczny odbiór i transmisję”.

uczysz się używać Raspberry Pi do budowania własnych projektów?

Sprawdź Raspberry Pi dla początkujących i dowiedz się krok po kroku.

zasadniczo jest to asynchroniczny protokół multi-master oparty na komunikacji szeregowej, który pozwoli Ci komunikować się między dwiema płytami. Bądź spokojny, istnieją biblioteki, które będą obsługiwać wszystkie niskie warstwy za Ciebie.

Multi-master oznacza, że wszystkie podłączone urządzenia będą mogły wysyłać dane, kiedy będą chciały. Jest to jedna z głównych różnic w protokołach master-Slave, gdzie tylko urządzenie master może zainicjować komunikację. Zwykle używasz innych protokołów, takich jak I2C i SPI, gdy potrzebujesz konfiguracji master-Slave: na przykład, gdy masz jedną płytę Arduino i wiele czujników lub siłowników.

Płyta Arduino Uno ma jeden UART, którego można użyć za pomocą kabla USB lub z pinów RX/TX (nie używaj go jednocześnie z obydwoma). Niektóre płyty mają więcej dostępnych UART. Na przykład Arduino Mega ma różne seriale (Serial, Serial1, Serial2, Serial3), a Arduino Zero ma tylko natywny port USB (użyj SerialUSB zamiast szeregowego).

na Raspberry Pi można podłączyć wiele urządzeń szeregowych na portach USB. Każde z nich będzie miało inną nazwę urządzenia (zobaczymy, jak je znaleźć w dalszej części tego samouczka). Możesz również użyć GPIOs (RX0 / TX0) dla dodatkowego UART.

prawdopodobnie znasz już komunikację szeregową

z pewnością wielokrotnie korzystałeś z komunikacji szeregowej. Jestem pewien, że znasz już bibliotekę szeregową Arduino, która pozwala rejestrować, co dzieje się w kodzie i uzyskać dane wejściowe od użytkownika. Kiedy używasz monitora szeregowego, cóż, zasadniczo Arduino IDE inicjuje komunikację szeregową z Arduino. Możesz odbierać i wysyłać dane bezpośrednio z monitora szeregowego.

co zrobimy tutaj jest prawie taka sama, z wyjątkiem, że zamiast Arduino IDE, druga strona komunikacji szeregowej będzie Raspberry Pi Pokładzie. Będziemy musieli zrobić trochę konfiguracji i napisać trochę kodu, aby to działało. Następnie, zarówno Raspberry Pi i Arduino będą mogli wysyłać wiadomości do siebie.

zobaczmy teraz, jak fizycznie połączyć 2 płyty razem.

konfiguracja sprzętu do komunikacji szeregowej

istnieją 2 sposoby podłączenia Raspberry Pi i Arduino do komunikacji szeregowej.

Serial via USB

najprostszym sposobem jest użycie kabla USB między obiema płytami.

po stronie Raspberry Pi wystarczy proste złącze USB. Możesz wybrać dowolny z 4 Portów USB dostępnych na płycie.

W przypadku Arduino użyjesz portu USB, którego używasz do przesyłania kodu z komputera (z Arduino IDE) na płytę. Tutaj złącze USB zależy od wersji, którą masz. W przypadku płyt takich jak Arduino Uno I Mega złącze będzie się różnić od Arduino Nano i Arduino Zero.

w tym przykładzie użyłem płyty Arduino Uno.

jak widać, jest to najprostsze połączenie sprzętowe, które można wykonać między Raspberry Pi i Arduino.

notka: najpierw musisz podłączyć Arduino do komputera, dzięki czemu możesz przesłać kod na płytkę. Następnie podłącz kabel USB do Raspberry Pi. Raspberry Pi będzie zasilać Arduino za pośrednictwem tego kabla.

Serial via GPIOs

aby nawiązać połączenie szeregowe, możesz również użyć zwykłych przewodów między GPIOs Raspberry Pi A pinami Arduino.

w zależności od płyty Arduino może być konieczne użycie dźwigni zmiany poziomu napięcia. Raspberry Pi działa na 3.3 V. dla płyt Arduino, takich jak Due, 101, będzie dobrze, ponieważ używają również 3.3 V.

ale dla wielu Arduino, takich jak Uno, Mega, Leonardo, Nano i wielu innych, płyta działa przy 5V. Tak więc, potrzebujesz 3.3 V/5V level-shifter, aby chronić Raspberry Pi podczas łączenia RX i TX (więcej informacji na temat pinów Raspberry Pi i pinów Arduino Uno).

do końca tego samouczka użyjemy konfiguracji za pomocą kabla USB. Będzie to łatwiejsze do zarządzania i o ile nie masz dobrego powodu, powinieneś preferować użycie kabla USB zamiast zwykłego gpios do komunikacji szeregowej.

konfiguracja oprogramowania Raspberry Pi

nie potrzebujesz żadnej specjalnej konfiguracji dla Arduino. Po prostu upewnij się, że pobrałeś i zainstalowałeś Arduino IDE.

teraz, na Raspberry Pi, kilka rzeczy są wymagane do pracy komunikacji.

Połącz się z Raspberry Pi przez ssh lub wtyczkę ekran + mysz + klawiatura i otwórz terminal. Jeśli jeszcze nie zainstalowałeś systemu operacyjnego na swoim Pi, możesz bardzo łatwo zainstalować Raspbian lub Ubuntu na karcie SD.

Wykryj płytkę Arduino

podczas podłączania Arduino za pomocą kabla USB powinieneś zobaczyć ją jako /dev/ttyACM0 lub /dev/ttyUSB0 (czasami liczba może być inna, na przykład /dev/ttyACM1).

po prostu uruchom ls /dev/tty* i powinieneś go zobaczyć. W tym momencie, jeśli nie masz pewności, które urządzenie jest płytą Arduino, po prostu Odłącz płytkę (wyjmij kabel USB) i uruchom ponownie ls /dev/tty*. W ten sposób można łatwo dostrzec nazwę urządzenia szeregowego Arduino.

uprawnienia sprzętowe dla Serial

ponadto możesz dodać użytkownika do grupy dialout, aby uniknąć błędów, takich jak: serial.serialutil.SerialException: nie można otworzyć portu / dev/ ttyACM0: Permission denied: '/ dev / ttyACM0′

$ sudo adduser your_username dialout

zapewni to dostęp do urządzeń szeregowych (/dev /ttyACMx,/dev / ttyUSBx, …).

po dodaniu siebie do grupy dialout, musisz ponownie uruchomić Pi (lub przynajmniej wylogować/zalogować się), aby zastosować zmianę – dowiedz się więcej o uprawnieniach sprzętowych Raspberry Pi.

zainstaluj Python Serial library na Raspberry Pi

aby móc korzystać z interfejsu szeregowego w Pythonie, musisz zainstalować bibliotekę.

w tym tutorialu użyjemy biblioteki pySerial (dokumentacja dla Pythona 3). Aby go zainstalować:

python3 -m pip install pyserial

ta Biblioteka Pythona jest dobrze znana i używana w wielu aplikacjach.

podczas instalacji, Jeśli pojawi się błąd, taki jak „/usr/bin/python3: brak modułu o nazwie pip”, musisz najpierw zainstalować pip za pomocą sudo apt install python3-pip.

prosta komunikacja szeregowa z Arduino do Raspberry Pi

Zacznijmy od bardzo prostego programu.

kod Arduino

prześlij ten kod z komputera do Arduino, używając Arduino IDE.

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

najpierw inicjujemy komunikację szeregową i wybieramy szybkość transmisji, tutaj 9600. 9600 jest powszechnie używaną prędkością transmisji,a także dość niską. W przyszłych zastosowaniach możesz bez problemu korzystać z prędkości transmisji 57600 lub nawet 115200. W tym samouczku będziemy kontynuować z 9600.

co sekundę sprawiamy, że Arduino wysyła ciąg z seryjnym.println(). funkcja println () doda znak nowej linii „\n ” na końcu łańcucha.

możesz otworzyć Monitor szeregowy, aby zobaczyć ciąg znaków na komputerze.

Kod Pythona Raspberry Pi

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

więc co robi ten kod?

#!/usr/bin/env python3import serial

najpierw importujemy bibliotekę szeregową, którą wcześniej zainstalowaliśmy.

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

komunikacja szeregowa jest inicjowana przez wywołanie serial.Serial () wraz z kilkoma parametrami:

• Nazwa urządzenia szeregowego dla Arduino: Zwykle '/ dev / ttyACM0′,’/dev / ttyUSB0 ’ lub podobne.
• Szybkość Transmisji: ten parametr jest bardzo ważny. Musisz użyć tej samej szybkości transmisji, co ta, której użyłeś na Arduino, w przeciwnym razie wszystko, co przeczytasz i napiszesz, będzie śmieciem. Wybieramy więc 9600, tak jak to zrobiliśmy w szkicu Arduino.
• timeout: jest to limit czasu dla operacji odczytu. Tutaj ustawiamy go na 1 sekundę. Oznacza to, że podczas odczytu z seryjnego, program nie utknie na zawsze, jeśli dane nie przyjdą. Po 1 sekundzie lub odczycie, jeśli nie wszystkie bajty zostaną odebrane, funkcja zwróci już odebrane bajty.

tak, serial.Serial() zwraca obiekt, którego można użyć do wszystkich operacji szeregowych. Przechowujemy go w zmiennej 'ser’.

 ser.flush()

następnie używamy funkcji flush (). Spowoduje to opróżnienie dowolnego bufora wejściowego i wyjściowego, dzięki czemu uniknie odbierania lub wysyłania dziwnych/nieużytecznych/niekompletnych danych na początku komunikacji.

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

w nieskończonej pętli (pomyśl o funkcji loop() w szkicu Arduino) sprawdzamy, czy niektóre dane są dostępne z atrybutem in_waiting (nie umieszczaj nawiasów, to nie jest funkcja). Jeśli tak, możemy odczytać dane.

funkcja readline() odczyta wszystkie bajty, dopóki nie zostanie wykryty znak nowej linii.

gdybyśmy tylko wydrukowali to, co otrzymaliśmy, zobaczylibyśmy b ’ Hello od Arduino!\R\n’. Otrzymujesz bajty podczas odczytu z szeregowego i musisz przekonwertować (dekodować) te bajty na odpowiedni typ danych. Tak więc, używamy decode (’utf-8′) – Możesz również użyć decode (’ascii’) – do dekodowania odebranych danych do ciągu znaków.

wreszcie, funkcja rstrip() jest specyficzna dla ciągów znaków, pozwala usunąć wszelkie końcowe znaki (nowa linia, powrót karetki). W ten sposób możemy usunąć '\r’ I '\n’ i uzyskać odpowiedni ciąg znaków.

Uwaga: tutaj za każdym razem czytamy pełną linię. Jeśli chcesz odczytać określoną ilość bajtów – jeden lub więcej-Użyj funkcji read (size=1).

testowanie komunikacji szeregowej

teraz Odłącz kartę Arduino od komputera i podłącz ją do płyty Raspberry Pi.

kod Arduino jest już uruchomiony, gdy tylko zostanie włączony.

na Raspberry Pi Utwórz plik wykonywalny Pythona i uruchom go.

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

to działa! Ciąg wysyłany przez Arduino co sekundę jest wyświetlany na terminalu Raspberry Pi.

Dwukierunkowa komunikacja szeregowa między Raspberry Pi i Arduino

zróbmy to trochę bardziej interesująco. Widziałeś, jak wysyłać dane z Arduino do Raspberry Pi. W tej części zobaczysz, jak rozmawiać z Raspberry Pi do Arduino. W ten sposób będziesz miał obie strony komunikacji i będziesz mógł tworzyć programy, które czekają na siebie nawzajem.

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

tutaj sprawdzamy, czy Arduino otrzymało dane z numerem seryjnym.dostępny(). To da ci liczbę bajtów już przybyłych i przechowywanych w buforze odbiorczym.

jeśli jakieś dane dotarły, używamy szeregowego.readStringUntil () ze znakiem nowej linii '\n’, aby uzyskać następną linię. Jest to podobne do funkcji readline (). Wszystkie otrzymane bajty do „\n”są automatycznie konwertowane i dodawane do obiektu ciągu Arduino.

następnie po prostu drukujemy dane, które otrzymaliśmy, z dodatkowym fragmentem tekstu.

Uwaga: Jeśli chcesz odczytywać bajty jeden po drugim, możesz to zrobić z seryjnym.funkcja read (). Następnie musisz przekonwertować ten(te) bajt (y) w razie potrzeby: int, String, itd.

Kod Pythona Raspberry Pi

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

Użyj funkcji pyserial write (), aby wysłać dane do Arduino. Tutaj możesz zobaczyć, że dodałem ’ b ’ przed łańcuchem do wysłania. Spowoduje to zakodowanie łańcucha na bajty, ponieważ możesz wysyłać bajty tylko przez Serial. Wszelkie dane, które nie są bajtami lub tablicą bajtów, muszą zostać przekonwertowane przed wysłaniem. Jeśli po prostu spróbujesz wysłać taki ciąg znaków, otrzymasz ten błąd „TypeError: ciągi unicode nie są obsługiwane, proszę zakodować na bajty:’ Hello from Raspberry Pi!'”

Uwaga: zamiast ser.write(b"Hello from Raspberry Pi!\n") mogłeś napisać ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) lub ser.write("Hello from Raspberry Pi!\n".encode('ascii')). To zrobi to samo. Funkcja encode () pobierze ciąg znaków i zakoduje go dla szeregowego.

dodajemy również znak nowej linii '\N’, ponieważ to właśnie Arduino ma zakończyć czytanie seryjnym.readStringUntil(’\n’).

następnie robimy to samo, co wcześniej: odczytujemy linię, dekodujemy ją na string i usuwamy wszystkie końcowe znaki. Nie używamy ser.in_waiting tutaj, ponieważ dla tej konkretnej aplikacji wiemy, że Arduino wyśle z powrotem niektóre dane zaraz po otrzymaniu ciągu znaków. Ponadto mamy 1-sekundowy timeout, aby uniknąć utknięcia na tej linii.

na koniec drukujemy odebrany łańcuch i czekamy na 1 sekundę z czasem.sleep () przed wysłaniem następnego ciągu Przez Serial.

testowanie dwukierunkowej komunikacji szeregowej

na Raspberry Pi, Utwórz plik Python wykonywalny i uruchom go.

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

sukces! Arduino otrzymał Sznurek i odesłał go z kilkoma słowami. Następnie Malina Pi otrzymał i wydrukował końcowy ciąg.

Raspberry Pi Arduino komunikacja szeregowa: przykład aplikacji

teraz, gdy wiesz, jak skonfigurować Arduino i Raspberry Pi do komunikacji szeregowej i pisać programy do rozmowy między każdą płytą, stwórzmy bardziej złożoną aplikację.

w tej aplikacji do płyty Arduino zostaną podłączone 4 diody LED i jeden przycisk.

Raspberry Pi i Arduino zostaną połączone kablem USB i będą używać komunikacji szeregowej, aby rozmawiać ze sobą.

oto wynik, który chcemy uzyskać:

• po naciśnięciu przycisku Arduino wyśle powiadomienie do Raspberry Pi (prosty bajt).
• Malina Pi następnie obliczy losową liczbę całkowitą między 1 A 4 i wyśle ją do Arduino.
• Arduino włącza diodę LED związaną z tym numerem i wyłącza inne diody LED.

to sprawi, że będziesz ćwiczyć komunikację i synchronizację zadań między Arduino i Raspberry Pi.

jeśli dotarłeś do tego punktu tutoriala (gratulacje!) Zachęcam do samodzielnego napisania kodu przed przeczytaniem kodu, który podałem poniżej. Ponadto, istnieje nie tylko jeden możliwy kod, aby spełnić te wymagania, więc Twój kod może się różnić od mojego, jest całkowicie OK. Możesz uzyskać pomoc od referencji szeregowej Arduino i referencji API pySerial.

Schematy

aby ten obwód:

• Podłącz 4 diody LED do pinów 9-12. Dodaj Rezystor 220 Ohm dla każdej diody LED między dłuższą nogą a pinem cyfrowym. Krótsza noga jest połączona z ziemią.
• Dodaj przycisk z rezystorem 10kohm podłączonym do masy (rezystor pull-down). Jedna strona przycisku jest podłączona do 5V, druga do cyfrowego pinu 5 do odczytu.
• nie zapomnij stworzyć wspólnej płaszczyzny między wszystkimi komponentami: płytą Arduino, 4 diodami LED i przyciskiem. Nie dodawaj żadnego zasilacza, jeśli przynajmniej nie prawidłowo podłączyłeś podstawy.
• podłącz Arduino i Raspberry Pi za pomocą kabla USB, do komunikacji szeregowej (Kabel USB zarządza już połączeniem uziemienia między 2 płytami).

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

w funkcji setup() inicjujemy tryby pin dla wszystkich 4 Diod Led i przycisku. Upewniamy się również, że wszystkie Diody LED są wyłączone.

następnie w loop() robimy 2 rzeczy: obsługę przycisku i zarządzanie 4 diodami LED. Obie czynności są wykonywane jeden po drugim, ale są obsługiwane bardzo szybko, więc to tak, jakby miały miejsce w tym samym czasie. To przypadek wielozadaniowości programu Arduino.

pierwsza czynność: obsługa przycisku.

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;

musimy debunkować przycisk, aby uniknąć niepożądanych wartości. Kiedy okaże się, że przycisk jest wciśnięty, możemy wysłać niektóre dane do Raspberry Pi przez szeregowy.

tutaj użyłem seryjnegofunkcja write (): wysyła bajt lub serię bajtów. To różni się od seryjnego.print (), która sprawi, że wyjście będzie ładne do zobaczenia na monitorze szeregowym. Jak mówimy do innej maszyny, a nie człowieka, nie ma problemu z tym.

liczba, którą tu wysyłamy to 18. Jest to po prostu losowa liczba, że będziemy kojarzyć się ze stanem „przycisk został wciśnięty”, więc kiedy Malina Pi otrzyma liczbę, to sprawdzi, czy jest równa 18. Można sobie wyobrazić wysyłanie różnych akcji lub wiadomości przez szereg, używając różnych numerów.

Uwaga: zazwyczaj można również użyć przerwań Arduino, aby wiedzieć, kiedy przycisk został naciśnięty. Jeśli to zrobisz,nie używaj Biblioteki szeregowej w przerwaniu. Jeśli bezwzględnie musisz używać przerwań, Ustaw flagę wewnątrz przerwania (prosta zmienna logiczna) i użyj szeregowego wewnątrz funkcji loop ().

i druga akcja: zarządzanie 4 diodami 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; } }

najpierw sprawdzamy, czy Arduino otrzymał pewne dane z Raspberry Pi przez komunikację szeregową.

jeśli tak, odczytujemy następny bajt z numerem szeregowym.read(). Tutaj można zauważyć mały trik, składający się z odejmowania za pomocą '0′, który przekształci znak na liczbę, którą reprezentuje – w tym przypadku liczbę całkowitą.

po tym jest to dość proste. Wyłączamy wszystkie Diody LED, a następnie włączamy tylko diody LED związane z liczbą: 1, 2, 3 lub 4. W przypadku wysłania błędnej wartości, Żadna DIODA LED nie zostanie włączona.

Kod Pythona Raspberry Pi

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

najpierw dodajemy jedną linię importu: bibliotekę losową Pythona.

W pętli nieskończonej („while True”) najpierw odczytujemy jeden bajt z szeregowego. Timeout jest ustawiony na 1 sekundę. Jeśli nic nie zostanie odebrane po jednej sekundzie, funkcja read() zwróci b”.

sprawdzamy więc, czy to, co otrzymaliśmy, jest po prostu puste (b”), czy naprawdę coś było. W tym drugim przypadku konwertujemy otrzymane dane na liczbę całkowitą, dzięki czemu możemy użyć w kodzie. Do tego używamy funkcji int.from_bytes (), która dekoduje b’ 0x12 ’ (szesnastkowa reprezentacja 18 to 0x12) do 18.

jak widać sprawdzamy, czy liczba to 18, aby kontynuować akcję. Jeśli masz różne polecenia do obsługi, używanie innego numeru dla każdego polecenia jest dobrą praktyką.

wybieramy losową liczbę od 1 do 4, Aby określić, która doprowadziła do włączenia zasilania. Następnie wysyłamy go za pomocą funkcji pyserial write (). Aby wysłać int przez szereg, najpierw konwertujemy go jako łańcuch za pomocą str (), a następnie kodujemy za pomocą encode(’utf-8′).

testowanie aplikacji

teraz możesz podłączyć Arduino do Raspberry Pi za pomocą kabla USB. Raspberry Pi będzie następnie dostarczać moc zarówno dla Arduino i 4 diody LED.

jeśli masz wiele rzeczy podłączonych do Arduino, możesz dodać zewnętrzny zasilacz do złącza zasilacza Arduino. Na przykład, jeśli chcesz użyć silnika krokowego, Raspberry Pi nigdy nie będzie miał wystarczającej ilości prądu dla siebie + Arduino + silnik. W tym przypadku z 4 diodami LED jest OK.

Uruchom skrypt Pythona i naciśnij przycisk. Zobaczysz dziennik i jedna z diod LED na Arduino zostanie włączona.

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

za każdym razem, gdy naciśniesz przycisk:

• Arduino wykryje go i wyśle 18 do Raspberry Pi.
• Raspberry Pi otrzyma niektóre dane z serii. Sprawdzi, czy liczba jest równa 18. Jeśli tak, wybierana jest liczba losowa (od 1 do 4). Malina Pi wyśle ten numer do Arduino.
• Arduino otrzyma ten numer i moc na powiązanej diodzie LED.

Uwaga: Aby wykonać tę aplikację szybciej i z mniejszą ilością kodu, Możesz również użyć protokołu Firmata, na przykład z biblioteką pyFirmata na Raspberry i biblioteką StandarfFirmata na Arduino. Sprawdź te samouczki, aby dowiedzieć się więcej.

wniosek

w tym samouczku nauczyłeś się komunikować między Raspberry Pi i Arduino pokładzie poprzez szeregowy.

czy w prawdziwym życiu będzie Ci to przydatne? Odpowiedź brzmi ” tak ” i to dość często.

Raspberry Pi jest świetny do posiadania dużej mocy obliczeniowej wbudowanej w Twoją aplikację. Możesz uruchamiać kompletne oprogramowanie w wielu językach, serwerach internetowych, aplikacjach robotycznych itp. Raspberry Pi z pewnością ma kilka GPIOs, które można użyć, ale nie są one tak dobre jak te Arduino. Ponadto masz więcej szans na spalenie Pi, jeśli zrobisz coś złego ze sprzętem.

Arduino jest bardziej odpowiedni do bezpośredniej obsługi czujników sprzętowych i siłowników: IMU, serwosilników, silników krokowych, wszystkiego, co wymaga większej mocy itp. – więcej informacji na temat tego, kiedy używać Arduino vs Raspberry Pi.

Podsumowując, 2 płyty mogą doskonale współpracować: Raspberry Pi jako ” mózg „aplikacji, i Arduino jako” mięśnie”, z komunikacją szeregową, aby rozmawiały ze sobą.