05/05/2017 HelloWorldnoRobotOperatingSystem(ROS)Embarcados

Criando um "Hello World" no Robot Operating System (ROS)

Por Francisco Erivaldo Fernandes Junior - 08/07/2016

Este post faz parte da srie ROS (Robot Operating System). Leia tambm os outros posts da srie:

Uma introduo ao Robot Operating System (ROS)

Entendendo os ns do ROS
Entendendo as mensagens e tpicos do ROS
Criando um "Hello World" no Robot Operating System (ROS)

ltimo artigo da srie introdutria sobre o Robot Operating System. Vamos nalmente colocar as mos na massa e construir nosso
primeiro pacote em C++ contendo um "Hello World" no ROS.

Criando um workspace para seus pacotes

Antes de criarmos nosso primeiro pacote no ROS, precisaremos criar um local aonde iremos armazenar todos os nossos pacotes
personalizados (pacotes criados por ns). Em nosso caso, chamamosesse local de umcatkin workspace.

Vamos criar nossocatkin workspace em nosso diretrio de usurio com os seguintes comandos:

1 ~$ mkdir -p ~/catkin_ws/src
2 ~$ cd ~/catkin_ws/src

1 beginner_tutorials_generate_messages_cpp

1 ~/catkin_ws/src$ catkin_init_workspace

Em outras palavras, nosso catkin workspace foi criado na pasta catkin_ws dentro do seu diretrio de usurio
(/home/SEU_USERNAME). Alm disso, todos os nossos pacotes caro armazenados na pasta src dentro do seu catkin
workspace.

Mesmo que no tenhamos criado nenhum pacote, j podemos compilar nossocatkin workspace com o comando catkin_make:

1 ~/catkin_ws/src$ cd ..

a
2 ~/catkin_ws$ catkin_make
86 d 0 f 2 k 42
Gostou? Junte-se comunidade Embarcados

https://www.embarcados.com.br/criandoumhelloworldnorobotoperatingsystem/ 1/10
05/05/2017 HelloWorldnoRobotOperatingSystem(ROS)Embarcados

O comandocatkin_make deve ser sempre executado na pasta raiz do seu catkin workspace, caso contrrio voc receber vrias
mensagens de erro.

Para que todos os seus pacotes sejam visveis em qualquer terminal de sua mquina, precisamos executar os seguintes comandos:

1 ~/catkin_ws$ echo "source /home/SEU_USERNAME/catkin_ws/devel/setup.bash" >> ~/.bashrc

2 ~/catkin_ws$ source ~/.bashrc

Nota: substitua SEU_USERNAME pelo seu nome de usurio.

Criando seu primeiro pacote

Agora que conguramos nosso catkin workspace, podemos nalmente criar nosso primeiro pacote. Navegue para a pasta
catkin/src e execute o seguinte comando:

1 ~/catkin_ws/src$ catkin_create_pkg ros_embarcados_tutorial std_msgs rospy roscpp

Pronto! Acabamos de criar um pacote chamado ros_embarcados_tutorial que depende dos pacotes std_msgs, rospy e roscpp.
Entretanto, o pacotes que acabamos de criar est vazio e precisamos adicionar nosso cdigo para termos nosso "Hello World" no
ROS. Mas, antes disso, vamos entender um pouco mais como a estrutura de um pacote no ROS.

O pacote std_msgs possui wrappers para os tipos primitivos de mensagens existentes no ROS, tais como Bool, Byte, Float32,
Float64, etc. Em outras palavras, o pacote bsico para qualquer pacote que voc esteja criando.

O pacote rospy o responsvel por criar uma interface para a criao de ns usando Python. um pacote bsico se voc estiver
criando pacotes que utilizem scripts escritos em Python. No nosso caso, como vamos criar nosso pacote usando C++, no
necessrio a sua utilizao.

O pacote roscpp semelhante ao pacote rospy, mas utilizado quando estamos criando pacotes com ns escritos em C++.

Entendendo a estrutura do seu primeiro pacote

a 86 d 0 f 2 k 42
Gostou? Junte-se comunidade Embarcados

https://www.embarcados.com.br/criandoumhelloworldnorobotoperatingsystem/ 2/10
05/05/2017 HelloWorldnoRobotOperatingSystem(ROS)Embarcados

Abra seu gerenciador de arquivos e navegue at a pasta que contm o seu pacote. Voc ver duas pastas (include e src) e dois
arquivos (CMakeLists.txt e package.xml), conforme mostrado na Figura 1.

Figura1EstruturadearquivosdeumpacotenoROS.

Como voc deve ter percebido, catkin um sistema baseado em cmake. Se voc possui familiaridade com cmake no ter
problemas em criar pacotes mais avanado. Para os que no sabem, eu incluso, temos que sofrer um pouco para entender as
sutilezas do cmake. Entretanto, mostrarei como modicar o arquivo CMakeLists.txt para nosso "Hello World".

Enquanto o arquivo CMakeLists.txt utilizado para compilar seu pacote, o arquivo package.xml utilizado como um manifesto para
seu pacote. Ele contm os dados bsicos do seu pacote. Por exemplo, nele que voc deve denir o tipo de licena utilizada em
seu pacote (GPL, BSD, etc), o nome do mantenedor e endereo de email, etc. Esse arquivo tambm contm a lista de dependncias
que seu pacote precisa para funcionar corretamente.

A pasta src utilizada para armazenar os cdigos fontes C++ do seu pacote e a pasta include utilizada para armazenar os
arquivos de cabealho do seu pacote (arquivos .h).

A estrutura de arquivos e pasta acima o bsico para todo e qualquer pacote, mas isso no quer dizer que todos os pacotes tero
essa estrutura. Por exemplo, voc pode criar ns utilizando Python. Nesse caso, voc precisa colocar todos os seus cdigos fontes
na pasta scripts que deve ser criada manualmente.

Escrevendo o cdigo para publicar seu "Hello World"

Para termos um pacote completo no ROS, precisamos de um n para publicar mensagens e um n para receber mensagens. Em
outras palavras, um n que publica mensagens em um tpico e um n que subscrever em um tpico.

Agora vamos criar um n para publicar a mensagem "hello world" no tpico /chatter. Abra seu editor de textos, como o GEdit ou o
Sublime Text e escreva o seguinte cdigo:

1 a
#include "ros/ros.h"
86 d 0 f 2 k 42
Gostou? Junte-se comunidade Embarcados

https://www.embarcados.com.br/criandoumhelloworldnorobotoperatingsystem/ 3/10
05/05/2017 HelloWorldnoRobotOperatingSystem(ROS)Embarcados
2 #include "std_msgs/String.h"
3
4 #include <sstream>
5
6 int main(int argc, char **argv)
7 {
8 ros::init(argc, argv, "talker");
9
10 ros::NodeHandle n;
11
12 ros::Publisher chatter_pub = n.advertise<std_msgs::String>("/chatter", 1000);
13
14 ros::Rate loop_rate(10);
15
16 int count = 0;
17 while (ros::ok())
18 {
19 std_msgs::String msg;
20
21 std::stringstream ss;
22 ss << "hello world " << count;
23 msg.data = ss.str();
24
25 ROS_INFO("%s", msg.data.c_str());
26
27 chatter_pub.publish(msg);
28
29 ros::spinOnce();
30
31 loop_rate.sleep();
32 ++count;
33 }
34
35
36 return 0;
37 }

Salve o arquivo com o nome talker.cpp na pasta src do nosso pacote ros_embarcados_tutorial:

/home/SEU_USERNAME/catkin_ws/src/ros_embarcados_tutorial/src/talker.cpp

Vamos explicar o cdigo linha por linha:

1 #include "ros/ros.h"

Nessa linha estamos adicionando os arquivos de cabealhos referentes ao ROS e todas as suas funes e mtodos.

1 #include "std_msgs/String.h"

Arquivo de cabealho referente ao pacote std_msgs. Em nosso caso, vamos utilizar mensagens do tipo String. Note que o tipo
String do ROS faz parte do pacote std_msgs e no relacionado com o tipo padro de strings utilizado no C++.

1 #include <sstream>

String stream padro do C++ no possui relao com o ROS.

1 ros::init(argc, argv, "talker");

a d f
Inicializar o ROS e cria um86 n com o 0nome talker.
2 k 42
Gostou? Junte-se comunidade Embarcados

https://www.embarcados.com.br/criandoumhelloworldnorobotoperatingsystem/ 4/10
05/05/2017 HelloWorldnoRobotOperatingSystem(ROS)Embarcados

1 ros::NodeHandle n;

Cria um objeto do tipo NodeHandle. Esse objeto essencialmente o nosso n. Toda publicao ou leitura de um tpico pelo n
talker ser feito utilizando o NodeHandle n que acabamos de criar.

1 ros::Publisher chatter_pub = n.advertise<std_msgs::String>("/chatter", 1000);

Cria o objeto chatter_pub responsvel por publicar mensagens do tipo std::msgs::String no tpico /chatter.

1 ros::Rate loop_rate(10);

Especica a frequncia do loop principal do seu n. Nesse caso, 10 Hz.

1 int count = 0;

Cria a varivel count para que possamos saber quantas mensagens foram publicadas at o momento.

1 while (ros::ok())

Esse o loop principal do seu n. Signica que seu n ir rodar indenidamente at que algum use Ctrl+C para parar a execuo.
ros::ok() ir retornarfalse, uma vez que o usurio use Ctrl+C, e o programa sair do loop, encerrando-o.

1 std_msgs::String msg;

Cria a varivel msg do tipo std_msgs::String. Essa varivel ir armazenar a mensagem que queremos publicar.

1 std::stringstream ss;
2 ss << "hello world " << count;
3 msg.data = ss.str();

Criamos a string "hello world" e adicionamos o nosso contador de mensagens. Note que qualquer mensagem do tipo
std_msgs::String possui um membro chamado data que aonde nossa string car armazenada.

1 ROS_INFO("%s", msg.data.c_str());

a 86 d 0 f 2 k 42
Gostou? Junte-se comunidade Embarcados

https://www.embarcados.com.br/criandoumhelloworldnorobotoperatingsystem/ 5/10
05/05/2017 HelloWorldnoRobotOperatingSystem(ROS)Embarcados

ROS_INFO o equivalente ao printf/cout em ROS. Usamos ROS_INFO para mostrar informaes ao usurio. Nesse caso, vamos
mostrar a string que est dentro da nossa mensagem, msg.

1 chatter_pub.publish(msg);

Essa linha far com que o ROS efetivamente publique nossa mensagem no tpico /chatter.

1 ros::spinOnce();

Faz com que o ROS atualize nosso n, publicando e subscrevendo mensagens.

1 loop_rate.sleep();

Faz com que nosso n durma a quantidade de tempo necessrio para que tenhamos uma frequncia de 10 Hz no nosso loop
principal.

Escrevendo o cdigo para receber seu "Hello World"

Agora que escrevemos nosso n para publicarmos nosso "Hello World", precisamos criar um n para se subscrever no tpico
/chatter e receber nosso "Hello World". Chamaremos esse n de listener. Use seu editor preferido para criar o arquivo listener.cpp
dentro da pasta src do nosso pacote ros_embarcados_tutorials
(/home/SEU_USERNAME/catkin_ws/src/ros_embarcados_tutorials/src/listener.cpp) com o seguinte cdigo:

1 #include "ros/ros.h"
2 #include "std_msgs/String.h"
3
4 void chatterCallback(const std_msgs::String::ConstPtr& msg)
5 {
6 ROS_INFO("I heard: [%s]", msg->data.c_str());
7 }
8
9 int main(int argc, char **argv)
10 {
11 ros::init(argc, argv, "listener");
12
13 ros::NodeHandle n;
14
15 ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
16
17 ros::spin();
18
19 return 0;
20 }

Vamos explicar as partes do cdigo que diferem do n criado anteriormente.

a 86 d 0 f 2 k 42
Gostou? Junte-se comunidade Embarcados

https://www.embarcados.com.br/criandoumhelloworldnorobotoperatingsystem/ 6/10
05/05/2017 HelloWorldnoRobotOperatingSystem(ROS)Embarcados
1 void chatterCallback(const std_msgs::String::ConstPtr& msg)
2 {
3 ROS_INFO("I heard: [%s]", msg->data.c_str());
4 }

A primeira diferena que precisamos de uma funo para lidar com as novas informaes que esto chegando no nosso tpico
/chatter. Sempre que uma nova mensagem publicada em /chatter, nosso subscriber ir chamar a funochatterCallback. Essa
funo ir receber a nova mensagem publicada (msg) e ir realizar alguma ao. No nosso caso, vamos simplesmente converter
nossa mensagem para string e mostrar em nossa janela de terminal usando ROS_INFO (note que ROS_INFO possui a mesma
sintaxe do tradicional printf em C).

1 ros::init(argc, argv, "listener");

Note que nosso subscriber ser um n totalmente independente do nosso publisher criado anteriormente e ser registrado com o
nome de listener.

1 ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);

Cria o objeto sub que ir subscrever no tpico /chatter e chamar a funo chatterCallback sempre que o tpico for atualizado com
uma nova mensagem.

1 ros::spin();

Faz com que o nosso n entre em um loop chamando a funo chatterCallback o mais rpido possvel assim que o tpico /chatter
seja atualizado. Nesse caso, a frequncia do loop ser totalmente relacionado com a frequncia de publicao do tpico /chatter.
Alm disso, ros::spin() ir nalizar a execuo do n uma vez que o usurio use a combinao de teclas Ctrl+C no terminal.

Pronto! Criamos nosso publisher e nosso subscriber usando C++ e ROS. Agora precisamos modicar nosso arquivo CMakeLists.txt
do nosso pacote ros_embarcados_tutorials para que possamos compilar nossos ns.

Compilando nosso publisher e subscriber

Abra o arquivo CMakeLists.txt no seu editor favorito. V para a linha 131 e substitua a linha pela seguinte linha:

1 add_executable(talker src/talker.cpp)

a
ROS Tutorial: Building a ROS
86 d
PackageSubstitua
0 f
2a linha 135 k
42 por:
Gostou? Junte-se comunidade Embarcados

https://www.embarcados.com.br/criandoumhelloworldnorobotoperatingsystem/ 7/10
05/05/2017 HelloWorldnoRobotOperatingSystem(ROS)Embarcados

1 add_dependencies(talker ros_embarcados_tutorials_generate_messages_cpp)

Substitua as linha 138 140 por:

1 target_link_libraries(talker ${catkin_LIBRARIES})

Com essas modicaes j podemos compilar o n talker, mas ainda precisamos adicionar as informaes referentes ao n
listener.

Abaixo da linha 138 adicione as seguintes linhas:

1 add_executable(listener src/listener.cpp)
2 add_dependencies(listener ros_embarcados_tutorials_generate_messages_cpp)
3 target_link_libraries(listener ${catkin_LIBRARIES})

Aqui est um exemplo do arquivo CMakeLists.txt funcional e sem todos os comentrios:

1 cmake_minimum_required(VERSION 2.8.3)
2 project(ros_embarcados_tutorials)
3
4 find_package(catkin REQUIRED COMPONENTS
5 roscpp
6 rospy
7 std_msgs
8 )
9
10 catkin_package()
11
12 include_directories(${catkin_INCLUDE_DIRS})
13
14 add_executable(talker src/talker.cpp)
15 add_dependencies(talker ros_embarcados_tutorials_generate_messages_cpp)
16 target_link_libraries(talker ${catkin_LIBRARIES})
17
18 add_executable(listener src/listener.cpp)
19 add_dependencies(listener ros_embarcados_tutorials_generate_messages_cpp)
20 target_link_libraries(listener ${catkin_LIBRARIES})

Agora podemos compilar nossos ns:

1 ~/catkin_ws$ catkin_make

Testando nosso publisher e subscriber

Agora que compilamos nossos ns, podemos nalmente test-los. Abra uma nova janela de terminal e inicialize o ROS:

a 86 d 0 f 2 k 42
Gostou? Junte-se comunidade Embarcados

https://www.embarcados.com.br/criandoumhelloworldnorobotoperatingsystem/ 8/10
05/05/2017 HelloWorldnoRobotOperatingSystem(ROS)Embarcados
1 ~$ roscore

Em outra janela de terminal, inicialize o n talker:

1 ~$ rosrun ros_embarcados_tutorials talker

Por m, em outra janela de terminal, inicialize o n listener:

1 ~$ rosrun ros_embarcados_tutorials listener

Se tudo ocorrer bem, voc ver os seguintes resultados:

E assim terminamos nossa sria introdutria ao ROS. Agora voc possui conhecimentos bsicos para comear a criar seus
prprios ns no ROS.

Referncias

ROS Tutorial: Writing a Simple Publisher and Subscriber (C++)

ROS Tutorial: Creating a ROS Package

ROS Tutorial: Building a ROS Package

Outros artigos da srie

<< Entendendo as mensagens e tpicos do ROS

Este post faz da srie ROS (Robot Operating System). Leia tambm os outros posts da srie:

Uma introduo ao Robot Operating System (ROS)

Entendendo os ns do ROS
Entendendo as mensagens e tpicos do ROS
Criando um "Hello World" no Robot Operating System (ROS)

a 86 d 0 f 2 k 42
Gostou? Junte-se comunidade Embarcados

https://www.embarcados.com.br/criandoumhelloworldnorobotoperatingsystem/ 9/10
05/05/2017 HelloWorldnoRobotOperatingSystem(ROS)Embarcados

Criando um "Hello World" no Robot Operating System (ROS) por Francisco Erivaldo Fernandes Junior. Esta obra est licenciado com
uma Licena Creative Commons Atribuio-CompartilhaIgual 4.0 Internacional.

Francisco Erivaldo Fernandes Junior

http://fcoerivaldojr.wix.com/aboutme

Estudante de Doutorado em Engenharia Eltrica na Oklahoma State University nos EUA. Possui Mestrado em Engenharia Eltrica pela UNICAMP e graduao em
Tecnologia em Mecatrnica Industrial pelo IFCE. Possui experincia em indstria e em desenvolvimento de software. Atualmente, trabalha desenvolvendo robs
sociais para auxiliar pessoas idosas.

Este site utiliza cookies. Ao us-lo voc concorda com nossa poltica de privacidade. Saiba mais. Continuar

a 86 d 0 f 2 k 42
Gostou? Junte-se comunidade Embarcados

https://www.embarcados.com.br/criandoumhelloworldnorobotoperatingsystem/ 10/10