Laboratorium Podstawy Robotyki

Programowanie robota mobilnego B-14

Opracował: dr inż. Andrzej Chmielniak

Wprowadzenie

Cechy robota mobilnego:

- możliwość ruchu (układ jezdny),

- możliwość rozpoznawania otoczenia (układy sensoryczne),

- autonomia działania (komputer, źródło zasilania),

- możliwość wykonywania czynności w otoczeniu

Ogólny podział robotów mobilnych (sposoby poruszania się):

- kołowe,

- kroczące,

- latające,

- pływające.

Zastosowania robotów mobilnych:

- transportowe (drogi, fabryki, magazyny, szpitale),

- inspekcyjne (miejsca trudno dostępne, niebezpieczne),

- usługowe (odkurzanie, sprzątanie, koszenie),

- informacyjne (przewodnik po muzeum),

- policyjne (rozbrajanie bomb, akcje przeciw terrorystom),

- wojskowe (rakiety, torpedy, wozy patrolowe, usuwanie min),

- rozrywkowe (zabawki, grające w piłkę, filmowe),

- naukowo-badawcze,

- inne.

Budowa robota mobilnego

Korpus robota

Wymagane cechy: lekkość, wytrzymałość mechaniczna, estetyka.

Napęd

Wymogi: odpowiednia moc przy małej masie

- silniki el.: prądu stałego, direct drive, krokowe,

- układy przenoszenia napędu: przekł. zębate, łańcuchowe, paski zębate, ...

- układy napędowe: różnicowe, synchroniczne i inne.

Zasilanie

Zapewnienie odpowiedniej mocy w określonym czasie pracy przy jak najmniejszej masie i maksymalnej niezależności od urządzeń stacjonarnych. Sposoby zasilania robota w energię elektryczną: autonomiczne (akumulatory) i zewnętrzne (kabel).

Czujniki

Układy czujników w robotach mobilnych służą do:

samolokalizacji:

- odometryczne (zliczanie obrotów kół)

- giroskopy, kompasy,

- bezwładnościowe (pomiar przyspieszeń),

- namiarowe (radiowe, GPS, optyczne);

rozpoznawania otoczenia:

- dotykowe (zderzaki, czułki, czujniki siły),

- zbliżeniowe pracujące w podczerwieni,

- ultradźwiękowe (sonary),

- radarowe,

- laserowe,

- wizyjne (kamery pojedyncze i stereowizyjne),

- specjalistyczne (temperatura, promieniowanie);

inne:

- np. pomiar stanu naładowania akumulatora,

Pokładowe systemy sterowania

System sterowania robota odpowiada za przetwarzanie informacji i współpracę z urządzeniami zewnętrznymi.

Zadania dla systemu sterowania:

- pobieranie i przetwarzanie danych z czujników,

- gromadzenie informacji,

- podejmowanie decyzji odnośnie działań,

- sterowanie urządzeniami wykonawczymi,

- współpraca z innymi urządzeniami i z operatorem;

- podział zadań dla systemu pokładowego i stacjonarnego,

- realizacje (mikrokontroler, komputer, kilka komputerów),

- wymiana danych z czujnikami - układy sprzęgające,

- wymiana danych z otoczeniem - RS-232 , Ethernet, inne

- system operacyjny - działający w czasie rzeczywistym;

Wyposażenie dodatkowe

Poza funkcjami lokomocyjnymi roboty mogą wykonywać inne zadania przy pomocy różnych urządzeń takich, jak:

- uchwyty, manipulatory,

- platformy,

- urządzenia usługowe: malarskie, kosiarki, odkurzacze, ...;

- urządzenia do rażenia wroga: broń palna, paralizatory.

Nawigacja robota mobilnego

1. Gdzie jestem?

- samolokalizacja (zliczeniowa i namiarowa)

- korekcja samolokalizacji:

2. Gdzie mam się udać?

- mapy obszaru działania (informacje o obszarach, po których robot może się poruszać oraz o celu):

- tworzenie mapy: gromadzenie danych z czujników, agregacja informacji z kilku systemów sensorycznych;

3. Jak tam dotrzeć?

- planowanie ścieżki bezkolizyjnej do celu.

Robot mobilny B-14

Budowa robota B-14

Korpus: 2-częściowy cylindryczny.

Napęd: 3-kołowy synchroniczny, silniki prądu stałego, przeniesienie napędu paskami zębatymi.

Zasilanie: 2 akumulatory 12V lub kabel z zasilacza.

Czujniki: 16 sonarów, 16 czujników zbliżeniowych na podczerwień (IR), 16 + 6 czujników dotykowych (mikrowyłączniki), kamera cyfrowa, 4 definiowalne przyciski.

Wyposażenie dodatkowe: syntezator mowy.

Komputer pokładowy: PC z Pentium Pro 200, system operacyjny Linux.

Producent robota dostarczył specjalny software, aby można było pod kontrolą systemu operacyjnego Linux zasymulować działanie systemu czasu rzeczywistego, tzn. aby istniała możliwość wykonywania funkcji w ściśle określonych odstępach czasu lub w odpowiedzi na tzw zdarzenia zewnętrzne.

Programowanie robota B-14:

Schemat programu sterującego

Rys. 1. Schemat programu sterującego robotem

Zadanie:

Zaprojektować funkcję sterującą realizującą podane na zajęciach zadanie (wyróżnione bloki funkcjonalne na rys. 1.)

Należy złożyć nie więcej, niż 3 części projektu:

1. Plik glob.c z deklaracjami zmiennych globalnych (jeśli są potrzebne)

2. Plik init.c z inicjowaniem zmiennych globalnych i ewentualną współpracą z operatorem (nie jest to konieczne)

3. Plik funkc.c z funkcją sterującą.

W komentarzach w każdym pliku należy umieścić imiona i nazwiska wszystkich członków grupy wykonującej ćwiczenie.

Uwagi:

1. Czas wykonywania każdej komendy robota jest pomijalnie mały. Programista musi zatroszczyć się o sprawdzenie, czy robot już wykonał zadanie, niekiedy także, czy rozpoczął wykonywanie zadania.

2. Funkcję tak należy zaprojektować, aby poprawnie pracowała podczas wywoływania (za pomocą zewnętrznego modułu przydzielania czasu procesora - nie programować!) co 250ms.

3. Nie wolno w funkcji sterującej zawieszać procesu ani wykonywać jakichkolwiek operacji, które mogą skutkować zawieszeniem funkcji (pętle nieskończone itp.). Nie wolno używać w funkcji żadnych pętli, których warunkiem zakończenia jest zmiana parametrów ruchu robota bądź jego czujników.

4. Nie wolno korzystać z funkcji powodujących zwłokę w wykonywaniu programu (np delay(), sleep() itp.). Jeśli konieczna jest zwłoka, należy zliczać wejścia w funkcję sterującą.

5. Prędkość (liniowa i kątowa) zaczyna być większa od zera po jakimś czasie od wywołania komendy ruchu. Należy zatem kontrolować prędkość dopiero po pewnym oddaleniu od punktu zmiany ruchu.

6. Wydanie komend rotateHalt() lub translateHalt() nie powoduje natychmiastowego stopu. Zwłoka zależy od prędkości.

7. Należy dokładnie skomentować to, co zostało zrobione. Dobry komentarz pozwoli prowadzącemu skutecznie poprawić błędy.

8. Nie chodzi o to, by program od razu był bezbłędny. Należy wykazać się inwencją w wykrywaniu odpowiednich zdarzeń: zmniejszeniu odległości od przeszkody poniżej zadanej, zwiększeniu odległości (liniowej lub kątowej) powyżej zadanej, zmianie prędkości obrotowej (kątowej) lub liniowej po wykonaniu fragmentu ścieżki.

9. Bardziej złożony program, niż zaproponowane wcześniej, będzie wyżej oceniany.

10. Komentarze w języku C piszemy następująco:

// Po dwóch slashach - komentarz jednowieroszowy

/* pomiędzy zestawami slash-gwiazdka - gwiazdka-slash komentarz blokowy */

Projekt należy złożyć KONIECZNIE w wersji elektronicznej (nie dotyczy ew. rysunku algorytmu) jako pliki tekstowe z nazwami wymienionymi wcześniej. Termin: 48 godzin przed rozpoczęciem laboratorium. Programy można oddawać osobiście (SL204 - u prowadzącego, sekretariat) lub pocztą elektroniczną pod adres [e-mail]. Zaliczenie na podstawie programu. Obecność obowiązkowa.

Rys.2. Schemat numeracji sonarów i czujników IR na robocie.

Najważniejsze komendy sterujące robotem B-14:

(są to deklaracje nagłówków funkcji języka C, float, int, void - określają typ zwracanej przez funkcję wartości)

Odometria (funkcje zwracają wartości zmniennoprzecinkowe - float):

float bGetRotVel();

Zwraca prędkość obrotową robota w rad/s (+ w prawo, - w lewo).

float bGetTransVel();

Zwraca prędkość liniową robota w cm/s (+ w przód, - w tył).

float bRobotHeading(0);

Parametr zawsze 0, funkcja zwraca kąt robota w radianach; położenie początkowe robota: π/2.

float bRobotX(0); float bRobotY(0);

Parametry zawsze 0, funkcje zwracają położenie robota w nieruchomym układzie X,Y; jednostka: cm.

Uwaga: przy korzystaniu z tych funkcji należy na początku działania programu (przed rozpoczęciem ruchu robota) odczytać i zapamiętać początkowe wartości, które następnie należy odejmować od bieżących. Wartości początkowe są niezerowe.

Obrót (funkcje nie zwracają żadnej wartości - void):

void setRotateVelocity(unsigned long predkosc_obr);

Ustawia nową prędkość obrotową robota na podaną w jednostkach wewnętrznych na sekundę. Jednostki wewnętrzne: 1024 jednostki = 360º.

void rotateHalt();

Zatrzymuje obrót.

void rotateRelativeNeg(unsigned long kat);

void rotateRelativePos(unsigned long kat);

Obrót robota o zadany kąt w lewo (Neg) lub w prawo (Pos). Jednostka kąta: wewnętrzna jednostka robota, 1024 jednostki wewnętrzne = 360º. Prędkość zadana wcześniej.

void rotateVelocityNeg(void);

void rotateVelocityPos(void);

Rozpoczęcie obrotu robota w lewo (Neg) lub w prawo (Pos).

Przemieszczenie (funkcje nie zwracają żadnej wartości - void):

void setTranslateVelocity(unsigned long predkosc_lin);

Ustawia nową prędkość liniową robota na podaną w mm/s.

void translateHalt();

Zatrzymuje przemieszczanie.

void translateRelativeNeg(unsigned long dystans);

void translateRelativePos(unsigned long dystans);

Przemieszczenie robota o zadany dystans w przód (Pos) lub w tył (Neg). Odległość podana w mm. Prędkość zadana wcześniej.

void translateVelocityNeg(void); void translateVelocityPos(void);

Rozpoczęcie przemieszczania robota z zadaną prędkością w przód (Pos). lub w tył (Neg).

Dostęp do czujników (przez zmienne globalne - tablice, wartości tablic typu int - całkowitoliczbowe):

int sonarValue[16];

Odległości w milimetrach środka robota od przeszkody dla sonarów 0..15. Numeracja sonarów: 0 z tyłu, następnie zgodnie ze wskazówkami zegara, przód robota dokładnie pomiędzy 7 i 8, 15 z tyłu (wg rysunku 2.).

Uwaga! Zasięg czujników wynosi ok. 6m dla przeszkód dużych i odbijających dźwięk bez dużych strat (np. ściany). Przy przeszkodach małych lub dźwiękochłonnych zasięg maleje do ok. 3-4m. Przekroczenie zasięgu (sonar nie rejestruje echa) sygnalizowane jest skokowym pojawieniem się dużej wartości (ponad 10000mm). W praktyce w laboratorium odczyty wartości większych, niż 3000mm, traktuje się jako niepewne. Niektóre czujniki ultradźwiękowe są uszkodzone i stale podają małą wartość (rzędu 200-230mm) - należy je wykryć i ignorować ich wyniki. Odczyty z czujników bywają obarczone błędem (najczęściej wykrycie nieistniejących przeszkód lub wykrywanie wielokrotnie odbitego echa).

int IrValue[16];

Wartości od 0 do 100 określające procent energii fali odbitej od przeszkody dla czujników 0..15. Wartość 0 oznacza, że czujnik nie wykrył przeszkody. W praktyce odległość ok. 10cm od przeszkody daje w przybliżeniu wyniki w zakresie 60% i więcej, próg wykrywania (1%) pojawia się przy odległości ok. 40-80cm (dokładne wartości są uzależnione od rodzaju materiału i koloru przeszkody). Numeracja czujników IR - jak dla sonarów.

int tactileValue[2][8];

Wartości z czujników taktylnych: 0 - brak kontaktu, 1 - wykryto przeszkodę. 0..1 - rzędy, 0..7 - kolumny.

Uwaga. Wszystkie czujniki rozpoczynają prawidłową pracę po ok. 0.5s od uruchomienia programu. Jeżeli więc jest potrzeba skorzystania z czujników na początku, to należy przewidzieć 3 cykle jałowej pracy funkcji sterującej.

Synteza mowy

void sendSpeech(char * );

Syntezator mowy wypowie w języku angielskim tekst, wskazany jako parametr. Nie należy dopuścić do zbyt częstego wysyłania tekstu, ponieważ skutkuje to wypowiadaniem tylko tych komunikatów, które zostały zlecone w czasie, gdy syntezator mowy nie jest zajęty.

Sterowanie

void RaiShutdown(void);

Zakończenie pracy robota

// Laboratorium Robotyki Programowanie robota mobilnego B-14

// Dwa znaki // rozpoczynają komentarz - linia jest ignorowana do końca wiersza

// Przykład funkcji realizującej jazdę w przód i skręt

// ===================================================

// Zmienna zadeklarowana poza funkcją - globalna

int stan = 0;

// =====================================================

// Zawartość funkcji

// Pominięty nagłówek: void funkcja(void)

// deklaracja zmiennej typu rzeczywistego

float v;

switch ( stan ) // Instrukcja "wybierz" wg wartości zmiennej "stan"

{

case 0: // Stan 0: Inicjowanie jazdy w przód

setTranslateVelocity(100); // Ustawienie prędkości liniowej (robot stoi)

translateRelativePos(1000); // Zainicjowanie jazdy w przód (1000mm)

// Ruch postępowy odbywa się z zadaną wyżej prędkością liniową

stan = 1; // Przypisanie nowego stanu

break; // Koniec działań dla stanu 0

case 1: // Stan 1: Oczekiwanie na rozpędzenie w ruchu postępowym

v = bGetTransVel(); // Pobranie aktualnej prędkości ruchu postępowego

if ( (v > 0.01) || ( v < -0.01) ) // || - oznacza logiczne OR

// przyrównanie v do 0.0 dla „float” nie przynosi oczekiwanych efektów

stan = 2; // Zmiana stanu, gdy robot się rozpędził

break; // Koniec działań dla stanu 1

case 2: // Stan 2: Oczekiwanie na zahamowanie w ruchu postępowym

v = bGetTransVel();

if ( ( v < 0.001 ) && ( v > -0.001 ) ) // && - oznacza logiczne AND

stan = 3; // Zmiana stanu, gdy robot się zatrzymał

break; Koniec działań dla stanu 2

case 3: // Stan 3: Inicjowanie obrotu (zmiany orientacji)

setRotateVelocity(50); // Ustawienie prędkości kątowej

rotateRelativePos(256); // Zainicjowanie ruchu obrotowego - kąt 90 st.

// Ruch odbywa się „w prawo” z zadaną wyżej prędkością kątową

stan = 4;

break;

case 4: // Stan 4: Oczekiwanie na rozpędzenie ruchu obrotowego

v = bGetRotVel(); // Pobranie aktualnej prędkości ruchu obrotowego

if ( (v > 0.01) || ( v < -0.01) )

stan = 5; // Zmiana stanu, gdy robot rozpoczął wykonywanie obrotu

break;

case 5: // Stan 5: Oczekiwanie na zakończenie ruchu obrotowego

v = bGetRotVel();

if ( ( v < 0.01 ) && ( v > -0.01 ) )

stan = 6; // Zmiana stanu, gdy robot zakończył ruch obrotowy

break;

case 6: // Stan 6: Zakończenie pracy robota, jeśli wykryto obiekt za robotem

if ( IrValue[7] > 70 ) // Odwołanie do czujnika zbliżeniowego (podczerwień)

RaiShutdown(); // Zakończenie pracy programu

break;

}

// Koniec zawartości funkcji

//===============================

1

2

---