O introducere în sistemul de operare robot: cadrul suprem de aplicație pentru robot

Sistemul de operare robot (ROS) nu este un sistem de operare real, ci un cadru și un set de instrumente care oferă funcționalitatea unui sistem de operare pe un cluster de computere eterogen. Utilitatea sa nu se limitează la roboți, dar majoritatea instrumentelor furnizate sunt concentrate pe lucrul cu hardware periferic.

ROS este împărțit în peste 2000 de pachete, fiecare pachet oferind funcționalități specializate. Numărul de instrumente conectate la cadru este probabil cea mai mare putere a acestuia.

De ce ar trebui să folosesc Robot OS?

ROS oferă funcționalități pentru abstracția hardware, drivere de dispozitiv, comunicare între procese pe mai multe mașini, instrumente pentru testare și vizualizare și multe altele.

Caracteristica cheie a ROS este modul în care este rulat software-ul și modul în care acesta comunică, permițându-vă să proiectați software complex fără a ști cum funcționează anumite componente hardware. ROS oferă o modalitate de a conecta o rețea de procese (noduri) cu un hub central. Nodurile pot fi rulate pe mai multe dispozitive și se conectează la acel hub în diferite moduri.

Principalele modalități de creare a rețelei sunt furnizarea de servicii solicitate sau definirea conexiunilor editor/abonat cu alte noduri. Ambele metode comunică prin tipuri de mesaje specificate. Unele tipuri sunt furnizate de pachetele de bază, dar tipurile de mesaje pot fi definite de pachete individuale.

Dezvoltatorii pot asambla un sistem complex prin conectarea soluțiilor existente pentru probleme mici. Modul în care este implementat sistemul, ne permite să:

• Înlocuiți componentele cu interfețe similare din mers, eliminând nevoia de a opri sistemul pentru diferite modificări

• Multiplexarea ieșirilor mai multor componente într-o intrare pentru o altă componentă, permițând rezolvarea în paralel a diferitelor probleme

• Conectați componentele realizate în diferite limbaje de programare prin simpla implementare a conectorilor corespunzători la sistemul de mesagerie, facilitând dezvoltarea software-ului prin conectarea modulelor existente de la diverși dezvoltatori

• Creați noduri printr-o rețea de dispozitive, fără să vă faceți griji cu privire la locul în care este rulat codul și să implementați sisteme de comunicare interproces (IPC) și apel de procedură la distanță (RPC)

• Conectați-vă direct la fluxuri la cerere de la hardware la distanță, fără a scrie niciun cod suplimentar, utilizând cele două puncte anterioare

Intenționăm să demonstrăm cât de util este acest lucru prin dezvoltarea iterativă a unei soluții simple. Există mai multe avantaje cheie în comparație cu alte abordări. ROS are suport pentru mai multe platforme și permite conexiuni între procese pe mai multe dispozitive prin conexiuni peer-to-peer care sunt gestionate în spatele scenei. Designul permite suport pentru orice limbă prin împachetarea claselor de comunicare C++ sau prin dezvoltarea manuală a claselor pentru interfața limbii.

ROS este realizat de propria comunitate, destinată comunității sale. După câțiva ani, asta a rezultat într-o cantitate mare de pachete reutilizabile care sunt ușor de integrat, datorită arhitecturii sistemului.

Abordări alternative precum MRPT, CARMEN, LCM, Player, Microsoft RDS și altele oferă unele dintre aceste caracteristici, dar nu toate. De cele mai multe ori, scăderile de proiectare sunt limitările suportului lingvistic, comunicarea neoptimizată între procese sau lipsa suportului pentru diferite dispozitive, care este probabil cea mai dificilă problemă de rezolvat.

Ce vom construi?

Deoarece focalizarea noastră este cadrul și nu algoritmii efectivi pentru anumite probleme, problema dată va fi destul de simplă. Scopul nostru este să construim software pentru un computer de bord care ne permite să controlăm și să monitorizăm de la distanță un robot, conectat la noi prin Wi-Fi, folosind un gamepad pe computerul nostru și un flux de la camera montată pe robot.

În primul rând, vom face un program simplu conectat la o simulare simplă, doar pentru a demonstra principiile de bază ale ROS. Vom atașa un gamepad la un computer și vom încerca să proiectăm o schemă de control bună pentru a transforma intrarea gamepadului în semnale de control pentru un robot.

Principalele limbaje de scriere a codului ROS sunt C++ și Python, C++ fiind preferat datorită performanțelor mai bune. Vom explica exemplele noastre în Python din cauza mai puține standarde în cod și nu este nevoie de construcție explicită.

Instalare și configurare

Versiunile ROS sunt denumite după nume. Începând cu această dată, cea mai recentă versiune este Jade Turtle și cea mai recentă versiune LTS Indigo Igloo . Este de preferat să alegeți versiunea LTS, iar compatibilitatea inversă nu este garantată în ROS, așa că toate exemplele vor fi scrise pentru Indigo .

ROS este disponibil pe diverse platforme *NIX. Versiunea acceptată oficial este pe Ubuntu. Versiunile OS X, Arch Linux, Debian, Raspbian și Android sunt acceptate de comunitate.

Vom trece prin procesul de instalare pentru Ubuntu 14.04 pe desktop. Procesele pentru toate versiunile și platformele acceptate sunt disponibile pe site-ul oficial. Sunt disponibile și mașini virtuale cu ROS instalat.

Instalarea depinde de platformă (și majoritatea platformelor au pachete furnizate), dar configurația spațiului de lucru este aceeași pentru toate platformele.

Instalare pe Ubuntu

ROS oferă propriile depozite. Primul pas este adăugarea lor.

 sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list' sudo apt-key adv --keyserver hkp://pool.sks-keyservers.net --recv-key 0xB01FA116 sudo apt-get update

După aceea, veți avea toate pachetele găzduite pentru toate versiunile ROS disponibile pentru versiunea Ubuntu. De exemplu, Ubuntu 14.04 acceptă indigo și jade .

Instalarea pachetelor de bază pe desktop are una dintre cele trei opțiuni:

• sudo apt-get install ros-indigo-ros-base pentru o instalare minimă

• sudo apt-get install ros-indigo-desktop pentru a avea instrumentele GUI suplimentare de bază

• sudo apt-get install ros-indigo-desktop-full pentru a avea toate caracteristicile oficiale, inclusiv diverse simulatoare și biblioteci pentru navigare și percepție

Pentru cea mai bună experiență de lucru, este recomandată opțiunea completă. Pentru instalarea pe dispozitive care vor fi folosite doar pentru a rula noduri, versiunea de bază este suficientă. Indiferent de opțiunea pe care o alegeți, puteți instala orice pachet necesar numit package_name rulând:

 sudo apt-get install ros-indigo-<package-name>

Literele de subliniere sunt înlocuite cu cratime în numele final, așa că stage_ros va fi în pachetul ros-indigo-stage-ros .

Următorul pas este să inițializați rosdep . Pachetele din ROS pot declara de ce componente depind. rosdep vă permite să compilați acele pachete fără prea multă manipulare manuală a dependențelor. Pentru a-l inițializa, sunați:

 sudo rosdep init rosdep update

ROS are mai multe variabile de mediu utilizate de instrumentele sale. Cu instalarea implicită, scriptul bash pentru a le inițializa se află în /opt/ros/indigo/setup.bash . Variabilele trebuie inițializate în fiecare sesiune bash, așa că cea mai bună soluție este să le adăugați la ~/.bashrc .

 echo "source /opt/ros/indigo/setup.bash" >> ~/.bashrc source ~/.bashrc

Unele pachete instalează dependențe externe prin rosinstall , care este disponibil ca pachet și instalat prin sudo apt-get install python-rosinstall .

Acesta este sfârșitul instalării pe Ubuntu. Ceea ce urmează este o scurtă introducere în instalarea spațiilor de lucru.

Configurare

Încă de la Groovy Galapagos , spațiile de lucru ROS sunt gestionate prin catkin . Trebuie să definim un director pentru toate pachetele pe care le găzduim. În director, creăm un folder src și apelăm formularul catkin_init_workspace în interiorul acestuia. Aceasta va crea diverse legături simbolice către versiunea ROS din sursa curentă. Următorul pas este să adăugați acest spațiu de lucru și la variabilele de mediu.

Pentru a efectua întreaga configurație a spațiului de lucru, alegeți un director gol și executați următoarele comenzi:

 mkdir src cd src catkin_init_workspace cd .. catkin_make echo "source $(pwd)/devel/setup.bash" >> ~/.bashrc source ~/.bashrc

Acum ați creat un spațiu de lucru în care vă puteți crea propriile pachete ROS.

Familiarizarea cu instrumentele

Crearea oricărui cod este un salt mare. Să ne familiarizăm mai întâi cu unele dintre sistemele care rulează în spatele scenei. Primul nostru pas va fi să rulăm GUI de bază și să vedem ce mesaje generează.

Pentru a rula orice în ROS, trebuie lansat un proces de bază. Este la fel de ușor ca să deschizi o nouă fereastră de terminal și să tastați:

 roscore

În întreaga rețea conectată de dispozitive, roscore trebuie să fie lansat o singură dată, pe dispozitivul care va găzdui hub-ul central pentru dispecerarea comunicațiilor.

Rolul principal al roscore este de a spune nodurilor la ce alte noduri ar trebui să se conecteze și în ce mod (fie printr-un port de rețea sau prin memorie partajată). Scopul este de a permite nodurilor să le pese doar de datele pe care doresc să le cunoască, mai degrabă decât de la ce nod doresc să se conecteze, minimizând în același timp timpul și lățimea de bandă necesare pentru a efectua toate comunicările.

rqt

După rularea roscore , putem lansa instrumentul principal GUI pentru ROS: rqt . Ceea ce vedem este foarte dezamăgitor - o fereastră goală. rqt găzduiește o mare varietate de pluginuri care pot fi configurate în orice configurație vizuală și orice număr de vizualizări predefinite.

Pentru început, să rulăm pluginul Robot Steering , alegându-l în Plugins > Robot Tools > Robot Steering . Ceea ce obținem sunt două glisoare, reprezentând mișcarea liniară și de rotație pe care vrem să o aibă robotul nostru. În partea de sus a pluginului vedem o casetă de text cu /cmd_vel în ea. Îl putem redenumi în orice dorim. Reprezintă numele subiectului la care se publică direcția. Instrumentele terminale sunt cel mai bun loc pentru a vedea ce se întâmplă în fundal.

Instrumente terminale

ROS are câteva instrumente puternice pentru inspectarea a ceea ce se întâmplă în sistem. Primul instrument pe care îl vom introduce este rostopic . Ne permite să inspectăm subiectele la care nodurile se pot abona și la care se pot publica. Rularea rostopic list va produce:

 /cmd_vel /rosout /rosout_agg

Ultimele 2 subiecte rulează mereu și sunt legate de sistemele centrale ROS. Subiectul /cmd_vel este publicat de directorul nostru. Redenumirea subiectului din direcție îl va redenumi și aici. Acum, suntem interesați de ceea ce se întâmplă în cadrul subiectului. Rularea rostopic echo /cmd_vel nu ne va arăta nimic (cu excepția cazului în care ați modificat glisoarele). Procesul rulează până când îl anulăm. Să mutăm acum glisorul vertical la 20 m/s. Privind ecoul, putem vedea următoarele repetate iar și iar:

 linear: x: 0.2 y: 0.0 z: 0.0 angular: x: 0.0 y: 0.0 z: 0.0

Cât de des trimite spam acest mesaj? rostopic hz /cmd_vel spune la o rată medie de 10 Hz. Ei bine, câte subiecte de genul acesta pot rula prin conexiunea mea lentă Wi-Fi? rostopic bw /cmd_vel detectează o medie de 480 B/s.

Acum totul este bine și bine, dar am vorbit despre tipurile de mesaje. Aceste date sunt bune pentru un om, dar o aplicație va avea nevoie de datele brute și va trebui să cunoască tipul de mesaj pentru a putea interpreta datele. Tipul poate fi determinat cu rostopic type /cmd_vel , spunându-ne că este un geometry_msgs/Twist . Toate instrumentele terminale ROS apelate fără niciun argument returnează un mesaj de ajutor standard.

Wiki ROS este suficient de bun pentru a face o căutare pe web pentru acest șir de caractere să rezulte într-o explicație Wiki despre ceea ce conține și cum este structurat. Dar nu trebuie să ne bazăm pe el. rosmsg este instrumentul general pentru tipurile de mesaje. Rularea rosmsg show geometry_msgs/Twist va reveni:

 geometry_msgs/Vector3 linear float64 x float64 y float64 z geometry_msgs/Vector3 angular float64 x float64 y float64 z

Mesajul constă din doi vectori 3D, reprezentând viteza liniară și unghiulară în spațiul 3D.

Dacă vrem la ce subiecte este conectat un nod, rosnode info <node-name> ne va oferi date detaliate despre nod. Instrumentele rostopic , rosmsg și rosnode sunt principalele instrumente pentru inspectarea funcționalității brute ROS. ROS are mult mai multe instrumente GUI și terminale, dar acestea sunt în afara domeniului nostru de aplicare pentru această introducere.

Principalele instrumente pentru rularea nodurilor ROS sunt rusrun și roslaunch . rosrun poate rula noduri prin rosrun <package_name> <node_name> , iar roslaunch rulează noduri pe baza fișierelor de lansare, cu care ne vom familiariza într-o mică măsură, deoarece sunt cel mai complex element al automatizării ROS.

Putem închide tot ce am alergat pentru a începe să lucrăm la primul nostru cod. Pentru referință ulterioară, este de la sine înțeles că rularea oricărui lucru legat de ROS necesită o instanță activă a roscore . O mulțime de probleme cu care vă confruntați pot fi rezolvate prin închiderea ferestrei terminalului în care se rulează roscore și prin deschiderea uneia noi pentru a o relansa. Aceasta actualizează toate dependențele care trebuiau reîncărcate, atât în bash , cât și în roscore .

Crearea Gamepad Teleoperation

Primul nostru obiectiv este să imitem funcționalitatea Robot Steering prin crearea unui nod care publică datele geometry_msgs/Twist în /cmd_vel pe baza intrării gamepadului. Prima noastră oprire este pachetul de joy .

Pachetul joy

Pachetul joy oferă drivere ROS generice pentru joystick-uri și gamepad-uri. Nu este inclus în instalarea implicită, așa că trebuie instalat prin:

 sudo apt-get install ros-indigo-joy

După instalare, putem rula rosrun joy joy_node . Acest lucru ne va conecta la joystick-ul sau gamepad-ul implicit. Rularea rostopic list ne arată că avem un subiect numit /joy . Ascultând-o prin rostopic echo , ne arată mesaje cu următorul format (rețineți că trebuie să interacționați cu gamepad-ul sau cu joystick-ul pentru ca mesajele să fie publicate).

 header: seq: 4156 stamp: secs: 1450707466 nsecs: 204517084 frame_id: '' axes: [0.0, 0.0, 0.0, -0.0, 0.0, 0.0, 0.0, 0.0] buttons: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Puteți ignora anteturile pentru moment. În afară de asta, avem axes și buttons , explicând frumos ce reprezintă ele. Mișcarea axelor și apăsarea butoanelor de pe controler va duce la schimbarea acestor numere. Folosind instrumentele noastre, putem determina că tipul de mesaj este sensor_msgs/Joy și formatul este:

 std_msgs/Header header uint32 seq time stamp string frame_id float32[] axes int32[] buttons

Crearea teleoperației noastre

Primul pas pentru scrierea codului este realizarea unui pachet. În folderul src al spațiului de lucru, rulați:

 catkin_create_pkg toptal_tutorial rospy joy geometry_msgs sensor_msgs

Aici menționăm numele pachetului pe care îl creăm, urmat de pachetele de care intenționăm să depindem. Nu vă faceți griji, dependențele pot fi actualizate manual ulterior.

Acum avem un folder toptal_tutorial . În cadrul folderului, creați un folder de scripts care va găzdui toate scripturile noastre Python.

Să creăm un fișier numit teleop.py și în el vom seta:

 #!/usr/bin/env python import rospy from sensor_msgs.msg import Joy def joy_callback(data): print data def main(): rospy.init_node('teleop') rospy.Subscriber('joy', Joy, joy_callback) while not rospy.is_shutdown(): pass if __name__ == '__main__': main()

De asemenea, va trebui să setăm chmod +x teleop.py , astfel încât scriptul să devină rulabil. Rularea rosrun joy joy_node într-un terminal și rosrun toptal_tutorial teleop.py în altul va duce la umplerea terminalului teleop.py cu mesaje Joy.

Să examinăm ce face codul.

În primul rând, importăm rospy, care găzduiește biblioteca pentru interacțiunea cu cadrul ROS. Fiecare pachet care definește mesaje are un subpachet msg cu definiții de mesaj în el. Importăm Joy pentru a gestiona intrarea. Nu este nevoie să importați tipuri de mesaje încorporate (cum ar fi Header din std_msgs.msg care se află în mesajul Joy ) decât dacă dorim să le menționăm în mod explicit.

Primul nostru pas este inițializarea unui nod cu un nume specific (în acest caz, îl numim „teleop”). După aceea creăm un abonat care se abonează la subiectul „joy” de tip sensor_msgs.msg.Joy și care gestionează fiecare mesaj apelând funcția joy_callback . Reapelurile primesc un parametru, datele din mesaj. Accesarea membrilor datelor este simplă. Dacă am vrea să tipărim starea primei axe, dacă ne reamintim tipul mesajului, am numi print data.axes[0] , iar acesta va fi un float. Bucla de la sfârșit se închide până când ROS este oprit.

Următorul nostru pas ar fi să ne gestionăm datele într-un fel. Ar trebui să creăm un mesaj Twist care se modifică în funcție de intrare și apoi îl vom publica în subiectul cmd_vel .

 #!/usr/bin/env python import rospy from sensor_msgs.msg import Joy from geometry_msgs.msg import Twist # new from functools import partial # new def joy_callback(pub, data): # modified cmd_vel = Twist() # new cmd_vel.linear.x = data.axes[1] # new cmd_vel.angular.z = data.axes[0] # new pub.publish(cmd_vel) # new def main(): rospy.init_node('teleop') pub = rospy.Publisher('cmd_vel', Twist, queue_size=1000) # new rospy.Subscriber('joy', Joy, partial(joy_callback, pub)) # modified while not rospy.is_shutdown(): pass if __name__ == '__main__': main()

Mai întâi, adăugăm mesajul Twist și adăugăm suport pentru argumentele funcției de legare prin functools.partial . Creăm un editor, pub , care publică pe cmd_vel un mesaj de tip Twist . Legăm acel editor de apel invers și îl facem să publice un mesaj Twist la fiecare intrare, vitezele fiind reprezentate de primele două axe. Acest cod face ceea ce ne așteptăm și putem vedea rezultatul rezultat prin rostopic echo /cmd_vel .

Mai avem o problemă. Subiectul /joy poate fi publicat la prețuri mari. Dacă monitorizăm rostopic hz /cmd_vel și mișcăm stick-ul analogic în cercuri, putem vedea un număr mare de mesaje. Nu numai că are ca rezultat o mare cantitate de comunicare, dar procesele care primesc aceste mesaje trebuie să proceseze fiecare dintre ele. Nu este nevoie să publicăm aceste date atât de des și este mai bine să publicăm doar la o rată stabilă de 10 Hz. Putem realiza asta cu următorul cod.

 #!/usr/bin/env python import rospy from sensor_msgs.msg import Joy from geometry_msgs.msg import Twist from functools import partial def joy_callback(cmd_vel, data): # modified cmd_vel.linear.x = data.axes[1] cmd_vel.angular.z = data.axes[0] # moved pub.publish(cmd_vel) to main loop def main(): rospy.init_node('teleop') cmd_vel = Twist() # new pub = rospy.Publisher('cmd_vel', Twist, queue_size=1000) rospy.Subscriber('joy', Joy, partial(joy_callback, cmd_vel)) # modified rate = rospy.Rate(10) # new while not rospy.is_shutdown(): pub.publish(cmd_vel) # new rate.sleep() # new if __name__ == '__main__': main()

Am modificat apelul invers pentru a primi obiectul mutabil Twist și a-l modifica în buclă. Funcția de sleep de la rospy.Rate menține o frecvență de ieșire stabilă.

Codul final va avea ca rezultat ca subiectul /cmd_vel să primească comenzi de viteză la 10 Hz, imitând rezultatul pluginului Robot Steering rqt .

Rularea unui sistem simulat

Simulând lumea

Primul nostru obiectiv este să creăm un mediu în care să putem simula un scenariu pe care vrem să-l realizăm. Nodul stageros din pachetul stage_ros ne permite să rulăm un robot într-o etapă 2D definită printr-o imagine. Există o întreagă sintaxă, descrisă în pachetul stage_ros pentru fișierele lumii și cum să le generezi. Este destul de simplu, dar în afara domeniului nostru de aplicare. Din fericire, pachetul vine cu mai multe lumi demo. Mai întâi, să mergem la directorul fișierelor rulând:

 roscd stage_ros cd world

În cadrul folderului există mai multe fișiere. Hai să alergăm unul.

 rosrun stage_ros stageros willow-erratic.world

Acest lucru a creat mai multe subiecte. Semnificația fiecăruia dintre ele este documentată și cu pachetul. Partea importantă este că are cmd_vel .

În cadrul etapei afișate, există un pătrat albastru, reprezentând robotul pe care îl controlați. Folosind fie codul nostru, fie Robot Steering , putem controla acest robot. Încearcă.

Configurarea sistemului nostru prin fișiere de lansare

haideți să creăm un folder de launch în pachetul nostru și să creăm în el un fișier numit teleop.launch . Structura finală a folderului ar trebui să arate astfel:

 toptal_tutorial/ ├── CMakeLists.txt ├── launch │ └── teleop.launch ├── package.xml ├── scripts │ └── teleop.py └── src

În cadrul fișierului teleop.launch vom defini un set de noduri și interconexiunile acestora.

 <launch> <arg name="world_file" default="$(find stage_ros)/world/willow-four-erratics-multisensor.world" /> <node pkg="stage_ros" type="stageros" name="simulated_world" args="$(arg world_file)"></node> <group ns="robot_0"> <node pkg="joy" type="joy_node" name="joy_input"></node> <node pkg="toptal_tutorial" type="teleop.py" name="joy_convert"></node> </group> </launch>

Noua lume este formată din patru roboți, iar fiecare dintre subiectele lor are un prefix robot_<n> . Deci, numărul robotului 0 are un subiect de comandă de viteză numit robot_0/cmd_vel . De aceea, ne punem controlul într-un spațiu de nume numit robot_0 , pentru a le ajusta numele la noua formă. În acest sens, vă puteți gândi la numele subiectelor ca foldere într-un sistem de fișiere.

Pentru a rula fișierele de lansare, nu este nevoie de roscore . Într-un fel, roscore este doar un caz special al unui fișier de lansare care nu face nimic. Dacă lipsește un roscore , doar primul fișier de lansare lansat va rula un nucleu, în timp ce restul se va conecta la acesta. Acum, lansăm cu:

 roslaunch toptal_tutorial teleop.launch

Dacă totul este corect, acest lucru va avea ca rezultat un simulator cu 4 roboți, dintre care unul este controlat cu gamepad-ul sau joystick-ul nostru. Lumea asta are mult mai multe sub capotă decât cea anterioară. Fiecare dintre cei patru roboți are:

 /robot_<n>/base_pose_ground_truth /robot_<n>/base_scan_0 /robot_<n>/base_scan_1 /robot_<n>/camera_info_0 /robot_<n>/camera_info_1 /robot_<n>/cmd_vel /robot_<n>/depth_0 /robot_<n>/depth_1 /robot_<n>/image_0 /robot_<n>/image_1 /robot_<n>/odom

Înlocuim <n> cu 0, 1, 2 sau 3. Aceasta ne duce la ultimul nostru subiect.

Vizualizarea datelor noastre cu rqt

Nu am aprofundat prea mult în rqt , dar este instrumentul perfect pentru vizualizarea datelor mai complexe. Puteți experimenta toate subiectele, dar ne vom concentra pe image_0 , image_1 , depth_0 și depth_1 .

Să lansăm rqt și să eliminăm orice plugin deschis. Acum vom deschide 4 vizualizatoare de imagine ( Plugins > Visualization > Image View ) și le vom plasa într-o formațiune de grilă 2x2. În cele din urmă, în colțul din stânga sus al fiecărei vizualizări, să alegem unul dintre cele patru subiecte menționate pentru robot_0 .

Ceea ce obținem este vedere stereo cu percepție în profunzime, cu camere cu rezoluție joasă. Rețineți că am fi putut chiar obține acest rezultat fără sistemul nostru de introducere. Dacă pur și simplu rulăm acest lucru (din folderul stage_ros/world ):

 rosrun stage_ros stageros willow-four-erratics-multisensor.world

și adăugați pluginul Robot Steering cu un subiect numit /robot_0/cmd_vel , am fi obținut aceleași rezultate cu controalele fiind glisoare de pe ecran.

Aplicarea rezultatelor la un sistem real

O mulțime de hardware are suport deplin pentru ROS, foarte adesea oferit de voluntari terți. Multe platforme de roboți au drivere care generează aceste tipuri de mesaje, iar ROS are noduri care preiau o cameră web și publică un flux de imagini.

În timp ce ultimul rezultat a fost o simulare a ceea ce dorim să realizăm, același lucru poate fi obținut cu următoarele modificări:

• Instalați ROS pe computerul de bord al robotului dvs
• Creați un fișier de lansare pentru computerul de bord care conectează ROS la platforma de bază și la toți senzorii de nivel înalt, cum ar fi camerele, telemetrele cu laser și altele. Nodurile necesare pot exista deja sau pot fi implementate prin crearea unui editor/abonat la ROS pe de o parte și un driver pentru comunicații seriale pe de altă parte
• Rulați fișierul de lansare la pornire
• Pe computerul dvs. de la distanță adăugați export ROS_MASTER_URI=http://<robot_hostname>:11311/ la pornirea bash, făcând computerul de la distanță să caute roscore pe acel nume de gazdă și portul dat
• Lansați rqt și/sau orice scripturi pentru monitorizarea și controlul robotului

La ce se reduce acest lucru este doar exportarea variabilei de mediu adecvate pe dispozitivul de la distanță, iar restul se ocupă singur. Rularea ROS pe un cluster de computere necesită doar un singur pas făcut pentru fiecare mașină.

Concluzie

Am demonstrat cum, cu foarte puțină codare, poți avea un sistem complex de variabile pe care le poți manipula după dorința ta. Sistemul simplu editor/abonat vă permite să dezvoltați rapid o conductă de software care prelucrează date într-un cluster de computere, fără a vă face griji cu privire la implementarea de bază a anumitor elemente.

În timp ce am folosit un simulator simplu, simulatoarele mai complexe, cum ar fi gazebo (incluse și în versiunea completă pentru desktop) vă permit să creați lumi 3D cu fizică și senzori complecși și vă pot oferi o experiență a rezultatelor finale și a produsului cu mult înainte de a fi dezvoltat.

Această introducere a fost una foarte simplă, dar speranța este că ați devenit mai interesat să lucrați cu acest cadru versatil.