ROS学习笔记（二）

最新推荐文章于 2024-02-23 02:07:59 发布
最新推荐文章于 2024-02-23 02:07:59 发布
阅读量689 收藏 2
点赞数
分类专栏： ros仿真 文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D123445/article/details/128066622
版权

目录

话题通信

话题通信

话题通信C++实现

自定义msg

服务通信

服务通信模型

自定义srv

参数服务器

理论模型

 新增参数

获取参数

删除参数

话题通信

话题通信模型

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

以发布订阅的方式实现不同节点之间数据交互的通信模式。用于不断更新的、少逻辑处理的数据传输场景。

话题通信模型中涉及到三个角色:

  • ROS Master (管理者)
  • 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 照常通信。

  • 话题通信C++实现

src右键Create Catkin Pakage 输入包名plumbing_pub_sub回车，输入依赖roscpp rospy std_msgs

1.发布方

#include "ros/ros.h"
#include "std_msgs/String.h" //普通文本类型的消息
#include <sstream>

int main(int argc, char *argv[])
{   
    /*
        发布方实现：
            1.包含头文件
              ROS中文本类型 --> std_msgs/String.h
            2.初始化 ROS 节点；
            3.创建节点句柄；
            4.创建发布者对象；
            5.编写发布逻辑并发布数据。
    */

    //解决中文乱码
    setlocale(LC_ALL,"");
    //2.初始化 ROS 节点；erGouZi是节点名称
    ros::init(argc,argv,"erGouZi");
    //3.创建节点句柄；
    ros::NodeHandle nh;
    //4.创建发布者对象；话题一致 。队列中最大保存的消息数，超出此阀值时，先进的先销毁(时间早的先销毁)
    ros::Publisher pub = nh.advertise<std_msgs::String>("fang",10);
    
    //5.编写发布逻辑并发布数据。要求以10hz的频率发布数据，并且文本后添加编号。
    //先创建被发布的消息
    std_msgs::String msg;
    
    //发布频率，1s/次
    ros::Rate rate(2);
    //设置编号，消息计数器
    int count = 0;
    //延时3秒发布，避免订阅者收不到前几条消息。
    ros::Duration(3).sleep();
    //编写循环，循环中发布数据
    while (ros::ok())
    {   
        count++;
        //msg.data = "hello";
        //实现字符串拼接数字
        std::stringstream ss;
        ss << "hello -->" << count;
        msg.data = ss.str();
        pub.publish(msg);//发布消息
        //添加日志：
        ROS_INFO("发布的数据是:%s",ss.str().c_str());
        rate.sleep();//根据前面制定的发送贫频率自动休眠 休眠时间 = 1/频率；
        ros::spinOnce();//处理回调函数
    }

  return 0;
}

测试：配置CMake文件，编译，测试。

 

 

roscore

cd demo03_ws/
source ./devel/setup.bash
rosrun plumbing_pub_sub demo01_pub


rostopic echo fang

2.订阅方

#include "ros/ros.h"
#include "std_msgs/String.h" //普通文本类型的消息

//传入的消息是std_msgs，String类型的，常量指针引用
void doMsg(const std_msgs::String::ConstPtr &msg){
    //通过msg获取并操作订阅到的数据
    ROS_INFO("翠花订阅的数据:%s",msg->data.c_str());
}

int main(int argc, char *argv[])
{   
    /*
        发布方实现：
            1.包含头文件
              ROS中文本类型 --> std_msgs/String.h
            2.初始化 ROS 节点；
            3.创建节点句柄；
            4.创建订阅者对象；
            5.处理订阅到的数据。
            6.spin()函数
    */

    //解决中文乱码
    setlocale(LC_ALL,"");
    //2.初始化 ROS 节点；cuiHua是节点名称
    ros::init(argc,argv,"cuiHua");
    //3.创建节点句柄；
    ros::NodeHandle nh;
    //4.创建订阅者对象； doMsg是回调函数
    ros::Subscriber sub = nh.subscribe<std_msgs::String>("fang",10,doMsg);
    
    //5.处理订阅到的数据。
    ros::spin();
    
    return 0;
}

3.配置 CMakeLists.txt

 

 编译运行

roscore

cd demo03_ws/
source ./devel/setup.bash
rosrun plumbing_pub_sub demo01_pub

cd demo03_ws/
source ./devel/setup.bash
rosrun plumbing_pub_sub demo02_sub

自定义msg

1.定义msgs文件。demo03/src/plumbing_pub_sub/msg/Person.msg

2.编写package.xml文件

3.编写CMake文件

Person.msg是文件名

4.编译后的中间文件

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

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

5.终端打开，pwd 复制

c_cpp文件，加入路径

6.编写发布者cpp文件

#include "ros/ros.h"
#include "plumbing_pub_sub/Person.h"
/*
    发布方：发布人消息
        1.包含头文件
            ROS中文本类型 --> std_msgs/String.h
        2.初始化 ROS 节点；
        3.创建节点句柄；
        4.创建发布者对象；
        5.编写发布逻辑并发布数据。
*/

int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ROS_INFO("这是消息的发布方");
    //  2.初始化 ROS 节点；
    ros::init(argc,argv,"banzhuren");
    //  3.创建节点句柄；
    ros::NodeHandle nh;
    // 4.创建发布者对象；
    ros::Publisher pub = nh.advertise<plumbing_pub_sub::Person>("liaotian",10);
    // 5.编写发布逻辑并发布数据。
    // 5-1.创建被发布的数据。
    plumbing_pub_sub::Person person;
    person.name = "张三";
    person.age = 18;
    person.height = 1.73;
    // 5-2.设置发布频率
    ros::Rate rate(1);
    //延时3秒发布，避免订阅者收不到前几条消息。
    ros::Duration(3).sleep();
    // 5.3.循环发布数据
    while (ros::ok())
    {   
        
        //核心：数据发布
        pub.publish(person);
        ROS_INFO("发布的消息:%s,%d,%.2f",person.name.c_str(),person.age,person.height);
        //修改数据
        person.age += 1;
        //休眠
        rate.sleep();
        // 
        ros::spinOnce();
    }
    
    return 0;
}

7.编写订阅者cpp文件，注意回调函数。

#include "ros/ros.h"
#include "plumbing_pub_sub/Person.h"

/*
    发布方：发布人消息
        1.包含头文件
            ROS中文本类型 --> std_msgs/String.h
        2.初始化 ROS 节点；
        3.创建节点句柄；
        4.创建订阅者对象；
        5.处理订阅数据。
        6.调用spin()函数。
*/
//回调函数，常量指针引用。
void doPerson(const plumbing_pub_sub::Person::ConstPtr& person)
{
    ROS_INFO("订阅人的消息:%s,%d,%.2f",person->name.c_str(),person->age,person->height);
}
int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ROS_INFO("订阅方实现");
    // 2.初始化 ROS 节点；
    ros::init(argc,argv,"jiazhang");
    // 3.创建节点句柄；
    ros::NodeHandle nh;
    // 4.创建订阅者对象；
    ros::Subscriber sub = nh.subscribe("liaotian",10,doPerson);
    // 5.处理订阅数据。
    // 6.调用spin()函数。
    ros::spin();
    return 0;
}

8.配置CMake文件

9.编译 ctrl+shift+B

roscore

cd demo03_ws/
source ./devel/setup.bash
rosrun plumbing_pub_sub demo03_pub_person

cd demo03_ws/
source ./devel/setup.bash
rosrun plumbing_pub_sub demo04_sub_person


计算图  rqt_graph

服务通信

服务通信模型

服务通信也是ROS中一种极其常用的通信模式，服务通信是基于请求响应模式的，是一种应答机制。也即: 一个节点A向另一个节点B发送请求，B接收处理请求并产生响应结果返回给A

以请求响应的方式实现不同节点之间数据交互的通信模式。用于偶然的、对时时性有要求、有一定逻辑处理需求的数据传输场景。

 

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

0.Server注册

Server 启动后，会通过RPC在 ROS Master 中注册自身信息，其中包含提供的服务的名称。ROS Master 会将节点的注册信息加入到注册表中。

1.Client注册

Client 启动后，也会通过RPC在 ROS Master 中注册自身信息，包含需要请求的服务的名称。ROS Master 会将节点的注册信息加入到注册表中。

2.ROS Master实现信息匹配

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

3.Client发送请求

Client 根据步骤2 响应的信息，使用 TCP 与 Server 建立网络连接，并发送请求数据。

4.Server发送响应

Server 接收、解析请求的数据，并产生响应结果返回给 Client。

注意:

1.客户端请求被处理时，需要保证服务器已经启动；

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

自定义srv

服务通信中，数据分成两部分，请求与响应，在 srv 文件中请求和响应使用---分割，

新建plumbing_server_client 功能包下新建 srv 目录，添加 AddInts.srv 文件

1.书写AddInts.srv文件

int32 num1
int32 num2
---
int32 sum

2.配置xml文件

配置CMake文件

 3.需要像之前自定义 msg 实现一样配置c_cpp_properies.json 文件(加入路径)如果以前已经配置且没有变更工作空间，可以忽略，如果需要配置，配置方式与之前相同。

4.编写服务端cpp文件

#include "ros/ros.h"
#include "plumbing_server_client/AddInts.h"

/*
    服务端实现：解析客户端所提交的数据，并运算再产生响应。
        1.包含头文件
        2.初始化ROS节点
        3.创建节点句柄
        4.创建一个服务对象
        5.处理请求并产生响应
        6.spin()
*/

bool doNums(plumbing_server_client::AddInts::Request& request,
            plumbing_server_client::AddInts::Response& response){
    // 1.处理请求；
    int num1 = request.num1;
    int num2 = request.num2;
    ROS_INFO("收到的请求数据:num1 = %d,num2 = %d",num1,num2);
  
    // 2.组织响应；
    int sum = num1 + num2;
    response.sum = sum;
    ROS_INFO("求和结果:sum = %d",sum );

    return true;
}

int main(int argc, char *argv[])
{   
    setlocale(LC_ALL,"");
    //  2.初始化 ROS 节点；
    ros::init(argc,argv,"AddInts_Server");
    //  3.创建节点句柄；
    ros::NodeHandle nh;
    // 4.创建一个服务对象
    ros::ServiceServer server = nh.advertiseService("AddInts",doNums);
    ROS_INFO("服务已经启动...");
    // 5.处理请求并产生响应
    // 6.spin()
    ros::spin();
    return 0;
}

5.

配置CMake文件

编译，测试

roscore

cd demo03

source ./devel/setup.bash

rosrun plumbing_server_client demo01_server



cd demo03

source ./devel/setup.bash

rosservice call AddInts （Tab补齐，更改数字，回车）

6.编写客户端cpp文件

#include "ros/ros.h"
#include "plumbing_server_client/AddInts.h"

/*
    服务端实现：提交两个整数，并处理响应的结果。
        1.包含头文件
        2.初始化ROS节点
        3.创建节点句柄
        4.创建一个客户端对象
        5.提交请求并处理响应
        
    实现参数的动态提交:
        1.格式：ros xxx xxx 12 34. 此时argc包含三个参数--文件名 12 34
        2.节点执行时，需要获取命令中的参数，并组织进 request
    问题：
        如果先启动客户端，请求异常
    需求：
        如果先启动客户端，则先挂起，等服务器启动后，再正常请求。
    解决：
        在ros中有内置函数 ,这些函数可以让客户端启动后挂起,等待服务器启动
        client.waitForExistence();
        ros::service::waitForService("AddInts");
*/

int main(int argc, char *argv[])
{   
    setlocale(LC_ALL,"");
    if(argc != 3 )
    {
        ROS_INFO("提交的参数个数不对。");
        return 1;
    }
    // 2.初始化ROS节点
    ros::init(argc,argv,"AddInts_client");
    // 3.创建节点句柄
    ros::NodeHandle nh;
    // 4.创建一个客户端对象
    ros::ServiceClient client = nh.serviceClient<plumbing_server_client::AddInts>("AddInts");
    // 5.提交请求并处理响应
    plumbing_server_client::AddInts ai;
    // 5-1 组织请求,用atoi把argv解析出来的字符串型变为整形
    ai.request.num1 = atoi(argv[1]);
    ai.request.num2 = atoi(argv[2]);
    // 5-2 处理响应。
    // 调用判断服务器状态的函数
    // client.waitForExistence();
    ros::service::waitForService("AddInts");
    bool flag = client.call(ai); 
    /*
    1.client.call(ai) 相当于我客户端访问了服务器并且把这个ai对象提交了，ai对象里面有request，request里面有num1和num2 2.他响应回来的结果就是那个sum会继续封装在这个ai对象，在这ai对象中除了有request还有response他会把那个结果封装在response，接下来我们就可以通过ai的response来获取数据了。3.客户端访问服务器：client.call(ai),客户端访问服务器并且把ai对象提交了。服务器会返回结果
    */
    if (flag)
    {
        ROS_INFO("响应成功");
        // 获取结果
        ROS_INFO("响应结果 = %d",ai.response.sum);
    }
    else
    {
        ROS_INFO("处理失败...");
    }
    return 0;
}

配置CMake文件

编译，运行

roscore
source ./devel/setup.bash
rosrun plumbing_server_client demo01_server
source ./devel/setup.bash
rosrun plumbing_server_client demo02_client

参数服务器

理论模型

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

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

1.Talker 设置参数

Talker 通过 RPC 向参数服务器发送参数(包括参数名与参数值)，ROS Master 将参数保存到参数列表中。

2.Listener 获取参数

Listener 通过 RPC 向参数服务器发送参数查找请求，请求中包含要查找的参数名。

3.ROS Master 向 Listener 发送参数值

ROS Master 根据步骤2请求提供的参数名查找参数值，并将查询结果通过 RPC 发送给 Listener。

 新增参数

#include "ros/ros.h"

/*
    需要实现参数的新增与修改
    需求:设置机器人的共享参数,类型\半径(0.15m)
        再修改半径(0.2m)
    实现:
        ros::NodeHandle
            setParam()
        ros::param
            set()
    修改：
        继续调用setParam()或set()，键已经存在的话，值会被替换
*/

int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    //初始化节点
    ros::init(argc,argv,"set_param_c");
    // 创建ROS节点句柄
    ros::NodeHandle nh;
    //参数增--
    //方案一:nh
    nh.setParam("type","xiaohuang");
    nh.setParam("radius",0.15);
    // 方案二：ros::param
    ros::param::set("type_param","xiaobai");
    ros::param::set("radius_param",0.15);

    // 参数改
    // 方案1：nh
    nh.setParam("radius",0.2);//键重复，产生参数覆盖。
    // 方案2：ros::param
    ros::param::set("radius_param",0.25);

    return 0;
}

配置，编译，运行 

roscore
source ./devel/setup.bash
rosrun plumbing_param_server demo01_param_set
rosparam list
rosparam get /radius

获取参数

#include "ros/ros.h"

/*
    参数查询
        ros::NodeHandle -------------
            1.param(键，默认值)
            存在，返回对应结果，否则返回默认值。

            2.getParam(键,存储结果的变量)
                存在,返回 true,且将值赋值给参数2
                若果键不存在，那么返回值为 false，且不为参数2赋值

            3.getParamCached键,存储结果的变量)--提高变量获取效率
                存在,返回 true,且将值赋值给参数2
                若果键不存在，那么返回值为 false，且不为参数2赋值

            4.getParamNames(std::vector<std::string>)
                获取所有的键,并存储在参数 vector 中 

            5.hasParam(键)
                是否包含某个键，存在返回 true，否则返回 false

            6.searchParam(参数1，参数2)
                搜索键，参数1是被搜索的键，参数2存储搜索结果的变量
        
        ros::param ------------- 与上述类似

*/

int main(int argc, char *argv[])
{   
    // 中文
    setlocale(LC_ALL,"");
    // 初始化节点
    ros::init(argc,argv,"get_param_c");
    // 创建节点句柄
    ros::NodeHandle nh;

    // ros::NodeHandle  ----------
    // 1.param
    double radius = nh.param("radius",0.5); //默认值是0.5
    ROS_INFO("radius = %.2f",radius);

    // 2.getParam
    double radius2 = 0.0;
    bool result = nh.getParam("radius",radius2);//把获取到的radius值存在radius2中。
    // 3.getParamCached 与 getParam 类似，只是性能有所提升
    if (result)
    {
        ROS_INFO("获取的半径是: %.2f",radius2);
    }
    else{
        ROS_INFO("被查询的变量不存在。");
    }

    // 4.getParamNames
    std::vector<std::string> names;//表示可以改变大小的数组的序列容器。创建一个集合
    nh.getParamNames(names);
    for (auto &&name : names)/*auto的原理就是根据后面的值，来自己推测前面的类型是什么。
auto的作用就是为了简化变量初始化，如果这个变量有一个很长很长的初始化类型，就可以用auto代替。 &&右值引用，元素name,被遍历的是names*/
    {
        ROS_INFO("遍历的元素:%s",name.c_str());
    }
    // 5.hasParam
    bool flag1 = nh.hasParam("radius");
    bool flag2 = nh.hasParam("radiusxxx");
    ROS_INFO("radius 存在吗？%d",flag1);
    ROS_INFO("radiusxxx 存在吗？%d",flag2);

    // 6.searchParam
    std::string key;
    nh.searchParam("radius",key);
    ROS_INFO("搜索结果:%s",key.c_str());//%s字符串，c_str()函数返回一个指向正规C字符串的指针常量


    // ros::param---------
    double radius_param = ros::param::param("radius",100.5);
    ROS_INFO("radius_param = %.2f",radius_param);

    std::vector<std::string> names_param;
    ros::param::getParamNames(names_param);
    for (auto &&name : names_param)
    {
        ROS_INFO("键:%s",name.c_str());
    }
    return 0;
}

删除参数

#include "ros/ros.h"

/* 
    参数服务器操作之删除_C++实现:

    ros::NodeHandle
        deleteParam("键")
        根据键删除参数，删除成功，返回 true，否则(参数不存在)，返回 false

    ros::param
        del("键")
        根据键删除参数，删除成功，返回 true，否则(参数不存在)，返回 false
*/

int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"param_del_c");
    ros::NodeHandle nh;
    // 删除 NodeHandle
    bool flag1 = nh.deleteParam("radius");
    if (flag1)
    {
        ROS_INFO("删除成功");
    }
    else{
        ROS_INFO("删除失败");
    }
    // 删除 ros::param
    bool flag2 = ros::param::del("radius_param");
     if (flag2)
    {
        ROS_INFO("删除成功");
    }
    else{
        ROS_INFO("删除失败");
    }
    return 0;
}

宾格果
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
小心stringstream.str()字符串用法的陷阱
119365374的专栏
08-21 2993
在编写应用程序时，我们经常要使用到字符串。C++标准库中的和为我们操作字符串提供了很多的方便，例如：对象封装、安全和自动的类型转换、直接拼接、不必担心越界等等。但今天我们并不想长篇累牍得去介绍这几个标准库提供的功能，而是分享一下stringstream.str()的一个有趣的现象。我们先来看一个例子： #include #include #include using
ROS话题通信基本操作(C++)
weixin_63780683的博客
12-04 400
【代码】ROS话题通信基本操作(C++)
stringstream 的.str()正确用法和清空操作
iteye_11190的博客
09-11 1310
streamstring在调用str()时，会返回临时的string对象。而因为是临时的对象，所以它在整个表达式结束后将会被析构。 如果需要进一步操作string对象，先把其值赋给一个string变量后再操作。 stringstream ss("012345678901234567890123456789012345678901234567890123456789"); //错误用法 ...
ROS话题通信 理论＋实操（C++）
最新发布
weixin_52493604的博客
02-23 1334
1.talker、listener、ROSmaster 2.话题通讯使用场景 3.实操案例（如何设置订阅者和发布者的cpp文件，如何配置相关的CMakelist文件）
ROS学习笔记（二）：话题通信、服务通信的了解和对应节点的搭建（C++）
xztli的博客
01-04 1122
在ros这种分布式框架中，各个节点可以独立的运行，但是在实际运用的多数情况下各个节点之间都需要有一定的联系或者说是信息的共享，因此在程序的设计上，各节点之间的通信尤为重要。如下所示可让我们对ros通信机制有初步的了解，其中也包括了对应通信节点的搭建。
【ROS】话题通信--从理论介绍到模型实现(C++)
Silver_Bullet的博客
08-15 430
介绍ROS中的话题通信，以及其理论模型的C++实现
ROS入门之---话题通信（简单C++实现）
Smith_Chai的博客
09-09 1434
ROS入门之---话题通信，vscode中进行C++ 的简单编程实现
string中c_str()的用法
热门推荐
Lemon的博客
09-13 8万+
1. 语法: 1 const char *c_str(); c_str()函数返回一个指向正规C字符串的指针常量, 内容与本string串相同。 这是为了与c语言兼容，在c语言中没有string类型，故必须通过string类对象的成员函数c_str()把string 对象转换成c中的字符串样式。 注意：一定要使用strcpy()函数 等来操作方法c_str()返回的指针。 比如：...
stringstream.str()和c_str()有关内存问题
qq_44798380的博客
08-06 870
stringstream.str()、 c_str()
ROS通信机制
m0_66712565的博客
01-09 350
通信机制是比较重要的一部分，里面有很多知识点，不懂得要赶紧复习C和Python
ROS讲义学习笔记.pdf
06-22
思慕课程ROS的讲义学习笔记。总结了讲义中提到的一些指令及其使用方法，方便查阅。也简单介绍了ROS的通信方式。
ROS学习笔记之——多机器人探索环境
01-06
本博文是基于这个ROS软件包（https://github.com/hrnr/m-explore）的学习笔记 目录 multi robot exploration nav_msgs/OccupancyGrid  map_msgs/OccupancyGridUpdate move_base multirobot_map_merge 参考资料 ...
ROS2学习笔记之创建工作空间篇
01-20
ROS2学习笔记之创建工作空间篇背景前期准备学习内容1. Source ROS 2 环境变量2. 创建一个新的文件夹3. 下载一个简单的例子4. 解决依赖关系5. 使用colcon编译工作空间6. 加载新建的工作空间7. 修改新建的工作空间中的...
ROS基础学习笔记
06-20
ROS进阶入门学习笔记，一些ROS的总结还有官网教程的总结，
古月居ROS入门21讲学习笔记（核心概念6-8课）
01-06
第六课 ROS是什么 ROS=通信机制+开发工具+应用功能+生态系统 通信机制 松耦合分布式通信 开发工具 命令行&编译器 TF坐标变换 QT工具箱 Rviz Gazebo 应用功能 SLAM Navigation Movelt！ 关注接口，输入输出就行，其次...
ROS通信——C++实现
qq_58011370的博客
08-26 2093
一、普通话题通信 二、自定义话题通信
[ROS 系列学习教程] ROS话题(Topic)通信：自定义msg - 例程与讲解
淋曦的进击手记
11-17 2625
在 ROS 通信协议中，数据是以约定好的结构传输的，即数据类型，比如Topic使用的msg，Service使用的srv，ROS 中的 std_msgs 封装了一些原生的数据类型，比如：Bool、Char、Float32、Int64、String等，但这些类型结构简单，常常不能满足我们的需要，这时我们可以使用自定义的消息类型。比如我们创建一个自定义消息，定义一个机器人的ID，位置（x, y）。
ROS学习笔记（十四）
09-09
在ROS学习笔记（十四）中，我们学习了如何使用roswtf命令来检查ROS系统并发现问题。引用中介绍了如何使用roswtf命令来进行系统检查，包括静态检查和图检查。如果系统没有问题，那么输出信息中会显示"Static checks summary: No errors or warnings"。然而，如果roscore没有运行，那么图检查将被忽略。 引用中给出了一个错误报告的例子，当ROS_PACKAGE_PATH环境变量中存在错误路径时，roswtf会报告错误。在这种情况下，输出信息中会显示"Found 1 error(s). ERROR Not all paths in ROS_PACKAGE_PATH [bad] point to an existing directory"。 最后，引用中再次运行roswtf命令，这次进行了运行时检查。输出信息中显示"Online checks summary: Found 1 warning(s)"，其中警告指出rosout节点订阅了一个没有节点向其发布的话题。尽管出现了警告，但由于除了roscore没有其他节点在运行，我们可以忽略这些警告。 综上所述，ROS学习笔记（十四）介绍了如何使用roswtf命令进行系统检查，并说明了不同情况下的输出信息含义。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值