GUIDA A ROS
Irene Maria Gironacci
INTRODUZIONE
COS'È ROS
ROS è un sistema per il controllo di componenti robotici da PC. Un sistema ROS è costituito da un numero
indipendente di nodi, ognuno dei quali comunica con gli altri nodi usando un modello di messaggistica basato su
pubblicazione e iscrizione.
Esempio:
Arduino pubblica messaggi su un topic, un laptop si iscrive al topic, e un cellulare Android comanda i
motori.
Esempio:
Abbiamo una telecamera su un robot e vogliamo vedere le immagini da un laptop. Viene creato un nodo
CameraNode che si occupa della comunicazione con la telecamera, un nodo di ProcessingNode sul robot che si occupa
di processare i dati dell'immagine, e un nodo DisplayNode sul laptop che si occupa di visualizare su un monitor il video.
All' inizio tutti i nodi si iscrivono al master.
I VANTAGGI DI ROS
In ROS i nodi possono non risiedere sullo stesso sistema e non appartenere alla stessa architettura. ROS è flessibile e
adattabile alle esigenze dell'utente. E' open source.
COMPONENTI PRINCIPALI
package: sono unità per organizzare il codice ROS. Contengono nodi eseguibili di ROS, librerie, datasets, file
di configurazione e altro.
Repository: è una collezione di packages che condividono un comune sistema VCS
stack: è un insieme di packages che forniscono una funzione di alto livello (per es. una libreria)
nodo: è un eseguibile che può pubblicare su un topic o iscriversi ad un topic
topic:
è un contenitore di messaggi pubblicati da uno o più nodi e a cui possono iscriversi altri nodi.
messaggi:
tipo di dato usato dai nodi per pubblicare informazioni nel topic
servizi:
sono messaggi di tipo client-server che si aspettano una risposta dopo un dato inviato
CONCETTI GENERALI DI ROS
ROS è strutturato intorno ad un nodo master. Il nodo master consente a tutti gli altri componenti software (i nodi) di
comunicare fra loro. In questo modo non si deve necessariamente imporre di inviare dei dati sensoriali ad un
computer all'indirizzo 127.0.0.1, ma si può semplicemente dire al nodo 1 di inviare un messaggio al nodo 2.
Nell'esempio della telecamera, il nodo CameraNode appena riceve alcuni dati dalla telecamera li pubblicherà su un
topic chiamato per esempio /image_data e il nodo ProcessingNode che il nodo DisplayNode si iscriveranno al topic
/image_data per ricevere tali dati.
ROS_PACKAGE_PATH
E' un ambiente di variabili che consente di aggiungere package ROS al proprio ambiente di lavoro.
Per visualizzare la lista dei package ROS si ricorre al comando echo come nel Listato 1.1: in questo listato
viene visualizzata una lista delle directory dove risiedono i package ROS separati da colonne (i due punti). Si
possono aggiungere ulteriori directory inserendo una colonna (' : ' ) e di seguito un path aggiuntivo
$ echo $ROS_PACKAGE_PATH
es: $ echo $ROS_PACKAGE_PATH
/home/style/groovy_workspace:/home/style/groovy_workspace/cv_bridge:
/home/style/groovy_workspace/sandbox:/opt/ros/groovy/share:/opt/ros/groovy/stacks
Listato 1.1 ROS_PACKAGE_PATH
..continua
2. INSTALLAZIONE
..continua
3.
..continua
4. STRUMENTI
Per i vari esempi verrà usato il package uvc_camera, con un esempio di uso generico (font di colore nero e
stile normale), specifico ( font di colore nero e stile corsivo) e l'output ottenuto (font di colore rosso e stile
corsivo)
Rospack
Questo strumento consente di ottenere informazioni sui package. Nel Listato 4.1 è mostrato un codice di
utilizzo.
$ rospack find [package_name]
es: $rospack find uvc_camera
/opt/ros/groovy/stacks/camera_umd/uvc_camera
Listato 4.1 rospack
Roscd
Permette di cambiare directory (equivalente al comando cd nei sistemi operativi ubuntu), trovando i
package ROS presenti all'interno delle directory elencate in ROS_PACKAGE_PATH.
$ roscd [ locationname [/subdir] ]
es: $roscd uvc_camera
style@styleHP:/opt/ros/groovy/stacks/camera_umd/uvc_camera$
Listato 4.2 roscd
E' possibile inoltre consultare un file di log di una directory ROS attraverso il comando roscd log, come
mostrato nel Listato 4.3
$ roscd log
es: $roscd log
Listato 4.3 roscd log
Pwd
Visualizza il contenuto della cartella
$ pwd
es: $pwd
/opt/ros/groovy/stacks/camera_umd/uvc_camera
Listato 4.4 pwd
creazione package: roscreate-pkg
Tutti i package ROS sono costituiti dai seguenti file in genere: manifest.xml, CMakeList.txt, mainpage.dox,
Makefile.
Quando si utilizza il comando roscreate-pkg vengono generati questi file, insieme alle dipendenze
specificate nel comando.
Prima di tutto si va nella propria workspace (generalmente in ~/groovy_workspace/sandbox) attraverso il
comando cd (Listato 4.1) o roscd (Listato 4.2) e successivamente si prosegue digitando il comando nel
Listato 4.3.
cd ~/groovy_workspace/sandbox
Listato 4.5
roscd
cd sandbox
Listato 4.6
$ roscreate-pkg [package_name] [depend1] [depend2] … [dependN]
es: $roscreate-pkg package_test std_msgs uvc_camera
es: $roscreate-pkg package_test_2
Created package directory /home/style/groovy_workspace/sandbox/package_test
Created package file /home/style/groovy_workspace/sandbox/package_test/Makefile
Created package file /home/style/groovy_workspace/sandbox/package_test/manifest.xml
Created package file /home/style/groovy_workspace/sandbox/package_test/CMakeLists.txt
Created package file /home/style/groovy_workspace/sandbox/package_test/mainpage.dox
Please edit package_test/manifest.xml and mainpage.dox to finish creating your package
Listato 4.7 roscreate-pkg
Ricerca di un package
Digitando il comando rospack profile è possibile assicurarsi che ROS ha individuato il nostro nuovo package
(Listato 4.4).
$ rospack profile
$ rospack find [nome_package]
$ rospack profile
$ rospack find package_test
Listato 4.8
Visualizzazione dipendenze di un package
$ rospack depends1 [nome_package]
Listato 4.9
Modifica dipendenze di un package
Per modificare le dipendenze bisogna aprire il file manifest.xml e modificarlo.
$ roscd [nome_package]
$ cat manifest.xml
$ roscd package_test
$ cat manifest.xml
Listato 4.10
building packages
Per il build dei packages si utilizza il comando rosmake, equivalente al comando make.
$ rosmake [package]
$ rosmake package_test
[…]
[ rosmake ] Results:
[ rosmake ] Built 21 packages with 0 failures.
Listato 4.11
Nodi ROS
Un nodo è un file eseguibile all'interno di un pacchetto ROS. I nodi ROS usano una libreria (ROS client library) per
comunicare con altri nodi, attraverso il linguaggio C++ (roscpp) o Python (rospy). I nodi ROS possono:
a) pubblicare su un topic / iscriversi a un topic
b) fornire / usare servizi.
$ sudo apt-get install ros-groovy-ros-tutorials
Listato 4.12 installing tutorials
Comunicazione fra nodi: roscore
E' una collezione di nodi e programmi necessari ad un sistema basato su ROS. Per garantire la comunicazione fra nodi
è necessario eseguire sempre Roscore attraverso il comando roscore.
Questo comando farà partire: ROS master, un ROS parameter server, un nodo per il logging rosout.
$ roscore
Listato 4.13 roscore
Visualizzare informazioni di un nodo: rosnode
E' uno strumento per visualizzare informazioni riguardanti un nodo che sta attualmente eseguendo.
$ rosnode list
/rosout
Listato 4.14 rosnode list
$ rosnode info /rosout
Listato 4.15 rosnode info
Esecuzione di un nodo: rosrun
E' uno strumento che consente di usare il nome di package per eseguire un nodo all' interno di un package (senza
conoscere il percorso del package).
$ rosrun [package_name] [node_name]
$ rosrun turtlesim turtlesim_node
Listato 4.16 rosrun
$ rosnode ping [node_name]
$ rosnode ping turtlesim
Listato 4.17 rosnode ping
...continua
5.
6. BUILD
Il build può essere effettuato in due modi: attraverso catkin o attraveso rosbuild. Di seguito verrà analizzato
rosbuild.
BUILD FILES
Con rosbuild, un package deve avere un file manifest.xml e un Makefile. Tipicamente ha anche un file
CMakeList.txt usato dal Makefile.
Nel file CMakeList.txt viene inserito il build e i passi della generazione, nel Makefile vengono dichiarate le
dipendenze, mentre nel file manifest.xml sono dichiarate attributi per l'esportazione.
manifest.xml
E' un file XML che rappresenta la descrizione di un package (ne definisce le proprietà), quali per esempio il nome, il
numero della versione, l'autore, e le sue dipendenze da altri packages.
La sua struttura base è costituita dal tag package presente nel Listato 6.1.
<!-- Questa è la struttura base -->
<package>
</package>
Listato 6.1
Altri tag generalmente presenti in questo file sono:
vedere nel Listato 6.2
name, version, description, mantainer, license, come è possibile
<!-- Questa è la struttura base con altre informazioni-->
<package>
<name> foo_core
</name>
<version> 1.2.4
</version>
<description>
This package provides foo capability.
</description>
<maintainer email="[email protected]">
<license> BSD </license>
</package>
Irene Maria Gironacci </maintainer>
Listato 6.2
Oltre alle informazioni base sono presenti, come già mensionato, le dipendenze da altri pacchetti (vedi Listato 6.3). si
possono avere diversi tipi di dipendenze:
dipendenze di build: specifica i packages necessari per fare il buid del package corrente (Listato 6.4)
dipendenze per l'esecuzione: speficia i packages necessari per eseguire il codice del package corrente (Listato
6.5)
strumenti per le dipendenze di build: specifica gli strumenti di sistema che sono necessari al package
corrente per fare il build (Listato 6.6)
dipendenze di test: specifica dipendenze aggiuntive per dei test (Listato 6.7)
<!-- Questa è la struttura base con altre informazioni e le dipendenze-->
<package>
<name> foo_core
</name>
<version> 1.2.4
</version>
<description>
This package provides foo capability.
</description>
<maintainer email="[email protected]"> Irene Maria Gironacci </maintainer>
<license> BSD </license>
<depend package="std_msgs"/>
<depend package="roscpp"/>
<depend package="cv_bridge"/>
<depend package="image_transport"/>
</package>
Listato 6.3
<!-- Questa è la struttura base -->
<package>
<build_depend>
<!-- inserire qui le dipendenze -->
</build_depend>
</package>
Listato 6.4
<!-- Questa è la struttura base -->
<package>
<run_depend>
<!-- inserire qui le dipendenze -->
</run_depend>
</package>
Listato 6.5
<!-- Questa è la struttura base -->
<package>
<buildtool_depend>
<!-- inserire qui le dipendenze -->
</buildtool_depend>
</package>
Listato 6.6
<!-- Questa è la struttura base -->
<package>
<test_depend>
<!-- inserire qui le dipendenze -->
</test_depend>
</package>
Listato 6.7
Si possono anche inserire dei metapackage.
….
CMakeList.txt
…continua
7. APPLICAZIONI
7.1 pubblicazione / iscrizione
- creazione package:
$ roscreate-pkg ros_tutorial std_msgs rospy roscpp
Listato 7.1
- build package:
$ rosmake ros_tutorial
Listato 7.2
- Creazione del nodo pubblicante (talker): aprire un file di testo, nominarlo talker.cpp e salvarlo all'interno
di ros_tutorial/src
#include "ros/ros.h"
#include "std_msgs/String.h"
#include <sstream>
int main (int argc, char **argv){
ros::init(argc, argv, "talker");
ros::NodeHandle n;
ros::Publisher chatter_pub = n.advertise <std_msgs::String>("chatter",1000);
ros::Rate loop_rate(10);
int count = 0;
while (ros::ok()){
std_msgs::String msg;
std::stringstream ss;
ss << "hello world" << count;
msg.data = ss.str();
ROS_INFO("%s",msg.data.c_str());
chatter_pub.publish(msg);
ros::spinOnce();
loop_rate.sleep();
++count;
}
return 0;
}
Listato 7.3
Nodo Ascoltatore (Listener): aprire un file di testo, nominarlo Listener.cpp e salvarlo all'interno della
directory ros_tutorial/src
#include "ros/ros.h"
#include "std_msgs/String.h"
void chatterCallback(const std_msgs::String::ConstPtr& msg){
ROS_INFO("I heard: [%s]", msg->data.c_str());
}
int main(int argc, char **argv){
ros::init(argc, argv, "listener");
ros::NodeHandle n;
ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
ros::spin();
return 0;
}
Listato 7.4
$ rosmake ros_tutorial
Listato 7.5
Avvio del roscore dal terminale:
$ roscore
Listato 7.6
Figura 7.1
Avvio del nodo talker da un nuovo terminale:
$ rosrun ros_tutorial talker
Listato 7.7
Figura 7.2
Avvio del nodo listener da un nuovo terminale:
$ rosrun ros_tutorial listener
Listato 7.8
Figura 7.3
LISTA COMANDI
TOPIC
Mostrare la lista dei topic
$ rostopic list
Mostrare il contenuto di un topic
$ rostopic echo NomeTopic
Mostrare informazioni di un topic
$ rostopic info NomeTopic
NODI
Mostrare la lista dei nodi in esecuzione
$ rosnode list
Mostrare informazioni di un nodo
$ rosnode info NomeNodo
Esecuzione di un nodo
$ rosrun NomePacchetto NomeNodo __name:= NomeNodoAlternativo
Vedere quali nodi sono attivi e come interagiscono fra loro
$ rxgraph
Verifica della connettività di un nodo
$ rosnode ping NomeNodo
PACKAGES
Conoscere le dipendenze di un pacchetto
$ rospack depends
Creazione di un package con le varie dipendenze
$ roscreate-pkg NomePacchetto Dipendenza1
Compilazione di un package
$ rosdep install NomePackage
MASTER
Avvio del processo Master
$ roscore
REFERENCES
[1] http://wiki.ros.org/CppStyleGuide
Dipendenza2
… DipendenzaN
© Copyright 2024 ExpyDoc
