Witold Czajewski

Po uruchomieniu programu zobaczymy domyślną scenę zawierającą podstawowe obiekty takie jak podłoga, światła i kamera. W takim środowisku możemy umieścić i symulować naszego robota.

Prostego robota możemy stworzyć z podstawowych brył geometrycznych dostępnych z menu Add/Primitive Shape. Do zbudowania robota o napędzie różnicowym wystarczy podstawa robota w postaci płaskiego prostopadłościanu (Cuboid), dwa silniki (Joint/Revolute) i dwa koła (Cylinder). Zaczynamy od podstawy robota, dodając ją do sceny i ustawiając wymiary np. na 15×10 cm i grubość na 2,5 mm:

W związku z tym, że CoppeliaSim symuluje dynamiczne zachowanie obiektów, istotne może być podanie parametrów materiałów zbliżonych do rzeczywistości. Podczas tworzenia nowego obiektu, poza jego wymiarami, podajemy także ich ciężar właściwy. Domyślnie wynosi on 1000 kg/m3, jednak jeśli podstawa naszego robota miałaby być wykonana z blachy aluminiowej, to należy uwzględnić ciężar właściwy tego metalu wynoszący ok. 2700 kg/m3. Koła niewielkich robotów zwykle są wykonywane z plastiku z gumową oponą, jednak dla uproszczenia zamodelujemy je jako w całości wykonane z jednego materiału o domyślnej gęstości. Przyjmiemy parametry jak na rysunku (średnica 6 cm, grubość 5 mm):

Pozostaje dodanie silników. Faktycznie nie będziemy modelować silnika jako takiego, ale dodamy złącza obrotowe, których długość i średnicę ustalimy odpowiednio na 5 cm i 1 cm. W przeciwieństwie do innych obiektów geometrycznych, złącza obrotowe pojawią się z domyślnymi parametrami, które możemy zmienić po dwukrotnym kliknięciu na symbol złącza w drzewie obiektów symulacji:

Istotne jest, by zmienić właściwości dynamiczne tych silników, gdyż domyślnie złącza są swobodne, tymczasem my będziemy realizować sterowanie prędkościowe. Należy więc zmienić ich tryb (Control mode) na prędkościowy (Velocity), a docelową prędkość (Target velocity) ustawić na 0 (w przeciwnym razie silnik będzie się od razu obracał).

Powyższe okno dialogowe umożliwia ustawienie zaawansowanych parametrów silników, niemniej do podstawowej symulacji robota o napędzie różnicowym nie będzie to potrzebne.

Po utworzeniu wszystkich niezbędnych komponentów należy połączyć je ze sobą przeciągając odpowiednie obiekty w hierarchii na siebie. Nadrzędnym obiektem będzie podstawa robota, do niej będę podłączone silniki, a do każdego silnika – koło. Hierarchia obiektów powinna wyglądać następująco:

Warto w tym momencie zmienić domyślne nazwy komponentów robota na lepiej oddające ich charakter:

Pozostaje teraz odpowiednie ułożenie komponentów względem siebie, tak by zrobić z nich dwukołową platformę jeżdżącą. Na razie wszystkie elementy składowe robota znajdują „jeden na drugim” w początku układu współrzędnych. Aby je przesunąć bądź obrócić, należy kliknąć na ikonę danego obiektu w hierarchii lub na sam obiekt w oknie sceny (co może być kłopotliwe, gdy obiekty zachodzą na siebie), a następnie wybrać jedną z dwóch ikon na pasku narzędziowym:

W pierwszej kolejności należy rozsunąć silniki na boki (koła leżące niżej w hierarchii przesuną się razem z nimi), a następnie obrócić je o -90 stopni wokół osi X w lokalnym układzie współrzędnych (Own frame) jak na rysunku poniżej:

Ważne, by oba silniki obrócić w tę samą stronę – wówczas kierunek obrotów obu kół będzie jednakowy przy tym samym znaku zadanej prędkości obrotowej. Na bieżącym etapie komponenty robota powinny wyglądać jak na rysunku:

Wystarczy teraz przesunąć koła na końce silników, same silniki nasunąć na platformę i wszystko unieść nieznacznie nad powierzchnią podłogi. Przy przesuwaniu komponentów wygodnie jest poruszać nimi względem obiektu nadrzędnego, co znacznie ułatwia określenie współrzędnych dla obu silników – będą się one różnić jedynie znakiem przy współrzędnej Y.

Po odpowiednim ułożeniu wszystkich elementów powinniśmy otrzymać platformę zbliżoną do tej na poniższym rysunku:

Po uruchomieniu symulacji platforma opadnie, a jeśli nadamy jej silnikom dodatnią prędkość, zacznie poruszać się do przodu (w prawo, na poniższym rysunku). Jeśli platforma jedzie w przeciwną stronę, oznacza to, że albo silniki zostały obrócone w drugą stronę, albo zostały przesunięte ku przodowi, a nie tyłowi platformy. Należy wówczas poprawić orientację lub położenie silników i upewnić się, że prawy silnik znajduje się z prawej strony robota, a dodatnia prędkość powoduje jazdę robota do przodu – pozwoli to uniknąć późniejszych pomyłek w kodzie.

Tak skonstruowany robot będzie wprawdzie jeździł, ale warto dodać do niego przednie kółko podpierające, zwłaszcza jeśli w przyszłości będziemy chcieli umieścić jakieś czujniki z przodu robota. Kółko samonastawne najłatwiej wybrać z biblioteki gotowych elementów (Model browser/components/locomotion and propulsion):

Jest ono nieco za duże do naszego robota. Należy je odpowiednio przeskalować, klikając dwukrotnie w ikonę kółka (Caster) i wybierając przycisk Scaling z zakładki Common.

Zaznaczenie opcji In-place scaling oraz zastosowanie współczynnika skalowania 0,7 powinno dać odpowiedni rezultat. Pozostaje jedynie przesunięcie kółka nieco poniżej platformy i dołączenie go do hierarchii robota. Ostateczny efekt powinien wyglądać tak:

W symulatorze CoppeliaSim istnieje wiele metod sterowania obiektami i wpływania na przebieg symulacji, a najprostszą z nich jest skorzystanie ze skryptów języka Lua. Obsługa tych skryptów jest wbudowana w środowisko i nie wymaga żadnych zewnętrznych narzędzi, zaś sam język Lua jest prostym językiem obiektowym zbliżonym składniowo do języka Pascal. Opis interfejsu użytkownika w CoppeliaSim dla języka Lua można znaleźć pod adresem: https://coppeliarobotics.com/helpFiles/en/apiFunctions.htm

Do naszego robota dodajemy skrypt, klikając na ikonie robota prawym przyciskiem myszy:

Skrypt składa się z czterech funkcji, która są początkowo puste.

Funkcja sysCall_init() zostanie wywołana raz, zaraz po uruchomieniu symulacji. Funkcje sysCall_actuation() oraz sysCall_sensing() będą wywoływane cyklicznie i umożliwią odpowiednio sterowanie oraz odczyt czujników robota podczas symulacji. Funkcja sysCall_cleanup() jest uruchamiana raz, na końcu symulacji. Aby wysterować robota, wystarczy nadać jego silnikom prędkość obrotową. W tym celu należy utworzyć uchwyty do obiektów w funkcji sysCall_init(), a następnie wykorzystać je do nadania prędkości silnikom:

Po uruchomieniu symulacji, robot będzie poruszał się powoli po trajektorii prostoliniowej. Na zachowanie robota możemy wpływać zmieniając jego prędkość w cyklicznie wywoływanej funkcji sysCall_actuation(). Poniższy skrypt zmniejszy prędkość jednego z kół po 5 sekundach od rozpoczęcia symulacji, przez co robot zacznie jeździć w kółko. Po kolejnych 5 sekundach, koła robota będą się kręcić z tą samą prędkością, ale w przeciwnych kierunkach, w wyniku czego robot będzie obracał się w miejscu.

Wykorzystując liczniki czasu można łatwo napisać program, który będzie cykliczne zmieniał zachowanie robota. Przy odpowiednio dobranej długości cyklu i prędkości kół, można uzyskać na przykład trajektorię w kształcie ósemki.

Bardzo przydatną możliwością, łatwą do zrealizowania w symulacji, a znacznie trudniejszą w przypadku rzeczywistego robota, jest opcja rysowania jego trajektorii ruchu. Pozwala to na znacznie lepszą ocenę przebiegu drogi robota niż zwykła obserwacja robota w ruchu. Do rysowania trajektorii wykorzystujemy informację o rzeczywistym położeniu robota w symulowanym świecie. Ta informacja w przypadku robota rzeczywistego jest niedostępna, nie należy więc nadużywać możliwości odczytania faktycznej pozycji robota do jego sterowania, niemniej rysowanie śladu robota takim nadużyciem nie jest. Aby to zrobić w symulatorze, trzeba najpierw dodać uchwyt do robota w funkcji sysCall_init():

a następnie dokonać właściwego odczytu pozycji w funkcji sysCall_actuation():

Najprostsza metoda rysowania trajektorii zakłada wykorzystanie bufora, w którym przechowywane są kolejne współrzędne robota. Będą one następnie łączone linią. Ślad robota powinien zostać zainicjowany w funkcji sysCall_init() jak pokazano poniżej:

Będzie on rysowany za pomocą linii (drawing_linestrip) o rozmiarze 5, bez pomijania żadnych punktów (0), w globalnym układzie współrzędnych (-1). Bufor ma rozmiar tysiąca punktów, a linia będzie miała kolor niebieski ({0,0,1}). Powyższe polecenie niczego jeszcze nie rysuje, jedynie inicjuje obiekt do narysowania.

Kolejne punkty pozycji robota będą dodawane do jego trajektorii w funkcji sysCall_actuation() i automatycznie rysowane:

W efekcie, otrzymamy rysunek trajektorii robota:

Po dodaniu, w analogiczny sposób, linii dla kół otrzymamy:

Tak narysowany ślad robota będzie miał 1000 punktów i przestanie się rysować po około 50 sekundach (przy domyślnych ustawieniach symulatora). Nowe pozycje robota nie będą już rejestrowane i wizualizowane. Najprostszą radą jest zwiększenie liczby punktów, jednak może to spowodować, że rysunek śladu robota stanie się nieczytelny, gdyż nowe ślady będą się nakładać na stare. Poza tym, w przypadku długich symulacji, bufor pozycji robota musiałby być ogromny, co negatywnie odbiłoby się na wydajności symulatora. Jego twórcy przewidzieli jednak taką sytuację i umożliwiają wykorzystanie bufora cyklicznego, który po zapełnieniu będzie nadpisywał się od początku. W efekcie tego podejścia, ślad robota będzie się cały czas rysował, ale jego najstarsze punkty będą po jakimś czasie znikać. W ten sposób zawsze będziemy widzieć ostatnie n punktów trajektorii naszego robota, a wcześniejsze nie będą zaciemniać obrazu. Aby włączyć cykliczną wersję bufora punktów należy nieznacznie zmodyfikować polecenie tworzące ślad robota poprzez dodanie właściwości sim.drawing_cyclic:

Wyżej pokazany ślad robota rysuje się w miejscu, w którym znajduje się obiekt tworzący ślad. Jest to zazwyczaj środek geometryczny takiego obiektu, a więc ślad zostawiony przez koła będzie „unosił się” nad podłożem na wysokości osi koła. W przypadku dużych kół, ślad będzie dość daleko od podłoża, a nie w miejscu styku kół z podłożem, co jest intuicyjnie oczekiwane przez użytkownika. Podczas obserwacji pionowo z góry, nie będzie to miało większego znaczenia, ale jeśli kamera będzie ustawiona pod kątem, powstanie błąd paralaksy, który może być mylący. Aby ślad wyglądał naturalniej, należy zmienić jego współrzędną Z na niewiele powyżej zera (powyżej powierzchni podłoża). Można to zrobić modyfikując trzecią współrzędną odczytanej pozycji obiektu np. tak:

W ramach ćwiczenia należy zrealizować kolejno poniższe zagadnienia:

1. Zapoznać się z symulatorem, poznać jego interfejs, umieścić w przestrzeni roboczej kilka gotowych robotów i uruchomić symulację oraz obserwować roboty podczas jazdy.
2. Zbudować własnego robota o napędzie różnicowym.
3. Na podstawie przeprowadzonych eksperymentów wyznaczyć czas, w którym robot pokonuje zadaną odległość oraz obraca się w miejscu o zadany kąt i napisać dwie funkcje: jedna przemieszczająca robota o zadaną odległość, druga obracająca go o zadany kąt.
4. Wykorzystać funkcje z poprzedniego punktu do realizacji trajektorii o kształcie kwadratu.
5. Zwizualizować faktycznie zrealizowane trajektorie i określić błędy odometrii robota.

1. Jakie są zalety napędu różnicowego?

Napęd różnicowy jest prosty w sterowaniu, a robot może zmienić swą orientację w miejscu, co pozwala na realizację dowolnych trajektorii ruchu. Ponadto, roboty o napędzie różnicowym zbudowane na podstawie w kształcie koła są w stanie odwrócić się w miejscu także w wąskich przestrzeniach, dzięki czemu mogą z nich wyjechać bez problemu przodem, a nie tyłem, co może być istotne w przypadku, gdy jakiś czujnik (np. kamera) umieszczony jest wyłącznie na przodzie robota.

2. Jaki wpływ na trajektorię robota ma podpierające go trzecie koło samonastawne?

Koło samonastawne powoduje nieznaczną zmianę orientacji robota, zwłaszcza w przypadku wykonywania obrotu w miejscu o duży kąt lub zmiany kierunku jazdy o 180 stopni bez obracania się. Jest to szczególnie widoczne w tym ostatnim przypadku. Koło podpierające zmienia wówczas swą orientację o 180 stopni i w czasie przekręcania się wpływa na trajektorię robota.

3. Czy istnieją inne rozwiązania niemające wad koła samonastawnego?

Tak, istnieją. W przypadku małych i lekkich robotów koło samonastawne można zastąpić ślizgaczami albo kulką. Oba rozwiązania wymagają także, aby powierzchnia po której porusza się robot była równa i czysta, w przeciwnym razie ślizgacze będą zawadzały o nierówności, a kulka zatrze się w swoim uchwycie.

4. Co zrobić w symulatorze CoppeliaSim, aby rysowana trajektoria zawsze pokazywała ostatnie n punktów, a najstarsze punkty były kasowane?

Do funkcji tworzącej trajektorię należy dodać opcję sim.drawing_cyclic.

5. Czy w przypadku robota o dużych kołach, ich trajektoria utworzona w standardowy sposób będzie poprawna?

Taka trajektoria znajdzie się na wysokości osi kół, a więc ślad koła nie znajdzie się na podłożu, co jest intuicyjnie oczekiwane przez użytkownika. Podczas obserwacji z góry nie będzie to miało większego znaczenia, ale przy obserwacji pod kątem pojawi się błąd paralaksy. Będzie on tym większy im większe są koła. Aby uniknąć tego błędu, należy przypisać Z-owej współrzędnej śladu wartość niewiele większą od zera.

W ćwiczeniu wykorzystywany jest plik Cockroach.ttt. Plik ten stanowi symulacje˛ sześcionożnego robota mobilnego w pustym środowisku jak przedstawiono na poniższym rysunku

Na tym rysunku widzimy tył Karalucha co powoduje, iż jego prawa strona to również nasza prawa strona oraz lewa to lewa. Nogi Karalucha ponumerowane są od 1 do 6 gdzie noga pierwsza to prawy przód, druga – prawy środek, trzecia – prawy tył, czwarta – lewy przód, piąta – lewy środek i szósta – lewy tył. Elementy ruchome nóg nazywają się kolejno: LegXHipH, LegXHipV oraz LegXKnee, gdzie X to numer nogi. Trzy przeguby czyli trzy stopnie swobody w każdej nodze pozwalają na osiągnięcie przez końcówkę nogi dowolnego punktu w zakresie jej ruchu.

Projekt aplikacji znajdującej się w pliku Karaluch.zip to szablon programu służącego do zrealizowania zadań przypisanych do ćwiczenia. Na poniższym rysunku znajduje się diagram prezentujący budowę programu zaimplementowanego w aplikacji Karaluch.

Program na początku inicjuje zmienne robocze i wyświetla menu. Po zainicjowaniu wszystkich elementów przechodzimy do głównej pętli programu, która jest pętlą działającą w nieskończoność. Podstawową funkcjonalnością realizowaną w tej pętli jest odczyt klawiatury i realizacja czynności zdefiniowanych w menu po ich wybraniu przez użytkownika.

Nie można zapominać o sprawdzeniu dodatkowych parametrów i ustawień projektu aplikacji. Niewłaściwa definicja ustawień projektu aplikacji spowoduje wystąpienie błędów krytycznych i nie pozwoli na skompilowanie programu. Należy również pamiętać o tym, iż aplikacja musi być kompilowana i uruchamiana w trybie Release.

Symulacja z pliku CockroachSensors3.ttt