2 ROS1通讯编程基础(1)

爬楼的猪

已于 2023-03-25 23:28:04 修改

阅读量914

点赞数 2

CC 4.0 BY-SA版权

分类专栏： ROS1学习笔记文章标签： ROS

于 2020-09-02 21:40:29 首次发布

本文链接：https://blog.csdn.net/qq_42727752/article/details/108370604

ROS1学习笔记专栏收录该内容

8 篇文章

订阅专栏

其他ROS1学习笔记： ROS1学习笔记
代码仓库：Github连接地址
欢迎各位互相学习交流

2.1 通信编程概述

ROS是进程（也称为Nodes）的分布式框架，参考：Understanding ROS Nodes。ROS各个节点之间的数据交互，即ROS的通讯。其 ROS进程之间的的基本通信机制主要有如下三种实现策略:

话题通信(话题的实时发布和订阅模式)，话题通信是ROS中使用频率最高的一种通信模式，比如说机器人在执行导航功能，使用的传感器是激光雷达，机器人会采集激光雷达感知到的信息并计算，然后生成运动控制信息驱动机器人底盘运动。话题通讯常常用于不断更新的、少逻辑处理的数据传输场景。
服务通信(任务的请求和响应模式)，服务通信也是ROS中一种极其常用的通信模式，服务通信是基于请求响应模式的，是一种应答机制。也即: 一个节点A向另一个节点B发送请求，B接收处理请求并产生响应结果返回给A。比如机器人巡逻过程中，控制系统分析传感器数据发现可疑信息，此时需要拍摄照片并留存，服务通信更适用于对时时性有要求、具有一定逻辑处理的应用场景。
参数服务器(参数数据共享模式)，参数服务器在ROS中主要用于实现不同节点之间的数据共享，类似于一个全局的公开数据库，其数据类型为(key，value)类似于C++的map和Python的字典。参数服务器相当于是独立于所有节点的一个公共容器，可以将数据存储在该容器中，被不同的节点调用，当然不同的节点也可以往其中存储数据，关于参数服务器的典型应用场景如路径规划时，需要参考小车的尺寸，我们可以将这些尺寸信息存储到参数服务器，全局路径规划节点与本地路径规划节点都可以从参数服务器中调用这些参数，参数服务器作用主要在于存储一些多节点共享的数据，类似于全局变量或者公开数据库。

接下来，分别介绍ROS的三种通讯机制。整个介绍框架如下图所示：

在这里插入图片描述

进程和线程参考：进程和线程

进程和线程概念：进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。进程是一种抽象的概念，从来没有统一的标准定义。进程一般由程序，数据集合和进程控制块三部分组成。程序用于描述进程要完成的功能，是控制进程执行的指令集；数据集合是程序在执行时所需要的数据和工作区；程序控制块包含进程的描述信息和控制信息是进程存在的唯一标志。

线程是程序执行中一个单一的顺序控制流程，是程序执行流的最小单元，是处理器调度和分派的基本单位。一个进程可以有一个或多个线程，各个线程之间共享程序的内存空间(也就是所在进程的内存空间)。

进程和线程的区别：

线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位；
一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线；
进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段，数据集，堆等)及一些进程级的资源(如打开文件和信号等)，某进程内的线程在其他进程不可见；
调度和切换：线程上下文切换比进程上下文切换要快得多。

2.2话题通讯编程

2.2.1 话题通讯理论模型

如图所示，模型涉及三个角色ROS Master（管理员）、Talker （发布者）和Listener （订阅者），其中，ROS Master 负责保管 Talker 和 Listener 注册的信息，并匹配话题相同的 Talker 与 Listener，帮助 Talker 与 Listener 建立连接，连接建立后，Talker 可以发布消息，且发布的消息会被 Listener 订阅。

在这里插入图片描述

整个通讯的步骤大致为七步：

①Talker 注册：Talker启动后，会通过RPC在ROSMaster中注册自身信息，其中包含所发布消息的话题名称。ROSMaster会将节点的注册信息加入到注册表中。
②Listener 注册：Listener启动后，也会通过RPC在ROSMaster中注册自身信息，包含需要订阅消息的话题名。ROSMaster会将节点的注册信息加入到注册表中。
③ROSMaster 实现信息匹配：ROSMaster会根据注册表中的信息匹配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建立网络连接。
⑦Talke向Listener发送消息：连接建立后，Talker开始向Listener发布消息。

Tips

上述实现流程中，前五步使用的RPC协议，最后两步使用的是TCP协议
Talker与Listener的启动无先后顺序要求，且Talker与Listener都可以有多个
Talker与Listener连接建立后，不再需要ROSMaster。也即，即便关闭ROSMaster，Talker与Listern照常通信。

2.2.2 C++编写话题

编写基础消息的话题，主要是消息的数据类型是编程语言内置的一些，如string类型、uint 16等等。同时基本的代码包括C++和Python版本，依次介绍：

下面的代码Github连接：topic_communication
话题编程的内容：主要为两个节点，一个节点发布数字，另一个节点接收这个数字信息。

2.2.2.1 创建C++项目

创建基本项目方法见1.5；

创建话题通讯功能包topic_communication，即： ~/catkin_ws/src$ catkin_create_pkg topic_communication std_msgs rospy roscpp 位置和依赖项见下图；

图片.png

在功能包topic_communication创建几个文件夹，如include(已存在)、src(已存在)、scripts、launch、msg等文件夹用于存放对应文件，见1.4.2.，文件树如图所示：

ubuntu@ubuntu:~/catkin_ws/src/topic_communication$ tree.
├── CMakeLists.txt
├── include
│   └── topic_communication
├── launch
├── msg
├── package.xml
├── scripts
└── src

2.2.2.2 编写发布者和订阅者

发布者和订阅者代码。注意，publish_talker_cpp.cpp和subscribe_listener_cpp.cpp是放在功能包的src目录里面的（即topic_communication的src目录下） ，代码可以是C++或者python等。

catkin_ws/src/topic_communication/src/publish_talker_cpp.cpp

/**
 * catkin_ws/src/topic_communication/src/publish_talker_cpp.cpp
 * 该例程将发布talker(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;
}

catkin_ws/src/topic_communication/src/subscribe_listener_cpp.cpp

/**
 * catkin_ws/src/topic_communication/src/subscribe_listener_cpp.cpp
 * 该例程将订阅listener（subscriber）话题，消息类型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;
}

2.2.2.3 配置C++工程

1. 配置CMakeList.txt编译选项。打开topic_communication功能包里的CmakeLists.txt文件，对subscribe_listener_cpp和publish_talker_cpp话题进行add_executable和target_link_libraries的配置，其中：

add_executable(生成的话题名 /路径/通过什么文件来生成(可以多个文件生成一个可执行的话题))；
target_link_libraries(生成的话题名字 ${生成话题所需要的库})。

有以下内容：/home/ubuntu/catkin_ws/src/topic_communication/CMakeList.txt

# /home/ubuntu/catkin_ws/src/topic_communication/CMakeList.txt
add_executable(talker_cpp_node src/publish_talker_cpp.cpp)
target_link_libraries(talker_cpp_node ${catkin_LIBRARIES})
add_executable(listener_cpp_node src/subscribe_listener_cpp.cpp)
target_link_libraries(listener_cpp_node ${catkin_LIBRARIES})

Tips：在CmakeList.txt文件，要严格按照如下的顺序，否则会报错。

# /home/ubuntu/catkin_ws/src/topic_communication/CMakeList.txt
find_package()
catkin_package()
include_directories()
add_executable()
target_link_libraries()

即所添加的add_executable和target_link_libraries的内容添加在文件最后面，否则会报错

[rosrun] Couldn't find executable named talker_cpp below /home/ubuntu/catkin_ws/src/topic_communication

图片.png

这时候查看catkin_ws/devel/lib文件夹下，也没有存放node文件，修改顺序后，观察catkin_ws/devel/lib文件夹的变化：

图片.png

2.2.2.4 编译并运行C++工程

1. 编译功能包，在工作空间的根目录catkin_ws下执行catkin_make来进行编译成可执行文件，对于python文件它本身就是个可执行文件，可以不需要编译。

图片.png

1. 运行
6.1. 首先打开一个终端输入roscore代开ROS，
6.2. 再打开新终端输入rosrun topic_communication talker_cpp_node即可打开talker话题;
6.3. 最后新打开一个终端输入rosrun topic_communication listener_cpp_node，演示结果为talker发布的指令listener全部都能同步接收到。

图片.png

2.2.3 Python编写话题

下面的代码Github连接：topic_communication

2.2.3.1 创建工程文件夹并编写Python话题

1. 新建scripts文件夹，同C++话题创建的功能包topic_communication，Python文件主要在scripts文件夹编写
1. 编写publish_talker_py.py文件和subscribe_listener_py.py文件，此listener与wiki有改动

catkin_ws/src/topic_communication/scripts/publish_talker_py.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import rospy
from std_msgs.msg import String

def talker():
#话题名，rostopic list查看
    pub = rospy.Publisher('chatter', String, queue_size=10)
#节点名，rosnode list 查看
    rospy.init_node('talker')
    rate = rospy.Rate(1) # 1hz
    i = 1
    while not rospy.is_shutdown():
        hello_str = "number: %d" % i
        rospy.loginfo(hello_str)
#在listener.py里的data即是hello_str所有的内容
        pub.publish(hello_str)
        i += 1
        rate.sleep()

if __name__ == '__main__':
    try:
        talker()
    except rospy.ROSInterruptException:
        pass

catkin_ws/src/topic_communication/scripts/subscribe_listener_py.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import rospy
from std_msgs.msg import String

#data即chatter带来的所有内容()
def callback(data):
    rospy.loginfo("publisher is " + rospy.get_caller_id() + ' I subscribe %s', data.data)

def listener():
#节点名
    rospy.init_node('listener')
#这里的chatter是在talker.py定义的publish的话题名，区分节点名和话题名
    rospy.Subscriber('chatter', String, callback)

    # spin() simply keeps python from exiting until this node is stopped
    rospy.spin()

if __name__ == '__main__':
    listener()

2.2.3.2 运行Python话题通讯项目

1. 给Python文件赋予可执行权限，在script文件夹下输入命令sudo chmod +x *.py即可赋予所有Python可执行权限。
1. 在catkin_ws/路径下编译文件，与C++项目一致
1. 运行py文件；先roscore打开ROS，再输入rosrun topic_communication publish_talker_py.py即可运行py文件，同理运行subscribe_listener_py.py文件

2.2.4 自定义消息类型的话题通讯

ROS内置的基础类型的msg主要为string、int32、int64、char、bool或者一些数组数据，和多ROS通讯直接的header标记的信息，如果需要其他复杂数据类型的信息时候，需要自定义一些msgs添加到ROS通讯中。

自定义的话题编程的内容：主要为两个节点，一个节点发布复杂数据类型即人物信息包括姓名、年龄和性别等，另一个节点接收这个人物信息。
使用自定义话题的步骤主要为如下四步：①在功能包下的msg文件夹编写自定义msg文件；②在package.xml和CMakeList.tx文件配置msg文件；③编译文件；④使用C++/Python来调用自定义msg文件。
下面的代码Github连接：topic_communication

2.2.4.1 编写msg文件

1. 定义话题文件msg。在功能包的目录下的msg文件夹下，创建话题文件.msg。如在topic_communication/msg创建了Person.msg话题文件。

catkin_ws/src/topic_communication/msgs/Person.msg

string name
string sex
uint8 age

2.2.4.2 配置msg文件

配置msg文件包括在package.xml和CMakeList.txt配置两部分。

1. 在功能包的package.xml里添加话题的依赖。如在topic_communication文件夹的package.xml里添加：

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

其中message_runtime和message_generation都是关键字，message_runtime用在执行时候调用，message_generation在编译时调用。

1. 在功能包的CmakeLists.txt添加编译选项，包括四部分。
3.1 添加编译依赖项功能包：find_package(catkin REQUIRED COMPONENTS ..+依赖项功能包) ，大约在第10行，此时依赖项功能包名字为message_generation(build_depend的内容)，而且必须有std_msgs作为基础在里面， 配置的内容如下所示：

catkin_ws/src/topic_communication/CMakeLists.txt

find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
  message_generation
)

3.2 添加自定义msg文件：add_message_files(FILES文件名) ，大约在第51行，如此时的文件名为Person.msg：

add_message_files(
  FILES
  Person.msg
)

3.3 添加msg的编译依赖项：generate_messages(DEPENDENCIES std_msgs) ，大约在第71行，即表示在编译msg时候得依赖于std_msgs：

generate_messages(
  DEPENDENCIES
  std_msgs
)

3.4 添加执行时的依赖：catkin_package的关键字CATKIN_DEPENDS后+包，大约在106行，其中存在关系为，在新建功能包topic_communication时候，依赖于find_package的内容，而find_package在执行过程中又依赖于catkin_package的内容，因此在CATKIN_DEPEND后面添加的依赖项为message_runtime(exec_depend的内容)，如：

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

2.2.4.3 编译msg文件，查看中间文件

4 .编译Perison.msg文件，查看ROS为其生成的中间文件：
4.1 在工作空间下编译，此时在工作空间的devel目录会多出几个文件，如C++的中间文件在/home/ubuntu/catkin_ws/devel/include/功能包名/文件夹下，Python的中间文件在/home/ubuntu/catkin_ws/devel/lib/python2.7/dist-packages/功能包名/msg文件夹下，如图所示：了解这些中间文件位置，对于编写C++/Python文件的配置很重要！

图片.png

4.2 编译成功后，也可以新建终端，输入命令runmsg show Person（这个Person是话题文件名），查看话题。

2.2.4.4 编写C++代码调用自定义话题（类似于结构体的调用）

1. 编写C++代码调用自定义话题，主要包括调用自定义msg生成的.h文件，类似于命名空间一样调用其对象：
5.1 编写发布者代码：myTalker_cpp.cpp

catkin_ws/src/topic_communication/src/myTalker_cpp.cpp

#include "ros/ros.h"
// 添加自定义的头文件
#include "topic_communication/Person.h"
using namespace std;

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_communication::Person>("chatter_person",1000);

    //4.组织被发布的消息，编写发布逻辑并发布消息
    topic_communication::Person p;
    p.name = "zhangsan";
    p.sex = "man";
    p.age = 18;

    ros::Rate r(1);
    while (ros::ok())
    {
        pub.publish(p);
        p.age += 1;
        ROS_INFO("我叫:%s,性别:%s，年龄:%d", p.name.c_str(), p.sex.c_str(), p.age);

        r.sleep();
        ros::spinOnce();
    }
    return 0;
}

5.2 编写订阅者代码：myListener_cpp.cpp

catkin_ws/src/topic_communication/src/myListener_cpp.cpp

#include "ros/ros.h"
// 添加自定义的头文件
#include "topic_communication/Person.h"

using namespace std;

void doPerson(const topic_communication::Person::ConstPtr& person_p){
    ROS_INFO("订阅信息:%s, %s, %d", person_p->name.c_str(), person_p->sex.c_str(), person_p->age);
}

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<topic_communication::Person>("chatter_person",10,doPerson);

    //4.回调函数中处理 person

    //5.ros::spin();
    ros::spin();    
    return 0;
}

5.3 配置C++的CMakeList.txt文件，其中和基本数据类型区别主要在于需要增加一项add_dependencies的依赖项：${PROJECT_NAME}_generate_messages_cpp，如下所示：

catkin_ws/src/topic_communication/CMakeList.txt

add_executable(mytalker_cpp_node src/myTalker_cpp.cpp)
add_dependencies(mytalker_cpp_node ${PROJECT_NAME}_generate_messages_cpp)
target_link_libraries(mytalker_cpp_node ${catkin_LIBRARIES})

add_executable(mylistener_cpp_node src/myListener_cpp.cpp)
add_dependencies(mylistener_cpp_node ${PROJECT_NAME}_generate_messages_cpp)
target_link_libraries(mylistener_cpp_node ${catkin_LIBRARIES})

5.4 在工作空间下编译文件，如果没有出错的话，新建终端，打开ROS，打开节点查看话题：

图片.png

2.2.4.5 编写Python文件使用自定义节点

1. 编写Python代码，关键点在于导入自定义话题的路径和不要忘记给py文件赋予可执行权限。
6.1 在script文件夹编写mytalker_py.py文件和mylistener_py.py****

catkin_ws/src/topic_communication/scripts/mytalker_py.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import rospy
from topic_communication.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 = "zhangsan"
    p.sex = "man"
    p.age = 18

    #4.编写消息发布逻辑
    rate = rospy.Rate(1)
    while not rospy.is_shutdown():
        pub.publish(p)  #发布消息
        p.age = p.age+1
        rate.sleep()  #休眠
        rospy.loginfo("我叫:%s,性别:%s，年龄:%d", p.name, p.sex, p.age)

catkin_ws/src/topic_communication/scripts/subscribe_listener_py.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import rospy
from topic_communication.msg import Person

def doPerson(p):
    rospy.loginfo("接收信息:%s, %s, %d",p.name, p.sex, p.age)


if __name__ == "__main__":
    #1.初始化节点
    rospy.init_node("listener_person_p")
    #2.创建订阅者对象
    sub = rospy.Subscriber("chatter_person",Person,doPerson,queue_size=10)
    rospy.spin() #4.循环

6.2 给Python文件赋予可执行权限，在script文件夹下输入命令sudo chmod +x *.py即可赋予所有Python可执行权限。
6.3 在catkin_ws/路径下编译文件
6.4 先roscore打开ROS，再输入rosrun topic_communication mytalker_py.py即可运行py文件，同理运行mylistener_py.py文件

图片.png

2.2.5 话题通讯总结

对于话题通讯的理解，作为第一个ROS编程例子，其主要在于熟悉ROS功能包的概念，ROS的文件夹系统，关键在于自定义的一些内容在CMakeList.txt和package.xml文件的配置。如下图所示：

图片.png

2.2.5.1 话题通讯理论模型

话题通讯理论模型主要掌握的内容包括如下三点：

1. 发布者和订阅者的启动，启动顺序无关；
1. ROSMaster的作用：信息匹配，并且使用PRC连接发布者和订阅者的RPC地址，连接成功后，ROSMaster可以关闭；
1. 实现通讯：发布者和订阅者连接到后，发送TCP/IP地址，使用TCP/IP通讯。

图片.png

2.2.5.2 基础话题通讯总结

基础消息通讯包括如下三点：

新建功能包，添加依赖项，建立好功能包的文件夹层次，编写代码；
C++代码：①正常代码编写；②CMakeList.txt进行配置(主要为add_executable和target_link_libraries的配置注意配置在CMakeList.txt的位置）；③编译运行；
Python代码：①正常代码编写；②CMakeList.txt进行配置(catkin_install_python()目前配置不配置影响不大）；③赋予py文件可执行权限；④编译运行。

图片.png

2.2.5.3 自定义话题通讯总结

自定义话题类型主要包括：

在msg文件夹编写自定义msg文件，配置package.xml文件包括①exec_depend>message_runtime</exec_depend>；②<build_depend>message_generation</build_depend>；
配置CMakeList.txt文件包括①添加编译依赖项功能包：find_package；②添加自定义msg文件：add_message_files；③添加msg的编译依赖项：generate_messages；④添加执行时的依赖：catkin_package；
C++代码：①添加头文件（头文件为功能包名字/自定义消息名.h）；②正常编写代码；③CMakeList.txt进行配置(不仅有add_executable和target_link_libraries还包括add_dependencies）；④编译运行；
Python代码：①添加包，from 功能包名.msg import *；②正常代码编写；②CMakeList.txt进行配置(目前配置不配置影响不大）；③赋予py文件可执行权限；④编译运行。整个内容如图所示：

图片.png