Važan dio priče o robotima je svakako i njihovo programiranje. Tako dugo dok neki AI sustav u potpunosti ne preuzme njihovim upravljanjem (kao što je to slučaj u filmu „Ja robot“ iz 2004. godine), robote moraju programirati ljudi, a za to su im potrebni odgovarajući razvojni alati.
Iako postoje i drugi specijalizirani alati za pojedine konfiguracije robota, jedan od najpopularnijih alata za takvu namjenu (i za istraživačku i za industrijsku primjenu) je ROS 2 (Robot Operating System 2) o kojem će više riječi biti u ovom tekstu. Prvo malo povijesti. Rad na ROS sustavu započeo je sad već davne 2007. godine na Sveučilištu Stanford, da bi prva službena verzija - s brojnim ograničenjima u odnosu na stvarne potrebe u razvoju robota - bila objavljena 2010. godine. Razvoj verzije 2.0 preuzela je organizacija Open Source Robotics Foundation (OSRF), danas poznatija kao Open Robotics u suradnji s brojnim partnerima širom svijeta. Prvo izdanje verzije 2 ugledalo je svjetlo dana 8. prosinca 2017. godine.
U nastavku teksta svako korištenje skraćenice ROS zapravo podrazumijeva ROS 2 zbog jednostavnijeg načina korištenja u različitim jezičnim konstrukcijama. Na kraju krajeva, službena podrška za stari sustav već je istekla 2025. godine. Razjasnimo u uvodu još jednu bitnu stvar. Tako da odmah odlučite je li uopće ovako nešto za vas ili nije. Ako o programiranju robota razmišljate na razini prisutnoj u brojnim uradcima znanstvene fantastike, počevši od svojevrsnog barda na ovom području (Isaac Asimov), onda ćete svakako doživjeti svojevrsno razočaranje kad počnete koristiti ROS.
Na trenutačnom stupnju razvoja robotske tehnologije u pogledu softvera još uvijek ne radite na implementaciji zakona robotike, eventualnim logičkim izuzecima tih zakona ni sprečavanju zaobilaženja zakona u „centralnom pozitronskom mozgu robota“, nego se bavite mnogo primitivnijim stvarima. Kao što je prijenos podataka od različitih senzora i drugih ulaznih uređaja poput kamere do centralne jedinice zadužene za njihovu interpretaciju. A nakon obrade, i izdavanjem naredbi različitim elektromotorima i drugim sličnim uređajima kako bi se robot uopće pokrenuo i odgovorio na situaciju iz okoline.
Budući da se robot može sastojati od velikog broja spomenutih uređaja, postupak programiranja sa ciljem njihovog usklađivanja u radu nije uopće trivijalan (upravo suprotno), a u velikoj većini slučajeva (za sada) još manje povezan s nekakvom „višom inteligencijom“.
Što je zapravo ROS?
Iako se u punom nazivu sustava spominje pojam „operativni sustav“, ROS zapravo nije operativni sustav u klasičnom smislu, kakav poznajemo na stolnim ili mobilnim računalima. ROS se prije svega može smatrati svojevrsnim „srednjim slojem“ (takozvani „middleware“) sastavljenim od čitavog niza alata, biblioteka i pravila za njihovo korištenje pomoću kojih se razvija softver za konkretnu hardversku konfiguraciju robota.
Neki od ključnih pojmova povezanih s programiranjem u ROS-u su:
Nodes (čvorovi)
Pojedinačni procesi za obavljanje točno određenih zadataka kao što su obrada podataka pristiglih s nekog posebnog senzora ili kamere, odnosno upravljanje izvođenjem pojedine operacije kao što je okretanje kotača.
Topics (kanali)
Da bi mogli normalno funkcionirati, čvorovi međusobno razmjenjuju poruke preko posebnih kanala. Pri tome se komunikacija porukama odvija asinkrono prema takozvanom publish/subscribe modelu. Način na koji putuju poruke po kanalima nije ograničen na samo dva čvora, nego ti odnosi mogu biti puno složeniji, kao što to pokazuju prateće slike uz tekst.
Messages (poruke)
Poruke koje putuju preko kanala nisu pripremljene u bilo kakvom slobodnom formatu, nego moraju imati točno definiranu strukturu koja se bilježi u .msg datotekama. Primjer dijela takve .msg datoteke naveden je u nastavku:
# RobotConfig.msg
# Opće postavkestring robot_namestring base_framestring odom_framestring map_frame
# Maksimalne brzinefloat32 max_linear_speed # m/sfloat32 max_angular_speed # rad/s...
ROS grafikoni prikazuju sve dijelove i komunikaciju između svih dijelova sustava
Services (servisi)
Osim pomoću kanala, komunikacija između čvorova može se također izvoditi korištenjem servisa. Postupak nalikuje dobro poznatoj request/response komunikaciji iz HTTP protokola.
Definicije servisa nalaze se u .srv datotekama. Primjer takve datoteke mogao bi biti:
# TestService.srv# Request partbool enablestring note---# Response partbool successstring message
Iako i kanali i servisi služe za međusobnu komunikaciju između čvorova, među njima ima bitnih razlika. Kanali se u pravilu koriste za kontinuirane tijekove podataka, kao što je neprekidno slanje podataka od senzora robota prema drugim čvorovima. Pri tome nije potrebno da se dobije odgovor čvora (ili više njih) kojem se šalju podaci. Servisi su namijenjeni za izvođenje brzih i kratkih zadataka na zahtjev, pri čemu klijent obično čeka da dobije odgovor poslužitelja.
Akcije (akcije)
Osim kanala i servisa, treći način komunikacije predstavljaju akcije. Akcije se koriste u slučajevima kad je potrebno obaviti dugotrajne složene zadatke kao što je kretanje robota od jedne do druge točke.
Najjednostavniji primjer .action datoteke je takozvana Fibonacci akcija:
# Fibonacci.action# Goal – što želimo da se dogodiint32 order---# Result – što smo dobili na krajuint32[] sequence---# Feedback – periodične informacije o napretkuint32[] partial_sequence
Navođenje dijela koji se sastoji od tri znaka minusa --- (kao i kod definiranja poruka, odnosno servisa) predstavlja važan dio sintakse, jer služi za međusobno odvajanje posebnih dijelova u datoteci.
Parameters (parametri)
Parametri predstavljaju posebne konfiguracijske vrijednosti različitih čvorova u robotskom sustavu. Svaki parametar sastoji se od naziva, vrijednosti parametra u nekom od dozvoljenih formata podataka te dodatnog opisa ili ograničenja. Primjer parametra je maksimalna brzina okretanja kotača.
ROS graph (grafikoni)
Predstavlja logički prikaz svih čvorova sustava i njihovih međusobnih veza (kanali, servisi i akcije). Pomoću ovakvog grafikona može se jednostavnije razumjeti kako funkcionira cjelokupni sustav. Ako ste upoznati s tehnologijom baza podataka, ovo predstavlja svojevrsni ekvivalent dijagramu baze podataka (pregled tablica u bazi i njihovih međusobnih veza). Pomoću ROS grafikona možete lako uočiti ne šaljete li između čvorova nekakve poruke koje odredišni čvor ne može ni razumjeti niti obraditi.
Osim navedenih ključnih pojmova, ROS uključuje čitav niz dodatnih razvojnih alata, simulatora, paketa i svega ostalog potrebnog za razvoj sustava.
Čvorovi i kanali: Osnovni oblik komunikacije u ROS modelu
Kanali i servisi: Razlike u funkcioniranju u ROS modelu
Akcije: Namijenjene su za izvođenje dugotrajnih operacija
Podržani operativni sustavi i programski jezici
Primarni operativni sustav povezan s ROS-om je Linux - posebno Ubuntu distribucija. U praksi se često koristi i Debian, dok se na ostalim distribucijama Linuxa (ako to baš zatreba) može krenuti s pripremom ROS sustava od prevođenja njegovog izvornog koda.
ROS se može normalno koristiti i na Windowsima (minimum 10), ali je instalacija kompliciranija nego na Linuxu, jer je potrebno pojedinačno instalirati dosta dodatnih komponenti i provjeriti/podesiti da to sve skupa radi u harmoniji.
Što se tiče Appleovog macOS-a, teoretski postoji podrška za ROS, ali ovdje treba krenuti od prevođenja izvornog koda. Tako da je podrška trenutačno više u statusu eksperimentalne. Drugim riječima, ako imate mogućnost izbora, izbjegavajte macOS za ovu namjenu.
Budući da je u konačnici ROS planiran za industrijsku primjenu, podržani su također specijalizirani operativni sustavi kao što su QNX, VxWorks (oba se najčešće koriste u automobilskoj i zrakoplovnoj industriji, medicini i vojnim primjenama) ili FreeRTOS. Ne treba zaboraviti ni mogućnost korištenja na Arduino pločama i sličnim kontrolerima.
U popis podržanih operativnih sustava uključen je i Android. Budući da ćemo se u nastavku teksta vraćati na Linux i Windowse, na ovom mjestu ćemo se malo detaljnije osvrnuti upravo na korištenje ROS u kombinaciji s Androidom. Uz pomoć posebnog rješenja pod nazivom rosjava (https://github.com/rosjava) moguće je u ROS mrežu uključiti Android uređaje.
Linux Ubuntu: Instalacija osnovnih komponenti sustava poput Pythona
Takva mogućnost je zapravo genijalno dobra. Kad se u obzir uzme današnja ogromna procesorska snaga i kapacitet memorije Android uređaja te opremljenost brojnim hardverskim dodacima kao što su kamera, mikrofon, zvučnik, GPS, žiroskop, akcelerometar i ostalo, u malom pakiranju dobije se nešto za što bi inače trebalo uložiti puno truda, vremena i financijskih sredstava da bi se jednake mogućnosti ugradile u robota uz pomoć pojedinačnih komponenti. Naravno, ne treba zaboraviti ni vrlo bitnu mogućnost izravne veze Android uređaja na Internet preko mobilne mreže, kao ni vrlo kvalitetne ekrane kao sastavne dijelove uređaja.
Zbog toga se Android uređaji mogu koristiti u ROS mreži na više načina (pojedinačno ili kombinirano):
- već spomenuta mogućnost upotrebe ugrađenih senzora i ostalog hardvera na različite načine
- vizualizacija različitih podataka o stanju robota na ekranu Android uređaja
- mogućnost daljinskog praćenja i upravljanja robotom
Repozitorij primjera: Preuzimanje programskog koda nakon instalacije osnovnih alata
U pogledu korištenja programskih jezika u kombinaciji s ROS-om, dva najčešća izbora u praksi su C++ i Python. C++ je prvi izbor kad su u pogledu performanse, a Python (zbog jednostavnosti) kad na robotima radi ekipa bez profesionalnih programera u timu. ROS se može koristiti u kombinaciji s drugim programskim jezicima kao što su Rust, Go, Java, ali često je ta podrška više na eksperimentalnoj razini.
Osvrnimo se dodatno na problematiku korištenja Pythona u ROS projektima. Riječ je o jeziku kojeg danas poznaju (bar na nekakvoj početničkoj/srednjoj razini) brojni „neprogrameri“, ali istovremeno vrhunski stručnjaci u svojem području. Zbog čega je uostalom Python postao tako popularan. Istovremeno se Python obično omalovažava kao izuzetno spor jezik zbog čega se često zapravo ne može ozbiljno koristiti u profesionalnim ili komercijalnim projektima. Što je potpuno točno na područjima gdje treba izvesti milijune operacija nad brojčanim podacima ili bazom podataka u što kraćem vremenu. U takvim slučajevima, neki drugi jezici su apsolutni pobjednici i bolji izbor.
Međutim, u pogledu korištenja Pythona u robotici to ne mora biti uvijek baš tako. U ovom slučaju brze softverske komponente (da, tu se sad ubraja i Python) rade neusporedivo brže od sporog hardvera. Tu ne mislimo na procesore, nego na elektromotore i druge slične komponente. Na primjer, vrijeme koje je potrebno da se u Pythonu „proračuna“ sve što je potrebno za pokretanje robotske ruke od položaja A do položaja B, neusporedivo je kraće od samog izvođenja pokreta te iste ruke.
Priprema za korištenje
Instalacija svih potrebnih softverskih komponenti na računalo, nažalost, baš i nije trivijalna operacija, kao što je to slučaj kod brojnih drugih softverskih alata i aplikacija. Izvodi se u čitavom nizu koraka, gdje jedna greška u nekom koraku može dovesti do nepredviđenih i nepremostivih problema u nastavku. Zato priprema računala za korištenje s ROS-om nije nešto što ćete napraviti „onako usput da bi nešto malo probali“, nego je riječ o zadatku koji morate izvesti vrlo oprezno i koncentrirano da bi sve skupa postalo upotrebljivo. Osim samih alata potrebnih za razvoj, u pravilu treba instalirati različite dodatne biblioteke koda, ali i primjere da biste mogli analizirati kako je nešto napravljeno, odnosno kako se koristi.
U Linux okruženju za instalaciju morate izvesti čitav niz naredbi kao što su (naveden je samo dio):
sudo apt update && sudo apt install -y \
python3-flake8-docstrings \
python3-pip \
python3-pytest-cov \
ros-dev-tools
sudo apt install -y \
python3-flake8-blind-except \
python3-flake8-builtins \
python3-flake8-class-newline \
python3-flake8-comprehensions \
python3-flake8-deprecated \
python3-flake8-import-order \
python3-flake8-quotes \
python3-pytest-repeat \
python3-pytest-rerunfailures
mkdir -p ~/ros2_humble/src
cd ~/ros2_humble
vcs import --input https://raw.githubusercontent.com/ros2/ros2/humble/ros2.repos src
Kako izgleda takva instalacija možete vidjeti na pratećim slikama uz tekst.
Na Windowsima je situacija još gora. Trebate instalirati sve alate sa sljedećeg popisa i na kraju podesiti sve potrebne parametre za međusobnu suradnju alata.
Installing prerequisites
Install Chocolatey
Install Python
Install Visual C++ Redistributables
Install OpenSSL
Install Visual Studio
Install OpenCV
Install dependencies
Install Qt5
RQt dependencies
Downloading ROS 2
Install additional DDS implementations (optional)
Environment setup
Opis oba postupka daleko premašuje okvire nekakvog početnog teksta o predstavljanju ROS-a u časopisu. Sve potrebne detalje o instalaciji možete pronaći na web adresi https://docs.ros.org/en/humble/Installation.html. Ali se kod provođenja same instalacije svakako naoružajte dobrim strpljenjem.
Kao kontrola da je sve skupa prošlo dobro može poslužiti istovremeno pokretanje dva modula (objašnjeno u istim uputama) pripremljena u različitim programskim jezicima (C++ i Python) koji komuniciraju međusobno preko kanala. Na taj način ste sigurni da imate dobro instalirana oba programska jezika, sam ROS, kao i odgovarajuće primjere iz repozitorija programskog koda.
ROS Simulacija: Primjer simulacije bez korištenja grafičkog korisničkog sučelja
Simulatori
U prethodnom dijelu teksta istaknuli smo da priprema računala za korištenje ROS-a uopće nije trivijalna. Postoji li način da na neki jednostavniji način isprobamo ROS? I druga bitna „sitnica“. Čak i ako uspijemo instalirati sve potrebne komponente apsolutno savršeno, kako ćemo sve to skupa isprobati? Lako je uočiti da nam je zapravo potreban i pravi robot, zar ne?
Srećom, tu u igru ulaze simulatori robota, koji omogućavaju dvije bitne stvari:
Zainteresirani početnici mogu se početi upoznavati s ROS-om i ostalom robotskom tehnologijom bez potrebe za početnom kompliciranom instalacijom razvojnog sustava koja prelazi okvire prosječnog korisnika računala.
Iskusni korisnici mogu pisati i testirati zbilja „prave“ dijelove programskog koda na simuliranim uređajima. Ne moraju čekati da se prvo napravi nekakav robot od „željeza“, da bi na njega mogli instalirati svoj kod i isprobavati ga. Drugim riječima, na razvoju novog robota hardverska i softverska ekipa mogu raditi paralelno.
ROS je srećom podržan brojnim simulatorima koji se mogu iskoristiti za simulaciju različitih konfiguracija robota. Standardni simulator naziva se Gazebo, a svi detalji o njegovoj instalaciji i korištenju nalaze se na adresi https://gazebosim.org/home. Iako se Gazebo u praksi može koristiti bez grafičkog korisničkog sučelja (takozvani headless mode pogodan za izvođenje na serverima), svoju pravu snagu pokazuje tek na računalu s grafičkim sučeljem. U takvoj okolini Gazebo može prikazati detaljne pokrete pojedinog robota ili njegovog dijela (na primjer, robotske ruke) te simulirati okolinu u kojoj se robot nalazi. To mogu biti:
- Statični objekti - zidovi, zgrade i slično.
- Dinamički objekti – drugi roboti, ljudi, vozila i slično.
- Fizikalna svojstva – sila gravitacije, vjetar, trenje podloge i ostalo.
- Različiti tereni – osim ravnih mogu se koristiti i proizvoljne neravne podloge.
- Senzorska interakcija – simulacija što roboti „vide i osjećaju“ u svojim senzorima u odnosu na sve navedeno u prethodnim točkama.
Određeni problem (početnicima) s korištenjem Gazebo simulatora je u tome što njegova instalacija na Linux ili Windows računalo ponovno nije baš trivijalan zadatak.
Osim Gazeba na raspolaganju su i drugi simulatori. Na primjer:
Webots
Puno jednostavniji za instalaciju i korištenje od Gazeba, a istovremeno se isporučuje s velikim brojem primjera za korištenje. Na primjer, na Windowsima se instalira kao bilo koja druga aplikacija bez potrebe za prethodnom ili dodatnom instalacijom drugih modula.
NVIDIA Isaac Sim
Simulator posebno prilagođen za NVIDIA Omniverse platformu, a tijekom rada koristi GPU akceleraciju za fiziku i fotorealističan prikaz (RTX ray-tracing). Idealan je za primjenu u situacijama gdje se zahtijeva puno resursa poput razvoja umjetne inteligencije i robotskog vida.
Gazebo 1: Primjer simulacije robotske ruke
Gazebo 2: Primjer simulacije cijelog robota
Unity (ili Unreal)
Spomenuti sustavi dobro poznati u industriji igara mogu se također iskoristiti za simulaciju ROS robota. Kod ovakve simulacije se Unity okolina prvo povezuje s ROS sustavom. Nakon uspostave veze zadužena je za grafički prikaz podataka nastalih u ROS sustavu. Pri tome je kvaliteta prikaza u pravilu bolja nego kod drugih sustava. Uostalom, pogledajte prateće slike uz tekst i usporedite grafičku kvalitetu različitih simulatora.
U ostatku teksta osvrnut ćemo se malo na primjere koji se isporučuju s Webotsom, jer ih zbog jednostavnosti instalacije simulatora najjednostavnije možete probati sami. Ti primjeri pisani su u jezicima C/C++, Python, Java i Matlab, jer za njih Webots nudi službene API-je za pisanje kontrolera robota. Drugim riječima, ako se želite upoznati s pisanjem koda za robotske sustave možete koristiti i alternativne (jednostavnije) pristupe, a ne isključivo ROS.
Na pratećim slikama uz tekst može se vidjeti kako u Webotsu izgleda simulacija kretanja NASA-inog robota. Pogledajmo detaljan programski kod za upravljanje robotom.
Gazebo 3: Simulacija različitih objekata u okolici robota
#include <stdio.h>#include <webots/keyboard.h>#include <webots/motor.h>#include <webots/robot.h>
#define TIME_STEP 64#define VELOCITY 0.6
Gazebo 4: Simulacija vrlo složenog prostora oko robota
enum { back_left_bogie, front_left_bogie, front_left_arm, back_left_arm, front_left_wheel, middle_left_wheel, back_left_wheel, back_right_bogie, front_right_bogie, front_right_arm, back_right_arm, front_right_wheel, middle_right_wheel, back_right_wheel, JOINTS_MAX};
WbDeviceTag joints[JOINTS_MAX];
NVIDIA Isaac Sim: Primjer simulacije pomoću NVIDIA simulatora
void move_4_wheels(double v) { wb_motor_set_velocity(joints[front_left_wheel], v * VELOCITY); wb_motor_set_velocity(joints[middle_left_wheel], v * VELOCITY); wb_motor_set_velocity(joints[back_left_wheel], v * VELOCITY); wb_motor_set_velocity(joints[front_right_wheel], v * VELOCITY); wb_motor_set_velocity(joints[middle_right_wheel], v * VELOCITY); wb_motor_set_velocity(joints[back_right_wheel], v * VELOCITY);
wb_motor_set_available_torque(joints[middle_right_wheel], 0.0); wb_motor_set_available_torque(joints[middle_left_wheel], 0.0);}
void move_6_wheels(double v) { wb_motor_set_available_torque(joints[middle_right_wheel], 2.0); wb_motor_set_available_torque(joints[middle_left_wheel], 2.0);
wb_motor_set_velocity(joints[front_left_wheel], v * VELOCITY); wb_motor_set_velocity(joints[middle_left_wheel], v * VELOCITY); wb_motor_set_velocity(joints[back_left_wheel], v * VELOCITY); wb_motor_set_velocity(joints[front_right_wheel], v * VELOCITY); wb_motor_set_velocity(joints[middle_right_wheel], v * VELOCITY); wb_motor_set_velocity(joints[back_right_wheel], v * VELOCITY);}
void turn_wheels_right() { wb_motor_set_position(joints[front_left_arm], 0.4); wb_motor_set_position(joints[front_right_arm], 0.227); wb_motor_set_position(joints[back_right_arm], -0.227); wb_motor_set_position(joints[back_left_arm], -0.4);}
void turn_wheels_left() { wb_motor_set_position(joints[front_left_arm], -0.227); wb_motor_set_position(joints[front_right_arm], -0.4); wb_motor_set_position(joints[back_right_arm], 0.4); wb_motor_set_position(joints[back_left_arm], 0.227);}
void wheels_straight() { wb_motor_set_position(joints[front_left_arm], 0.0); wb_motor_set_position(joints[front_right_arm], 0.0); wb_motor_set_position(joints[back_right_arm], 0.0); wb_motor_set_position(joints[back_left_arm], 0.0);}
void turn_around(double v) { wb_motor_set_position(joints[front_left_arm], -0.87); wb_motor_set_position(joints[front_right_arm], 0.87); wb_motor_set_position(joints[back_right_arm], -0.87); wb_motor_set_position(joints[back_left_arm], 0.87);
wb_motor_set_velocity(joints[front_left_wheel], v * VELOCITY); wb_motor_set_velocity(joints[middle_left_wheel], v * VELOCITY); wb_motor_set_velocity(joints[back_left_wheel], v * VELOCITY); wb_motor_set_velocity(joints[front_right_wheel], -v * VELOCITY); wb_motor_set_velocity(joints[middle_right_wheel], -v * VELOCITY); wb_motor_set_velocity(joints[back_right_wheel], -v * VELOCITY);
wb_motor_set_available_torque(joints[middle_right_wheel], 0.0); wb_motor_set_available_torque(joints[middle_left_wheel], 0.0);}
int main() { // Required to initialize Webots wb_robot_init();
joints[back_left_bogie] = wb_robot_get_device(“BackLeftBogie”); joints[front_left_bogie] = wb_robot_get_device(“FrontLeftBogie”); joints[front_left_arm] = wb_robot_get_device(“FrontLeftArm”); joints[back_left_arm] = wb_robot_get_device(“BackLeftArm”); joints[front_left_wheel] = wb_robot_get_device(“FrontLeftWheel”); joints[middle_left_wheel] = wb_robot_get_device(“MiddleLeftWheel”); joints[back_left_wheel] = wb_robot_get_device(“BackLeftWheel”); joints[back_right_bogie] = wb_robot_get_device(“BackRightBogie”); joints[front_right_bogie] = wb_robot_get_device(“FrontRightBogie”); joints[front_right_arm] = wb_robot_get_device(“FrontRightArm”); joints[back_right_arm] = wb_robot_get_device(“BackRightArm”); joints[front_right_wheel] = wb_robot_get_device(“FrontRightWheel”); joints[middle_right_wheel] = wb_robot_get_device(“MiddleRightWheel”); joints[back_right_wheel] = wb_robot_get_device(“BackRightWheel”);
wb_motor_set_position(joints[front_left_wheel], INFINITY); wb_motor_set_position(joints[middle_left_wheel], INFINITY); wb_motor_set_position(joints[back_left_wheel], INFINITY); wb_motor_set_position(joints[front_right_wheel], INFINITY); wb_motor_set_position(joints[middle_right_wheel], INFINITY); wb_motor_set_position(joints[back_right_wheel], INFINITY);
Unity: Grafički možda najljepši oblik simulacije
printf(“Select the 3D window and use the keyboard to drive this robot:\n”); printf(“\n”); printf(“Q: forwards-left; W: forwards; E: forwards-right\n”); printf(“S: spin counter-clockwise\n”); printf(“Y: backwards-left; X: backwards; C: backwards-right\n”); wb_keyboard_enable(TIME_STEP);
// start moving move_6_wheels(1.0);
while (wb_robot_step(TIME_STEP) != -1) { int key = wb_keyboard_get_key(); switch (key) { case ‘W’: // forwards wheels_straight(); move_6_wheels(1.0); break;
case ‘X’: // backwards wheels_straight(); move_6_wheels(-1.0); break; case ‘Q’: // forwards left turn_wheels_left(); move_4_wheels(1.0); break; case ‘E’: // forwards right turn_wheels_right(); move_4_wheels(1.0); break; case ‘Y’: // backwards left turn_wheels_left(); move_4_wheels(-1.0); break; case ‘C’: // backwards right turn_wheels_right(); move_4_wheels(-1.0); break; case ‘S’: // spin counter-clockwise turn_around(1.0); break; } } wb_robot_cleanup(); return 0;}
Webots: Simulacija kretanja NASA robota po terenu
Čak i ako niste neki vrsni poznavatelj programiranja, nije teško razumjeti kako sve skupa funkcionira. Svaki pritisak na odgovarajuću tipku na tipkovnici poziva izvođenje određene funkcije zadužene za izvođenje točno određene operacije na „NASA-inom hardveru“. Još bolje je što odmah možete raditi korekcije programskog koda te vidjeti kako te promjene utječu na simulaciju. Uz Webots se isporučuje čitav niz različitih primjera, pa zaista imate što probati i učiti usput.
Ako u Webotsu želite pokrenuti baš primjer povezan s ROS tehnologijom, onda osim samog simulatora treba na isto računalo instalirati dodatne ROS pakete sa sljedeće web adrese: https://github.com/cyberbotics/webots_ros2
Na ovom mjestu ponovno stižemo do dijela koji nije trivijalan, jer je više u stilu instalacije samog ROS-a. Ono što će vas sigurno potaknuti da se malo potrudite oko instalacije je činjenica da su primjeri zbilja sjajni. Uključuju upravljanje dronovima, pa čak i Teslinim vozilima. Svakako istražite prije spomenutu web adresu.
Nakon instalacije modula za korištenje ROS-a u kombinaciji s Webotsom, svojevrsni „Hello word“ primjer napisan u Pythonu imao bi sljedeći oblik.
import rclpyfrom rclpy.node import Nodefrom geometry_msgs.msg import Twistfrom webots_ros2_driver.webots_node import WebotsNodeclass MyRobotDriver(WebotsNode): def __init__(self, args): super().__init__(‘my_robot_driver’, args=args) self.left_motor = self.robot.getDevice(‘left wheel motor’) self.right_motor = self.robot.getDevice(‘right wheel motor’) self.left_motor.setPosition(float(‘inf’)) self.right_motor.setPosition(float(‘inf’)) self.left_motor.setVelocity(0.0) self.right_motor.setVelocity(0.0) self.sub = self.create_subscription( Twist, ‘cmd_vel’, self.cmd_vel_callback, 10) def cmd_vel_callback(self, msg: Twist): v = msg.linear.x w = msg.angular.z wheel_distance = 0.2 wheel_radius = 0.03 v_l = (v - w * wheel_distance / 2.0) / wheel_radius v_r = (v + w * wheel_distance / 2.0) / wheel_radius self.left_motor.setVelocity(v_l) self.right_motor.setVelocity(v_r)def main(args=None): rclpy.init(args=args) driver = MyRobotDriver(args=args) driver.run() # petlja koju daje WebotsNode rclpy.shutdown()if __name__ == ‘__main__’: main()
Ako se putem Webotsa uvjerite da je programiranje robota područje koje vas privlači, onda u sljedećem koraku možete odlučiti da prođete cijeli postupak instalacije ROS-a i pratećih alata te krenete s detaljnijim istraživanjem u tom smjeru.
Zaključak
Nadamo se da vam ovaj tekst može poslužiti kao svojevrsni vodič za programiranje robota. Na trenutačnom stupnju razvoja ne radi se tu još uvijek o visoko inteligentnom AI programiranju, ali to ne znači da nije zanimljivo.
Spomenimo na kraju teksta kako se ROS u praksi koristi i u Hrvatskoj. Neke od institucija koje ga intenzivno koriste su Fakultet elektronike i računalstva (https://larics.fer.hr/), Regionalni centar izvrsnosti za robotske tehnologije (https://crta-robotics.com/) i Sveučilište u Rijeci (Tehnički fakultet).
