Roboty Mobilne -...
-
Upload
vuongkhanh -
Category
Documents
-
view
213 -
download
0
Transcript of Roboty Mobilne -...
2
1 Spis treści 2 Przygotowanie do laboratorium ...................................................................................................... 3
3 Cel laboratorium .............................................................................................................................. 3
4 Robot mobilny PIONEER AT-DX3 ..................................................................................................... 4
4.1 Silniki........................................................................................................................................ 4
4.2 Akwizycja danych..................................................................................................................... 4
4.2.1 Sonary .............................................................................................................................. 4
4.2.2 Akwizycja danych z zderzaków ........................................................................................ 5
4.3 Awaryjne zatrzymanie robota ................................................................................................. 6
5 Zagadnienia laboratoryjne .............................................................................................................. 7
5.1 Regulator ................................................................................................................................. 7
5.2 Automat skończony ................................................................................................................. 8
6 Tworzenie i testowanie aplikacji dla robota Pioneer ...................................................................... 9
6.1 Testowanie kodu na robocie ................................................................................................... 9
6.2 Tworzenie nowej aplikacji ..................................................................................................... 12
6.3 Testowanie aplikacji .............................................................................................................. 13
6.4 Symulator robota................................................................................................................... 14
7 Przykłady ....................................................................................................................................... 15
7.1 Sterowanie bezpośrednie ...................................................................................................... 15
7.2 Sterowanie pośrednie przy wykorzystaniu akcji ................................................................... 16
8 Zadania do wykonania ................................................................................................................... 20
9 Dodatki .......................................................................................................................................... 21
9.1 Wymagane oprogramowanie ................................................................................................ 21
9.2 Literatura ............................................................................................................................... 21
3
2 Przygotowanie do laboratorium Instrukcja obejmuje dwa spotkania laboratoryjne. Od studentów wymaga się wcześniejszego
przygotowania do laboratorium z zagadnień wymienionych w instrukcji.
Pierwsze laboratorium wymaga od studentów znajomości następujących zagadnień:
Podstawy programowania w języku C++ :
o Znajomość instrukcji if, switch.
o Znajomość pętli for, while.
o Znajomość obiektowych typów danych
Znajomości podstawowych funkcji i cech środowiska ARIA i robota Pioneer
Drugie laboratorium wymaga od studentów znajomości dodatkowych zagadnień:
Podstawowej wiedzy o zagadnieniach regulacji:
o Regulator PID, PI, PD
Znajomość projektowania i tworzenia automatów skończonych.
Ponadto studenci powinni wykazywać się znajomością języka angielskiego w stopniu umożliwiającym
prace z dokumentacją techniczną.
3 Cel laboratorium Celem laboratorium jest zapoznanie studentów z robotem mobilnym Pioneer, jego konfiguracją
w środowisku laboratoryjnym oraz poznanie podstaw środowiska programistycznego ARIA, które
umożliwia sterowanie klasą robotów mobilnych Pioneer. Środowisko to składa się z symulatora
robota i biblioteki programistycznej dla języka C oraz C++. W trakcie laboratoriów studenci zapoznają
się ze środowiskiem symulacyjnym robota, tworzeniem map dla tego środowiska oraz poznają
podstawy programowania z wykorzystaniem biblioteki programistycznej ARIA. Poznane fragmenty
biblioteki obejmą metody sterowania silnikami robota i akwizycję danych z sensorów robota tzn.
sonarów oraz zderzaków. Studenci na zajęciach zapoznani zostaną z metodami regulacji,
w szczególności regulatorem PID. Ponadto poznają metody sterowania robota przy wykorzystaniu
automatów skończonych. Laboratorium realizowane będzie w postaci zadań praktycznych
obejmujących sterowanie robotem, podążanie za obiektem, itp. Część uwagi poświęcona zostanie
również systemom lokalizacji i nawigacji robota mobilnego Pioneer.
Cykl laboratoriów składa się z następujących tematów:
Zapoznanie się z środowiskiem Aria.
Akwizycja danych pomiarowych z sensorów zamontowanych na robocie mobilnym.
Sterowanie robotem w środowisku laboratoryjnym.
Wykorzystanie zadnień regulacji dla sterowania silnikami robota mobilnego.
Sterowanie robota przy wykorzystanie automatu skończonego.
4
4 Robot mobilny PIONEER AT-DX3 Robot mobilny Pioneer AT-DX3 wyposażony jest w silniki elektryczne oraz kilka sensorów, które
umożliwiają interaktywne sterowanie robota oraz jego interakcje z otoczeniem (m.in. omijanie
przeszkód).
4.1 Silniki Robot mobilny wyposażony jest w dwa silniki elektryczne, które pracują niezależnie dzięki temu
możliwe jest jazda robota po zadanej trajektorii jak również obrót robota wokół własnej osi.
Robotem mobilnym pionier można sterować na dwa sposoby, pierwszym z nich jest tryb bezpośredni,
w którym robot wykonuje przekazywane zadanie natychmiast. Drugi sposób sterowania robotem
nazywany jest trybem pośrednim, w tym trybie robot realizuje zadania w odpowiedzi na występujące
zdarzenie, lub występujące czynniki zewnętrzne.
W celu bezpośredniego sterowania robotem wykorzystywane są miedzy innymi następujące metody
klasy ArRobot:
void ArRobot::setRotVel(double velocity);
void ArRobot::setVel2(double leftVelocity, double rightVelocity);
void ArRobot::setVel(double velocity);
void ArRobot::move(double distance);
void ArRobot::moveTo(ArPose pose, bool doCumulative = true );
bool ArRobot::isMoveDone(double delta = 0.0 );
bool ArRobot::isTryingToMove (void);
void ArRobot::forceTryingToMove(void);
void ArRobot::setHeading(double heading);
bool ArRobot::isHeadingDone(double delta = 0.0) const;
void ArRobot::setDeltaHeading(double deltaHeading);
4.2 Akwizycja danych Robot Pionner wyposażony jest w serie sensorów umożliwiających interakcje z otoczeniem i
nawigację w środowisku miejskim, przestrzeni otwartej lub zamkniętej. Robot fabrycznie wyposażony
jest w dwa typy czujników tzn. sonar oraz zderzaki. Konstrukcja robota umożliwia podpięcie
praktycznie dowolnych dodatkowych sensorów, które zwiększają możliwości robota. Warto
wspomnieć że maksymalne obciążenie robota wynosi 40 kilogramów, przez co możliwe jest
podpięcie jednocześnie wielu zaawansowanych sensorów i urządzeń dodatkowych.
4.2.1 Sonary
Podstawowym sensorem, w który wyposażony jest praktycznie każdy robot z serii pionier są sonary.
Sonar jest urządzeniem wykorzystującym fale dźwiękowe (długie, średnie lub krótkie) do określenia
pozycji obiektów. Sonar z racji swojej konstrukcji jest w stanie wykryć obiekt jedynie w małym polu
widzenia. Z tego powodu na robocie mobilnym zamontowana została seria sonarów, dzięki której
możliwa jest detekcja obiektów w szerokim polu widzenia.
Pobieranie danych z sonarów robota mobilnego w odbywa się przy wykorzystaniu następujących
metod klasy ArRobot:
5
int ArRobot::getNumSonar (void) const
int ArRobot::getSonarRange (int num) const;
ArSensorReading* ArRobot::getSonarReading(int num) const;
Metoda ArRobot::getNumSonar zwraca ilość dostępnych sonarów. Metoda ArRobot::getSonarRange
zwraca odległość do najbliższego obiektu z zadanego sonaru. Natomiast metoda
ArRobot::getSonarReading zwraca obiekt klasy ArSonarReading. Obiekt ten umożliwia pobranie
dodatkowych parametrów takich jak pozycja sonaru na robocie itp.. Obiekt zwracany przez tą
metodę nie powinien być usuwany przez użytkownika ani tez zapisywany.
Rys. 1 Konfiguracja sonarów robota mobilnego
4.2.2 Akwizycja danych z zderzaków
Zderzaki spełniają role sensora odległości w przypadku, gdy pozostałe metody detekcji przeszkody
zawiodły. Robot posiada dwie grupy zawierające po piec zderzaków, grupy te umieszczone są z
przodu i z tylu robota mobilnego. Detekcję kolizji z którymś z boków robota mobilnego realizuje się
przez sprawdzenie czy dany silnik nie jest zakleszczony (ang. Stall) tzn. pomimo ustalonej prędkości
koła nie wykonują ruchu obrotowego.
6
Rys. 2 Konfiguracja zderzaków robota mobilnego
Pobieranie danych ze zderzaków robota mobilnego może odbywać się przy wykorzystaniu
następujących metod:
bool hasRearBumpers (void) const
int ArRobot::getStallValue (void) const;
int ArRobot::getNumFrontBumpers (void) const;
int ArRobot::getNumRearBumpers (void) const;
bool ArRobot::isLeftMotorStalled (void) const;
bool ArRobot::isRightMotorStalled (void) const;
Metody ArRobot::hasFrontBumpers oraz ArRobot::hasRearBumpers służą do sprawdzenia obecności
zderzaków z przodu i z tyłu robota. Funkcjonalność tych metod może nie być dostępna na wszystkich
modelach robotów, uniwersalnym rozwiązaniem jest sprawdzanie ilości dostępnych zderzaków
metodą ArRobot::getNumFrontBumpers oraz ArRobot::getNumRearBumpers.
Bit 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Wartość 32768 16384 8192 4096 2048 1024 512 256 128 64 32 16 8 4 2 1
Znaczenie Numer Tylniego zderzaka Lewe
kolo
Numer przedniego zderzaka Prawe
koło 7 6 5 4 3 2 1 7 6 5 4 3 2 1
Tab. 1 Znaczenie bitów wartości ArRobot::getStallValue
Sprawdzenie stanu zderzaków odbywa się przez sprawdzenia stanu poszczególnych bitów
zwracanych liczby całkowitej zwracanej przez metodę ArRobot::getStallValue (zob. Tab. 1).
4.3 Awaryjne zatrzymanie robota W przypadku, gdy program sterujący utracił kontrolę nad robotem lub zderzył się on z przeszkodą
bezzwłocznie należy zatrzymać pracę silników robota. Zatrzymanie silników może odbyć się z
poziomu programowano jednak w opisanym wcześniej przypadku należy bezzwłocznie włączyć
7
przycisk STOP znajdujący się na tylniej części pokładu robota. Aktywowanie przycisku STOP
sygnalizowane będzie przez sygnał dźwiękowy, gdy przycisk jest aktywowany wszystkie instrukcje
programu sterującego będą ignorowane przez robota mobilnego.
5 Zagadnienia laboratoryjne
5.1 Regulator Regulator jest urządzeniem, którego zadaniem jest sterowanie procesem. W układach z ujemnym
sprzężeniem zwrotnym regulator wyznacza zadaną wartość wielkości sterującej na podstawie uchybu
regulacji, czyli różnicy pomiędzy wartością zmierzoną a zadaną wartością tej wielkości.
Sygnał wyjściowy z regulatora oznaczany jest zazwyczaj, jako u(t), natomiast wejściem do regulatora
jest wykonawczy sygnał uchybu e(t).
Najbardziej znanym regulatorem używanym w praktyce jest regulator PID, w którym w nazwie
znajdują się litery pochodzące od rodzajów sterowania, jakie on w sobie zawiera: proporcjonalne P
(ang. proporcjonal), całkujące I (ang. Integral), różniczkujące D (ang. Derivative).
Wartość sygnału wyjściowego w regulatorze PID wyznacza się zgodnie z wzorem:
0
t
g i d
de tu t P e t P e t P
dt (1.1)
Stosowane są również wersje uproszczone regulatora PID składające się z wybranych elementów
składowych tego: I, P, PI, PD.
Wartość sygnału wyjściowego regulatora I wyznacza się zgodnie z wzorem:
0
t
iu t P e t dt (1.2)
Wartość sygnału wyjściowego regulatora P wyznacza się zgodnie z wzorem:
gu t P e t (1.3)
Wartość sygnału wyjściowego regulatora PI wyznacza się zgodnie z wzorem:
0
t
g iu t P e t P e t dt (1.4)
Wartość sygnału wyjściowego regulatora PD wyznacza się zgodnie z wzorem:
g d
de tu t P e t P
dt (1.5)
8
5.2 Automat skończony Automat skończony (ang. finite state machine, FSM) – abstrakcyjny, matematyczny, iteracyjny model
zachowania systemu dynamicznego oparty na tablicy dyskretnych przejść między jego kolejnymi
stanami (diagram stanów).
Automaty skończone idealnie nadają się do sterowania prostymi zadaniami robotyki. Robot ma
poruszać się tak, aby jego ruch nakreślił kształt kwadratu długości 50 cm. W tym szczególnym
przypadku wyróżniać będziemy dwa stany:
S1 – robot porusza się po linii
S2 – robot obraca się o 90 stopni w prawą stronę
Zmiana stanu z stanu S1 na stan S2 będzie następowało, gdy robot przejedzie odcinek 50 cm.
Natomiast przejście pomiędzy stanem S2 a S1 następować będzie, gdy robot zakończy proces obrotu.
Schemat tego automatu zaprezentowany został na poniższym rysunku.
Rys. 3 Automat skończony
Automatu skończony implementuje się zazwyczaj wykorzystując pętlę while oraz instrukcje switch:
int stan = 1;
while (true)
{
switch (stan)
{
case 1:
{
jedź_do_przodu;
if ( jeśli_przejechał_daną_odległość == 50_cm )
{
stan = 2;
}
break;
}
case 2:
{
Wykonuj_obrót;
if ( kąt_obrotu == 90_deg )
{
stan = 1;
9
}
break;
}
}
}
6 Tworzenie i testowanie aplikacji dla robota Pioneer
6.1 Testowanie kodu na robocie Sterowanie robotem odbywa się przy wykorzystaniu złącza transmisyjnego RS232, podłączonego do
komputera pokładowego lub do komputera osobistego przez wykorzystanie odpowiednio długiego
przewodu sterującego łączącego robota z jednostką centralna. Alternatywnym rozwiązaniem jest
wykorzystanie urządzenia Lantronix WiBox umożliwiającego przesyłanie danych do portu sterującego
przez sieć komputerową lub przez sieć bezprzewodową.
Konfiguracja stanowiska laboratoryjnego składa się z następujących elementów:
Robota mobilnego Pionner 3-AT,
Urządzenia Lantronix WiBox,
Rutera bezprzewodowego TP Link, tworzącego otwarty punkt dostępowy „Pioneer”
służącego do przyłączenia robota do lokalnej sieci Ethernet,
Komputera przyłączonego do lokalnej sieci komputerowej lub przyłączonego do punktu
dostępowego „Pioneer” wraz z pakietem oprogramowania ARIA.
Po uruchomieniu punktu dostępowego do sieci Ethernet, oraz uruchomienia robota należy sprawdzić,
pod jakim adresem w lokalnej sieci widoczny jest ruter. Adres rutera jest wykorzystywany w celu
połączenia się z robotem w trakcie laboratorium, adres nie jest stały i może się on zmieniać pomiędzy
kolejnymi ćwiczeniami laboratoriami.
Rys. 4 Budowa sieci wykorzystywanej do polaczenia się z robotem.
10
Adres IP pod, którym widoczny jest ruter może pobrać na dwa sposoby. Pierwszym z nich jest
fizycznie podpięcie komputera do portu sieciowego 1, 2, 3, lub 4 ruter bezprzewodowego lub
podłączenie się z punktem dostępowym Pioneer. Komputerowi podłączonemu do rutera zostanie
automatycznie przydzielony adres IP z puli adresów z przedziału 192.168.0.<2-255>. W celu
sprawdzenia adresu zewnętrznego rutera należy z poziomu przeglądarki internetowej przejść pod
adres http://192.168.0.1, który daje dostęp do panelu administracyjnego rutera. W przypadku prośby
o autoryzację dostępu należy podać następujący login ‘admin’, ‘admin’. Sprawdzenie zewnętrznego
adresu IP, pod którym dostępny jest ruter odbywa się przez wybranie zakładki Network/WLAN,
zewnętrzny adres rutera będzie widoczny jest w polu IP Address.
Rys. 5 Sprawdzanie adresu zewnętrznego rutera bezprzewodowego
Z poziomu panelu administracyjnego możliwa jest także weryfikacja podłączenia robota mobilnego
do punktu dostępowego. W tym celu należy wybrać z menu element DHCP/DHCP Client List. Jeśli na
liście widoczny jest klient o adresie IP 192.168.0.100 oznacza to, że robot połączył się z punktem
dostępowym. Jeśli adres ten nie jest widoczny należy zweryfikować czy urządzenia WBox jest
poprawnie podłączony z robotem mobilnym i dokonać restartu robota.
Jeśli pomimo widoczności adresu na liście klientów połączenie z robotem nie może zostać ustalone
należy sprawdzić konfigurację WiBox’a. W tym celu będąc połączonym do rutera bezprzewodowego
należy z poziomu przeglądarki internetowej wejść na adres http://192.168.0.100 i autoryzować się
pustym loginem i pustym hasłem w celu konfiguracji urządzenia WiBox.
Opisana powyżej metoda powinna być wykorzystywana jedynie w szczególnych przypadkach, tzn. w
przypadku problemów z polaczeniem się z robotem mobilnym, lub brakiem dostępu do sieci
laboratoryjnej.
Drugie podejście wymaga uruchomienia darmowego narzędzia FastResolver. Program umożliwia
pobranie adresów fizycznych wszystkich komputerów podłączonych do lokalnej sieci komputerowej.
Po uruchomieniu aplikacji użytkownik powitany zostanie oknem dialogowym Select Hosts / IP
Adresses (rys. 8). W tym oknie należy wybrać opcję Retrieve MAC Adresses, powoduje ona że
11
aplikacja będzie pobierała adresy fizyczne kart sieciowych urządzeń przyłączonych do sieci
komputerowej. W polach Resolve IP Addresses range należy wpisać przedział adresów sieci
laboratoryjnej np. From: 10.10.2.1, To: 10.10.2.255. Wartość przedziału może się zmieniać
w zależności od laboratorium z tego powodu zaleca się wcześniejsze zweryfikowanie puli adresów
sieci przez wyświetlenie właściwości połączenia sieciowego ( rys. 4 ).
Rys. 6 Właściwości połączenia sieciowego
Adres IP widoczny będzie w polu IPv4 Address. Zakres sieci lokalnej w znaczącej ilości przypadków
zakres który należy podać w polach From, To będzie składał się z trzech pierwszych cyfr adresu IP
natomiast ostatnia składowa będzie w przedziale od 0 do 255.
Po wprowadzeniu prawidłowego zakresu adresów sieciowych należy wybrać przycisk Ok, który
uruchomi proces skanowania sieci. Będzie on trwać kilka sekund, użytkownik zostanie
poinformowany o zakończenia procesu skanowania przez dezaktywacja przycisku stop oraz
pojawienie się przy każdym z adresów z puli zielonego lub czerwonego okręgu informującego
o dostępności adresu w sieci komputerowej.
Rys. 7 Okno startowe narzędzia FastResolver
12
Rys. 8 Rezultat skanowania sieci lokalnej
Rys. 9 Właściwości urządzenia
Po zakończeniu procesu skanowania należy na liście wyników znaleźć urządzenie którego adres
fizyczny (adres MAC) ma wartość F8-D1-11-32-50-3F. Wyszukiwanie to może być realizowane przez
przeglądanie dostępnych wyników, lub przez wykorzystanie funkcji wyszukiwania, którą można
uruchomić przez aktywację menu Edit/Find lub przez wybranie klawiszowego Ctrl-f. Adres urządzenia
IP o wskazanym adresie fizycznym służyć będzie do komunikacji programów z robotem mobilnym.
Adres IP może zostać skopiowany po wybraniu właściwości znalezionego urządzenia sieciowego i
zaznaczenie wartości pola IP Address.
Wszystkie programy napisane z wykorzystaniem biblioteki Aria maja możliwość przesyłania instrukcji
sterujących poprzez siec lub bezpośrednio przez port RS. W przypadku, gdy robot nie jest podpięty do
danego stanowiska biblioteka spróbuje automatycznie połączyć się do symulatora przez siec. W celu
specyfikacji adresu, z jakim biblioteka będzie się łączyła należy przekazać w parametrach
uruchomienia argumenty „-rh XXX”, gdzie XXX jest adresem sieciowym robota lub rutera, do którego
podłączony jest robot.
6.2 Tworzenie nowej aplikacji Utworzenie nowego projektu wykorzystującego bibliotekę Aria odbywa się przez utworzenie nowego
projektu Win32 Console Application. Przy tworzeniu projektu należy odznaczyć opcję Precompiled
header i zaznaczyć opcję Empty Project.
Wykorzystanie biblioteki ARIA w środowisku programistycznym sprowadza się do dodania ścieżek do
plików nagłówkowych i bibliotek w projekcie, oba zadania można wykonać przez zmianę w
13
właściwościach projektu. Dodawanie katalogów zawierających pliki nagłówkowe odbywa się w
elemencie Configuration Properties / C/C++ / General modyfikując wartość Additional Include
Directories przez dodanie ścieżki „C:/Program Files/MobileRobots/Aria/include”. Ścieżkę do bibliotek
modyfikuje się w elemencie Configuration Properties/Linker/General modyfikując pole Additional
Library Directories przez dodanie wartości “C:/Program Files/MobileRobots/Aria/lib”.
Dodanie bibliotek odbywa się w elemencie Configuration Properties/Linker/Input. Biblioteki dodaje
się do wartości pola Additional Dependencies, należy tutaj dodać biblioteki AriaVC10.lib I
AriaDebugVC10.lib w zależności od wybranej konfiguracji.
Jednym z (uruchomienie Aria.lib w trybie DEBUG) objawów wykorzystania błędnej biblioteki jest
krytyczny błąd aplikacji podczas wywołania metody ArRobot::lock().
Należy także w elemencie Configuration Properties -> Debugging wprowadzić wartość Environment
wartość PATH=%PATH%;C:\Program Files\MobileRobots\Aria\bin .
6.3 Testowanie aplikacji Posiadając uzyskany adres IP rutera bezprzewodowego należy przetestować komunikacje z robotem
mobilnym w tym celu należy uruchomić przygotowany program z stosownymi parametrami.
W tym celu należy wybrać właściwości projektu i wybrać z listy Configuration element ‘All
configurations’. Następnie rozwinąć drzewo Configuration Properties i wybrać element Debugging i w
polu Command argument wprowadzić wartość ‘-rh XXX.XXX.XXX.XXX’ gdzie XXX.XXX.XXX.XXX oznacza
adres rutera bezprzewodowego lub robota.
Rys. 10 Konfiguracja uruchomienia aplikacji
14
6.4 Symulator robota Pakiet narzędziowy Aria wyposażony jest w symulator robota mobilnego MobileSim. Symulator ten z
powodzeniem symuluje zachowanie robota w statycznym środowisku laboratoryjnym. Jednak
środowisko to nie symuluje zderzaków robota, ani innych sensorów za wyjątkiem sonarów. Częstą
sytuacją jest także błędne zachowanie robota w symulatorze.
Rys. 11 Uruchomienie symulatora MobileSim
Symulator dostarcza dwie wbudowane mapy pomieszczeń: AMROffice.map i Columbia.map.
Dodatkowa aplikacja Mapper3 umożliwia samodzielne tworzenie map, dla które mogą zostać
wykorzystane przez symulator.
Rys. 12 Mapper3
W celu utworzenia nowej mapy należy z menu File wybrać element New. Tworzenie mapy odbywa
się przez rysowanie elementów w postaci linii lub prostokątów, które służą do określenia przeszkód
dla robota. W celu narysowania linii należy wybrać ikonę Forbidden Line i kursorem myszy zaznaczyć
15
miejsce, w którym ma znajdować się dana przeszkoda. W analogiczny sposób tworzy się prostokątne
przeszkody wybierając ikonę Forbidden Area. Przeszkody na mapie można tworzyć także przez
wykorzystanie narzędzia Line. Opcjonalnie możliwe jest także umieszczenie punktu startowego
robota przez wybranie elementu Dock Point. Usuwanie elementów odbywa się przez wybranie
elementu wykorzystując narzędzia Select i wciśnięcie przycisku Del. Innymi tworzonymi elementami
są linie symbolizujące przeszkody na scenie. Do usunięcia linii z mapy wykorzystywanie jest narzędzie
Erese.
Uwaga symulator robota nie jest w stanie precyzyjnie odwzorować zachowania prawdziwego robota,
ponadto w niektórych sytuacjach bezpośredniego sterowania robotem symulator może dawać wręcz
błędne wyniki – z tego powodu zaleca się testowanie programów na robocie.
7 Przykłady Przedstawione poniżej przykłady prezentują metodę inicjalizacji robota, w trybie sterowania
bezpośredniego i pośredniego. Biblioteka Aria posiada bardzo dobra dokumentacje oraz zbiór
przykładów, który w doskonały sposób prezentują wykorzystanie biblioteki, z tego powodu w tym
punkcji przedstawione zostaną trzy najprostsze przykłady wykorzystania biblioteki Aria do sterowania
robotem.
7.1 Sterowanie bezpośrednie Szablon sterowania robotem mobilnym przy wykorzystaniu automatów skończonych lub przy
wykorzystaniu bezpośrednich metod sterowania robotem.
#include <cstdlib>
#include <Aria.h>
int main(int argc, char **argv)
{
// Inicjalizacja biblioteki
Aria::init();
// formatowanie parametrów programu
ArArgumentParser parser(&argc, argv);
parser.loadDefaultArguments();
// Sprawdzenie czy przekazano prawidłowe argumenty do programu
if (!Aria::parseArgs() || !parser.checkHelpAndWarnUnparsed())
{
Aria::logOptions();
Aria::exit(1);
return 1;
}
// Robot
ArRobot robot;
// Obiekt sterujący połączeniem z robotem
ArRobotConnector robotConnector(&parser, &robot);
if(!robotConnector.connectRobot())
{
ArLog::log(ArLog::Terse, "Bład połączenia z robotem.");
16
Aria::exit(1);
}
// uruchom wątek robota
robot.runAsync(true);
ArUtil::sleep(1000);
// uruchomienie silników
robot.lock();
robot.comInt(ArCommands::ENABLE, 1);
robot.unlock();
// Kod sterowania robotem
//
//
//
// poczekaj na watek robota
robot.waitForRunExit();
ArLog::log(ArLog::Normal, "Połączenie z robotem się powiodło.");
Aria::exit(0);
return 0;
}
7.2 Sterowanie pośrednie przy wykorzystaniu akcji Sterowanie robota przy wykorzystaniu akcji odbywa się przez utworzenie klasy, której rodzicem są
klasy: ArMode, ArAction, ArActionGroup. Klasy te służą do określenia jak robot zachowywać się
będzie w zależności od występujących sytuacji zewnętrznych.
Klasa ArAction reprezentuje pojedynczą akcję, którą zostaje podjęta w wyniku wystąpienia jakiejś
sytuacji. Implementacja klasy pochodnej powinna zawierać metodę ArAction::fire. Metoda ta
w parametrze przyjmuje informacje o tym co robot będzie wykonywał w danej jednostce czasu.
Zwracany obiekt określa jaka akcja będzie wykonywana. Zwrócenie wartości NULL jest równoznaczne
z brakiem chęci modyfikacji poprzedniej akcji. Kolejność w jakiej uruchamiane są metody fire zależy
od nadanego jej priorytetu. Ponadto biblioteka oferuje wiele gotowych akcji np. ActionGoto,
ArActionTurn, ArActionAvoidFront, ArActionAvoidSide, ArActionBumpers, ArActionColorFollow,
ArActionConstantVelocity, ArActionDeceleratingLimiter, ArActionDriveDistance, ArActionGoto,
ArActionGotoStraight, ArActionInput, ArActionIRs, ArActionJoydrive, ArActionKeydrive,
ArActionLimiterBackwards, ArActionLimiterForwards, ArActionLimiterTableSensor,
ArActionMovementParameters, ArActionRatioInput, ArActionRobotJoydrive, ArActionStallRecover,
ArActionStop, ArActionTriangleDriveTo, ArActionTurn, Chase i JoydriveAction.
Przykład wykorzystania akcji:
#include <Aria.h>
class ActionGoForward : public ArAction
17
{
public:
ActionGo(double maxSpeed, double distance) {
this->myMaxSpeed = maxSpeed;
this->myStopDistance = distance;
this->mySonar = nullptr;
setNextArgument(ArArg("maximum speed", &myMaxSpeed, "Maximum speed to go."));
setNextArgument(ArArg("stop distance", &myStopDistance, "Stop Distance. "));
}
virtual ArActionDesired *fire(ArActionDesired currentDesired) {
double range;
double speed;
myDesired.reset();
if (mySonar == NULL)
{
deactivate();
return NULL;
}
range = mySonar->currentReadingPolar(-70, 70) - myRobot->getRobotRadius();
if (range > myStopDistance)
{
speed = range * .3;
if (speed > myMaxSpeed)
{
speed = myMaxSpeed;
}
myDesired.setVel(speed);
} else {
myDesired.setVel(0);
}
return &myDesired;
}
virtual void setRobot(ArRobot *robot) {
ArAction::setRobot(robot);
mySonar = robot->findRangeDevice("sonar");
if (robot == NULL)
{
ArLog::log(ArLog::Terse, "No sonar found, deactivating.");
deactivate();
}
}
protected:
ArRangeDevice *mySonar;
ArActionDesired myDesired;
double myMaxSpeed;
double myStopDistance;
};
18
int main(int argc, char** argv)
{
Aria::init();
ArSimpleConnector conn(&argc, argv);
ArRobot robot;
ArSonarDevice sonar;
ActionGoForward goForward(500, 350);
if(!Aria::parseArgs())
{
Aria::logOptions();
return 1;
}
if(!conn.connectRobot(&robot))
{
ArLog::log(ArLog::Terse, "Could not connect to robot! Exiting.");
return 2;
}
robot.addRangeDevice(&sonar);
robot.addAction(&goForward, 50);
robot.enableMotors();
robot.run(true);
Aria::exit(0);
}
Klasa ArMode służy do reprezentowania tybu pracy robota. Tryb pracy robota zwykle określą się
przez instancje klasy ArActionGroup, która reprezentuje zbiór akcji. Zbiór ten z kolei reprezentuje
zachowanie robota przypisane danemu trybowi.
Przykład wykorzystania ArActionGroup:
#include <Aria.h>
ArActionGroup *teleop;
ArActionGroup *wander;
void teleopMode(void)
{
teleop->activateExclusive();
printf("\n== Teleoperation Mode ==\n");
printf(" Use the arrow keys to drive, and the spacebar to stop.\n For
joystick control hold the trigger button.\n Press 'w' to switch to wander mode.\n
Press escape to exit.\n");
}
void wanderMode(void)
19
{
wander->activateExclusive();
printf("\n== Wander Mode ==\n");
printf(" The robot will now just wander around avoiding things.\n Press
't' to switch to teleop mode.\n Press escape to exit.\n");
}
int main(int argc, char** argv)
{
Aria::init();
ArArgumentParser argParser(&argc, argv);
ArSimpleConnector con(&argParser);
ArRobot robot;
ArSonarDevice sonar;
argParser.loadDefaultArguments();
if(!Aria::parseArgs() || !argParser.checkHelpAndWarnUnparsed())
{
Aria::logOptions();
return 1;
}
teleop = new ArActionGroup(&robot);
teleop->addAction(new ArActionLimiterTableSensor, 100);
teleop->addAction(new ArActionLimiterForwards("speed limiter near",
300, 600, 250), 95);
teleop->addAction(new ArActionLimiterForwards("speed limiter far",
300, 1100, 400), 90);
teleop->addAction(new ArActionLimiterBackwards, 85);
ArActionJoydrive joydriveAct("joydrive", 400, 15);
teleop->addAction(&joydriveAct, 50);
teleop->addAction(new ArActionKeydrive, 45);
wander = new ArActionGroup(&robot);
wander->addAction(new ArActionStallRecover, 100);
wander->addAction(new ArActionBumpers, 75);
wander->addAction(new ArActionAvoidFront("Avoid Front Near", 225, 0), 50);
wander->addAction(new ArActionAvoidFront, 45);
wander->addAction(new ArActionConstantVelocity("Constant Velocity", 400), 25);
20
ArKeyHandler *keyHandler = Aria::getKeyHandler();
if (keyHandler == NULL)
{
keyHandler = new ArKeyHandler;
Aria::setKeyHandler(keyHandler);
robot.attachKeyHandler(keyHandler);
}
ArGlobalFunctor teleopCB(&teleopMode);
ArGlobalFunctor wanderCB(&wanderMode);
keyHandler->addKeyHandler('w', &wanderCB);
keyHandler->addKeyHandler('W', &wanderCB);
keyHandler->addKeyHandler('t', &teleopCB);
keyHandler->addKeyHandler('T', &teleopCB);
if (!joydriveAct.joystickInited())
printf("Note: Do not have a joystick, only the arrow keys on the keyboard
will work.\n");
joydriveAct.setStopIfNoButtonPressed(false);
robot.addRangeDevice(&sonar);
if(!con.connectRobot(&robot))
{
ArLog::log(ArLog::Terse, "Could not connect to the robot.");
Aria::exit(1);
}
robot.enableMotors();
teleopMode();
robot.run(true);
Aria::exit(0);
}
8 Zadania do wykonania Z wykonywanych zadań laboratoryjnych należy przygotować sprawozdanie. Sprawozdanie powinno
zawierać kody źródłowe wykonanych na laboratorium programów wraz z stosownym opisem, oraz
zrzuty ekranu zawierające przygotowane środowisko symulacyjne.
1. Uruchom aplikację MobileSim i zaprojektuj środowisko laboratoryjne.
2. Znajdź w dokumentacji biblioteki ARIA metody wymienione w rozdziale 4.
3. Napisz program umożliwiający robotowi jazdę do przodu.
4. Uruchom aplikację MobileSim i podłącz się do symulowanego robota wykorzystując projekt
program z punktu drugiego.
5. Zmodyfikuj projekt tak, aby zaprezentować sterowanie robotem wykorzystując bezpośrednie
metody sterowania (losowe obroty, jazda do przodu i do tylu).
6. Pobierz adres robota w lokalnej sieci komputerowej i uruchom na nim projekt z punktu
drugiego.
21
7. Zmodyfikuj projekt tak, aby na ekranie pojawiała się informacja o stanie zderzaków robota,
wytestuj działanie programu na fizycznym robocie oraz na symulatorze.
8. Zmodyfikuj projekt tak, aby na ekranie pojawiała się informacja o stanie sonarów robota,
wytestuj działanie programu na fizycznym robocie oraz na symulatorze.
9. Popraw projekt tak, aby robot unikał zderzeń z przeszkodami, gdy kolizja jest nie unikniona
(przeszkoda w odległości 30 cm) robot powinien się zatrzymać.
10. Zmodyfikuj projekt tak, aby robot łagodnie wytracił prędkość przed przeszkodą i zatrzymał się
5 centymetrów przed nią (wykorzystaj kod dostarczonych regulatorów).
11. Zmodyfikuj projekt tak, aby robot sterowany był przez automat skończony zgodny z
automatem opisanym w rozdziale 5.2.
12. Zrealizuj zadanie z punktu piątego wykorzystując klasę ArAction.
13. Zmodyfikuj kod projektu tak, aby robot obracał się w kierunku najbliższej przeszkody.
9 Dodatki
9.1 Wymagane oprogramowanie Oprogramowanie wymagane:
Aria http://robots.mobilerobots.com/wiki/ARIA
MobileSim
Visual Studio 2010 Express
9.2 Literatura 1. http://robots.mobilerobots.com/wiki/ARIA
2. http://ctms.engin.umich.edu/CTMS/index.php?example=Introduction§ion=ControlPID