Referencia: "Práctica de desarrollo de robots ROS"
Nota: Continúe implementando la programación de comunicación en el paquete de funciones learning_communication en el espacio de trabajo catkin_ws creado en la sección anterior

1. Modelo de comunicación temática

Inserte la descripción de la imagen aquí

Segundo, la realización de la programación de temas básicos.

1. Proceso de programación del tema:

1. Crear un editor (hablador);
2. Crear un suscriptor (escucha);
3. Agregar opciones de compilación;
4. Ejecutar un archivo ejecutable;

2. Implementar el editor (Hablador)

a. Cree el archivo talker.cpp en el siguiente directorio:
Inserte la descripción de la imagen aquí
b. El código del archivo talker.cpp es el siguiente:

/*
该例程将发布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 implementación
(1) Inicialice el nodo ROS;
(2) Registre la información del nodo con el ROS Master, incluido el nombre del tema publicado y el tipo de mensaje en el tema;
(3) Haga circular el mensaje de acuerdo con una frecuencia determinada;

3. Implemente el suscriptor (oyente)

a. Cree el archivo listener.cpp en el siguiente directorio:
Inserte la descripción de la imagen aquí
b. El código del archivo listener.cpp es el siguiente:

/*
该例程将订阅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 implementación
(1) Inicialice el nodo ROS;
(2) Suscríbase al tema requerido;
(3) Espere el mensaje del tema en un bucle e ingrese la función de devolución de llamada después de recibir el mensaje;
(4) Complete el procesamiento del mensaje en la función de devolución de llamada;

4. Agregar opciones de compilación

Método de compilación

Compile el código en el archivo CMakeLists.txt:

(1) Establecer el código que se compilará y el archivo ejecutable generado;
(2) Establecer la biblioteca de enlaces;
(3) Establecer la dependencia;

Operación específica

Abra el archivo CMakeLists.txt en el paquete de funciones learning_communication y agregue el siguiente 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})

Generar

Genere un archivo ejecutable en el espacio de trabajo catkin_ws:

catkin_make

5. Ejecute el archivo ejecutable

Tenga en cuenta que cada vez que abra una nueva terminal para agregar variables de entorno: (si necesita agregar manualmente)

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

a. Abra
la terminal de ROS Master :

roscore

b. Inicie el hablador y
abra una nueva terminal:

rosrun learning_communication talker

Inserte la descripción de la imagen aquí
c. Inicie el oyente y
abra la terminal:

rosrun learning_communication listener

Inserte la descripción de la imagen aquí
Ambas partes transmiten y reciben datos en tiempo real

Tres, programación de temas personalizados

Podemos usar la estructura de mensajes definida por ROS, o podemos definir el mensaje del tema nosotros mismos, es decir, la programación personalizada del tema

1. Defina el archivo msg

Crear un directorio bajo learning_communication msg, Person.msg crear archivos en el directorio msg
Inserte la descripción de la imagen aquí
escribe:

string name
uint8 sex
uint8 age

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

2. Agregue la dependencia del paquete de funciones en package.xml

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

3. Agregue opciones de compilación en 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