Jak zbudować system ręcznego sterowania robotem Astorino za pomocą joysticków i Arduino

Przedstawiamy praktyczny przewodnik, który umożliwi stworzenie manualnego systemu sterowania robotem Astorino z wykorzystaniem dwóch analogowych joysticków oraz mikrokontrolera Arduino. Całość została opracowana z myślą o intuicyjnej obsłudze robota w czasie rzeczywistym – bez konieczności programowania trajektorii ruchu.

Wprowadzenie

Sterowanie robotem za pomocą joysticków to rozwiązanie umożliwiające intuicyjne i precyzyjne kontrolowanie pozycji oraz orientacji robota, bez potrzeby programowania trajektorii ruchu. W projekcie wykorzystano dwa analogowe joysticki oraz mikrokontroler Arduino, które wspólnie tworzą interfejs do ręcznego sterowania robotem w sześciu osiach.

Sygnały z joysticków są odczytywane przez przetworniki analogowo–cyfrowe (ADC) mikrokontrolera, następnie przetwarzane na uproszczone komendy znakowe i przesyłane do robota w czasie rzeczywistym – w zależności od wychylenia drążków oraz stanu przycisków.

Takie rozwiązanie może być wykorzystywane zarówno do nauki podstaw sterowania robotem (obsługa różnych komend ruchu), jak i jako baza do dalszego rozwoju bardziej zaawansowanych aplikacji.

Opis wymaganych elementów

Do wykonania układu sterowania robotem niezbędne są następujące komponenty:

• Robot edukacyjny Astorino.
• Komputer z zainstalowanym środowiskiem programistycznym Arduino IDE oraz oprogramowaniem do obsługi robota edukacyjnego Astorino.
• Mikrokontroler Arduino (np. Arduino UNO R3 z układem ATmega328P).
• Dwa analogowe joysticki 3–osiowe z przyciskiem – każdy joystick wyposażony jest w dwa potencjometry (do sterowania osiami) oraz wbudowany przycisk służący do zmiany trybu pracy lub sterowania chwytakiem.
• Przewody połączeniowe typu męsko-męskie i męsko-żeńskie (dupont).
• Wydrukowana w technologii 3D obudowa (gamepad) dla montażu joysticków i Arduino.

Założenia projektu

Projekt zakładał stworzenie systemu umożliwiającego manualne sterowanie robotem za pomocą dwóch analogowych joysticków podłączonych do mikrokontrolera Arduino. Celem było przełożenie fizycznych wychyleń drążków na ruchy robota w osiach przestrzennych oraz zmiany orientacji, bez konieczności programowania trajektorii ruchu.

Arduino odczytuje wartości analogowe z osi X, Y i Z oraz stany logiczne przycisków, a następnie przetwarza je na uproszczone komendy znakowe, które są przesyłane do robota za pośrednictwem interfejsu UART. Robot interpretuje przesłane dane i wykonuje odpowiednie ruchy w czasie rzeczywistym.

Joystick 1 odpowiada za sterowanie pozycją robota w osiach X i Y oraz obsługę chwytaka poprzez przycisk. Joystick 2 służy do sterowania ruchem w osi Z oraz do zmiany trybu pracy – po aktywacji przycisku, joystick przechodzi w tryb sterowania orientacją robota (rotacja wokół osi Rx, Ry, Rz).

Implementacja oprogramowania

Kod został podzielony na logiczne części – każda odpowiada za następny krok, który należy wykonać.

Montaż układu elektronicznego

Układ został zbudowany bez użycia płytki stykowej – wszystkie komponenty zostały bezpośrednio podłączone do pinów Arduino Uno R3 za pomocą przewodów połączeniowych.

Poprawne połączenie joysticków

Każdy z joysticków posiada następujące wyprowadzenia:

• zasilanie +5 V,
• masa GND,
• dwa wyjścia analogowe: VRx i VRy (odpowiadające za odczyt wychylenia potencjometrów),
• jedno wyjście cyfrowe: SW (służące do obsługi przycisku w joysticku).

Wyjścia VRx i VRy należy podłączyć do wejść analogowych mikrokontrolera (A0–A3), natomiast sygnał SW – do wejścia cyfrowego (D6, D7).

Piny analogowe umożliwiają odczyt napięcia w zakresie od 0 do 5V, co pozwala na dokładne określenie stopnia wychylenia joysticka. Z kolei piny cyfrowe rozróżniają tylko dwa stany logiczne: 0 (LOW) i 1 (HIGH).

Nieprawidłowe podłączenie wyprowadzeń (np. podłączenie VRx do pinu cyfrowego) uniemożliwia poprawny odczyt danych – zamiast rzeczywistego stopnia wychylenia otrzymamy wartość nieokreśloną lub zero. W konsekwencji układ nie będzie działał prawidłowo, a sterowanie robotem może być niemożliwe.

Komunikacja UART

Do przesyłania danych między Arduino a robotem wykorzystano interfejs komunikacyjny UART (Universal Asynchronous Receiver-Transmitter). Jest to dwukierunkowy protokół szeregowy, co oznacza, że możliwe jest zarówno wysyłanie, jak i odbieranie danych.

Aby komunikacja mogła się odbyć, należy:

• połączyć pin TX (Transmit) Arduino z pinem RX (Receive) robota – aby wysyłać dane z Arduino do robota,
• (opcjonalnie) połączyć pin RX Arduino z pinem TX robota, jeżeli planujemy odbierać dane z robota.

Uwaga – diagnostyka problemów oraz schemat połączenia

Uwaga: jeżeli poziomy napięć UART robota różnią się od 5V (np. pracuje na 3.3V), należy zastosować konwerter poziomów logicznych, aby uniknąć uszkodzenia sprzętu.

Schemat przedstawiający kompletne połączenia układu znajduje się poniżej.

Nawiązanie komunikacji za pomocą UART i sprawdzenie poprawności jej działania

Komunikacja Arduino

Po poprawnym podłączeniu wszystkich elementów układu do płytki Arduino, należy sprawdzić, czy komunikacja z robotem działa prawidłowo. W tym celu w programie Arduino IDE tworzymy nowy projekt, wybierając File → New Sketch. Otworzy się nowe okno, w którym można nazwać projekt.

Następnie w górnym pasku narzędzi klikamy nazwę płytki (np. Arduino Uno) i wybieramy Select other board and port… W nowym oknie wyszukiwania wpisujemy model swojej płytki (np. Arduino Uno R3) oraz wybieramy port COM, do którego została podłączona. Zatwierdzamy wybór klikając OK.

Aby sprawdzić, czy dane są poprawnie wysyłane, można napisać bardzo prosty program testowy, który co sekundę wysyła znak „1” przez UART. Do podglądu danych używamy narzędzia Serial Monitor, które uruchamiamy ikoną lupy w prawym górnym rogu Arduino IDE.

Ważne: komunikacja z robotem Astorino odbywa się z prędkością 115200 bps, dlatego taką samą wartość należy ustawić w dolnym pasku Serial Monitora.

Jeżeli wszystko działa poprawnie, w Serial Monitorze powinny pojawiać się cykliczne znaki  „1” wysyłane co sekundę.

Komunikacja Astorino

W pierwszym kroku sprawdzimy połączenie z robotem Astorino. W tym celu otwórz aplikację Astorino, a następnie połącz robota z komputerem, włącz napędy, wykonaj zerowanie osi i przejdź do pozycji domowej.

Teraz należy przejść do zakładki Program i utworzyć nowy program, zatwierdzając przyciskiem OK.

W nowym programie należy ustawić parametry początkowe, a następnie stworzyć pętlę WHILE, która sprawdzi połączenie szeregowe. W pętli WHILE należy zastosować komendę EXISTCOM, która zwraca informację o stanie komunikacji:

• Jeżeli komunikacja nie została nawiązana, program utknie w tej pętli.
• Jeżeli komunikacja działa poprawnie, robot przejdzie dalej – co pozwala kontynuować programowanie logiki ruchu.

Dla potwierdzenia poprawności połączenia można utworzyć prostą pętlę nieskończoną (WHILE TRUE), w której robot wykonuje dowolną bezpieczną instrukcje. Jeżeli zielony wskaźnik wykonania znajduje się wewnątrz tej pętli, oznacza to, że robot otrzymuje dane i program działa prawidłowo.

Uwagi – diagnostyka problemów

Uwaga: Arduino nie pozwala na wgrywanie nowego programu, jeśli linia transmisji UART (pin TX) jest połączona z urządzeniem zewnętrznym (np. robotem). Aby wgrać program:

• odłącz przewód komunikacyjny z pinu TX lub RX,
• wgraj kod,
• po wgraniu ponownie podłącz przewód.

Uwaga: W przypadku braku nawiązania komunikacji należy sprawdzić:

• poprawność montażu układu (w przypadku błędu, na robocie będzie świecić się czerwona dioda),
• czy odpowiednio ustalona jest wartość bps (115200).

Odczyt wychyleń joysticków – tworzenie ADC

Deklaracja zmiennych

ADC (Analog–to–Digital Converter) to przetwornik analogowo–cyfrowy, który przekształca sygnał napięciowy z urządzenia analogowego na wartość liczbową zrozumiałą dla mikrokontrolera. Joystick działa tak, jak dwa potencjometry – dla osi X i Y – które zmieniają napięcie w zakresie od 0 do 5 V w zależności od wychylenia drążka.

Mikrokontroler Arduino Uno wyposażony jest w 10–bitowy przetwornik ADC. Oznacza to, że napięcie w  przedziale 0–5 V będzie przeliczone na wartość liczbową w zakresie od 0 do 1023.

Aby odczytywać dane z joysticków, najpierw należy wskazać mikrokontrolerowi, z których pinów będzie korzystał. Dla trzech osi ruchu (X, Y, Z) wykorzystujemy wejścia analogowe A0, A1 i A2. W tym celu, jeszcze przed funkcją setup musimy zadeklarować stałe.

Użycie słowa kluczowego const oznacza, że przypisanie pinu nie może się zmienić podczas działania programu. To logiczne – oś X zawsze będzie odczytywana z tego samego pinu.

Wartości napięć (czyli wychylenia) będą zapisywane do zmiennych, które muszą być zdefiniowane w funkcji loop() – dzięki temu będą aktualizowane na bieżąco, w każdej pętli programu:

Gdyby zmienne zostały zadeklarowane w setup(), odczyt nastąpiłby tylko raz – na początku działania programu.

Martwa strefa

Pozycja neutralna drążka joysticka teoretycznie odpowiada wartości ADC około 512, ale w praktyce może się lekko różnić. Dlatego stosujemy tzw. martwą strefę (ang. dead zone), np. ±50 jednostek, aby zignorować drobne odchylenia i zapewnić stabilność.
Na poniższym rysunku przedstawiono przykładową interpretację wychylenia:

Interpretacja stopnia wychylenia drążka

Aby przypisać określone działanie do danego zakresu ruchu, wykorzystano instrukcje warunkowe if. Dla każdej osi tworzona jest osobna funkcja, która przypisuje wartość:

• 1 – ruch w jednym kierunku,
• 2 – w przeciwnym,
• 0 – brak ruchu (martwa strefa).

W projekcie zdecydowano się na przesyłanie pojedynczych cyfr (0, 1, 2) zamiast tekstowych komend typu „X+” lub „LEFT”, ze względu na:

• mniejszy rozmiar danych – pojedynczy znak to tylko 1 bajt,
• szybsze przetwarzanie po stronie robota,
• mniejsze zużycie pamięci RAM,
• większą przejrzystość struktury komunikacji UART.

Przygotowanie danych do wysyłki

Po zinterpretowaniu wychyleń tworzone są nowe zmienne (np. mappX, mappY, mappZ), które zawierają przypisaną wartość (0, 1 lub 2) i będą wysyłane przez UART. Zmienna ta może być nadpisywana w każdej pętli programu – dzięki temu komunikaty odzwierciedlają aktualne położenie joysticka.

Na końcu pętli loop() dane są wysyłane przez UART do robota. Aby ułatwić rozpoznawanie wartości, oddzielono je znakiem ukośnika „/”. Dzięki temu robot otrzymuje prosty, uporządkowany komunikat w postaci [0/0/0/]

W tym etapie usuwamy już wcześniejszy testowy Serial.print(„1”);, a opóźnienie delay(1000) zastępujemy wartością delay(200), pozwoli to uzyskać szybszą i bardziej płynną reakcję robota na ruch joysticka.

Cały kod ADC:

Otrzymany przykładowy rezultat (różnice mogą polegać na innym wychyleniu joysticków):

Uwaga – diagnostyka problemów

UWAGA! Jeżeli pomimo braku wychylenia odbierasz komunikat „1” lub „2”, oznacza to wypięty lub nie podpięty przewód GND lub +5V.

UWAGA! Jeżeli pomimo ruchu joystickiem ciągle otrzymujesz wartość „0”, sprawdź poprawność połączenia.

PAMIĘTAJ! Jedna z osi joysticka nie została podpięta, oznacza to że drugi joystick będzie reagować tylko na ruch przód–tył.

Odbieranie komunikacji przez robota

Odbiór danych z mikrokontrolera Arduino po stronie robota odbywa się przy użyciu instrukcji:

$nazwa_zmiennej = RECEIVE

Instrukcja ta odpowiada za pobranie łańcucha znaków wysłanego przez port szeregowy UART. Jednak samo odebranie danych to nie wszystko – należy je jeszcze poprawnie zdekodować i rozdzielić na pojedyncze wartości. W tym celu stosujemy funkcję:

$nowa_nazwa = DECODE ($nazwa_zmiennej, „znak_oddzielający”)

Dzięki temu możliwe jest rozdzielenie całego komunikatu na oddzielne fragmenty, które można dalej przetwarzać. Aby uzyskać konkretną wartość z danego segmentu, używamy polecenia:

zmienna = VAL ($nowa_nazwa)

Można w ten sposób rozbudować wcześniejszą pętlę warunkową, w której sprawdzaliśmy jedynie istnienie połączenia (EXISTCOM). Teraz, poza potwierdzeniem odbioru danych, możliwe jest również wykonanie konkretnego ruchu zależnie od zawartości przesłanego komunikatu.

Ponieważ ramkę, która wysyłamy ma postać [0/0/0/], trzeba zastosować trzy zmienne odpowiadające kolejna na wychylenie w osi X, Y, Z.

Dzięki temu zabiegowi faktycznie odbieramy informacje o wychyleniu joysticka w trzech osiach, ale fizycznie nie widzimy tego w kodzie programu. Możemy to zmienić za pomocą dodania instrukcji PRINT $ZMN.

Spowoduje to, że w zakładce ust. Sys. będziemy mogli odczytać odbieraną ramkę.

Nadanie pleceń ruchu w zależności od odczytu ADC

Logika ruchu robota

Po odebraniu i zdekodowaniu informacji o aktualnym stanie joysticków możemy przejść do implementacji logiki ruchu robota.

W zależności od sposobu, w jaki chcemy sterować robotem, możemy wykorzystać różne typy poleceń ruchu, np.:

• DRIVE – niezależne sterowanie każdą osią,
• DRAW – ruch względem układu współrzędnych bazy robota,
• TDRAW – ruch względem układu współrzędnych narzędzia.

Aby zapewnić jak najbardziej intuicyjne sterowanie, w projekcie zastosowano polecenie:

DRAW(ruchX, ruchY, ruchZ, obrótX, obrótY, obrótZ)

Funkcja ta pozwala na równoczesne zadawanie ruchu liniowego w trzech osiach przestrzennych oraz obrotów wokół tych osi.

Ruch w linii prostej

Na podstawie odczytanych danych z joysticków można napisać prostą instrukcję warunkową:

Jak zinterpretować tę instrukcję?Jeżeli zmienna DATAX ma wartość 1 (czyli joystick został wychylony w lewo), to robot powinien przesunąć się o 3 mm w lewo wzdłuż osi X.

W sytuacji, gdy ruch ma odbywać się tylko w jednej osi, wartości dla pozostałych osi należy ustawić na 0 (lub pominąć je, jeśli składnia na to pozwala).

Ruch po skosie

Jeśli zależy nam na wykonaniu ruchu po skosie (czyli jednocześnie w więcej niż jednej osi), wystarczy podać odpowiednie wartości w wielu argumentach funkcji DRAW.

Jak zinterpretować tę instrukcję? Jeżeli DATAX = 2 (czyli wychylenie joysticka w prawo), a DATAY = 1 (wychylenie w lewo), to robot wykona ruch o 3 mm w prawo wzdłuż osi X oraz o 3 mm w lewo wzdłuż osi Y – tym samym poruszy się po skosie.

Uzupełnienie

Analogicznie należy rozbudować logikę o warunki sterowania ruchem:

• w osi Z,
• wokół osi Rx, Ry, Rz (czyli orientacją narzędzia),

Kompletny kod sterujący ruchem robota znajduje się TUTAJ (LINK).

Programowa bistabilizacja przycisku

Zastosowany w układzie przycisk joysticka jest fizycznie monostabilny, co oznacza, że działa tylko podczas wciśnięcia – po puszczeniu natychmiast wraca do stanu początkowego. Aby wykorzystać go jako przełącznik trybu (czyli: klik – włącz, klik – wyłącz), należało zaprogramować jego zachowanie w sposób bistabilny.

Efekt bistabilności osiągnięto przez wprowadzenie zmiennej logicznej (bool), która zmienia swój stan (1/0) po każdym naciśnięciu przycisku. Program rozpoznaje moment wciśnięcia, porównując bieżący stan przycisku ze stanem poprzednim. Jeżeli nastąpi zmiana z 1 na 0 (czyli przycisk został wciśnięty), zmienna sterująca przełącza się na przeciwną wartość.

Jak to zrobić?

Należy zadeklarować wejścia przycisków do pinów cyfrowych, z których będą pobierać informacje. Dodatkowo potrzebujemy znać obecny stan przycisku (0/1) oraz jaki był ostatni stan (0/1).

W projekcie do obsługi przycisków zastosowano specjalny tryb konfiguracji wejścia cyfrowego: INPUT_PULLUP. Jest to wbudowana w Arduino funkcja, która automatycznie aktywuje wewnętrzny rezystor podciągający (pull–up resistor) dla danego pinu. Dzięki temu pin w stanie spoczynku (gdy przycisk nie jest wciśnięty) przyjmuje poziom logiczny HIGH (1), a w momencie naciśnięcia – jest ściągany do masy (GND), co daje poziom LOW (0).

Schemat działania:

• Gdy przycisk jest rozłączony, pin odczytuje HIGH (bo jest podciągnięty do +5 V wewnętrznie),
• Gdy przycisk jest wciśnięty, łączy pin z GND, co daje LOW.

Ten sposób pozwala zrezygnować z dodatkowych zewnętrznych rezystorów, upraszcza montaż i eliminuje przypadkowe „pływające” stany wejść.

Aby wykryć rzeczywiste kliknięcie przycisku (czyli moment jego wciśnięcia, a nie sam fakt bycia wciśniętym), program porównuje stan aktualny z poprzednim stanem przycisku. Dzięki temu system rozpoznaje tylko moment przejścia z HIGH na LOW, co oznacza jedno, pojedyncze kliknięcie.

Ten mechanizm zapobiega wielokrotnemu wykonaniu akcji, gdy użytkownik trzyma przycisk dłużej niż jedną iterację pętli loop().

Zastosowano uproszczoną formę warunku logicznego:

W celu wysłania stanu przycisków przez UART, zastosowano skrócony zapis instrukcji warunkowej w postaci operatora trójargumentowego:

Ten zapis oznacza:

• jeśli zmienna stan1 ma wartość true – zostanie wysłany znak „0”,
• jeśli stan1 ma wartość false – zostanie wysłany znak „1”.

Operator trójargumentowy pozwala zapisać tę logikę w jednej, czytelnej linijce kodu – zamiast rozbudowanej instrukcji if…else.

Sterowanie narzędziem

Dekodowanie nowej ramki znaków

Aby móc sterować narzędziem, a później orientacją robota, musimy zmienić sposób odbierania ramki. Wcześniejsza ramka, którą odbieraliśmy miała postać (0/0/0/), teraz wygląda (0/0/0/0/0/). W związku z tym należy zdekodować ją na nowo i odczytać, poniżej znajduje się poprawnie zdekodowana nowa ramka.

Instrukcja warunkowa sterująca chwytakiem

Aby móc teraz sterować chwytakiem, który podpięty jest do sygnału 57, należy napisać poniższą komendę warunkową:

Sterowanie orientacją robota

Aby móc sterować orientacją robota, należy przełączyć stan logiczny przycisku pierwszego z 0 na 1. Następnie należy napisać instrukcje warunkową:

IF STAN1==1
THEN
	(logika ruchu która była do tej pory)
ELSE
	(logika ruch, która była do tej pory ze zmianą na obrót w określonych osiach)

Rezultat

Gdy mamy już napisaną pełną logikę kodu, możemy przejść do testów, czy wszystko działa poprawnie zgodnie z naszymi przewidywaniami i intuicją. Realizacja ruchu, którą otrzymaliśmy:

Jeżeli stan1 = 1:

• joystick 1 w lewo: ruch robota w lewo,
• joystick 1 w prawo: ruch robota w prawo,
• joystick 1 do góry: robot się cofa,
• joystick 1 do dołu: robot „idzie w naszą stronę”,
• joystick 2 do góry: ruch robota w dół,
• joystick 2 do dołu: ruch robota w górę.

Jeżeli stan1 = 0:

• joystick 1 w lewo: obrót robota względem X w lewo,
• joystick 1 w prawo: obrót robota względem X w prawo,
• joystick 1 do góry: obrót robota względem Y w lewo,
• joystick 1 do dołu: obrót robota względem Y w prawo,
• joystick 2 do góry: obrót robota względem Z w lewo,
• joystick 2 do dołu: obrót robota względem Z w prawo.

Pomysły na rozbudowę projektu

Stworzony system sterowania robotem za pomocą joysticków i Arduino może stanowić solidną bazę do dalszego rozwoju. Potencjalne rozszerzenia funkcjonalności obejmują:

1. Sterowanie prędkością na podstawie wychylenia joysticka. Zamiast przesyłać tylko kierunek ruchu, można analizować, jak bardzo joystick jest wychylony, i przeliczać to na prędkość (np. za pomocą funkcji map() lub progów ADC).

2. Zastosowanie wyświetlacza OLED lub LCD. Można dodać ekran, na którym będą wyświetlane aktualne dane: stan joysticków, tryb pracy, status chwytaka, odebrane dane UART, itp.

3. Zapis i odtwarzanie sekwencji ruchów. Arduino mogłoby rejestrować wykonywane ruchy i umożliwić ich odtworzenie jako zaprogramowana ścieżka pracy robota (tryb „nagrywania”).

4. Interfejs graficzny (GUI) na komputerze lub smartfonie. Rozszerzenie systemu o graficzne sterowanie – np. aplikacja na PC lub telefon, która pokazuje aktualne pozycje i pozwala na sterowanie przyciskami ekranowymi.

Pliki z programem

Gotowy program Arduino w języku C++.

Gotowy program w języku AS – sterowanie pozycją i orientacją.

Gotowy program w języku AS – sterowanie pozycją za pomocą komend DRAW oraz DRIVE.

Opis błędów

E099 – Poza zasięgiem ramienia

Komunikat:

Możliwa przyczyna: Robot otrzymał komendę, która wymusza ruch poza jego fizyczny zasięg, np. zbyt dalekie wysunięcie w osi X lub z osiągnieciem kąta, którego nie jest w stanie wykonać.

Rozwiązanie:

• Zresetuj pozycję robota do puntku domowego (HOME) lub wykonaj ruch w przestrzeni roboczej.
• Sprawdź ograniczenie przestrzeni roboczej w aplikacji Astorino.

E067 – Bufor został przepełniony RECEIVE – maks 128 bajtów

Komunikat:

Uwaga! Błąd ten pojawia się po wprowadzeniu robota w tryb Hold, po resecie błędu robot może kontynuować pracę.

Możliwe przyczyny:

• Zbyt krótki odstęp między wysyłanymi komunikatami.
• Zbyt dużo danych przesyłanych w czasie bez możliwości ich przetworzenia.
• Robot pracuje w trybie pracy Teach.

Rozwiązanie:

• Restart błędu.
• Zwiększenie opóźnień przesyła informacji .
• Rozpoczęcie pracy w trybie Repeat.

E046 – Błąd komunikacji

Komunikat:

Możliwe przyczyny:

• Utrata komunikacji z robotem.

Rozwiązanie:

• Nawiązanie ponownego połączenia.