本文详细介绍了ROS中的三种主要通信机制：话题通信、服务通信和参数服务器。在话题通信中，节点通过发布和订阅实现数据交换；服务通信基于请求响应模式，提供应答机制；参数服务器则用于节点间的数据共享。文章通过实例展示了如何创建自定义消息类型、定义服务以及操作参数服务器，并提供了相关代码示例。
感谢3.1 常用API · Autolabor-ROS机器人入门课程《ROS理论与实践》零基础教程
第三节 ROS的通讯机制
这一节主要讲的是通讯机制
就像前面说的那样，ROS通过节点发布信息，节点订阅信息实现通讯。
基本的通讯机制主要有三种：
- 话题通信(发布订阅模式)
- 服务通信(请求响应模式)
- 参数服务器(参数共享模式)
话题通讯
这是一个话题通讯的流程图，可以看出主要是有三个角色参与：ROS Master (管理者)、Talker (发布者)、Listener (订阅者)
虽然中间又复杂的注册步骤，但是在模型实现中，ROS master 不需要实现，而连接的建立也已经被封装了，需要关注的关键点有三个:
1 发布方
2 接收方
3 数据(此处为普通文本)
1.发布方
/*
需求: 实现基本的话题通信，一方发布数据，一方接收数据，
实现的关键点:
1.发送方
2.接收方
3.数据(此处为普通文本)
PS: 二者需要设置相同的话题
消息发布方:
循环发布信息:HelloWorld 后缀数字编号
实现流程:
1.包含头文件
2.初始化 ROS 节点:命名(唯一)
3.实例化 ROS 句柄
4.实例化 发布者 对象
5.组织被发布的数据，并编写逻辑发布数据
*/
// 1.包含头文件
#include "ros/ros.h"
#include "std_msgs/String.h" //普通文本类型的消息，需要借助头文件来发信息
#include <sstream>//拼接编号用的
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.订阅方
/*
需求: 实现基本的话题通信，一方发布数据，一方接收数据，
实现的关键点:
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<std_msgs::String>("chatter",10,doMsg);
//5.处理订阅的消息(回调函数)
// 6.设置循环调用回调函数
ros::spin();//循环读取接收的数据，并调用回调函数处理
return 0;
}3.配置 CMakeLists.txt
…
add_executable(Hello_pub
src/Hello_pub.cpp
)
add_executable(Hello_sub
src/Hello_sub.cpp
)
target_link_libraries(Hello_pub
${catkin_LIBRARIES}
)
target_link_libraries(Hello_sub
${catkin_LIBRARIES}
)
…4.自定义消息类型
我们其实可以发现，这个消息是“定死了的”，在实际传感器传输的过程中信息是变化的。所以我们就需要一种自定义的消息类型。
首先需要配置vscode以防止报错
将前面生成的 head 文件路径配置进 c_cpp_properties.json 的 includepath属性:
{
"configurations": [
{
"browse": {
"databaseFilename": "",
"limitSymbolsToIncludedHeaders": true
},
"includePath": [
"/opt/ros/noetic/include/**",
"/usr/include/**",
"/xxx/yyy工作空间/devel/include/**" //配置 head 文件的路径
],
"name": "ROS",
"intelliSenseMode": "gcc-x64",
"compilerPath": "/usr/bin/gcc",
"cStandard": "c11",
"cppStandard": "c++17"
}
],
"version": 4
}这时候你就有种感觉：这似乎是把自定义的信息类型看成了.h头文件（还放到了devel（开发的）include里面）
观察前面的发布方和订阅方：都有头文件：#include "std_msgs/String.h"。已经说过：节点信息的发布和订阅需要借助中间方（在ROS中分装好了的）。只是现在这个中间放需要我们自己来写了。
5.发布方（二代）
{
"configurations": [
{
"browse": {
"databaseFilename": "",
"limitSymbolsToIncludedHeaders": true
},
"includePath": [
"/opt/ros/noetic/include/**",
"/usr/include/**",
"/xxx/yyy工作空间/devel/include/**" //配置 head 文件的路径
],
"name": "ROS",
"intelliSenseMode": "gcc-x64",
"compilerPath": "/usr/bin/gcc",
"cStandard": "c11",
"cppStandard": "c++17"
}
],
"version": 4
}6.订阅方（二代）
/*
需求: 订阅人的信息
*/
#include "ros/ros.h"
#include "demo02_talker_listener/Person.h"
void doPerson(const demo02_talker_listener::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<demo02_talker_listener::Person>("chatter_person",10,doPerson);
//4.回调函数中处理 person
//5.ros::spin();
ros::spin();
return 0;
}7.配置 CMakeLists.txt（二代）
！！！需要添加 add_dependencies 用以设置所依赖的消息相关的中间文件。
add_executable(person_talker src/自定义消息类型名.cpp)
add_executable(person_listener src/自定义消息类型名.cpp)
add_dependencies(person_talker ${PROJECT_NAME}_generate_messages_cpp)
add_dependencies(person_listener ${PROJECT_NAME}_generate_messages_cpp)
target_link_libraries(person_talker
${catkin_LIBRARIES}
)
target_link_libraries(person_listener
${catkin_LIBRARIES}
)8启动
1.启动 roscore;
2.启动发布节点;
3.启动订阅节点。
服务通信
服务通信也是ROS中一种极其常用的通信模式，服务通信是基于请求响应模式的，是一种应答机制。简单说就是客户提供输入，扔给服务端，服务端处理后，输出给客户端
最常见的案例就是计算器——输入运算公式，返回答案
和话题通讯不同，话题通讯是制造出一个话题，节点可能对这个话题感兴趣然后订阅接受。服务则是需要你事先准备一个格式，只有符合格式的输入才能传给服务端，服务端运行结果同样符合这个格式要求的返回给客户端
这个格式类似上面说过的msg数据类型，不过服务讯通称作srv文件
1.定义srv文件
服务通信中，数据分成两部分，请求与响应，在 srv 文件中请求和响应使用---分割，具体实现如下:
功能包下新建 srv 目录，添加 xxx.srv 文件，内容:
# 客户端请求时发送的两个数字
int32 num1
int32 num2
---
# 服务器响应发送的数据
int32 sum2.编辑配置文件
package.xml中添加编译依赖与执行依赖
<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>
<!--
exce_depend 以前对应的是 run_depend 现在非法
-->CMakeLists.txt编辑 srv 相关配置
find_package(catkin REQUIRED COMPONENTS
roscpp
rospy
std_msgs
message_generation
)
# 需要加入 message_generation,必须有 std_msgs
Copy
add_service_files(
FILES
AddInts.srv
)
Copy
generate_messages(
DEPENDENCIES
std_msgs
)注意: 官网没有在 catkin_package 中配置 message_runtime,经测试配置也可以
3.编译
编译后（快捷键ctrl+shift+B）查看生成的中间文件:
C++ 需要调用的中间文件(.../工作空间/devel/include/包名/xxx.h)
4vscode配置
同样要包含目录
{
"configurations": [
{
"browse": {
"databaseFilename": "",
"limitSymbolsToIncludedHeaders": true
},
"includePath": [
"/opt/ros/noetic/include/**",
"/usr/include/**",
"/xxx/yyy工作空间/devel/include/**" //配置 head 文件的路径
],
"name": "ROS",
"intelliSenseMode": "gcc-x64",
"compilerPath": "/usr/bin/gcc",
"cStandard": "c11",
"cppStandard": "c++17"
}
],
"version": 4
}5.服务端
/*
需求:
编写两个节点实现服务通信，客户端节点需要提交两个整数到服务器
服务器需要解析客户端提交的数据，相加后，将结果响应回客户端，
客户端再解析
服务器实现:
1.包含头文件
2.初始化 ROS 节点
3.创建 ROS 句柄
4.创建 服务 对象
5.回调函数处理请求并产生响应
6.由于请求有多个，需要调用 ros::spin()
*/
#include "ros/ros.h"
#include "demo03_server_client/AddInts.h"
// bool 返回值由于标志是否处理成功
bool doReq(demo03_server_client::AddInts::Request& req,
demo03_server_client::AddInts::Response& resp){
int num1 = req.num1;
int num2 = req.num2;
ROS_INFO("服务器接收到的请求数据为:num1 = %d, num2 = %d",num1, num2);
//逻辑处理
if (num1 < 0 || num2 < 0)
{
ROS_ERROR("提交的数据异常:数据不可以为负数");
return false;
}
//如果没有异常，那么相加并将结果赋值给 resp
resp.sum = num1 + num2;
return true;
}
int main(int argc, char *argv[])
{
setlocale(LC_ALL,"");
// 2.初始化 ROS 节点
ros::init(argc,argv,"AddInts_Server");
// 3.创建 ROS 句柄
ros::NodeHandle nh;
// 4.创建 服务 对象
ros::ServiceServer server = nh.advertiseService("AddInts",doReq);
ROS_INFO("服务已经启动....");
// 5.回调函数处理请求并产生响应
// 6.由于请求有多个，需要调用 ros::spin()
ros::spin();
return 0;
}
Copy6客户端
/*
需求:
编写两个节点实现服务通信，客户端节点需要提交两个整数到服务器
服务器需要解析客户端提交的数据，相加后，将结果响应回客户端，
客户端再解析
服务器实现:
1.包含头文件
2.初始化 ROS 节点
3.创建 ROS 句柄
4.创建 客户端 对象
5.请求服务，接收响应
*/
// 1.包含头文件
#include "ros/ros.h"
#include "demo03_server_client/AddInts.h"
int main(int argc, char *argv[])
{
setlocale(LC_ALL,"");
// 调用时动态传值,如果通过 launch 的 args 传参，需要传递的参数个数 +3
if (argc != 3)
// if (argc != 5)//launch 传参(0-文件路径 1传入的参数 2传入的参数 3节点名称 4日志路径)
{
ROS_ERROR("请提交两个整数");
return 1;
}
// 2.初始化 ROS 节点
ros::init(argc,argv,"AddInts_Client");
// 3.创建 ROS 句柄
ros::NodeHandle nh;
// 4.创建 客户端 对象
ros::ServiceClient client = nh.serviceClient<demo03_server_client::AddInts>("AddInts");
//等待服务启动成功
//方式1
ros::service::waitForService("AddInts");
//方式2
// client.waitForExistence();
// 5.组织请求数据
demo03_server_client::AddInts ai;
ai.request.num1 = atoi(argv[1]);
ai.request.num2 = atoi(argv[2]);
// 6.发送请求,返回 bool 值，标记是否成功
bool flag = client.call(ai);
// 7.处理响应
if (flag)
{
ROS_INFO("请求正常处理,响应结果:%d",ai.response.sum);
}
else
{
ROS_ERROR("请求处理失败....");
return 1;
}
return 0;
}7.配置 CMakeLists.txt
add_executable(AddInts_Server src/AddInts_Server.cpp)
add_executable(AddInts_Client src/AddInts_Client.cpp)
add_dependencies(AddInts_Server ${PROJECT_NAME}_gencpp)
add_dependencies(AddInts_Client ${PROJECT_NAME}_gencpp)
target_link_libraries(AddInts_Server
${catkin_LIBRARIES}
)
target_link_libraries(AddInts_Client
${catkin_LIBRARIES}
)8.执行
- Roscore
- 需要先启动服务:rosrun 包名 服务
- 然后再调用客户端 :rosrun 包名 客户端 参数1 参数2
参数服务器
参数服务器在ROS中主要用于实现不同节点之间的数据共享。参数服务器相当于是独立于所有节点的一个公共容器，可以将数据存储在该容器中，被不同的节点调用。简单来说，上面两种通讯方式都是1v1的。如果其他节点想要与其通讯，就需要上一个匹配的节点结束后才能匹配
而参数通讯则是1VN
ROS Master 作为一个公共容器保存参数，Talker 可以向容器中设置参数，Listener 可以获取参数。
但是这里的参数数据类型一般都是定义好了的
• 32-bit integers
• booleans
• strings
• doubles
• iso8601 dates时间
• lists
• base64-encoded binary data
• 字典主要是借助ros::NodeHandle 、ros::param、来实现的
1.参数服务器新增(修改)参数
/*
参数服务器操作之新增与修改(二者API一样)_C++实现:
在 roscpp 中提供了两套 API 实现参数操作
ros::NodeHandle
setParam("键",值)
ros::param
set("键","值")
示例:分别设置整形、浮点、字符串、bool、列表、字典等类型参数
修改(相同的键，不同的值)
*/
#include "ros/ros.h"
int main(int argc, char *argv[])
{
ros::init(argc,argv,"set_update_param");
std::vector<std::string> stus;
stus.push_back("zhangsan");
stus.push_back("李四");
stus.push_back("王五");
stus.push_back("孙大脑袋");
std::map<std::string,std::string> friends;
friends["guo"] = "huang";
friends["yuang"] = "xiao";
//NodeHandle--------------------------------------------------------
ros::NodeHandle nh;
nh.setParam("nh_int",10); //整型
nh.setParam("nh_double",3.14); //浮点型
nh.setParam("nh_bool",true); //bool
nh.setParam("nh_string","hello NodeHandle"); //字符串
nh.setParam("nh_vector",stus); // vector
nh.setParam("nh_map",friends); // map
//修改演示(相同的键，不同的值)
nh.setParam("nh_int",10000);
//param--------------------------------------------------------
ros::param::set("param_int",20);
ros::param::set("param_double",3.14);
ros::param::set("param_string","Hello Param");
ros::param::set("param_bool",false);
ros::param::set("param_vector",stus);
ros::param::set("param_map",friends);
//修改演示(相同的键，不同的值)
ros::param::set("param_int",20000);
return 0;
}
2.参数服务器获取参数
/*
参数服务器操作之查询_C++实现:
在 roscpp 中提供了两套 API 实现参数操作
ros::NodeHandle
param(键,默认值)
存在，返回对应结果，否则返回默认值
getParam(键,存储结果的变量)
存在,返回 true,且将值赋值给参数2
若果键不存在，那么返回值为 false，且不为参数2赋值
getParamCached键,存储结果的变量)--提高变量获取效率
存在,返回 true,且将值赋值给参数2
若果键不存在，那么返回值为 false，且不为参数2赋值
getParamNames(std::vector<std::string>)
获取所有的键,并存储在参数 vector 中
hasParam(键)
是否包含某个键，存在返回 true，否则返回 false
searchParam(参数1，参数2)
搜索键，参数1是被搜索的键，参数2存储搜索结果的变量
ros::param ----- 与 NodeHandle 类似
*/
#include "ros/ros.h"
int main(int argc, char *argv[])
{
setlocale(LC_ALL,"");
ros::init(argc,argv,"get_param");
//NodeHandle--------------------------------------------------------
/*
ros::NodeHandle nh;
// param 函数
int res1 = nh.param("nh_int",100); // 键存在
int res2 = nh.param("nh_int2",100); // 键不存在
ROS_INFO("param获取结果:%d,%d",res1,res2);
// getParam 函数
int nh_int_value;
double nh_double_value;
bool nh_bool_value;
std::string nh_string_value;
std::vector<std::string> stus;
std::map<std::string, std::string> friends;
nh.getParam("nh_int",nh_int_value);
nh.getParam("nh_double",nh_double_value);
nh.getParam("nh_bool",nh_bool_value);
nh.getParam("nh_string",nh_string_value);
nh.getParam("nh_vector",stus);
nh.getParam("nh_map",friends);
ROS_INFO("getParam获取的结果:%d,%.2f,%s,%d",
nh_int_value,
nh_double_value,
nh_string_value.c_str(),
nh_bool_value
);
for (auto &&stu : stus)
{
ROS_INFO("stus 元素:%s",stu.c_str());
}
for (auto &&f : friends)
{
ROS_INFO("map 元素:%s = %s",f.first.c_str(), f.second.c_str());
}
// getParamCached()
nh.getParamCached("nh_int",nh_int_value);
ROS_INFO("通过缓存获取数据:%d",nh_int_value);
//getParamNames()
std::vector<std::string> param_names1;
nh.getParamNames(param_names1);
for (auto &&name : param_names1)
{
ROS_INFO("名称解析name = %s",name.c_str());
}
ROS_INFO("----------------------------");
ROS_INFO("存在 nh_int 吗? %d",nh.hasParam("nh_int"));
ROS_INFO("存在 nh_intttt 吗? %d",nh.hasParam("nh_intttt"));
std::string key;
nh.searchParam("nh_int",key);
ROS_INFO("搜索键:%s",key.c_str());
*/
//param--------------------------------------------------------
ROS_INFO("++++++++++++++++++++++++++++++++++++++++");
int res3 = ros::param::param("param_int",20); //存在
int res4 = ros::param::param("param_int2",20); // 不存在返回默认
ROS_INFO("param获取结果:%d,%d",res3,res4);
// getParam 函数
int param_int_value;
double param_double_value;
bool param_bool_value;
std::string param_string_value;
std::vector<std::string> param_stus;
std::map<std::string, std::string> param_friends;
ros::param::get("param_int",param_int_value);
ros::param::get("param_double",param_double_value);
ros::param::get("param_bool",param_bool_value);
ros::param::get("param_string",param_string_value);
ros::param::get("param_vector",param_stus);
ros::param::get("param_map",param_friends);
ROS_INFO("getParam获取的结果:%d,%.2f,%s,%d",
param_int_value,
param_double_value,
param_string_value.c_str(),
param_bool_value
);
for (auto &&stu : param_stus)
{
ROS_INFO("stus 元素:%s",stu.c_str());
}
for (auto &&f : param_friends)
{
ROS_INFO("map 元素:%s = %s",f.first.c_str(), f.second.c_str());
}
// getParamCached()
ros::param::getCached("param_int",param_int_value);
ROS_INFO("通过缓存获取数据:%d",param_int_value);
//getParamNames()
std::vector<std::string> param_names2;
ros::param::getParamNames(param_names2);
for (auto &&name : param_names2)
{
ROS_INFO("名称解析name = %s",name.c_str());
}
ROS_INFO("----------------------------");
ROS_INFO("存在 param_int 吗? %d",ros::param::has("param_int"));
ROS_INFO("存在 param_intttt 吗? %d",ros::param::has("param_intttt"));
std::string key;
ros::param::search("param_int",key);
ROS_INFO("搜索键:%s",key.c_str());
return 0;
}
3.参数服务器删除参数
/*
参数服务器操作之删除_C++实现:
ros::NodeHandle
deleteParam("键")
根据键删除参数，删除成功，返回 true，否则(参数不存在)，返回 false
ros::param
del("键")
根据键删除参数，删除成功，返回 true，否则(参数不存在)，返回 false
*/
#include "ros/ros.h"
int main(int argc, char *argv[])
{
setlocale(LC_ALL,"");
ros::init(argc,argv,"delete_param");
ros::NodeHandle nh;
bool r1 = nh.deleteParam("nh_int");
ROS_INFO("nh 删除结果:%d",r1);
bool r2 = ros::param::del("param_int");
ROS_INFO("param 删除结果:%d",r2);
return 0;
}4cmakelist.txt配置
…
add_executable(Hello_pub
src/Hello_pub.cpp
)
add_executable(Hello_sub
src/Hello_sub.cpp
)5启动
roscore
rosrun 功能包名 cpp文件名
当然没有提示，但是新开窗口，输入roaparam list就能够查看自定义的参数列表
输入rosparam get /自定义参数名
就能够使用
扫一扫
758
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
