Referência: "Prática de desenvolvimento do robô ROS"
Nota: Continue a implementar a programação de comunicação no pacote de funções learning_communication no espaço de trabalho catkin_ws criado na seção anterior

1. Modelo de Comunicação de Tópicos

Insira a descrição da imagem aqui

Segundo, a realização da programação básica de tópicos

1. Processo de programação de tópicos:

1. Crie um editor (locutor),
2. Crie um assinante (ouvinte),
3. Adicione opções de compilação,
4. Execute um arquivo executável;

2. Implemente o editor (Talker)

Crie o arquivo talker.cpp no seguinte diretório:
Insira a descrição da imagem aqui
b O código do arquivo talker.cpp é o seguinte:

/*
该例程将发布chatter话题，消息类型String
*/

#include <sstream>
#include "ros/ros.h"
#include "std_msgs/String.h"

int main(int argc,char **argv)
{
  //ROS节点初始化
  ros::init(argc,argv,"talker");
  
  //创建节点句柄
  ros::NodeHandle n;
  //创建一个Publisher，发布名为chatter的topic，消息类型为std::msgs::String
  ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);

  //设置循环的频率
  ros::Rate loop_rate(10); 

  int count = 0;
  while (ros::ok())
  {
    //初始化std::msgs::String类型的消息
    std_msgs::String msg;
    std::stringstream ss;
    ss << "hello world " << count;
    msg.data = ss.str();

    //发布消息
    ROS_INFO("%s", msg.data.c_str()); 
    chatter_pub.publish(msg);
    
    //循环等待回调函数
    ros::spinOnce();

    //按照循环频率延时
    loop_rate.sleep();
    ++count;
  }

  return 0;
}

c) Lógica de implementação
(1) Inicialize o nó ROS;
(2) Registre as informações do nó no mestre ROS, incluindo o nome do tópico publicado e o tipo de mensagem no tópico;
(3) Circule a mensagem de acordo com uma determinada frequência;

3. Implemente o assinante (ouvinte)

Crie o arquivo listener.cpp no seguinte diretório:
Insira a descrição da imagem aqui
b) O código do arquivo listener.cpp é o seguinte:

/*
该例程将订阅chatter话题，消息类型String
*/
#include "ros/ros.h"
#include "std_msgs/String.h"

//接收到订阅的消息后，会进入消息回调函数
void chatterCallback(const std_msgs::String::ConstPtr& msg)
{
  //将接收到的消息打印出来
  ROS_INFO("I heard: [%s]", msg->data.c_str());
}

int main(int argc, char **argv)
{
  //初始化ROS节点
  ros::init(argc, argv, "listener");

  //创建节点句柄
  ros::NodeHandle n;

  //创建一个Subscriber，订阅名为chatter的topic，注册回调函数chatterCallback
  ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);

  //循环等待回调函数
  ros::spin(); 

  return 0;
}

c) Lógica de implementação
(1) Inicialize o nó ROS;
(2) Assine o tópico necessário;
(3) Aguarde a mensagem do tópico em um loop e insira a função de retorno de chamada após receber a mensagem;
(4) Conclua o processamento da mensagem na função de retorno de chamada;

4. Adicione opções de compilação

Método de compilação

Compile o código no arquivo CMakeLists.txt:

(1) Defina o código a ser compilado e o arquivo executável gerado;
(2) Defina a biblioteca de links;
(3) Defina a dependência;

Operação específica

Abra o arquivo CMakeLists.txt no pacote de funções learning_communication e adicione o seguinte código:

add_executable(talker src/talker.cpp)
target_link_libraries(talker ${catkin_LIBRARIES})

add_executable(listener src/listener.cpp)
target_link_libraries(listener ${catkin_LIBRARIES})

Gerar

Gere um arquivo executável na área de trabalho catkin_ws:

catkin_make

5. Execute o arquivo executável

Observe que toda vez que você abre um novo terminal para adicionar variáveis de ambiente: (se você precisar adicionar manualmente)

source ~/test/catkin_ws/devel/setup.bash

a. Por favor,
abra o terminal do ROS Master :

roscore

b. Inicie o locutor e
abra um novo terminal:

rosrun learning_communication talker

Insira a descrição da imagem aqui
c) Inicie o ouvinte e
abra o terminal:

rosrun learning_communication listener

Insira a descrição da imagem aqui
Ambos os lados transmitem e recebem dados em tempo real

Três, programação de tópicos personalizados

Podemos usar a estrutura de mensagens definida pelo ROS ou podemos definir a mensagem do tópico, como programação personalizada de tópicos

1. Defina o arquivo msg

Crie um diretório sob learning_communication msg, Person.msg criar arquivos no diretório msg
Insira a descrição da imagem aqui
escreve:

string name
uint8 sex
uint8 age

uint8 unknown = 0
uint8 male    = 1
uint8 female  = 2

2. Adicione a dependência do pacote de funções no package.xml

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

3. Adicione opções de compilação no CMakeLists.txt

find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
  message_generation
  )

catkin_package(
#  INCLUDE_DIRS include
#  LIBRARIES learning_communication
  CATKIN_DEPENDS roscpp rospy std_msgs message_runtime
#  DEPENDS system_lib
)

add_message_files(FILES Person.msg)
generate_messages(DEPENDENCIES std_msgs)

4. Compilar