POLITECHNIKA RZESZOWSKA

Roboty Mobilne Sterowanie robotem Pioneer

Bogusław Rymut

2018-04-15

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&section=ControlPID