In questo tutorial andremo a vedere come definire messaggi personalizzati da utilizzare all’interno dei nostri nodi e come comporli per ottenere messaggi più elaborati. Inoltre vedremo come poter accedere ai singoli campi dei messaggi in modo più intuitivo all’interno del codice.
Il progetto descritto da questo tutorial è disponibile sul sito di TheConstruct al seguente link: Definizione e nesting di messaggi personalizzati [ROS Noetic] [Python]
Definire la struttura dei messaggi
All’interno del package in cui vogliamo andare a definire i nostri messaggi personalizzati (in questo caso custom_messages_nesting) andiamo a creare una nuova cartella, identificata dal nome “msg”. Questa sarà la cartella che durante la compilazione sarà utilizzata per verificare la presenza dei file di definizione dei messaggi personalizzati (che indicheremo successivamente).
Quindi possiamo creare un file con estensione .msg per ogni tipo di messaggio personalizzato che vogliamo definire.
Nel caso di questo tutorial assumiamo di voler avere un messaggio che contiene delle letture provenienti da sensori di un robot mobile con una componente di edge computing visiva, e avremo quindi:
NestedCustomMessage.msg che conterrà un’istanza dei seguenti messaggi e vi aggiungerà un ID
LidarGradient.msg rappresentante i valori del gradiente computato su una serie di letture da parte di un LiDAR
BoundingBoxLabeled.msg contenente le coordinate di una bounding box e la relativa label
EncodersReadings.msg con i valori letti dagli encoder delle ruote del nostro robot
Di seguito riportiamo le definizioni dei messaggi, in modo da avere un’idea chiara e immediata della loro struttura. In particolare possiamo notare come messaggi personalizzati possano essere annidati per andare a comporne altri più complessi, nel caso di NestedCustomMessage.
NestedCustomMessage.msg
int32 id
LidarGradient gradient
BoundingBoxLabeled bb_labeled
EncodersReadings enc_readings
Garantire la compilazione e generazione dei messaggi
Per poter usufruire dei messaggi che abbiamo definito è necessario dare indicazione a ROS di dove si trovino e delle dependencies necessarie alla loro compilazione e generazione. Per questo motivo apporteremo delle modifiche al file CMakeLists.txt e al Package.xml del nostro package.
Package.xml
All’interno di questo file dobbiamo aggiungere le due seguenti righe:
E includiamo le dependencies necessarie per la generazione dei nostri messaggi. In questo caso i nostri messaggi dipendono solo da std_msgs (abbiamo usato solo stringhe e float), per cui sarà sufficiente includere:
generate_messages(
DEPENDENCIES
std_msgs
)
Generazione dei messaggi
Possiamo a questo punto verificare che tutto sia stato definito in modo corretto e che ROS sia in grado di trovare, identificare e generare i nostri messaggi personalizzati.
Ci spostiamo all’interno di un terminale, a livello del nostro workspace di catkin, e ricompiliamo.
catkin_make
Importare e accedere ai singoli campi dei messaggi
La situazione di partenza di questo tutorial è un semplice publisher (custom_messages_nesting/script/custom_user_node.py) che pubblica un Float32. Andremo ora a modificare il codice per poter includere i nostri messaggi.
#! /usr/bin/env python3
import rospy
from std_msgs.msg import Float32
def start_chatter():
rospy.init_node('custom_chatter')
pub = rospy.Publisher('custom_chatter_topic', Float32, queue_size = 10)
rate = rospy.Rate(1)
id = 0
while not rospy.is_shutdown():
id += 1
pub.publish(id)
rate.sleep()
if __name__ == "__main__":
try:
start_chatter()
except rospy.ROSInterruptException:
pass
Vogliamo per prima cosa importare i messaggi personalizzati. Aggiungiamo quindi (o rimpiazziamo l’import già presente con):
from custom_messages_nesting.msg import LidarGradient.msg, BoundingBoxLabeled.msg, EncodersReadings.msg, NestedCustomMessage.msg
Possiamo poi quindi ridefinire il publisher in modo che pubblichi il nostro NestedCustomMessage:
Per poter accedere ai singoli campi della struttura del NestedCustomMessage (nel caso della pubblicazione) sarà sufficiente istanziare i sottomessaggi di cui è composto e assegnare ai rispettivi campi i valori letti dai nostri ipotetici sensori. Istanziamo quindi tutti i messaggi necessari:
E procediamo ad assegnare loro dei valori, accedendo ai campi del messaggio con il nome che abbiamo indicato all’interno della rispettiva definizione. In particolare per questo esempio abbiamo selezionato i seguenti valori:
Avendo assegnato valori a tutte le componenti di NestedCustomMessage, queste possono poi essere unite per andare a comporre il nostro messaggio finale in questo modo:
Il risulato che ci aspettiamo è di osservare che il nostro messaggio viene pubblicato una volta al secondo, con ID crescente e con gli altri campi in accordo con quello che abbiamo indicato nel codice del nodo.
E con questo abbiamo accesso a infinite possibilità, componendo i messaggi come più conviene e utilizzandoli all’interno della nostra implementazione!
ROS (Robot Operating System) is a de facto standard for Robotics. In order to program Robots, simulation of Real world systems is very important to test and debug the systems. MoveIt is most commonly used Motion Planning Library for Robotic Arms or Manipulators. In this tutorial we will create MoveIt Package for simple robotic arm.
Opening the ROSJect:
To follow along the post, we need to have ROS2 installed in our system. To make things easier, we have created ROSJect to follow along: https://app.theconstruct.ai/l/5fcb7f9e/.
Next, fort the ROSJect and click Run. You will be presented with the interface like following.
In terminal, go to your workspace. by running the following command
cd catkin_ws/src
and then clone the resource Robotic arm Package from Github. by typing
Click on “Create New MoveIt Configuration Package”. and select URDF File for package we have cloned in our ROS Workspace.
Next, go to “Planning Groups” and create new Group “Add Group”, and write name of group, kinematic solver and Group Default planner as follows
Then Create new Kinematic Chain, as follows
Then select joints for this group
and after that select Links for this Planning Group
After going through this step, we can configure various poses for Robotic Arm.
Next fill out some author information,
and generate the MoveIt Package.
Final Thoughts
Now that we have generated the MoveIt package for our robotic arm, next we will add custom controllers and hardware interfaces for simulating this in Gazebo. MoveIt is very practically useful tool for robotic arms as it can be used for motion planning, trajectory generation and solving Inverse Kinematics for Robotic arms.
Olá! Hoje vamos explorar os serviços do ROS, focando no ROS 1 Noetic e em um dos robôs mais fascinantes disponíveis na plataforma: o BB-8 de Star Wars. Utilizaremos os serviços para criar comandos que permitam ao BB-8 desenhar formas no chão ou seguir trajetórias específicas, como quadrados ou círculos, por meio de mensagens customizadas.
Abrindo o rosject
Para acompanhar este tutorial, utilize um rosject, que é essencialmente um projeto ROS configurado para rodar um exemplo. Acesse o link fornecido e clique no botão vermelho.
Inicie abrindo um terminal e siga os comandos abaixo para criar o pacote e os arquivos necessários para nossa aplicação.
roscd; cd ..; cd src/bb8; catkin_create_pkg bb8_service_pkg roscpp std_msgs
cd bb8_service_pkg; mkdir srv;
cd srv; touch bb8ServiceMessage.srv; cd ..;
cd src; touch bb8_service_server.cpp; chmod +x *.cpp
Você notará que novos arquivos surgirão na árvore de pastas da janela IDE.
Configurando a mensagens de serviço As mensagens de serviço incluem sempre os requests e responses. Para comandar o BB-8, trataremos isso como uma string. Edite o arquivo bb8ServiceMessage.srv com o seguinte conteúdo:
string command # A string command representing the action
---
bool success # Did it achieve it?
Preparando para compilar
É importante modificar o CMakeList.txt copiando e colando o conteúdo abaixo, substituindo o conteúdo existente.
Não esqueça de adicionar as três linhas indicadas no final do package.xml. Atençã0, não substitua todo o conteúdo do arquivo! Apenas adicione as linhas:
Agora, você pode prosseguir para a parte onde os comandos são recebidos pelo servidor do serviço. Na pasta src, abra o arquivo bb8_service_server.cpp e insira o conteúdo necessário.
No terminal 1, xecute o comando abaixo para compilar apenas o pacote que criamos, economizando tempo.
cd ~/catkin_ws/; catkin_make --only-pkg-with-deps bb8_service_pkg; source devel/setup.bash
Se tudo foi feito corretamente, você não verá nenhum erro no prompt:
Após a compilação, inicie o Gazebo com o comando apropriado para visualizar o robô BB-8 preparado para funcionar.
roslaunch bb_8_gazebo main.launch
Isto fará aparecer a janela do Gazebo.
Rodando o servidor de serviços
No terminal 2, execute o comando para iniciar o servidor de serviços:
rosrun bb8_service_pkg bb8_service_server
Uma mensagem confirmará que o serviço está pronto.
Chamando o serviço criado
Utilize um terceiro terminal para enviar comandos ao BB-8. Por exemplo, para fazê-lo se mover em um quadrado ou círculo, ou até mesmo dançar, use os comandos apropriados.
Sa ating nakaraang ROSject, ating tinutukan ang hinggil sa paglikha ng mga packages at nodes sa ROS2. Ngayon naman sa maikling gabay na ito, ating dadaluban kung paano natin magagamit ang mga ito upang magpatakbo ng isang robot!
Bilang gabay sa mga tatalakayin ng proyektong ito, sila ay nakalista bilang mga sumusunod:
Introduksyon sa Kurso
1.1 Mga Pangangailangan sa Kurso at mga Sanggunian
Panunumbalik sa Konsepto ng Packages at Nodes
2.1 Madaliang Introduksyon sa ROS Package at Node
Paano Gumawa ng Packages at Nodes sa ROS2 para mapagalaw ang Turtlebot
3.1 Pagpapagalaw Padiretso 3.2 Pagpapagalaw ng Pabilog 3.3 Pagpapagalaw ng Parisukat
Takda: Paggawa ng Simpleng Obstacle Avoidance Algorithm para sa Turtlebot
Unit 1.1 Mga Pangangailangan sa Kurso at mga Sanggunian
Para sa kursong ito, tinataya ng may-akda na may kaalaman ka na sa pangunahing operasyong pang-terminal ng mga sistemang gumagana sa Ubuntu 22.04 LTS na OS at maging sa pangunahing nabigasyon and commands na ginagamit sa mga Linux terminals. Kung nais mo pang matuto ng mga programming fundamentals na kailangan para sa pag-aral ng ROS, mangyaring tumungo at tignan ang kursong Code Foundation for ROS Learning Path ng The Construct! Tiyak na matututunan mo ang lahat ng kailangan mong kaalaman upang masimulan mo na ang paggamit ng ROS!
Mga Akdang Kasama sa Code Foundation for ROS Learning Path:
At kung interesado ka na rin sa kung paano gumawa ng mga packages at nodes sa ROS2, mangyaring tignan mo na rin ang gabay na ito: How to Create Packages and Nodes in ROS2
Sa tutorial na ito, Gagamitin natin ang ROSject platform na handog ng TheConstruct! Subalit, kung nais niyong gumamit ng sariling virtual machine o computer, mangyaring gawing gabay ang OS-to-Distribution compatibilities na siyang ibinahagi ng opisyal na dokumentasyon ng ros.org para sa ROS2 Humble Hawksbill ROS2 Humble Hawksbill: PC o Virtual Machine na may Ubuntu 22.04 LTS
Unit 2 ROS Packages at Nodes?
Ating balikan ang konsepto ng mga ROS packages at nodes.
Sa madaling salita, maaari nating silang tignan sa lente na kung saan ang isang package ay maaring tumutukoy sa isang partikular na bahagi o functionality ng ating robot. Bilang payak na halimbawa, maaring itong maging isang camera. Ating isipin na ang camera ng ating robot ang siyang kabuuan ng package — at sa loob nito, mayroon tayong iba pang mas maliliit ng kumpuni na, sa kontektso ng ROS, ay silang mga modyul, code, at iba pang mga bahagi na kailangan upang mabuo at mapagana ang ating camera. Yan ang ideya ng mga package sa ROS — maaari itong ilarawan bilang isang koleksyon o lipon ng mga sub-component na sa simulang sila’y paganahin ay mabubuo nila ang isang operasyon na siyang maihahalintulad sa naturang katangian, kumpuni, o functionality ng ating robot.
Ngayon, ano namana ng mga tinatawag na NODES? Kung ang package ang siyang kumakatawan sa kabuuan ng isang kumpuni ng ating robot, ang nodes naman ang siyang maituturing na parte ng kumpuni ng ating robot. Ang mga ito, kapag pinagsama, ay siyang bumubuo o kumakatawan sa mga kakayanan o functionalities ng mga parte ng ating robot. Maaari nating isipin ito na parang ang workspace ang kabuuan ng ating robot habang ang isang parte nito, halimbawa na ay ang mga motor, ang siyang tinutukoy na package; habang ang mga nagpapagana naman sa ating motor ang siyang itinuturing na ROS Nodes!
Sa maikling bahagi na ito, tayo’y gagawa ng isang demonstrasyon hinggil sa kung paano ginagamit ang mga packages sa ROS2 sa pamamagitan ng Turtlesim! Para dito, kakailanganin nating gumamit ng hiwalay na virtual machine na mayroong Ubuntu 22.04 LTS na OS at may naka-install nang ROS2 Humble. Matapos dito ay tutungo na tayo sa paggawa ng ROS2 package sa ROSject na ito!
Paano Gumawa ng Packages at Nodes sa ROS2 para mapagalaw ang Turtlebot
Ngayon at may ideya na tayo hinggil sa Packages at Nodes, atin nang simulan ang pagpapatakbo ng ating Turtlebot! Para sa takdang ito, ating muling gagamitin ang Turtlesim platform upang magsilbing simulasyon para sa ating munting proyekto!
Bilang panimula, sa ating home directory, mangyaring gumawa ng Workspaces na folder na siyang maglalaman ng lahat ng ating mga workspaces. Matapos nito ay gumawa tayo ng turtlebot_ws na workspace sa loob na siyang maglalaman ng ating mga scripts upang mapatakbo ang turtlebot — at mangyaring patakbuhin ang colcon build upang mabuo ito.
In [ ]:
# Gawin sa Terminal 1
user:~$ mkdir Workspaces
user:~$ cd Workspaces
user:~/Workspaces$ mkdir turtlebot_ws
user:~/Workspaces$ cd turtlebot_ws
user:~/Workspaces/turtlebot_ws$ colcon build
Matapos patakbuhin ang mga ito, ganito dapat ang kalalabasan ng iyong directory para sa naturang workspace.
Sunod, siguraduhing naka-source nang maigi ang ating workspace sa papamamagitan ng pagpapatakbo ng:
In [ ]:
user:~/Workspaces/turtlebot_ws$ cd ~
user:~$ source ~/Workspaces/turtlebot_ws/install/devel/setup.bash
Ngayon naman ay ating nang gawin ang naturang package na magpapagalaw sa ating turtlesim!
Muli tayong bumalik sa ating turtlesim_ws, gumawa ng src folder at sa loob nito ay patakbuhin ang:
In [ ]:
user:~$ cd Workspaces/turtlebot_ws
user:~/Workspaces/turtlebot_ws$ mkdir src
user:~/Workspaces/turtlebot_ws$ cd src
user:~/Workspaces/turtlebot_ws/src$ ros2 pkg create moveturtle –build-type ament_python –dependencies rclpy geometry_msgs sensor_msgs std_msgs
Pag matagumpay ang iyong paggawa ng package, mangyaring tumungo muli sa ating workspace folder — turtlebot_ws — at patakbuhin ang colcon build. Dapat ay makita mong successful ang paggawa ng iyong package matapos ang hakbang na ito.
In [ ]:
user:~/Workspaces/turtlebot_ws$ colcon build
Kapag may lumabas na ganitong error o warning sa inyong webshell:
Mangyaring patakbuhin ang naturang syntax upang ma-update ang version ng setuptools na ginagamit ng ROSject na ito:
pip install setuptools==58.2.0
Matapos ang hakbang na ito, maaari na tayong gumawa ng ating mga nodes upang mapatakbo ang ating turtlebot!
Ngayon, tayo naman ay tumungo sa ating /moveturtle/moveturtle directory kung saan natin gagawin ang ating mga nodes.Para sa takdang ito, gagawa tayo ng tatlong uri ng galaw para sa ating turtlesim: Padiretso, Pabilog, at Parisukat na ating papangalanang line.py, circle.py, at square.py.
Upang matignan kung executable na ang ating mga nagawang file, mangyaring patakbuhin ang ‘ls-la’ sa terminal. Dapat ay may x nanakakabit sa access types ng iyong mga nalikhang files at makikita mo ring kulang luntian ang mga pangalan nito.
Ngayon, ang mga sumusunod na cells ay tumutukoy sa syntax ng bawat galaw na ating patatakbuhin para sa Turtlebot. Naglagay na rin ako ng mga pagpapaliwanang hinggil sa kung ano ang gamit ng bawat linyang nasa code.
–Syntax Para sa line.py–
In [ ]:
#!/user/env/python3
import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Twist
class LineNode(Node):
def __init__(self):
super().__init__("line")
self.cmd_vel_publisher_ = self.create_publisher(Twist, '/turtle1/cmd_vel', 10)
self.timer_ = self.create_timer(0.5, self.publish_velocity)
self.get_logger().info("Moving in a Line")
def publish_velocity(self):
msg = Twist()
msg.linear.x = 0.2
self.cmd_vel_publisher_.publish(msg)
def main(args=None):
rclpy.init(args=args)
node = LineNode()
rclpy.spin(node)
rclpy.shutdown
if __name__=='__main__':
main()
–Huling Bahagi ng Syntax Para sa line.py–
–Syntax Para sa circle.py–
In [ ]:
#!/user/env/python3
import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Twist
class CircleNode(Node):
def __init__(self):
super().__init__("circle")
self.cmd_vel_publisher_ = self.create_publisher(Twist, '/turtle1/cmd_vel', 10)
self.timer_ = self.create_timer(0.5, self.publish_velocity)
self.get_logger().info("Moving in a Circle")
def publish_velocity(self):
msg = Twist()
msg.linear.x = 0.2
msg.angular.z = 0.1
self.cmd_vel_publisher_.publish(msg)
def main(args=None):
rclpy.init(args=args)
node = CircleNode()
rclpy.spin(node)
rclpy.shutdown
if __name__=='__main__':
main()
Pagkatapos ng iyong paggawa ng mga program na ito, mangyaring pumunta sa setup.py at iinput ang mga sumusunod:
Muling bumalik sa workspace folder — turtlebot_ws — at patakbuhin ang colcon build. Kapag matagumpay itong nagawa, maaari na anting subukang patakbuhin ang ating turtlesim!
Sa ikalawang terminal, patakbuhin ang sumusunod na syntax upang mabuksan ang turtlesim:
In [ ]:
user:~$ ros2 run turtlesim turtlesim_node
Pagkatapos nito ay lalabas na ang naturang simulation:
Bumalik muli tayo sa terminal 1 at muling i-source ang workspace upang masigurong gumagana na ito. Matapos naman nito ay atin nang subukang patakbuhin ang mga nodes na ating nagawa!
In [ ]:
user:~/Workspaces/turtlebot_ws$ source install/setup.bash
Sa parehong terminal, atin munang siyasatin ang mga nainstall na nodes sa pamamagitan ng pagpapatakbo ng:
In [ ]:
user:~/Workspaces/turtlebot_ws$ ros2 run moveturtle
Kasunod nito ay pindutin ang ‘tab’ nang dalawang beses at ganito ang kaniyang kalalabasan.
Kung ating papansinin, makikita natin ang ating mga nalikhang nodes: circle_node, line_node, at square_node. Halina’t patakbuhin natin sila nang isa-isa.
In [ ]:
# Pagpapatakbo sa cirle_node
user:~/Workspaces/turtlebot_ws$ ros2 run moveturtle circle_node
In [ ]:
# Pagpapatakbo sa line_node
user:~/Workspaces/turtlebot_ws$ ros2 run moveturtle line_node
In [ ]:
# Pagpapatakbo sa square_node
user:~/Workspaces/turtlebot_ws$ ros2 run moveturtle square_node
Sa bawat pagtakbo nito, dapat makikita niyong bumubuo na ng mga hugis ang ating turtlesim — pabilog, padiretso, at parisukat!
At ayan! Matagumpay nating nagawa ang ating nodes sa ROS2 upang mapatakbo ang Turtlesim! Kapag tapos ka nang magsiyasat, maaarin mong pindutin ang “ctrl + c” upang patayon na ang naturang node at maging ang simulation. At diyan nagtatapos ang ating maikling gabay hinggil sa paggawa ng nodes para sa Turtlesim! Nawa’y may natutunan kayong bago na makatutulong sa inyong pag-aaral ng ROS!
Para sa iba pang mga ROSject na tulad nito, mangyaring bisitahin ang The Construct. Nag-aalok sila ng napakaraming praktikal na mga gabay sa ROS mula sa mga payak hanggang sa mga konseptong pangbihasa na!
Hanngang sa muli! Ito si Christian C. Anabeza, ang inyong ROSbotics Ambassador para sa Pilipinas!
In questo tutorial vedremo come sia possibile configurare ROS per funzionare su più macchine connesse attraverso la rete, espandendo le possibilità per i tuoi progetti.
La configurazione iniziale parte da un nodo publisher minimale chatter.py appartenente al pacchetto chatter, con un singolo publisher di stringhe.
roscore
Consideriamo che un roscore per poter essere eseguito necessita di una configurazione iniziale di due variabili principali all’interno del nostro terminale (che sono inizializzate con un valore di default).
ROS_MASTER_URI Definisce l’indirizzo della macchina che avrà il ruolo di “master” per la nostra rete di ROS. La sua struttura è definita come
http://< indirizzo_della_macchina>:11311
ROS_HOSTNAME Definisce l’indirizzo della macchine ospite (quella che vogliamo che sia in grado di comunicare con il roscore), tipicamente l’ip della macchina che stiamo configurando.
Possiamo leggere il contenuto di queste due variabili con le seguenti istruzioni:
Come puoi vedere il nome dell’ospite e del master corrente è settato con un nome simbolico a causa dell’implementazione dei Rosject, nella tua macchina potresti vedere “localhost” o un indirizzo specifico se hai già modificato le variabili.
Ora, possiamo provare a runnare un roscore in un primo terminal, e a osservare il suo output.
roscore
# Output: process[master]: started with pid [4295]
# ROS_MASTER_URI=http://4_xterm:11311/
Possiamo notare quindi, come previsto, il ROS_MASTER_URI settato sulla macchina corrente.
Settare il roscore per connettere altre macchine
All’interno della macchina su cui vogliamo far girare il roscore e ospitare altre macchine (tipicamente la nostra macchina) dovremo cambiare i valori all’interno delle due variabili già menzionate.
All’interno della macchina che vogliamo utilizzare come ospite (tipicamente il nostro robot, o i nostri robot) dovremmo fare lo stesso, ma con valori differenti.
Vediamo quindi nel dettaglio come impostare questi valori.
Macchina ospitante
ROS_MASTER_URI dovrà essere impostato con l’ip della macchina all’interno della nostra rete. Per trovare questo ip si possono utilizzare le impostazioni di rete, del router, o anche comandi da terminale come ifconfig o ip addr. Poiché lavoreremo su un solo Rosject, utilizzeremo l’indirizzo corrispondente al localhost.
Assumiamo quindi che la nostra macchina abbia come indirizzo 127.0.0.1. In una prima shell eseguiamo:
exportROS_MASTER_URI=http://127.0.0.1:11311
exportROS_HOSTNAME=127.0.0.1
ROS_HOSTNAME sarà l’ip stesso della macchina.
Faremo lo stesso in una seconda shell, per scopo di testing.
Macchina ospite (e.g. robot)
ROS_MASTER_URI dovrà essere impostato con l’ip della macchina ospitante all’interno della nostra rete. Perciò utilizzeremo lo stesso comando della configurazione sulla macchina ospitante. In una terza shell, eseguiamo:
export ROS_MASTER_URI=http://127.0.0.1:11311
Per quanto riguarda ROS_HOSTNAME dovremo usare invece l’ip della macchina ospite, recuperabile con gli stessi metodi già menzionati. Assumiamo quindi che il nostro robot abbia come indirizzo ip 127.0.0.42.
export ROS_HOSTNAME=127.0.0.42
A questo punto le due macchine saranno in grado di comunicare e di avere accesso a tutti i messaggi pubblicati all’interno della rete e di pubblicare a loro volta.
Considerazioni importanti per questo rosject
Quando si cambiano i valori di queste variabili, la modifica sarà limitata alla shell su cui viene invocato il comando. Di fatto, aprendo una nuova shell, essa avrà nuovamente le variabili settate con i valori di default.
Sicuramente è possibile inserire i due comandi nel file ~/.bashrc, ma in questo caso non lo faremo per verificare l’effetto della modifica.
Test del nostro nodo
Nella terza shell (che sarebbe eseguita sul robot), possiamo quindi lanciare l’esecuzione del nostro nodo chatter (che possiamo interpretare come un nodo nel nostro robot che pubblica lo stato di un sensore).
rosrun chatter chatter.py
Grazie alla stampa ad output possiamo notare che il nodo inizia a inviare messaggi.
Andando quindi nella seconda shell (che si troverebbe sulla macchina del master) possiamo andare a stampare la lista dei topic pubblicati.
rostopic list
Ecco qui, anche se ci troviamo su una macchina differente, riceviamo i messaggi mandati dal nostro robot.
Osservazione
Se proviamo ad aprire una quarta shell, che quindi sarà configurata con i valori di default (a meno che le istruzioni di export non siano state messe nel file ~/.bashrc), questa shell non sarà in grado di interagire con il roscore, nemmeno se aperta sulla stessa macchina del master.
La configurazione dovrà essere ripetuta per ogni shell aperta, in accordo con la macchina su cui viene aperta (vedi differenze tra macchina ospitante e macchina ospite), oppure per comodità si potrà utilizzare il file ~/.bashrc.