linux ros

ros学习记录（2）——ROS通信机制之话题通信

通信机制学习过程记录，ROS核心部分

Posted by R on 2023-05-09

前言

ROS 通信机制是 ros 的核心机制，各种数据的交互、节点之间的协作都要依靠通讯机制。本篇从话题的发布订阅、服务、参数等方面讲述通讯机制，以小乌龟为例，尽可能理解这一概念。

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

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

* 话题通信(发布订阅模式)
* 服务通信(请求响应模式)
* 参数服务器(参数共享模式)

本章的主要内容就是是介绍各个通信机制的应用场景、理论模型、代码实现以及相关操作命令，需要通过学习完成模型理解及实操。

话题通信

话题通信是ROS中使用频率最高的一种通信模式，话题通信是基于发布订阅模式的，也即:一个节点发布消息，另一个节点订阅该消息。

  • 以项目为例，在机械臂运行的过程中，在ROS中有一个节点需要实时的发布相机采集到的数据，对应的识别模块中会有节点订阅并解析图像数据。
  • 在过程中的运动控制方面，识别模块中根据对应的图像数据计算出运动控制信息并发布到机械臂，机械臂也有节点订阅这个运动信息，从而转换成控制机械臂运动的信号。

总而言之，话题通信要更加适用于不断更新的数据传输相关的应用场景，通过对这个模块的学习，要求能够实现最基本的发布订阅模型，能够对自定义消息进行发布订阅。

话题通信理论模型

话题通信实现模型是比较复杂的，该模型如下图所示,该模型中涉及到三个角色:ROS Master (管理者)、Talker (发布者)、Listener (订阅者)

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

  • Talker注册
    Talker启动后，会通过RPC在 ROS Master 中注册自身信息，其中包含所发布消息的话题名称。ROS Master 会将节点的注册信息加入到注册表中。
  • Listener注册
    Listener启动后，也会通过RPC在 ROS Master 中注册自身信息，包含需要订阅消息的话题名。ROS Master 会将节点的注册信息加入到注册表中。
  • ROS Master实现信息匹配
    ROS Master 会根据注册表中的信息匹配Talker 和 Listener，并通过 RPC 向 Listener 发送 Talker 的 RPC 地址信息。
  • Listener向Talker发送请求
    Listener 根据接收到的 RPC 地址，通过 RPC 向 Talker 发送连接请求，传输订阅的话题名称、消息类型以及通信协议(TCP/UDP)。
  • Talker确认请求
    Talker 接收到 Listener 的请求后，也是通过 RPC 向 Listener 确认连接信息，并发送自身的 TCP 地址信息。
  • Listener与Talker建立连接
    Listener 根据步骤4 返回的消息使用 TCP 与 Talker 建立网络连接。
  • Talker向Listener发送消息
    连接建立后，Talker 开始向 Listener 发布消息。

注意：上述流程中前五步使用的是RPC协议，最后两步使用的是TCP协议，TCP协议我做过相关学习，但RPC协议的具体内容还不太清楚，这里先挂起之后进行专门的学习。Talker 与 Listener 的启动无先后顺序要求并且可以多个存在，连接建立后，不再需要 ROS Master。也即，即便关闭ROS Master，Talker 与 Listern 照常通信。

话题通信基本操作(Python)

需求：编写发布订阅实现，要求发布方以10HZ(每秒10次)的频率发布文本消息，订阅方订阅消息并将消息内容打印输出。
分析：在模型实现中，ROS master 不需要实现，而连接的建立也已经被封装了，需要关注的关键点有三个:发布方、接收方和数据（此处传输数据为普通文本）
流程：编写发布方实现——编写订阅方实现——为python文件添加可执行权限——编辑配置文件——编译并执行

  1. 发布方：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    #! /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. 订阅方:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    #! /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

    1
    2
    3
    4
    5
    catkin_install_python(PROGRAMS
    scripts/talker_p.py
    scripts/listener_p.py
    DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
    )

  5. 执行：
    启动roscore——启动发布——启动订阅（这里按照前面实现hello world那一套流程来，编译、注册、执行）

疑惑点记录：bash文件是什么？python文件中的指令内容含义？CMakelist怎么去编辑？有没有更简便的方法？

话题通信自定义msg

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

上面的意思就是说std_msgs中定义的数据只包含数据本身，如果你想做个备注说这段数据表示什么，下一段又表示其它的含义，那就无法实现了，这就需要自定义类型。

msg只是简单的文本文件，每行具有字段类型和字段名称，可以使用的字段类型有：

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

需求：创建自定义消息，该消息包含人的信息:姓名、身高、年龄等。
流程：
1.按照固定格式创建 msg 文件
2.编辑配置文件
3.编译生成可以被 Python 或 C++ 调用的中间文件

  1. 定义msg文件

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

    1
    2
    3
    string name
    uint16 age
    float64 height

  2. 编辑配置文件

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

    1
    2
    3
    4
    5
    <build_depend>message_generation</build_depend>
    <exec_depend>message_runtime</exec_depend>
    <!-- 
    exce_depend 以前对应的是 run_depend 现在非法
    -->
    1
    2
    3
    4
    5
    ## 配置 msg 源文件
    add_message_files(
    FILES
    Person.msg
    )
    1
    2
    3
    4
    5
    # 生成消息时依赖于 std_msgs
    generate_messages(
    DEPENDENCIES
    std_msgs
    )
    1
    2
    3
    4
    5
    6
    7
    #执行时依赖
    catkin_package(
    #  INCLUDE_DIRS include
    #  LIBRARIES demo02_talker_listener
    CATKIN_DEPENDS roscpp rospy std_msgs message_runtime
    #  DEPENDS system_lib
    )

3.编译

编译后的中间文件查看:
Python 需要调用的中间文件(.../工作空间/devel/lib/python3/dist-packages/包名/msg)
![](https://pic2.imgdb.cn/item/6459fc640d2dde57770586cf.jpg)
后续调用相关 msg 时，是从这些中间文件调用的

这里编译出错大概率是因为复制粘贴的内容在txt里面已经存在，产生了重复，要注意检查，同时仔细阅读报错信息。嫌麻烦可以直接删除所有注释及自带内容然后复制粘贴（注意保留之前的内容）

话题通信自定义msg调用(Python)

需求：编写发布订阅实现，要求发布方以1HZ(每秒1次)的频率发布自定义消息，订阅方订阅自定义消息并将消息内容打印输出。
分析：在模型实现中，ROS master 不需要实现，而连接的建立也已经被封装了，需要关注的关键点有三个:需要关注的关键点有三个:发布方、接收方和数据（此处传输数据为自定义消息）
流程：编写发布方实现——编写订阅方实现——为python文件添加可执行权限——编辑配置文件——编译并执行

  • vscode配置

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

    1
    2
    3
    4
    5
    6
    {
        "python.autoComplete.extraPaths": [
            "/opt/ros/noetic/lib/python3/dist-packages",
            "/xxx/yyy工作空间/devel/lib/python3/dist-packages"
        ]
    }

  • 发布方

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    #! /usr/bin/env python
    """
        发布方:
            循环发送消息

    """
    import rospy
    from demo02_talker_listener.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)

  • 订阅方

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #! /usr/bin/env python
    """
        订阅方:
            订阅消息

    """
    import rospy
    from demo02_talker_listener.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.循环

  • 权限设置

    终端下进入 scripts 执行:chmod +x *.py

  • 配置 CMakeLists.txt

    1
    2
    3
    4
    5
    6
    7
    catkin_install_python(PROGRAMS
    scripts/talker_p.py
    scripts/listener_p.py
    scripts/person_talker.py
    scripts/person_listener.py
    DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
    )

  • 执行： 启动roscore——启动发布——启动订阅（这里按照前面实现hello world那一套流程来，编译、注册、执行）

小结

一定要跟着去尝试，后面会逐渐简化前面已经讲过的流程，这样给了一定的自由度，能够更有效的去领会整个编译执行流程。xml以及cmake文件都是一些定义性的文件，可以适当阅读一下，后期要想自己熟练掌握ros，还是要学会这两种文件的书写，json文件也是。对于python文件更应该主要研究，不需要去记忆，但一定要会用，用着用着自然而然的就记住了。

学ros涉及的范围太广了，先学会主要脉络，再不断扩展延申学习。

FEATURED TAGS
linux ros