(ROS)第2章 ROS通信机制——话题通信

第2章 ROS通信机制——话题通信

在机器人上可能集成各种传感器(雷达、摄像头、GPS…)以及运动控制实现，为了解耦合，在ROS中每一个功能点都是一个单独的进程，每一个进程都是独立运行的。更确切的讲，是进程（也称为Nodes）的分布式框架。因为这些进程甚至还可分布于不同主机，不同主机协同工作，从而分散计算压力。不过随之也有一个问题: 不同的进程是如何通信的？也即不同进程间如何实现数据交换的？在此就需要介绍一下ROS中的通信机制了。

ROS 中的基本通信机制主要有如下三种实现策略:

• 话题通信(发布订阅模式)
• 服务通信(请求响应模式)
• 参数服务器(参数共享模式)
  下面介绍一下话题通讯。

2.1 话题通信

话题通信是ROS中使用频率最高的一种通信模式，话题通信是基于发布订阅模式的，也即:一个节点发布消息，另一个节点订阅该消息。话题通信的应用场景也极其广泛，比如下面一个常见场景:机器人在执行导航功能，使用的传感器是激光雷达，机器人会采集激光雷达感知到的信息并计算，然后生成运动控制信息驱动机器人底盘运动。

概念：以发布订阅的方式实现不同节点之间数据交互的通信模式。

作用：用于不断更新的、少逻辑处理的数据传输场景。

2.1.1 理论模型：

话题通信实现模型是比较复杂的，该模型如下图所示,该模型中涉及到三个角色:

• ROS Master (管理者)
• Talker (发布者)
• Listener (订阅者)

ROS Master 负责保管 Talker 和 Listener 注册的信息，并匹配话题相同的 Talker 与 Listener，帮助 Talker 与 Listener 建立连接，连接建立后，Talker 可以发布消息，且发布的消息会被 Listener 订阅。

整个流程由以下步骤实现:

0.Talker注册

Talker启动后，会通过RPC在 ROS Master 中注册自身信息，其中包含所发布消息的话题名称。ROS Master 会将节点的注册信息加入到注册表中。

1.Listener注册

Listener启动后，也会通过RPC在 ROS Master 中注册自身信息，包含需要订阅消息的话题名。ROS Master 会将节点的注册信息加入到注册表中。

2.ROS Master实现信息匹配

ROS Master 会根据注册表中的信息匹配Talker 和 Listener，并通过 RPC 向 Listener 发送 Talker 的 RPC 地址信息。

3.Listener向Talker发送请求

Listener 根据接收到的 RPC 地址，通过 RPC 向 Talker 发送连接请求，传输订阅的话题名称、消息类型以及通信协议(TCP/UDP)。

4.Talker确认请求

Talker 接收到 Listener 的请求后，也是通过 RPC 向 Listener 确认连接信息，并发送自身的 TCP 地址信息。

5.Listener与Talker建立连接

Listener 根据步骤4 返回的消息使用 TCP 与 Talker 建立网络连接。

6.Talker向Listener发送消息

连接建立后，Talker 开始向 Listener 发布消息。

注意

注意1:上述实现流程中，前五步使用的 RPC协议，最后两步使用的是 TCP 协议

注意2: Talker 与 Listener 的启动无先后顺序要求

注意3: Talker 与 Listener 都可以有多个

注意4: Talker 与 Listener 连接建立后，不再需要 ROS Master。也即，即便关闭ROS Master， Talker 与 Listern 照常通信。

2.1.2 话题通信（C++）

需求:

编写发布订阅实现，要求发布方以10HZ(每秒10次)的频率发布文本消息，订阅方订阅消息并将消 息内容打印输出。

分析：

在模型实现中，ROS master 不需要实现，而连接的建立也已经被封装了，需要关注的关键点有三个:

• 发布方
• 接收方
• 数据(此处为普通文本)

流程

1. 编写发布方实现；
2. 编写订阅方实现；
3. 编辑配置文件；
4. 编译并执行。

开始前我们新创建一个功能包。

catkin_create_pkg 自定义ROS包名 roscpp rospy std_msgs

或者通过vscode中右键src创建新功能包

1.发布方publisher.cpp

/*
    需求: 实现基本的话题通信，一方发布数据，一方接收数据，
         实现的关键点:
         1.发送方
         2.接收方
         3.数据(此处为普通文本)
         PS: 二者需要设置相同的话题
    消息发布方:
        循环发布信息:HelloWorld 后缀数字编号
    实现流程:
        1.包含头文件
        2.初始化 ROS 节点:命名(唯一)
        3.实例化 ROS 句柄
        4.实例化 发布者 对象
        5.组织被发布的数据，并编写逻辑发布数据
*/
// 1.包含头文件
#include "ros/ros.h"
#include "std_msgs/String.h" //普通文本类型的消息
int main(int argc, char *argv[])
{
    // 设置编码
    setlocale(LC_ALL, "");
    // 2.初始化 ROS 节点:命名(唯一)
    //  参数1和参数2 后期为节点传值会使用
    //  参数3 是节点名称，是一个标识符，需要保证运行后，在 ROS 网络拓扑中唯一
    ros::init(argc, argv, "talker");
    // 3.实例化 ROS 句柄
    ros::NodeHandle nh; // 该类封装了 ROS 中的一些常用功能
    // 4.实例化 发布者 对象
    // 泛型: 发布的消息类型
    // 参数1: 要发布到的话题
    // 参数2: 队列中最大保存的消息数，超出此阀值时，先进的先销毁(时间早的先销毁)
    ros::Publisher pub = nh.advertise<std_msgs::String>("chatter", 10);
    // 5.组织被发布的数据，并编写逻辑发布数据
    // 数据(动态组织)
    std_msgs::String msg;
    // msg.data = "你好啊！！！";
    std::string msg_front = "Hello 你好！"; // 消息前缀
    int count = 0;                          // 消息计数器
    // 逻辑(一秒10次)
    ros::Rate r(1);
    // 节点不死
    while (ros::ok())
    {
        // 使用 stringstream 拼接字符串与编号
        std::stringstream ss;
        ss << msg_front << count;
        msg.data = ss.str();
        // 发布消息
        pub.publish(msg);
        // 加入调试，打印发送的消息
        ROS_INFO("发送的消息:%s", msg.data.c_str());
        // 根据前面制定的发送贫频率自动休眠 休眠时间 = 1/频率；
        r.sleep();
        count++; // 循环结束前，让 count 自增
        // 暂无应用
        ros::spinOnce();
    }
    return 0;
}

2.订阅方subscriber.cpp

/*
    需求: 实现基本的话题通信，一方发布数据，一方接收数据，
         实现的关键点:
         1.发送方
         2.接收方
         3.数据(此处为普通文本)
    消息订阅方:
        订阅话题并打印接收到的消息
    实现流程:
        1.包含头文件
        2.初始化 ROS 节点:命名(唯一)
        3.实例化 ROS 句柄
        4.实例化 订阅者 对象
        5.处理订阅的消息(回调函数)
        6.设置循环调用回调函数
*/
// 1.包含头文件
#include "ros/ros.h"
#include "std_msgs/String.h"
void doMsg(const std_msgs::String::ConstPtr &msg_p)
{
    ROS_INFO("我听见:%s", msg_p->data.c_str());
    // ROS_INFO("我听见:%s",(*msg_p).data.c_str());
}
int main(int argc, char *argv[])
{
    setlocale(LC_ALL, "");
    // 2.初始化 ROS 节点:命名(唯一)
    ros::init(argc, argv, "listener");
    // 3.实例化 ROS 句柄
    ros::NodeHandle nh;
    // 4.实例化 订阅者 对象
    ros::Subscriber sub = nh.subscribe("chatter", 10, doMsg);
    // 5.处理订阅的消息(回调函数)
    // 6.设置循环调用回调函数 
    ros::spin(); // 循环读取接收的数据，并调用回调函数处理
    return 0;
}

3.配置CMakeLists.txt

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

4.编译执行

1. 编译
2. 启动 roscore;
3. 启动发布节点;
4. 启动订阅节点。

2.1.3 话题通信（Python）

1.发布方pub_py.py

#! /usr/bin/env python
"""
    需求: 实现基本的话题通信，一方发布数据，一方接收数据，
         实现的关键点:
         1.发送方
         2.接收方
         3.数据(此处为普通文本)
         PS: 二者需要设置相同的话题
    消息发布方:
        循环发布信息:HelloWorld 后缀数字编号
    实现流程:
        1.导包 
        2.初始化 ROS 节点:命名(唯一)
        3.实例化 发布者 对象
        4.组织被发布的数据，并编写逻辑发布数据
"""
 #1.导包 
import rospy
from std_msgs.msg import String
if __name__ == "__main__":
    #2.初始化 ROS 节点:命名(唯一)
    rospy.init_node("talker_p")
    #3.实例化 发布者 对象
    pub = rospy.Publisher("chatter",String,queue_size=10)
    #4.组织被发布的数据，并编写逻辑发布数据
    msg = String()  #创建 msg 对象
    msg_front = "hello 你好"
    count = 0  #计数器 
    # 设置循环频率
    rate = rospy.Rate(1)
    while not rospy.is_shutdown():
        #拼接字符串
        msg.data = msg_front + str(count)
        pub.publish(msg)
        rate.sleep()
        rospy.loginfo("写出的数据:%s",msg.data)
        count += 1

2.订阅方sub_py.py

#! /usr/bin/env python
"""
    需求: 实现基本的话题通信，一方发布数据，一方接收数据，
         实现的关键点:
         1.发送方
         2.接收方
         3.数据(此处为普通文本)
    消息订阅方:
        订阅话题并打印接收到的消息
    实现流程:
        1.导包 
        2.初始化 ROS 节点:命名(唯一)
        3.实例化 订阅者 对象
        4.处理订阅的消息(回调函数)
        5.设置循环调用回调函数
"""
 #1.导包 
import rospy
from std_msgs.msg import String
def doMsg(msg):
    rospy.loginfo("I heard:%s",msg.data)
if __name__ == "__main__":
    #2.初始化 ROS 节点:命名(唯一)
    rospy.init_node("listener_p")
    #3.实例化 订阅者 对象
    sub = rospy.Subscriber("chatter",String,doMsg,queue_size=10)
    #4.处理订阅的消息(回调函数)
    #5.设置循环调用回调函数
    rospy.spin()

3.添加可执行权限

终端下进入 scripts 执行:

chmod +x *.py

4.配置CMakeLists.txt

catkin_install_python(PROGRAMS
	scripts/pub_py.py
    scripts/sub_py.py
    DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

5.编译执行

1. 编译
2. 启动 roscore;
3. 启动发布节点;
4. 启动订阅节点。

2.1.4 话题通信自定义msg

在ROS通信协议中，数据载体是一个较为重要组成部分，ROS中通过std_msgs封装了一些原生的数据类型,比如:String、Int32、Int64、Char、Bool、Empty….但是，这些数据一般只包含一个data字段，结构的单一意味着功能上的局限性，当传输一些复杂的数据，比如:激光雷达的信息…std_msgs由于描述性较差而显得力不从心，这种场景下可以使用自定义的消息类型msgs只是简单的文本文件，每行具有字段类型和字段名称，可以使用的字段类型有：

• int8,int16,int32,int64(或者无符号类型:uint*)
• float32,float64
• string
• time,duration
• other msg files
• variable-length array[] and fixed-length array[C]

ROS中还有一种特殊类型：文件的第一行具有Header，标头包含时间戳和ROS中常用的坐标帧信息。会经常看到msg文件的第一行具有Header标头。

需求：创建自定义消息，该消息包含人的信息:姓名、身高、年龄等。

流程：

1. 按照固定格式创建 msg 文件
2. 编辑配置文件
3. 编译生成可以被 Python 或 C++ 调用的中间文件

1.定义msg文件

功能包下新建 msg 目录，添加文件 Person.msg

string name
uint16 age
float64 height

2.编辑配置文件

package.xml中添加编译依赖与执行依赖中添加编译依赖与执行依赖

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

CMakeLists.txt编辑 msg 相关配置(在文件中对应的位置修改，不能直接复制粘贴，因为编译时有先后顺序)

find_package(catkin REQUIRED COMPONENTS
	roscpp
	rospy
	std_msgs
	message_generation
)
# 需要加入 message_generation,必须有 std_msgs
## 配置 msg 源文件
add_message_files(
	FILES
	Person.msg
)
# 生成消息时依赖于 std_msgs
generate_messages(
    DEPENDENCIES
    std_msgs
)
 #执行时依赖
catkin_package(
 #  INCLUDE_DIRS include
 #  LIBRARIES topic
 CATKIN_DEPENDS roscpp rospy std_msgs message_runtime
 #  DEPENDS system_lib
)

3.编译

编译后的中间文件查看

C++ 需要调用的中间文件(…/工作空间/devel/include/包名/xxx.h)

Python 需要调用的中间文件(…/工作空间/devel/lib/python3/dist-packages/包名/msg)

2.1.5 话题通信自定义msg调用（C++）

需求:

编写发布订阅实现，要求发布方以10HZ(每秒10次)的频率发布自定义消息，订阅方订阅自定义消 息并将消息内容打印输出。

分析:

在模型实现中，ROSmaster不需要实现，而连接的建立也已经被封装了，需要关注的关键点有三个:

• 发布方
• 接收方
• 数据(此处为自定义消息)

流程:

1. 编写发布方实现；
2. 编写订阅方实现；
3. 编辑配置文件；
4. 编译并执行。

0.vscode配置

为了方便代码提示以及避免误抛异常，需要先配置 vscode，将前面生成的 head 文件路径配置进 .vscode/c_cpp_properties.json 的 includePath属性:

{
  "configurations": [
    {
      "browse": {
        "databaseFilename": "${default}",
        "limitSymbolsToIncludedHeaders": false
      },
      "includePath": [
        "/opt/ros/noetic/include/**",
        "/home/ylm123/test/src/helloworld/include/**",
        "/home/ylm123/test/src/topic/include/**",
        "/home/ylm123/test/devel/include/**",//配置 head 文件的路径 
        "/usr/include/**"
      ],
      "name": "ROS",
      "intelliSenseMode": "gcc-x64",
      "compilerPath": "/usr/bin/gcc",
      "cStandard": "gnu11",
      "cppStandard": "c++14"
    }
  ],
  "version": 4
}

1.发布方pub_msg.cpp

/*
    需求: 循环发布人的信息
*/
#include "ros/ros.h"
#include "topic/Person.h"
int main(int argc, char *argv[])
{
    setlocale(LC_ALL, "");
    // 1.初始化 ROS 节点
    ros::init(argc, argv, "talker_person");
    // 2.创建 ROS 句柄
    ros::NodeHandle nh;
    // 3.创建发布者对象
    ros::Publisher pub = nh.advertise<topic::Person>("chatter_person", 1000);
    // 4.组织被发布的消息，编写发布逻辑并发布消息
    topic::Person p;
    p.name = "sunwukong";
    p.age = 2000;
    p.height = 1.45;
    ros::Rate r(1);
    while (ros::ok())
    {
        pub.publish(p);
        p.age += 1;
        ROS_INFO("我叫:%s,今年%d岁,高%.2f米", p.name.c_str(), p.age, p.height);
        r.sleep();
        ros::spinOnce();
    }
    return 0;
}

2.订阅方sub_msg.cpp

/*
   需求: 订阅人的信息
*/
#include "ros/ros.h"
#include "topic/Person.h"
void doPerson(const topic::Person::ConstPtr &person_p)
{
    ROS_INFO("订阅的人信息:%s, %d, %.2f", person_p->name.c_str(), person_p->age, person_p->height);
}
int main(int argc, char *argv[])
{
    setlocale(LC_ALL, "");
    // 1.初始化 ROS 节点
    ros::init(argc, argv, "listener_person");
    // 2.创建 ROS 句柄
    ros::NodeHandle nh;
    // 3.创建订阅对象
    ros::Subscriber sub = nh.subscribe("chatter_person", 10, doPerson);
    // 4.回调函数中处理 person
    // 5.ros::spin();
    ros::spin();
    return 0;
}

3.配置CMakeLists.txt

需要添加add_dependencies用以设置所依赖的消息相关的中间文件。

add_executable(pub_msg
  src/pub_msg.cpp
)
add_executable(sub_msg
  src/sub_msg.cpp
)

add_dependencies(pub_msg ${PROJECT_NAME}_generate_messages_cpp)
add_dependencies(sub_msg ${PROJECT_NAME}_generate_messages_cpp)

target_link_libraries(pub_msg
  ${catkin_LIBRARIES}
)
target_link_libraries(sub_msg
  ${catkin_LIBRARIES}
)

4.编译执行

1. 编译
2. 启动 roscore;
3. 启动发布节点;
4. 启动订阅节点。

2.1.6 话题通信自定义msg调用（Python）

0.vscode配置

为了方便代码提示以及误抛异常，需要先配置 vscode，将前面生成的 python 文件路径配置进 .vscode/settings.json

{
    "python.autoComplete.extraPaths": [
        "/opt/ros/noetic/lib/python3/dist-packages",
        "/home/ylm123/test/devel/lib/python3/dist-packages" //添加python 文件路径
    ],
    "python.analysis.extraPaths": [
        "/opt/ros/noetic/lib/python3/dist-packages"
    ]
}

1.发布方pub_msg_py.py

#! /usr/bin/env python
"""
    发布方:
        循环发送消息
"""
import rospy
from topic.msg import Person
if __name__ == "__main__":
    #1.初始化 ROS 节点
    rospy.init_node("talker_person_p")
    #2.创建发布者对象
    pub = rospy.Publisher("chatter_person",Person,queue_size=10)
    #3.组织消息
    p = Person()
    p.name = "葫芦瓦"
    p.age = 18
    p.height = 0.75
    #4.编写消息发布逻辑
    rate = rospy.Rate(1)
    while not rospy.is_shutdown():
        pub.publish(p)  #发布消息
        rate.sleep()  #休眠
        rospy.loginfo("姓名:%s, 年龄:%d, 身高:%.2f",p.name, p.age, p.height)

2.订阅方sub_msg_py.py

#! /usr/bin/env python
"""
    订阅方:
        订阅消息
"""
import rospy
from topic.msg import Person
def doPerson(p):
    rospy.loginfo("接收到的人的信息:%s, %d, %.2f",p.name, p.age, p.height)
if __name__ == "__main__":
    #1.初始化节点
    rospy.init_node("listener_person_p")
    #2.创建订阅者对象
    sub = rospy.Subscriber("chatter_person",Person,doPerson,queue_size=10)
    rospy.spin() #4.循环

3.权限设置

终端下进入 scripts 执行:

chmod +x *.py

4.配置CMakeLists.txt

catkin_install_python(PROGRAMS
  scripts/pub_py.py
  scripts/sub_py.py
  scripts/pub_msg_py.py
  scripts/sub_msg_py.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

5.编译执行

1. 编译
2. 启动 roscore;
3. 启动发布节点;
4. 启动订阅节点。