Desbravando espaços com o BB8 e ROS em C++ via Actions personalizadas – ROS Portuguese Tutorial

This tutorial is created by Robotics Ambassador Anderson

Robotics Ambassador Program https://www.theconstruct.ai/robotics-ambassador/

O que nós vamos aprender:

1. Configurar e criar um pacote em ROS para um robô BB-8.
2. Criar e configurar mensagens de Action para controlar o movimento do robô.
3. Escrever um servidor de ações em C++ para processar os comandos recebidos.
4. Compilar e lançar a simulação do robô BB-8 no Gazebo.
5. Enviar comandos para o robô BB-8 via terminal e receber feedback de sua posição no espaço tridimensional.

Lista de recursos usados neste post:

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

Panorama

Bem-vindo! Neste tutorial, iremos mergulhar nos recursos de Actions no ROS, com foco no ROS 1 Noetic e em um dos robôs mais encantadores disponíveis na plataforma: o BB-8 do universo de Star Wars. Vamos explorar como usar Actions para enviar comandos personalizados que permitem ao BB-8 executar ações específicas, como caminhar, girar e parar, em resposta a objetivos definidos. Ao longo do processo, você aprenderá a criar mensagens customizadas para interagir com o BB-8 de maneira controlada e divertida.

Abrindo o rosject

Para acompanhar este tutorial utilize o rosject acessando o link fornecido e clique no botão vermelho

https://app.theconstruct.ai/l/60394ad6/

Criando o pacote

Abra um terminal e cole os comandos abaixo para criar o pacote e os arquivos necessários para a simulação.

roscd; cd ..; cd src/bb8; catkin_create_pkg bb8_action_pkg roscpp actionlib actionlib_msgs geometry_msgs std_msgs
cd bb8_service_pkg; mkdir action;
cd action; touch CustomActionMsg.action; cd ..;
cd src; touch bb8_service_server.cpp; chmod +x *.cpp

Novos arquivos aparecerão na árvore de pastas em sua IDE.

Configurando as mensagens de Action
Mensagens de Action são compostas pelos elementos goal, result e feedback. No caso da nossa aplicação, trataremos cada um dos elementos como uma string diferente. Salve o arquivo CustomActionMsg.action incluindo o seguinte conteúdo:

string goal
---
string result
---
string feedback

Preparando para compilar

Para atualizar seu CMakeList.txt, é crucial copiar o seguinte conteúdo e colá-lo no arquivo, substituindo o que estiver presente.

cmake_minimum_required(VERSION 3.0.2)
project(bb8_action_pkg)
find_package(catkin REQUIRED COMPONENTS
actionlib
actionlib_msgs
geometry_msgs
roscpp
std_msgs
)
add_action_files(
FILES
CustomActionMsg.action
)
generate_messages(
DEPENDENCIES
geometry_msgs# std_msgs
actionlib_msgs
)
catkin_package(
CATKIN_DEPENDS actionlib actionlib_msgs roscpp
)
include_directories(
${catkin_INCLUDE_DIRS}
)
add_executable(bb8_action_server src/bb8_action_server.cpp)
add_dependencies(bb8_action_server ${bb8_action_server_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
target_link_libraries(bb8_action_server
${catkin_LIBRARIES}
)
add_dependencies(bb8_action_server bb8_action_pkg_generate_messages_cpp)

Escrevendo o servidor de ações

Agora, vamos para a etapa em que os comandos são enviados ao servidor do ações. No diretório ‘src’, abra o arquivo bb8_action_server.cpp e adicione o seguinte código.
#include "geometry_msgs/Twist.h"
#include "nav_msgs/Odometry.h"
#include <actionlib/server/simple_action_server.h>
#include <bb8_action_pkg/CustomActionMsgAction.h>
#include <ros/ros.h>
class MoveAction {
protected:
ros::NodeHandle nh_;
actionlib::SimpleActionServer<bb8_action_pkg::CustomActionMsgAction> as_;
std::string action_name_;
bb8_action_pkg::CustomActionMsgFeedback feedback_;
bb8_action_pkg::CustomActionMsgResult result_;
ros::Publisher pub;
ros::Subscriber sub;
geometry_msgs::Twist mov;
nav_msgs::Odometry odom;
ros::Rate *rate_;
public:
MoveAction(std::string name)
: as_(nh_, name, boost::bind(&MoveAction::Callback, this, _1), false),
action_name_(name) {
as_.start();
rate_ = new ros::Rate(1);
pub = nh_.advertise<geometry_msgs::Twist>("cmd_vel", 1000);
sub = nh_.subscribe("/odom", 1000, &MoveAction::odomCallback, this);
}
void Callback(const bb8_action_pkg::CustomActionMsgGoalConstPtr &goal) {
ROS_INFO("Goal received: %s", goal->goal.c_str());
while (ros::ok() && !as_.isPreemptRequested()) {
if (goal->goal == "walk") {
mov.linear.x = 0.5;
mov.angular.z = 0;
pub.publish(mov);
} else if (goal->goal == "turn") {
mov.linear.x = 0;
mov.angular.z = 1;
pub.publish(mov);
usleep(2000000);
} else if (goal->goal == "stop") {
mov.linear.x = 0;
mov.angular.z = 0;
pub.publish(mov);
}
feedback_.feedback =
"Received position: x=" + std::to_string(odom.pose.pose.position.x) +
", y=" + std::to_string(odom.pose.pose.position.y) +
", z=" + std::to_string(odom.pose.pose.position.z);
as_.publishFeedback(feedback_);
rate_->sleep();
}
if (as_.isPreemptRequested()) {
ROS_INFO("Goal preempted.");
as_.setPreempted();
} else {
ROS_INFO("Goal succeeded.");
result_.result = "Action completed.";
as_.setSucceeded(result_);
}
}
void preemptCallback() {
ROS_INFO("Goal preempted.");
as_.setPreempted();
}
void odomCallback(const nav_msgs::Odometry::ConstPtr &msg) { odom = *msg; }
};
int main(int argc, char **argv) {
ros::init(argc, argv, "node_action");
MoveAction server("action_custom_msg_as");
ros::spin();
return 0;
}

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

Em um terminal, inicie o Gazebo usando o comando apropriado para visualizar o robô BB-8 pronto para operação. Isso abrirá a janela do Gazebo.

roslaunch bb_8_gazebo main.launch

No segundo terminal, execute o seguinte comando para compilar apenas o pacote que criamos. Isso economiza tempo, já que compilará apenas um pacote em vez de todos os existentes.

cd ~/catkin_ws/; catkin_make --only-pkg-with-deps bb8_action_pkg; source devel/setup.bash

Se tudo foi feito corretamente, o prompt não acusará nenhum erro:

Rodando o servidor de serviços

No terminal 3, execute o comando para iniciar o servidor de ações:

rosrun bb8_action_pkg bb8_action_server

Não se preocupe com este terminal, abra um novo para prosseguir com os passos deste tutorial.

Invocando o feedback da ação

Abra um quarto terminal para receber feedback do robô com informações sobre sua localização no espaço tridimensional. Essas atualizações são recebidas a cada dois segundos, permitindo que você saiba a posição do robô mesmo que ele não esteja visível.

rostopic echo action_custom_msg_as/feedback

Não se preocupe se nada aparecer inicialmente, pois o servidor ainda não está em execução, então não haverá feedback disponível ainda. Isso é normal.

Chamando a ação criada

No quinto terminal, execute o seguinte comando:

rostopic pub action_custom_msg_as/goal bb8_action_pkg/CustomActionMsgActionGoal

Após digitar o comando, não pressione ‘Enter’. Em vez disso, pressione ‘Tab’ duas vezes para autocompletar com os elementos necessários. Em seguida, você poderá selecionar o goal desejado, como ‘turn’, ‘walk’ ou ‘stop’.”

O robô deve se mover de acordo.

Visualizando o feedback

De volta ao terminal 4 temos:

As informações de odometria sempre indicarão onde seu robô está localizado, mesmo que a visualização seja obstruída por um Star Destroyer. Aliás, este método é excelente para explorar e localizar aquela entrada secreta em uma colossal nave inimiga.

Esperamos que este tutorial 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.