O que nós vamos aprender:

1. Entender o funcionamento dos serviços no ROS Noetic, e como eles podem ser utilizados para controlar o robô BB-8.
2. Desenvolver mensagens customizadas em C++ para enviar comandos específicos ao BB-8.
3. Configurar e compilar um pacote ROS do zero, incluindo a criação de serviços e mensagens de serviço.
4. Lançar e interagir com a simulação do BB-8 no Gazebo, utilizando os comandos desenvolvidos para controlar o robô.
5. Escrever e rodar um servidor de serviços em ROS, que permitirá enviar comandos para o BB8.

Lista de recursos usados neste post:

1. Use este rosject: https://app.theconstructsim.com/l/5e7ce8b4/
2. The Construct: https://app.theconstructsim.com/
3. ROS Courses: ROS Basics in 5 Days (C++) https://app.theconstructsim.com/courses/56

Panorama

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.

https://app.theconstructsim.com/l/5fc3aef0/

Criando o pacote

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.

cmake_minimum_required(VERSION 3.0.2)
project(bb8_service_pkg)

find_package(catkin REQUIRED COMPONENTS
roscpp
std_msgs
message_generation
)

add_service_files(
FILES
bb8ServiceMessage.srv
)

generate_messages(
DEPENDENCIES
std_msgs
)

catkin_package(
CATKIN_DEPENDS roscpp
)

include_directories(include ${catkin_INCLUDE_DIRS})

add_executable(bb8_service_server src/bb8_service_server.cpp)
add_dependencies(bb8_service_server ${bb8_service_server_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
target_link_libraries(bb8_service_server
${catkin_LIBRARIES}
)

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:

<build_depend>message_generation</build_depend>
<build_export_depend>message_runtime</build_export_depend>
<exec_depend>message_runtime</exec_depend>

 Escrevendo o servidor de serviços

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.

#include "geometry_msgs/Twist.h"
#include "ros/ros.h"
#include <bb8_service_pkg/bb8ServiceMessage.h>
#include
#include

ros::Publisher pub;
geometry_msgs::Twist mov;

using namespace std;

bool my_callback(bb8_service_pkg::bb8ServiceMessage::Request &req,
bb8_service_pkg::bb8ServiceMessage::Response &res) {

ROS_INFO("The Service has been called");

if (req.command == "square") {
int j = 0;
while (j < 4) {
// straight
mov.linear.x = 0.5;
mov.angular.z = 0.0;
pub.publish(mov);
usleep(4000000);

// spin
mov.linear.x = 0;
mov.angular.z = 1.0;
pub.publish(mov);
usleep(2000000);
j++;
}
}

if (req.command == "circle") {
mov.linear.x = 1.5;
mov.angular.z = 1.5;
pub.publish(mov);
usleep(6000000);
}

if (req.command == "dance") {
int j = 0;
while (j < 4) {
mov.linear.x = 1.5;
mov.angular.z = 0.5;
pub.publish(mov);
usleep(2000000);

mov.linear.x = -0.5;
mov.angular.z = -1.0;
pub.publish(mov);
usleep(3000000);
j++;
}
}

mov.linear.x = 0;
mov.angular.z = 0;
pub.publish(mov);
ROS_INFO("Finished service");

res.success = true;
return res.success;
}

int main(int argc, char **argv) {
ros::init(argc, argv, "server_node");
ros::NodeHandle nh;

ros::ServiceServer my_service = nh.advertiseService("/move_bb8", my_callback);
pub = nh.advertise("cmd_vel", 1000);
ROS_INFO("Service Ready");
ros::spin();

return 0;
}

Compilando o pacote e lançando a simulação

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.

rosservice call /move_bb8 "command: 'square'"
rosservice call /move_bb8 "command: 'circle'"
rosservice call /move_bb8 "command: 'dance'"

Esperamos que este post seja útil e que você se divirta trabalhando com o BB-8, um robô incrível tanto em termos gráficos quanto funcionais.

 Vídeo no YouTube

Este foi o post de hoje. Lembre-se que nós temos uma versão deste post em vídeo no YouTube.

Se você gostou do conteúdo, por favor, considere se inscrever no nosso canal do YouTube. Estamos publicando novos conteúdos quase todos os dias.

Continue avançando no seu aprendizado de ROS.

Video Tutorial