Guida Introduttiva a ROS (Robot Operating System) per la Robotica - Prof. Cavallo, Appunti di Robotica

Scarica Guida Introduttiva a ROS (Robot Operating System) per la Robotica - Prof. Cavallo e più Appunti in PDF di Robotica solo su Docsity!

ROS

1.INTRODUZIONE ROS

ROS (robot operating system) è un meta-operating system tramite il quale è possibile programmare alcuni tasks del robot (es. portare il robot da un punto A un punto B, interagire con un untente,…). Fornisce librerie e strumenti per aiutare gli sviluppatori di software a creare applicazioni robotiche. ROS si basa su un vero sistema operativo, ovvero UBUNTU. ROS è concesso in licenza con una licenza open source → ovvero che il codice scritto per un robot idealmente può andare bene su un qualsiasi altro robot, quindi il vantaggio principale è poter scrivere un codice ed utilizzarlo su tutte le piattaforme robotiche. È formato da tanti blocchi interconnessi tra loro ma che lavorano in maniera indipendente → questo permette di creare delle architetture software incrementabili a cui si possono aggiungere un po’ di blocchi per volta aumentando la capacità del robot. I robot basati su ROS li ritroviamo in tantissimi settori (aereo, marino, terreno, industriale, di servizio).

CONCETTI FONDAMENTALI DEL LINGUAGGIO DI PROGRAMMAZIONE

NODI : I nodi sono processi che eseguono calcoli/computazioni utilizzando utilizzando le librerie client ROS come roscpp e rospy. Sono organizzate in pacchetti. Quindi il nodo è un eseguibile che usa ROS per comunicare con altri nodi. Supponendo di avere un robot dotato di telecamera che deve riconoscere la presenza delle persone, si avrà:

• 1 nodo della camera che gestisce il flusso di immagini all’interno del sistema
• Nodo che processa le immagini Questi due nodi sono separati, in quanto svolgono il proprio processo in maniera indipendente, ma comunque comunicano tra di loro scambiandosi dei messaggi. MESSAGGI = strutture di dati (che possono essere interi, stringhe, matrici,..) usati quando si sottoscrive o pubblica un topic. Quando i nodi comunicano, i messaggi si muovono da un nodo all’altro tramite il sistema Publish-Subscribe. Per l’esempio di prima: 1 nodo fa da Publisher (che prende le immagini dalla videocamera e le trasforma in matrici) e poi c’è l’altro nodo Subscriber che deve processare l’immagine. Quest’ultimo si dice che sottoscrive questo TOPIC. Un nodo PUBLISHER invia un messaggio pubblicandolo su un determinato TOPIC, cioè un nodo può pubblicare dati mandando messaggi al topic. Un nodo SUBSCRIBER, interessato a un certo tipo di dati, sotto - scriverà argomento appropriato (riceverà un messaggio). Un nodo può sottoscrivere dati, leggendo i messaggi dal topic. Possono essere presenti più subscriber simultanei per un singolo argomento. Un singolo nodo può pubblicare o sottoscrivere più argomenti. TOPIC = nome utilizzato per descrivere cosa si sta trasmettendo durante questa comunicazione, quindi è sostanzialmente il CONTENUTO del messaggio. Quindi il TOPIC può essere visto come una lavagna: per mandare messaggi, un nodo può scrivere sulla lavagna; mentre per ricevere messaggi, un nodo può leggere dalla lavagna. I nodi non possono comunicare direttamente tra di loro.

PARAMETRI DI ROS

Quando si programma un robot:

• Si deve definire i parametri del robot
• Si deve condividere gli stessi parametri tra 2 o + programmi
• All’aumentare del numero di parametri, dobbiamo memorizzarli come file Il server dei parametri è simile a un magazzino di costanti che possono essere utilizzati da qualsiasi nodo o servizio nel grafo. I valori delle costanti possono anche essere modificati durante il runtime (es. guadagni del controller). Un nodo può leggere, scrivere, modificare ed eliminare i valori dei parametri dal server dei parametri.

RECUP

➢ NODI : i nodi sono unità computazionali individuali e indipendenti, quindi sono come programmi autonomi. Più nodi possono lavorare insieme per raggiungere un particolare task a un alto livello. ➢ MESSAGGI : Strutture di dati che facilitano questo tipo di comprensione tra i nodi. I tipi di messaggio possono essere una stringa semplice, un valore booleano o una struttura C personalizzata a seconda dell'applicazione. ➢ TOPIC : è l' etichetta attaccata alle informazioni inviate da un nodo ➢ ROS MASTER : ROS master fornisce un servizio look-up table per ogni componente registrato nel grafo computazionale. ROS master dispone di strumenti che consentono di vedere lo stato e le proprietà di ciascun nodo ➢ SERVIZI : I servizi ROS gestiscono la richiesta-risposta tramite chiamate di procedura remota ➢ SERVER DEI PARAMETRI : Il server dei parametri è simile a un magazzino di costanti che possono essere utilizzati da qualsiasi nodo o servizio nel grafo. I valori delle costanti possono anche essere modificati durante il runtime. Un nodo può leggere, scrivere, modificare ed eliminare i valori dei parametri dal server dei parametri. ESECIZIO 1 Assumendo di avere un robot con una telecamera, la telecamera gli permette di verificare se ci sono persone che stanno camminando nell’ambiente. Se ci sono persone lungo il percorso, il robot stima le performarce dell'andatura e le mostra sul tablet. Come sarà il grafo computazionale? Quanti nodi? Quanti topics? Una possibile soluzione -------------> ESERCIZIO 2 Assumendo di avere un robot con una telecamera, la telecamera permette al robot di trovare l’arredamento lungo il percorso (es. piante, sedie,...). Se è presente una sedia davanti al robot, il robot si ferma. Se l’ostacolo è una pianta, il robot cambia traiettoria. Come sarà il grafo computazionale? Quanti nodi e quanti topic? Servono dei servizi per raggiungere questo task?

ESERCIZIO 3

Assumendo di avere un robot maggiordomo, quando lo chiedi, tale robot riempe un bicchiere con acqua e ti dà il bicchiere. Come sarà il grafo computazionale? Quanti nodi e quanti topic? Servono dei servizi per raggiungere questo task? ESERCIZIO 4 Assumendo di avere un robot con una telecamera, la telecamera permette al robot di vedere se ci sono delle persone che stanno camminando nell’ambiente. Se viene trovata una persona, il robot dice “ciao”. Come sarà il grafo computazionale? Quanti nodi e quanti topic? Servono dei servizi per raggiungere questo task? ESERCIZIO 5 Assumendo di avere un robot con un laser sulla base, il laser permette al robot di trovare gli ostacoli lungo il suo percorso. Considerando solo i muri, se il robot trova un muro deve ruotare di 90° e continuare a camminare. Come sarà il grafo computazionale? Quanti nodi e quanti topic? Servono dei servizi per raggiungere questo task? Unendo le due soluzioni:

Per navigare nelle cartelle utilizzando il Terminale, possiamo utilizzare i seguenti comandi

➢ cd : se mi trovo in una qualsiasi sottocartella del desktop, per tornare alla home utilizzo questo

comando senza argomenti.

➢ cd / : serve per andare alla ROOT, cioè prima della home

➢ cd .. : questo comando permette di tornare indietro di un livello (es. se sono in home/Desktop/prova2,

con questo comando al terminale torno in desktop)

➢ cd (seguito dal nome cartella) : Per accedere a questa cartella e muoverci all’interno di essa.

➢ ls (senza argomento): stampo a video il contenuto della mia cartella attuale.

ls (seguito dalla cartella ): stampo a video il contenuto della cartella specificata nel percorso.

ESERCIZIO : esegui il seguente task usando solo il terminal

1. Dal repository HOME, vai al Desktop
2. Crea una nuova cartella chiamata "Test"
3. In "Test", crea un nuovo file chiamato "hello.txt" e scrivi all'interno "Hello". Quindi, salva il file e chiudilo
4. Crea una nuova cartella chiamata "Saluti" e sposta il "hello.txt" al suo interno
5. Controlla il contenuto delle cartelle "Test" e "Saluti"
6. Rimuovi entrambe le cartelle
7. Torna alla cartella HOME e visualizza il contenuto Ti porta alla directory HOME (non importa dove ti trovi) Ti porta alla directory ROOT (non importa dove ti trovi) Ti porta a una cartella di livello precedente Consente di accedere alla cartella specificata nel percorso. Il percorso deve fare riferimento a una cartella, altrimenti restituisce un errore Mostra il contenuto della cartella attuale Mostra il contenuto della cartella specificata nel percorso. Il percorso deve fare riferimento a una cartella, altrimenti restituisce un errore.

ROS FILESYSTEM

Il software ROS è diviso in pacchetti che contengono vari tipi di programmi, immagini, dati e eventualmente tutorials. A livello software uno o + nodi sono gestiti da pacchetti. I pacchetti non contengono solo l’implementazione del nodo (e quindi il programma che deve eseguire il nodo), ma anche una serie di files, librerie organizzati al suo interno. Il PACKAGES per noi sarà una cartella, all’interno della quale c’è sicuramente il PACKAGE MANIFEST , ossia un file.xml in cui sono scritte tutte le specifiche del pacchetto (se si basa su c++, su python, ecc..). Ogni PACKAGES per l’esecuzione di un programma deve essere salvato in un workspace che in ROS prende il nome di CATKIN WORKSPACE. ➢ action : Questa cartella contiene i file delle azioni. ➢ config : Tutti i file di configurazione utilizzati in questo pacchetto ROS vengono conservati in questa cartella. Questa cartella viene creata dall'utente ed è pratica comune denominarla config per mantenere i file di configurazione al suo interno. ➢ include/package_name : Questa cartella è composta da intestazioni e librerie che dobbiamo utilizzare all'interno del pacchetto. ➢ launch : questa cartella conserva i file di avvio utilizzati per avviare uno o più nodi ROS. ➢ msg : questa cartella contiene definizioni di messaggi personalizzate. ➢ script : questa cartella conserva gli script Python eseguibili. ➢ src : questa cartella memorizza i codici sorgente C++. ➢ srv : questa cartella contiene le definizioni dei servizi (ad esempio il tipo di dati di risposta e richiesta). Presente se e solo se il pacchetto implementa un servizio ➢ CMakeLists.txt : Questo file contiene le direttive per compilare il pacchetto. ➢ package.xml : questo è il file manifesto del pacchetto di questo pacchetto.

2.TELEOPERATING TIAGO

GAZEBO = simulazione dell’ambiente virtuale 3D, visione ESTERNA del robot. Quindi Gazebo è un simultaore fisico che serve per simulare il mondo fisico. TIAGO ROBOT

• RGB-D camera
• Pannello di espansione
• Base omni- direzionale (2 ruote)
• Collo con 2DOF
• Schermo touschscreen
• Gripper intercambiabili Funzionalità del robot:
• Navigazione autonoma nell’ambiente
• Manipolazione oggetti
• Interazione uomo-robot LANCIARE GAZEBO e svegliare robot

1. Aprire terminale, fare il build e il source del workspace $ cd ~/tiago_public_ws $ catkin build $ source devel/setup.bash
2. Lanciare gazebo $ roslaunch tiago_gazebo tiago_gazebo.launch public_sim:=true end_effector:=pal- gripper Nel caso in cui apparisse un ERRORE nel momento in cui lanci l’ambiente Gazebo, puoi digitare: $ killall - 9 gzserver E dopo puoi rilanciare Gazebo NODI ROS Per runnare (run) un nodo all’interno di un pacchetto, si utilizza rosrun: $ rosrun [package_name] [node_name] $ rosrun key_teleop key_teleop.py (example) Per runnare 2 o + nodi simultaneamente, si utilizza roslaunch: $ roslaunch [package_name] [file_name].launch $ roslaunch tiago_gazebo tiago_gazebo.launch (example)

Quando devo cambiare dei parametri o vedere delle caratteristiche del nodo vado nel formato XLM di ROSLaunch: Param : puoi cambiare i parametri Rosparam : per caricare un file che ha all’interno tutti i parametri

COMANDI ROSNODE

➢ rosnode : restituisce informazioni su come usare questo comando ➢ rosnode info /node_name : stampa informazioni su quel nodo ➢ rosnode kill /nome_name: termina il nodo ➢ rosnode kill - a oppure rosnode kill – all : termina tutti i nodi attivi (oppure per terminare l’esecuzione di un nodo si può digitare ctrl+c oppure chiudere il terminale ) ➢ rosnode list : permette di vedere la lista di tutti i nodi attivi COME INIZIARE UN NODO

1. Aprire nuovo terminale e per vedere tutti i nodi attivi digita: $ rosnode list
2. Aprire un 2° terminale e runnare il nodo con il pacchetto $ source devel/setup.bash $ rosrun key_teleop key_teleop.py Teleop-->permette di muovere il robot attraverso la tastiera
3. Per vedere il grafo del sistema, ovvero la schermata per vedere come sono interconessi nodi (cerchio) e topic (rettangolo), si apre un nuovo terminale e si digita: $ rosrun rqt_graph rqt_graph

ROS SERVICE

➢ rosservice list : lista dei servizi attivi ➢ rosservice type /service_name : stampa il tipo di servizio ➢ rosservice type service_name | rossrv show : stampa il tipo di servizio e il file srv che definisce il servizio ➢ rossservice call /service_name “args” : chiama un servizio con i parametri richiesti (args) ➢ rosservice find /service_type : restituisce tutti i servizi relativi a quella tipologia di servizio che ci interessa ➢ rosservice uri /service_name : visualizza l’URI di un servizio (identifica l’indirizzp del nodo che offre un servizio) ESECUZIONE DI UN SERVIZIO (esempio con GRASP ) $ rosservice type /parallel_gripper_controller/grasp GRASP: si riferisce a un servizio che permette di chiudere le dita del gripper del robot finché non afferra qualcosa (poi blocca le dita con una fora sufficiente per tenere l’oggetto). Quindi è un servizio che fa parte del CONTROLLO DEL GRIPPER ( parallel_gripper_controller ).

ROS PARAMETERS

Parametri= variabili accessibili e modificabili da tutti i nodi durante l’esecuzione (runtime) dei nodi stessi COMANDI PARAMETRI ➢ rosparam set /param_name valore : settare il valore del parametro (nome del parametro e accanto il valore che si vuole settare per questo parametro) ➢ rosparam get /param_name : visualizza il valore attuale del parametro. ➢ rosparam load file_name.formato namespace : carica i parametri da un file (in questo caso params.yaml) nel parameter server di ROS se dopo il file scrivo anche il namespace tutti i parametri vengono raggruppati sotto lo stesso nome ➢ rosparam dump file_name.formato namespace : salvare i parametri in un file ➢ rosparam delete /param_name : cancella il parametro ➢ rosparam list oppure rosparam get / : lista dei nomi dei parametri. Si può utilizzare anche UN’INTERFACCIA GRAFICA , che permette di selezionare i parametri e modificarli, utilizzando il comando: $ rosrun rqt_reconfigure rqt_reconfigure

LASER READING

il laser è un sensore che permette al robot di misurare le distanze dagli oggetti circostanti. In base alle informazioni ottenute dal laser, il robot sa quanto vicino/lontano è da questi oggetti e quindi può muoversi di conseguenza. COME LEGGERE I DATI DEL LASER

1. Crea un nuovo pacchetto detto custom_navigation: $ cd catkin_ws/src →mi sposto nella cartella src del workspace ROS (catkin_ws) $ catkin_create_pgk custom_navigation rospy std_msgs geometry_msgs sensor_msgs actionlib move_base_msgs →crea il nuovo pacchetto (nella cartella src) custom_navigation che dipende dagli elementi scritti dopo (ovvero tutti gli elementi che sono usati nel codice)
2. Crea una nuova cartella scripts nel pacchetto custom_navigation creato prima $ mkdir custom_navigation/scripts
3. Crea un nuovo file detto reading_laser.py $ cd custom_navigation/scripts $ gedit reading_laser.py Il file reading_laser.py è uno script Python è un nodo ROS scritto per leggere e processare i dati di un sensore LIDAR (LaserScan), pubblicati sul topic /scan_raw (che è stato selezionato su Rviz). PER COMPILARE E RENDERE ESEGUIBILE LO SCRIPT PYTHON
4. Compila lo script python $ chmod +x /reading_laser.py
5. Fai build e source del workspace $ catkin build custom_navigation $ source devel/setup.bash
6. Rendi eseguibile lo script python $ rosrun custom_navigation reading_laser.py Lista di distanze misurate dal laser LIDAR, una per ogni angolo Stampa la distanza rilevata in 3 direzioni: 0= a sx del robot, 333= davanti, 665= dx Divide il campo visivo del LIDAR in 5 settori e per ciascuno calcola la distanza più vicina rilevata rispetto all’ostacolo È simile alla parte precedente, ma limita il valore massimo a 10metri (se un oggetto è troppo lontano, si considera come fosse a 10m al massimo) Si inizializza il nodo subscriber reading_laser e ogni volta che riceve messaggi dal topic /scan_raw (che contiene tutti i dati prelevati dal laser)si attiva la funzione clbk_laser(msg) spiegata prima

OBSTACLE AVOIDANCE (evitare)

1. Per evitare gli ostacoli crea un nuovo file detto obstacle_avoidance.py nella cartella scripts del

pacchetto custom_navigation:

$ cd custom_navigation/scripts

$ gedit obstacle_avoidance.py

2. (script di python, in cui vengono aggiunte delle parti relative all’evitare gli ostacoli rispetto al

file python visto prima)

PER COMPILARE E RENDERE ESEGUIBILE LO SCRIPT PYTHON

1. Compila

$ chmod +x /obstacle_avoidance.py

$ catkin build custom_navigation

$ source devel/setup.bash

2. Rendi eseguibile

$ rosrun custom_navigation obstacle_avoidance.py

ACTIONLIB : Actionlib è una versione modificata dei servizi ROS, che permette di annullare un

processo in esecuzione sul server, se necessario. Viene utilizzato per eseguire azioni lunghe e

complesse, gestendone anche il feedback durante l’esecuzione.

Esempi: far navigare il robot verso un obiettivo, oppure pianificare un percorso di movimento.

CREA UNA MAP CON GMAPPING

SEGUIRE IL MURO

1. Crea un nuovo file detto follow_wall.py nella cartella script del pacchetto custom_navigation $ cd custom_navigation/scripts $ gedit follow_wall.py
2. Compilare $ chmod +x /follow_wall.py $ catkin build custom_navigation $ source devel/setup.bash
3. Rendere eseguibile il file $ rosrun custom_navigation follow_wall.py CREARE UNA MAPPA
4. Apri un terminare e sveglia tiago (source) $ cd /tiago_public_ws/ $ source devel/setup.bash
5. Lancia Gazebo e Rviz per la simulazione della navigazione: $ roslaunch tiago_2dnav_gazebo tiago_mapping.launch public_sim:=true
6. Aprire un 2° terminale e sveglia tiago $ cd /tiago_public_ws/ $ source devel/setup.bash
7. Muovere il robot per costruire la mappa $ rosrun custom_navigation follow_wall.py

5. Salva la mappa mentre la navigazione sta runnando

$ rosrun map_server map_saver

La mappa ha 2 formati: file.pgm (immagine della mappa) e file.yaml (contiene l’origine, la risoluzione e le caratteristiche della mappa)

6. Per controllare se è stata creata la mappa $ cd .pal/tiago_maps/config $ xdg-open map.pgm

LOCALIZZARE IL ROBOT NELL’AMBIENTE

1. Aprire 1° terminale e fare il source $ cd /tiago_public_ws/ $ source devel/setup.bash
2. Lanciare l’ambiente di simulazione della navigazione, aprendo Gazebo e Rviz $ roslaunch tiago_2dnav_gazebo tiago_navigation.launch public_sim:=true lost:=true world:=small_office
3. Aprire 2° terminale e fare source $ cd /tiago_public_ws/ $ source devel/setup.bash
4. Chiama il servizio AMCL (localizzazione probabilistica: tutti i punti della mappa hanno la stessa probabilità di essere occupati dal robot, quindi il robot può trovarsi ovunque)

$ rosservice call /global_localization “{}”

5. Per far arrivare il robot nella pose giusta, si può far ruotare il robot su se stesso, utilizzando

$ rosrun key_teleop key_teleop.py

6. Quando il robot è localizzato, si può ripulire (azzerare) la mappa dei costi

$ rosservice call /move_base/clear_costmaps “{}”

NAVIGAZIONE AUTONOMA RVIZ

1. Aprire 1° terminale e fare il source $ cd /tiago_public_ws/ $ source devel/setup.bash
2. Lanciare l’ambiente virtuale per la simulazione della navigazione, aprendo Gazebo e Rviz $ roslaunch tiago_2dnav_gazebo tiago_navigation.launch public_sim:=true world:=small_office
3. Premi il tasto 2D Nav Goal su Rviz e posiziona la freccia nella posizione e orientazione desiderata

NAVIGAZIONE AUTONOMA IMPOSTANDO UN GOAL

Per selezionare un goal premo il tasto Publish Point e in basso a sx appaiono le coordinate del goal che hai selezionato.

1. Aprire 1° terminale e fare source $ cd /tiago_public_ws/ $ source devel/setup.bash
2. Lanciare l’ambiente di simulazione, aprendo gazebo e rviz $ roslaunch tiago_2dnav_gazebo tiago_navigation.launch public_sim:=true world:=small_office
3. Eseguire il nodo custom_nav_goal.py $ rosrun custom_navigation custom_nav_goal.py