开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> 第二章、ROS通信机制 -> 正文阅读

[C++知识库]第二章、ROS通信机制

第二章、ROS通信机制

一、话题通信（发布订阅）

1.话题通信理论模型

角色

ROSMaster 管理者（媒婆）
talker 发布者（男方）
listener 订阅者（女方）

流程

ROSMaster可以根据话题建立发布者和订阅者的连接

注意事项

RPC协议
TCP协议
步骤0和步骤1没有顺序要求
talker和listener可以存在多个
talker个listener建立联系后，master就可以关闭了
上述实现流程已经被封装，直接调用就可以了

关注点

大部分实现已经被封装了
设置一致的话题
主要关注发布者的实现，订阅者的实现，消息载体

2.话题通信基本操作

C++实现

流程
- 编写发布者
- 编写订阅者
- 配置文件
- 编译执行
发布者

#include "ros/ros.h"
#include "std_msgs/String.h"
#include "sstream"
/*
发布方实现：
    1.包含头文件
    2.初始化ROS节点
    3.创建节点句柄
    4.创建发布者对象
    5.编写发布逻辑并发布数据
*/
int main(int argc,char* argv[]) {
    ros::init(argc,argv,"结点名称");
    ros::NodeHandle nh;
    ros::Publisher pub = nh.advertise<std_msgs::String>("话题名称",10);
    std_msgs::String msg;
    // 发布频率10Hz
    ros::Rate rate(10);
    // 设置编号
    int count = 0;
    while(ros::ok()){
        setlocale(LC_ALL,"");
        count++;
        // msg.data = "hello";
        std::stringstream ss;
        ss << "hello--->" << count;
        msg.data = ss.str();
        ROS_INFO("发布的数据%s",ss.str().c_str());
        pub.publish(msg);
        rate.sleep();
    }
    return 0;
}

检查是否有问题

rostopic echo 话题名称

订阅者实现

#include "ros/ros.h"
#include "std_msgs/String.h"
/*
订阅方实现：
    1.包含头文件
    2.初始化ROS节点
    3.创建节点句柄
    4.创建订阅者对象
    5.编写订阅逻辑并订阅数据
    6.声明spin();函数处理回调函数
*/
void 回调函数名(const std_msgs::String::ConstPtr& msg) {
    // 通过msg获取得到的数据
    ROS_INFO("翠花订阅到的数据%s",msg->data.c_str());
}
int main(int argc,char* argv[]) {
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"结点名");
    ros::NodeHandle nh;
    ros::Subscriber sub = nh.subscribe("订阅的话题名",10,回调函数名);
    ros::spin();
}

python实现

发布者

#! /usr/bin/env python
import rospy
from std_msgs.msg import String
if __name__ == "__main__":
    rospy.init_node("sanDai")
    pub = rospy.Publisher("che",String,queue_size=10)
    msg = String()
    rate = rospy.Rate(1)
    count = 0
    while not rospy.is_shutdown():
        count += 1
        msg.data = "hello" + str(count)
        pub.publish(msg)
        rospy.loginfo("发布的数据是%s",msg.data)
        rate.sleep()

订阅者

#! /usr/bin/env python
import rospy
from std_msgs.msg import String

def doMsg(msg):
    rospy.loginfo("我订阅的数据%s",msg.data)


if __name__ == "__main__":
    rospy.init_node("huahua")
    sub = rospy.Subscriber("che",String,doMsg,queue_size=10)

    rospy.spin()
    pass

注意事项

数据丢失：加延时

3.自定义话题通信

**简介：**ROS 中通过 std_msgs 封装了一些原生的数据类型,比如:String、Int32、Int64、Char、Bool、Empty…但是，这些数据一般只包含一个 data 字段，结构的单一意味着功能上的局限性。

可以使用的字段类：

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

自定义msg文件

msg目录下文本文件

string name
uint16 age
float64 height

编辑文件配置

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

  <build_depend>message_generation</build_depend>
  <exec_depend>message_runtime</exec_depend>
  <!-- 
  exce_depend 以前对应的是 run_depend 现在非法
  -->

CMakeList.txt编辑msg相关配置

# 需要加入 message_generation,必须有 std_msgs
find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
  message_generation
)
## 配置 msg 源文件
add_message_files(
  FILES
  Person.msg
)
# 生成消息时依赖于 std_msgs
generate_messages(
  DEPENDENCIES
  std_msgs
)
#执行时依赖
catkin_package(
#  INCLUDE_DIRS include
#  LIBRARIES demo02_talker_listener
  CATKIN_DEPENDS roscpp rospy std_msgs message_runtime
#  DEPENDS system_lib
)
# 防止编译时，编译顺序错误
add_dependencies(demo02_pub ${PROJECT_NAME}_generate_messages_cpp)

编译及VC配置

{
  "configurations": [
      {
          "browse": {
              "databaseFilename": "",
              "limitSymbolsToIncludedHeaders": true
          },
          "includePath": [
              "/opt/ros/noetic/include/**",
              "/usr/include/**",
              "/home/zhf/Learn_ROS/demo03_ws/devel/include/**" //配置 head 文件的路径 
          ],
          "name": "ROS",
          "intelliSenseMode": "gcc-x64",
          "compilerPath": "/usr/bin/gcc",
          "cStandard": "c11",
          "cppStandard": "c++17"
      }
  ],
  "version": 4
}

C++实现

#include "ros/ros.h"
#include "plumbing_pub_sub/Person.h"
int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"Person");
    ros::NodeHandle nh;
    // 设置话题
    ros::Publisher pub = nh.advertise<plumbing_pub_sub::Person>("teacher",20);
    plumbing_pub_sub::Person stu;
    stu.age = 1;
    stu.name = "张三";
    stu.height = 1.7;
    ros::Rate rate(1);
    while (ros::ok()) {
        rate.sleep();
        pub.publish(stu);
        ROS_INFO("name:%s,age:%d,height:%0.2f",stu.name.c_str(),stu.age,stu.height);
        stu.age ++;
        ros::spinOnce();
    }
    return 0;
}

#include "ros/ros.h"
#include "plumbing_pub_sub/Person.h"
using namespace ros;
void doMsg(const plumbing_pub_sub::Person::ConstPtr & msg) {
    ROS_INFO("%s,%d,%0.2f",msg->name.c_str(),msg->age,msg->height);
}
int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    init(argc,argv,"student");
    NodeHandle np;
    Subscriber sub = np.subscribe("teacher",20,doMsg);

    spin();
    return 0;
}

这个函数的参数是针对消息的一个指针，const plumbing_pub_sub::Person::ConstPtr & msg
这是在ros里面固定格式的一个调用，plumbing_pub_sub::Person 对应于我们主函数里面话题内容/turtle1/pose是一样的，后面的ConstPtr是一个常指针，msg以一个常指针的形式指向plumbing_pub_sub::Person所有的信息的数据内容

python实现

VC 配置d

{
    "python.autoComplete.extraPaths": [
        "/opt/ros/noetic/lib/python3/dist-packages",
        "/home/zhf/Learn_ROS/demo03_ws/devel/lib/python3/dist-packages" // 导入生成发python 路径
    ],
    "python.pythonPath": "/usr/bin/python",
    "cmake.configureOnOpen": false
}

pub

#! /usr/bin/env python
import rospy
from plumbing_pub_sub.msg import Person 

if __name__ == "__main__":
    # 初始化节点
    rospy.init_node("father")
    pub = rospy.Publisher("liaotian",Person,queue_size=10)
    fat = Person()
    fat.name = "李四"
    fat.age = 1
    fat.height = 1.8
    rate = rospy.Rate(1)
    while not rospy.is_shutdown():
        pub.publish(fat)
        fat.age += 1
        rate.sleep()

sub

#! /usr/bin/env python

import rospy
from plumbing_pub_sub.msg import Person 

def doMsg(p):
    rospy.loginfo("%s,%d,%0.2f",p.name,p.age,p.height)

if __name__ == "__main__":
    # 初始化节点
    rospy.init_node("mather")
    sub = rospy.Subscriber("liaotian",Person,doMsg,queue_size=10)
    rospy.spin()

二、服务通信（请求响应）

1.概念

以请求响应的方式实现不同节点之间数据交互的通信模式。

用于偶然的、对时时性有要求、有一定逻辑处理需求的数据传输场景。

2.模型

ROS master
Talker(Server)
Listener(Client)

注意事项

1.服务端是先启动的，客户端后请求

2.客户端和服务端都可以存在多个

3.话题需要一致

4.数据格式自定义

3.自定义服务通信数据类型srv

按照固定格式创建srv文件

包含两部分，请求部分，和响应部分

编辑配置文件

package.xml

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

CMakeList.txt

find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
  message_generation
)

add_service_files(
  FILES
  AddInts.srv
)

generate_messages(
  DEPENDENCIES
  std_msgs
)

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

编译文件就好了

4.C++实现

配置vscode

// 配置路径
/home/zhf/Learn_ROS/demo03_ws/devel/include/**

服务端

#include "ros/ros.h"
#include "plumbing_server_client/AddInts.h"
using namespace ros;
/* 
服务器实现:
        1.包含头文件
        2.初始化 ROS 节点
        3.创建 ROS 句柄
        4.创建 服务 对象
        5.回调函数处理请求并产生响应
        6.由于请求有多个，需要调用 ros::spin()
*/
bool doNums(plumbing_server_client::AddInts::Request & request,
    plumbing_server_client::AddInts::Response & response) {
    int num1 = request.num1;
    int num2 = request.num2;
    int sum = num1 + num2;
    ROS_INFO("%d+%d=%d",num1,num2,sum);
    response.sum = sum;
    return true;
}
int main(int argc, char *argv[])
{
    // 初始化ROS节点
    init(argc,argv,"server");
    // 创建句柄
    NodeHandle nh;
    // 创建服务对象
    ServiceServer server = nh.advertiseService("addInts",doNums);
    // 处理请求并产生响应
    spin();
    return 0;
}

CMakeList.txt

add_executable(demo01_server src/demo01_server.cpp)
# 后面的参数可以使用默认值
add_dependencies(demo01_server ${PROJECT_NAME}_gencpp)
target_link_libraries(demo01_server
  ${catkin_LIBRARIES}
)

测试指令

rosservice call addInts "num1: 6
num2: 5"

客户端

#include "ros/ros.h"
#include "plumbing_server_client/AddInts.h"
using namespace ros;
int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    init(argc,argv,"client");
    NodeHandle nh;
    plumbing_server_client::AddInts msg;
    msg.request.num1 = 5;
    msg.request.num2 = 10;
    ServiceClient client = nh.serviceClient<plumbing_server_client::AddInts>("addInts");
    bool flag=true;
    Rate rate(10);
    while (flag) {
        msg.request.num1++;
        flag = client.call(msg);
        ROS_INFO("响应结果%d",msg.response.sum);
        rate.sleep();
    }
    return 0;
}

实现参数的动态提交

// 在client.call(msg);之前加一个函数
client.waitForExistence();
// 或者
ros::service::waitForService("等待的服务名称");

5.python实现

服务端

#! /usr/bin/env python

import rospy
from plumbing_server_client.srv import *
# 参数必须用request
def doNum(request):
    sum = request.num1 + request.num2
    response = AddIntsResponse()
    response.sum = sum
    rospy.loginfo(response.sum)
    return response.sum
if __name__ == "__main__":
    rospy.init_node("demo01_server")
    ser = rospy.Service("server_1",AddInts,doNum)
    rospy.loginfo("服务器已经启动")
    rospy.spin()

客户端

#! /usr/bin/env python
import rospy
from plumbing_server_client.srv import *
# 优化
import sys
if __name__ == "__main__":
    rospy.init_node("demo01_client")
    cli = rospy.ServiceProxy("server_1",AddInts)
    num1 = int(sys.argv[1])
    num2 = int(sys.argv[2])
    # 等待服务器启动
    # cli.wait_for_service()  rospy.wait_for_service("话题名称")
    rospy.wait_for_service("server_1")
    response = cli.call(num1,num2)
    rospy.loginfo("响应数据%d",response.sum)

三、参数服务器（参数共享）

1.概念

参数服务器在ROS中主要用于实现不同节点之间的数据共享。参数服务器相当于是独立于所有节点的一个公共容器，可以将数据存储在该容器中，被不同的节点调用，当然不同的节点也可以往其中存储数据。

以共享的方式实现不同节点之间的数据交互
作用
- 存储多借点共享数据
参数服务器的增删改查

2.模型

注意：

参数服务器不是为高性能而设计的

数据类型

32-bit integers  // 4字节int
booleans	// 布尔数据
strings		// 字符数据
doubles		// 浮点数据
iso8601 dates	// 时间数据
lists		// 列表
base64-encoded binary data	// 二进制数据
字典

3.C++实现

实现的AIP

ros::NodeHandle
    setParam("键",值)
ros::param
    set("键",值)

增加与修改

#include "ros/ros.h"
using namespace ros;

int main(int argc, char *argv[])
{
    init(argc,argv,"ros_param_C");
    NodeHandle nh;
    // 增加数据
    // 方案1：nh  参数一：书记名，参数二：数据
    nh.setParam("type","xiaoHuang");
    nh.setParam("radius_1",0.15);
    // 方案2：参数一：书记名，参数二：数据
    param::set("type_param","xiaoBai");
    param::set("radius_2",0.15);
    // 修改， 相当于覆盖
    // 方案一
    nh.setParam("radius_1",0.3);
    // 方案二
    param::set("radius_2",0.25);
    return 0;
}

调用指令获取数据

rosparam list // 获取数据列表
rosparam get /数据名 // 获取数据

查找

#include "ros/ros.h"
using namespace ros;
/*
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  -------------------------------------------------
        和上面的一样
*/
int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    init(argc,argv,"ros_param_C");
    NodeHandle nh;
    // 查询
    //ros::NodeHandle  --------------------------------------------------
    //1. 找到返回该结果的值
    float radius = nh.param("radius",0.0);
    ROS_INFO("radius:%0.2f",radius);
    float radius_1;
    // 返回bool类型数据
    // 2. 查找并返回true/flase
    bool result = nh.getParam("radius_111",radius_1);
    if(result)
        ROS_INFO("radius:%0.2f",radius_1);
    else
        ROS_INFO("没有找到数据");
    // getParamCached// 是性能提升
    // 3. 查找并返回true/flase提升效力
    result = nh.getParamCached("radius_1",radius_1);
    if(result)
        ROS_INFO("radius:%0.2f",radius_1);
    else
        ROS_INFO("没有找到数据");
    // 4. 获取所以参数
    std::vector<std::string> names;
    nh.getParamNames(names);
    for (auto &&name : names){
        ROS_INFO("便利到的元素%s",name.c_str());
    }
    // 5. 判断键是否存在，存在返回true,参数是键名  nh.hasParam("radius_1");
    result = nh.hasParam("radius_1");
    if(result)
        ROS_INFO("键存在");
    else
        ROS_INFO("没有找到数据");
    // 6. 查询键，并保存键名
    std::string key;
    nh.searchParam("type",key);
    ROS_INFO("搜索结果：%s",key.c_str());
    //ros::param 函数和上面的一样 -------------------------------------------------
    return 0;
}

删除

#include "ros/ros.h"
using namespace ros;
/*
ros::NodeHandle
    deleteParam()
ros::param
    del()
*/
int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    init(argc,argv,"ros_param_C");
    NodeHandle nh;
    // 参数的删除
    nh.setParam("radius",0.5);
    // 方案一 参数一：键
    bool flag1 = nh.deleteParam("radius");
    if (flag1) {
        ROS_INFO("删除成功");
    }else{
        ROS_INFO("删除失败");
    }
    // 方案二
    flag1 = ros::param::del("radius");
    if (flag1) {
        ROS_INFO("删除成功");
    }else{
        ROS_INFO("删除失败");
    }
    // 打印所以参数
    std::vector<std::string> names;
    ros::param::getParamNames(names);
    for (auto && name :names) {
        ROS_INFO("节点有%s",name.c_str());
    }
    return 0;
}

4.Python实现

增加和修改

#! /usr/bin/env python
"""
    参数服务器操作之新增与修改(二者API一样)_Python实现:
"""
import rospy
if __name__ == "__main__":
    rospy.init_node("set_update_paramter_p")
    # 设置各种类型参数
    rospy.set_param("p_int",10)
    rospy.set_param("p_double",3.14)
    rospy.set_param("p_bool",True)
    rospy.set_param("p_string","hello python")
    rospy.set_param("p_list",["hello","haha","xixi"])
    rospy.set_param("p_dict",{"name":"hulu","age":8})
    # 修改
    rospy.set_param("p_int",100)

查找

#! /usr/bin/env python
"""
    参数服务器操作之查询_Python实现:    
        get_param(键,默认值)
            当键存在时，返回对应的值，如果不存在返回默认值
        get_param_cached
        get_param_names
        has_param
        search_param
"""
import rospy
if __name__ == "__main__":
    rospy.init_node("get_param_p")
    #获取参数
    int_value = rospy.get_param("p_int",10000)
    double_value = rospy.get_param("p_double")
    bool_value = rospy.get_param("p_bool")
    string_value = rospy.get_param("p_string")
    p_list = rospy.get_param("p_list")
    p_dict = rospy.get_param("p_dict")

    rospy.loginfo("获取的数据:%d,%.2f,%d,%s",
                int_value,
                double_value,
                bool_value,
                string_value)
    for ele in p_list:
        rospy.loginfo("ele = %s", ele)

    rospy.loginfo("name = %s, age = %d",p_dict["name"],p_dict["age"])
    # get_param_cached
    int_cached = rospy.get_param_cached("p_int")
    rospy.loginfo("缓存数据:%d",int_cached)
    # get_param_names
    names = rospy.get_param_names()
    for name in names:
        rospy.loginfo("name = %s",name)
        
    rospy.loginfo("-"*80)
    # has_param
    flag = rospy.has_param("p_int")
    rospy.loginfo("包含p_int吗？%d",flag)
    # search_param
    key = rospy.search_param("p_int")
    rospy.loginfo("搜索的键 = %s",key)

删除

#! /usr/bin/env python
"""
    参数服务器操作之删除_Python实现:
    rospy.delete_param("键")
    键存在时，可以删除成功，键不存在时，会抛出异常
"""
import rospy
if __name__ == "__main__":
    rospy.init_node("delete_param_p")

    try:
        rospy.delete_param("p_int")
    except Exception as e:
        rospy.loginfo("删除失败")

四、常用命令

如何获取话题和消息载体、可以通过下面命令得到
动态获取结点数据
官方链接：

1.rosnode:操作结点

是用于获取结点信息的命令
用法

rosnode ping 节点名称  	// 测试结点的连接情况，看是否连接正常
    // rosnode ping /Person
rosnode list	// 列出活动结点
    // rosnode list
rosnode info 结点名称	// 打印结点日志
    //rosnode info /Person
rosnode machine	设备名称 // 列出指定设备上的节点
	// rosnode machine zhf
rosnode kill 结点名称	// 杀死某个节点
    // rosnode kill /Person
rosnode cleanup // 清除不可连接的节点，也叫僵尸结点
    // rosnode cleanup

2.rostopic:操作话题

用于获取ROS主题调试信息，包括订阅者，发布者，发布频率和ROS消息
用法

rostopic bw     // 显示主题使用的带宽
rostopic delay  // 显示带有 header 的主题延迟
rostopic echo   // 打印消息到屏幕、需要找到对应的包下面，source一下
    // rostopic echo 话题名
rostopic find   // 根据类型查找主题
rostopic hz     // 显示主题的发布频率
    // rostopic hz liaotian(话题名称)
rostopic info   // 显示主题相关信息
    // rostopic info Person（话题名）
rostopic list   // 显示所有活动状态下的主题(和rosnode list差不多)
    // rostopic list
rostopic pub    // 将数据发布到主题
rostopic type   // 打印主题类型

3.rosmsg:操作msg消息

显示消息类型

rosmsg show    		// 显示消息描述
rosmsg info    		// 显示消息信息
rosmsg list    		// 列出所有消息
rosmsg md5    		// 显示 md5 加密后的消息
rosmsg package    	// 显示某个功能包下的所有消息
rosmsg packages    	// 列出包含消息的功能包

4.rosservice:操作服务

列出和查询服务通信的命令工具
用法

rosservice args 	// 打印服务参数
rosservice call    	// 使用提供的参数调用服务
    // rosservice call addIns(服务名称) 数据
rosservice find   	// 按照服务类型查找服务
rosservice info    	// 打印有关服务的信息
    // rosservice info addIns(服务名称)
rosservice list    	// 列出所有活动的服务
rosservice type    	// 打印服务数据类型
rosservice uri    	// 打印服务的 ROSRPC uri

5.rossrv:操作srv消息

显示服务类型信息的命令

rossrv show    	// 显示服务消息详情
rossrv info    	// 显示服务消息相关信息
rossrv list    	// 列出所有服务信息
rossrv md5    	// 显示 md5 加密后的服务消息
rossrv package	// 显示某个包下所有服务消息
rossrv packages // 显示包含服务消息的所有包

6.rosparm:操作参数

用于使用YAML编码文件在参数服务器上获取和设置ROS参数。
用法

rosparam set    	// 设置参数
rosparam get    	// 获取参数
rosparam delete    	// 删除参数
rosparam list    	// 列出所有参数
rosparam load    	// 从外部文件加载参数
    // rosparam load 名称.yaml
rosparam dump    	// 将参数写出到外部文件
    // rosparam dump 名称.yaml

五、通信实操

案例一、话题发布

命令获取结点话题名称和数据类型

C++实现

#include "ros/ros.h"
// 数据类型
#include "geometry_msgs/Twist.h"
/*
发布方实现：
    1.包含头文件
    2.初始化ROS节点
    3.创建节点句柄
    4.创建发布者对象
    5.编写发布逻辑并发布数据
*/
int main(int argc,char* argv[]) {
    ros::init(argc,argv,"test_pub");
    ros::NodeHandle nh;
    // /turtle1/cmd_vel发布的话题名称
    ros::Publisher pub = nh.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel",100);
    // 发布频率10Hz
    ros::Rate rate(100);
    geometry_msgs::Twist msg;
    msg.linear.x = 0.1;
    msg.linear.y = 0.0;
    msg.linear.z = 0.0;
    msg.angular.z = 0.8;
    msg.angular.y = 0.0;
    msg.angular.x = 0.0;
    while(ros::ok()){
        pub.publish(msg);
        msg.linear.x += 0.001;
        ROS_INFO("haha");
        rate.sleep();
        ros::spinOnce();
    }
    return 0;
}

案例二、话题订阅

命令查找数据

C++实现

#include "ros/ros.h"
#include "turtlesim/Pose.h"
using namespace ros;
void doTurtlesim(const turtlesim::Pose::ConstPtr & pose) {
	ROS_INFO("位置信息：");
	ROS_INFO("位置(x:%0.2f,y:%0.2f)朝向(theta:%0.2f)线速度(linear_velocity:%0.2f)加速度(angular_velocity:%.2f)",pose->x,pose->y,pose->theta,pose->linear_velocity,pose->angular_velocity);
}
int main(int argc,char* argv[]) {
	
	setlocale(LC_ALL,"");
	init(argc,argv,"test_sub");
	NodeHandle nh;
	Subscriber sub = nh.subscribe("/turtle1/pose",100,doTurtlesim);
	spin();
	return 0;
}

效果

补、

案例一和案例二需要手动添加依赖

pakeage.xml

CMakeList.txt

案例三、服务调用

命令查询数据

命令调用服务

需要依赖包turtlesim

C++实现

#include "ros/ros.h"
#include "turtlesim/Spawn.h"
using namespace ros;
int main(int argc,char* argv[]) {
	setlocale(LC_ALL,"");
	init(argc,argv,"test_ser");
	NodeHandle nh;
	ServiceClient client = nh.serviceClient<turtlesim::Spawn>("/spawn");
	turtlesim::Spawn msg;
	msg.request.x = 1.0;
	msg.request.y = 1.0;
	msg.request.theta = 1.0;
	msg.request.name = "turtle3";
    client.waitForService();
	bool flag = client.call(msg);
	if (flag)
    {
        ROS_INFO("新的乌龟生成,名字:%s",msg.response.name.c_str());
    } else {
        ROS_INFO("乌龟生成失败！！！");
    }
	spinOnce();
	return 0;
}

结果：

案例四、参数服务调用

命令行查看数据

C++实现

#include "ros/ros.h"
using namespace ros;
int main(int argc,char* argv[]){
	init(argc,argv,"test_param");
	param::set("/turtlesim/background_r",255);
	param::set("/turtlesim/background_g",0);
	param::set("/turtlesim/background_b",0);
	return 0;
}

命令调用服务

[外链图片转存中…(img-vBl8Uuzu-1629810352567)]

需要依赖包turtlesim

C++实现

#include "ros/ros.h"
#include "turtlesim/Spawn.h"
using namespace ros;
int main(int argc,char* argv[]) {
	setlocale(LC_ALL,"");
	init(argc,argv,"test_ser");
	NodeHandle nh;
	ServiceClient client = nh.serviceClient<turtlesim::Spawn>("/spawn");
	turtlesim::Spawn msg;
	msg.request.x = 1.0;
	msg.request.y = 1.0;
	msg.request.theta = 1.0;
	msg.request.name = "turtle3";
    client.waitForService();
	bool flag = client.call(msg);
	if (flag)
    {
        ROS_INFO("新的乌龟生成,名字:%s",msg.response.name.c_str());
    } else {
        ROS_INFO("乌龟生成失败！！！");
    }
	spinOnce();
	return 0;
}

结果：

[外链图片转存中…(img-fveLxOQC-1629810352568)]

案例四、参数服务调用

命令行查看数据

[外链图片转存中…(img-2s9OOhEB-1629810352568)]

C++实现

#include "ros/ros.h"
using namespace ros;
int main(int argc,char* argv[]){
	init(argc,argv,"test_param");
	param::set("/turtlesim/background_r",255);
	param::set("/turtlesim/background_g",0);
	param::set("/turtlesim/background_b",0);
	return 0;
}