【Autolabor初级教程】ROS机器人入门 第 3 章 ROS通信机制进阶 个人学习笔记

于 2024-03-29 00:49:38 发布
阅读量951 收藏 17
点赞数 18
文章标签： 机器人 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51247800/article/details/137128754
版权
本文详细介绍了ROS机器人的通信机制，包括初始化API、话题与服务相关对象的创建、ros::spin和ros::spinOnce的区别，以及时间操作如定时器和消息队列的处理。
摘要由CSDN通过智能技术生成

【Autolabor初级教程】ROS机器人入门 第 3 章 ROS通信机制进阶 笔记

官方API文档及参考源码

APIs - ROS Wiki

roscpp: roscpp

3.1 常用API

3.1.1 初始化
/*
    ros::init()

    1.argc      ——封装实参个数（n+1）
    2.argv      ——封装参数的数组
    3.name      ——为节点命名（唯一性）
    4.options   ——节点启动选项

    返回值：void
*/

  1. argc与argv的使用

    如果按照特定格式传入实参，ros可以加以使用，如用来设置全局参数、给节点重命名等

    eg：

    设置全局参数格式rosrun 包名 可执行文件名 _参数名:=参数值（注意参数名前加下划线）

    实测如果没有传入参数值，该全局参数也不会被创建

    image-20240326205852625

    其他使用比如通过命令行传入参数，参考第二章服务通信自定义srv(C++)小节（6.对于客户端的优化实现（通过命令行输入参数，增加交互））

  2. options的使用

    ros运行过程中，节点名称需保证唯一（测试时重复启动同一个节点，后运行的节点会打断前一个）

    image-20240326211459399

    在特定场景中，如果需要一个节点多次启动且正常运行，可以设置启动项ros::init_options::AnonymousName，设置后在创建ros节点时，会在自定义的节点名称后缀随机数，避免重名

    使用方法：

    ros::init(argc,argv,"pub",ros::init_options::AnonymousName);

    运行结果：

    image-20240326212130869

3.1.2 话题与服务相关对象
/*
    ros::NodeHandle nh;
    nh.advertise<>();nh.advertise

    作用：创建发布者对象

    模板：被发布的消息的类型

    参数：
        1.话题名称
        2.队列长度
        3.latch（可选） 如果设置为true，会保存最后一条发布者消息
                    当新的订阅方连接到发布方时，发布方会将这条消息发送给订阅者

    返回值：
*/

latch设置为true的应用场景（以静态地图发布为例）

当发布方发布静态地图（地图信息很少更新或几乎不更新）信息时：

方案1：以固定频率发送地图信息（频率太高会占用资源，导致效率低；方案太低可能会影响实时性）

方案2：将地图发布方的latch设置为true，并且只发送一次数据，这样每当订阅方连接到发布方时，可以订阅到地图数据（仅连接时一次），这样既保证实时性，又不影响效率

使用方法：

ros::Publisher pub = nh.advertise<std_msgs::String>("pos",10,true);
3.1.3 回旋函数
/*
    ros::spinOnce()

    作用：处理一轮回调;在循环体内，处理所有可用的回调函数

*/

/*
    ros::spin()

    作用：进入循环处理回调

*/

**相同点:**二者都用于处理回调函数；

不同点:

这里先了解ros如何处理回调函数

ROS：回调函数处理与回调队列_ros 回调函数队列-CSDN博客

A.ros::spin()

当函数执行到ros::spin()，就不再继续向下执行，而是循环且监听消息队列。

ros::spin() 是进入了循环监听消息队列，且执行对应回调函数，在 ros::spin() 后的语句不会执行到； ros::spin() 一般不会放在循环体里执行（会使循环失去意义），常放到程序的末尾执行。

B.ros::spinOnce()

ros::spinOnce() 只会执行一次回调函数，处理结束后继续执行ros::spinOnce()后的代码

个人理解：当每次执行到回调函数时，并不会立即调用并处理，而是将其放到一个回调函数的消息队列中，spin就是循环监听这个队列，等待新消息的到来，当队列中有了新的回调函数就处理，而spinonce是处理一次消息队列中的所有消息，然后就去执行其他代码。

示例：

# 发布方
// 1.包含头文件
#include "ros/ros.h"
#include "std_msgs/String.h" // ros中文本类型
#include <sstream>

int main(int argc, char *argv[])
{
    // 2.初始化ros节点
    ros::init(argc,argv,"pub");
    // 3.创建节点句柄
    ros::NodeHandle nh;
    // 4.创建发布者对象
    ros::Publisher pub = nh.advertise<std_msgs::String>("pos",10);
    // 5.编写发布逻辑并发布数据
    // 要求以10hz的频率发布数据，并且文本后添加编号
    // 先创建被发布消息
    std_msgs::String msg;
    // 发布频率
    ros::Rate rate(5); // 该参数为指定频率
    // 设置编号
    int count = 0;
    // 程序休眠，防止节点还未在roscore中注册时就发送消息
    ros::Duration(3).sleep();
    // 编写循环，循环中发布数据
    while(ros::ok())
    {
        // 输出中文
        setlocale(LC_ALL,"");
        count++;
        // 实现字符串拼接数字
        // msg.data = "here";
        std::stringstream ss;
        ss << "hello ---> " << count;
        msg.data = ss.str();
        pub.publish(msg);
        ROS_INFO("发布的数据是：%s",ss.str().c_str());
        // 根据前面制定的发送频率自动休眠 休眠时间 = 1/频率；
        rate.sleep();
    }
    return 0;
}

# 订阅方
// 1.包含头文件
#include "ros/ros.h"
#include "std_msgs/String.h" // ros中文本类型

void domsg1(const std_msgs::String::ConstPtr &msg)
{
    // 通过msg获取并操作订阅到的数据
    //ros::Duration(1);
    ROS_INFO("A接受到的数据是:%s",msg->data.c_str());
}

void domsg2(const std_msgs::String::ConstPtr &msg)
{
    // 通过msg获取并操作订阅到的数据
    ROS_INFO("B接受到的数据是:%s",msg->data.c_str());
}

int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    // 2.初始化ros节点
    ros::init(argc,argv,"sub");
    // 3.创建节点句柄
    ros::NodeHandle nh;
    // 4.创建订阅者对象
    ros::Subscriber sub1 = nh.subscribe("pos",10,domsg1);
    ros::Subscriber sub2 = nh.subscribe("pos",10,domsg2);
    int count_tmp = 0;
    while(ros::ok()){
        count_tmp++;
        ros::Duration(1).sleep();
        ROS_INFO("这是第%d次接受数据。",count_tmp);
        ros::spinOnce();
    }
   
    // 5.处理订阅到的数据
    // 6.循环读取接收的数据，并调用回调函数处理
    // 如果要用回调函数必须用spin
    
    ROS_INFO("I'm here!");
    return 0;
}

运行结果：

image-20240327205604136

分析：

发布方的发布频率是每秒5个包，订阅方每1秒执行一次ros::spinOnce()，此时消息队列里面存放了过去1s两个订阅方收到的2*5条消息（除第1次，可能发布方发布消息时订阅方已经开始计时），程序会处理当时队列中存在的所有回调函数，处理完毕后继续向下执行。

理解过程中遇到的问题：

发布方代码如上，订阅方代码刚开始如下：

#include "ros/ros.h"
#include "std_msgs/String.h" // ros中文本类型

void domsg1(const std_msgs::String::ConstPtr &msg)
{
    //ros::Duration(1);
    ROS_INFO("A接受到的数据是:%s",msg->data.c_str());
}

void domsg2(const std_msgs::String::ConstPtr &msg)
{
    ROS_INFO("B接受到的数据是:%s",msg->data.c_str());
}

int main(int argc, char *argv[])
{
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"sub");
    ros::NodeHandle nh;
  
    ros::Subscriber sub1 = nh.subscribe("pos",10,domsg1);
    ros::Subscriber sub2 = nh.subscribe("pos",10,domsg2);
    //！！！注意这里注释了延时函数
    //ros::Duration(1).sleep();
  
    ros::spinOnce();
    ROS_INFO("I'm here!");
    return 0;
}

运行结果：

image-20240327210528982

在这种状态下多次执行订阅方代码并没有订阅到数据，预期应该是会执行一次回调函数，所以一直不理解ros::spinOnce()的工作原理（其实这里应该是对消息订阅的工作模式没有理解）

此时，解开这句注释 ros::Duration(1).sleep();

再次执行：

image-20240327210810673

分析：

在执行以下两行代码时，应该是打开对于话题"pos"的订阅状态，如果不延时，程序很快（执行一两行代码的时间）就跑到ros::spinOnce()，而发布方的发布频率是每秒5个包，在这么短时间，确实没有订阅到话题"pos"的相关消息，导致相关回调函数也没有得到执行；而在代码后延时1s，在这1s过程中，就可以接收到"pos"话题相关的消息，从而使回调函数得到执行。

ros::Subscriber sub1 = nh.subscribe("pos",10,domsg1);
ros::Subscriber sub2 = nh.subscribe("pos",10,domsg2);
3.1.4 时间
/*
    时间相关操作：
        1.准备
            头文件：包含在ros.h中
            节点初始化
            NodeHandle创建:必须要创建一个,否则会导致API调用失败
        2.获取当前时刻
            ros::Time right_now = ros::Time::now();
            right_now.toSec()   这里返回的是double类型的距参考系过去的秒数
            right_now.sec       这里返回的是int32类型的距参考系过去的秒数
                now函数会返当前时刻(被调用执行是)封装并返回;
                参考系:1970年1月1日 00:00:00
                    PS:这里应该是零时区时间,中国是东八区,实测中国时间的参考系是1970年1月1日08:00:00
        3.设定指定时刻
            有以下格式:
                ros::Time t1(s,ns);
                ros::Time t2(s);
        4.在程序中休眠指定时间
            A.创建持续时间对象
                ros::Duration duration(3.5);
            B.休眠
                duration.sleep();
        5.时间运算
            A.时刻与持续时间可以相加减
            B.时刻之间只能相加不能相减(相加无意义)
            C.持续时间可以相加减
        //感觉6和7有点像delay()和定时器中断
        6.设置运行频率
            A.设置运行频率
            B.搭配循环及休眠使代码按照制定频率运行
            ros::Rate rate(1);
            while(ros::ok()){
                rate.sleep();
            }
        7.定时器使用
            ros::Timer createTimer(ros::Duration period,    //定时器时间间隔设置s
                const ros::TimerCallback &callback,         //回调函数,封装执行的操作
                bool oneshot = false,                       //定时器是否只执行一次回调函数
                bool autostart = true) const                //是否自动启动定时器
                    如果autostart设置为false,需要通过timer.start()手动打开对应的定时器
*/

eg:

#include "ros/ros.h"

void time1_callback(const ros::TimerEvent& event){
    ROS_INFO("定时器time1回调函数被调用");
    ROS_INFO("当前时刻:%.2f",event.current_real.toSec());
}

int main(int argc, char *argv[])
{
    /* code */
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"api_time");

    ros::NodeHandle nh;
    
    ROS_INFO("-------------------------------");
    ROS_INFO("获取当前时刻");
    ros::Time right_now = ros::Time::now();
    ROS_INFO("当前时刻:%.2f",right_now.toSec());
    ROS_INFO("当前时刻:%d",right_now.sec);

    ROS_INFO("-------------------------------");
    ROS_INFO("设定指定时刻");
    ros::Time t1(20,312789456);
    ros::Time t2(456.789);
    ROS_INFO("当前时刻:%.2f",t1.toSec());
    ROS_INFO("当前时刻:%.2f",t2.toSec());

    ROS_INFO("-------------------------------");
    ROS_INFO("休眠指定时间");
    ros::Time start_sleep = ros::Time::now();
    ROS_INFO("当前时刻:%.2f",start_sleep.toSec());
    ROS_INFO("开始休眠");
    ros::Duration duration(3.5);
    duration.sleep();
    ROS_INFO("结束休眠");
    ros::Time end_sleep = ros::Time::now();
    ROS_INFO("当前时刻:%.2f",end_sleep.toSec());

    ROS_INFO("-------------------------------");
    ROS_INFO("时间计算");
    // A.时刻与持续时间计算
    ros::Time begin1 = ros::Time::now();
    ros::Duration duration1(2);
    ros::Time end1 = begin1 + duration1;
    ROS_INFO("开始时刻是%.2f,持续时间为%.2fs,结束时刻是%.2f",begin1.toSec(),duration1.toSec(),end1.toSec());
    // B.时刻与时刻的运算
    // 两时刻相加没有对应的重载,只能相减,且结果为ros::Duration类型
    ros::Duration sub = end1 - begin1;
    // ros::Duration sum = end1 + begin1;
    ROS_INFO("开始时刻是%.2f,结束时刻是%.2f,持续时间为%.2fs",begin1.toSec(),end1.toSec(),sub.toSec());
    // C.持续时间与持续时间的运算
    ros::Duration sum1 = duration1 + sub;
    ros::Duration sub1 = duration1 - sub;
    ROS_INFO("持续时间1是%.2f,持续时间2是%.2f,相加为%.2f",duration1.toSec(),sub.toSec(),sum1.toSec());
    ROS_INFO("持续时间1是%.2f,持续时间2是%.2f,相减为%.2f",duration1.toSec(),sub.toSec(),sub1.toSec());

    ROS_INFO("-------------------------------");
    ROS_INFO("定时器使用");
    ros::Timer timer = nh.createTimer(ros::Duration(1),time1_callback,false,false);
    ros::Time test1 = ros::Time::now();
    ROS_INFO("当前时刻:%.2f,定时器未启动",test1.toSec());
    ros::Duration(3).sleep();
    timer.start();
    ros::Time test2 = ros::Time::now();
    ROS_INFO("当前时刻:%.2f,计时器启动",test2.toSec());
    ros::spin();
    return 0;
}

运行结果：

image-20240328170129643

Note：

  1. ros::NodeHandle nh;

    尽管nh没有被使用，但也必须初始化，否则运行会出现以下问题（编译正常）

    image-20240328151434813

  2. 时刻之间相加没有对应的重载函数

    image-20240328161131006

3.1.5 其他函数

A.节点关闭函数ros::shutdown();

直接关闭节点

#include "ros/ros.h"

int main(int argc, char *argv[])
{
    /* code */
    ros::init(argc,argv,"api_log");
    ros::NodeHandle nh;
    int count = 0;
    ros::Rate rate(10);
    while (ros::ok())
    {
        /* code */
        count++;
        ROS_INFO("%d---------I'm here!",count);
        if(count >= 20){
            ros::shutdown();
            //break;
        }
        rate.sleep();
    }
    ROS_INFO("Finally-------------I'm here!");
    return 0;
}

以上代码提供了两种跳出循环的方式：

i.ros::shutdown();通过关闭节点的方式跳出循环，其后的代码将不再被执行；

ii.break;就是正常的跳出while，代码继续向下执行

两次运行结果对比

i.image-20240328173551787

ii.image-20240328173611397

B.日志函数

ROS_DEBUG("调试信息"); //不会输出
ROS_INFO("一般信息"); //默认白色字体
ROS_WARN("警告信息"); //默认黄色字体
ROS_ERROR("错误信息");//默认红色字体
ROS_FATAL("严重错误");//默认红色字体

#include "ros/ros.h"

int main(int argc, char *argv[])
{
    /* code */
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"api_log");
    ros::NodeHandle nh;
    int count = 0;
    ros::Rate rate(10);
    ROS_DEBUG("调试信息"); //不会输出
    ROS_INFO("一般信息"); //默认白色字体
    ROS_WARN("警告信息"); //默认黄色字体
    ROS_ERROR("错误信息");//默认红色字体
    ROS_FATAL("严重错误");//默认红色字体
    return 0;
}

image-20240328174308067

Ps：ROS_DEBUG()一般不输出，若要输出其中的信息，可以通过相关配置输出调试信息

3.2 ROS中的头文件与源文件

有以下两种类型封装代码：

  1. 自定义头文件调用（相当于只声明.h，实现部分在主代码的文件中）
  2. 自定义源文件调用（相当于.h声明，.cpp实现，主代码文件调用封装即可）
3.2.1 自定义头文件调用

这里真是把坑都踩完了😵🙃😫

  1. 编写头文件

    A.创建.h文件

    image-20240328205116421

    务必！放在！include/包名！放在包名这里！再右键新建.h文件

    B.编写.h文件

    内容格式如下（这里只声明）：

    // 注意class声明结束有一个;

    #ifndef _HELLO_H
#define _HELLO_H

/* 
    声明namespace
        |--class
            |--run
 */

namespace hello_ns{
    class myhello{
        public:
            void run();
    };
}

#endif

  2. 编写可执行文件(同时也是源文件)

    编写前请先编辑.vscode/c_cpp_properties.json，否则在include导入自定义包时会报错

    复制include的路径，加上/**，加入到”includePath“中（记得在上一行加上，）

    image-20240328211757310

    image-20240328211944776

    添加好路径之后，就可以编辑hello.cpp

    i.导入头文件

    ii.在namespace中实现run函数

    iii.在main函数中进行调用

    #include "ros/ros.h"
#include "hello_head/hello.h"

namespace hello_ns{
    void myhello::run(){
        ROS_INFO("hello,run已经被执行!");
    };
}

int main(int argc, char *argv[])
{
    /* code */
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"hellohead");

    hello_ns::myhello hello;
    hello.run();

    return 0;
}

    注意!这会不要妄想去编译他！会报错！这没有问题！因为还没有配置！

    刚刚就是吃了这个亏，编译的时候一直说找不到头文件，一直在找.vscode/c_cpp_properties.json的问题，只要在编写代码的时候能自动补全，就是配置好了！

  3. 编辑配置文件CMakeLists并执行

    i.include解注释

    一定注意这一步！问就是踩坑了！

    image-20240328214142235

    ii.这三个部分解注释，并编辑蓝色箭头的地方

    image-20240328214344583

现在代码可以正常执行：

image-20240328214527249

3.2.1 自定义头文件调用

  1. 编写头文件

    同上，并配置.vscode/c_cpp_properties.json

  2. 编写源文件

    在src下新建hello.cpp，用于run函数的实现

    #include "ros/ros.h"
#include "hello_src/hello.h"

namespace hello_ns{
    void myhello::run(){
        ROS_INFO("hello,run已经被执行!");
    }
}

  3. 编写可执行文件

    在src下新建use_hello.cpp，编写main函数

    #include "ros/ros.h"
#include "hello_src/hello.h"

int main(int argc, char *argv[])
{
    /* code */
    setlocale(LC_ALL,"");
    ros::init(argc,argv,"hellohead");

    hello_ns::myhello haha;
    haha.run();

    return 0;
}

  4. 编辑配置文件并执行

    来到CMakeLists，库的相关配置：以下两部分解注释并编辑

    image-20240328215932637

    修改为

    image-20240329003757927

    继续库的相关配置

    image-20240328220719972

    可执行文件的相关配置

    注意，在链接库时比之前多了一步，还要将自己的库链接进去

    image-20240328221012342

编译执行：

image-20240329004400554

Ps：这里提到的可执行文件指的是程序主要运行的节点部分所对应的源文件，并非严格意义上的可执行文件

咕噜咕噜咕噜噜噜噜
关注
  • 18
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
ROS学习入门教程 | 零基础上手机器人开发
autolabor的博客
12-04 3158
在和很多用户聊了之后，我们发现 ROS 是大家开发机器人的一个痛点。 尽管和几年前ROS刚在国内兴起时相比，现在ROS的使用人群有一定的增长，网上ROS的资料和教程也多了起来。 但对机器人开发感兴趣的初学者来说，仍然缺少免费、系统、详细、全面，手把手的ROS教程。
ROS的服务通信实现
想做一条贪吃蛇
04-04 1505
ros服务通信框架
ROS入门教程
weixin_41977938的博客
10-08 195
ROS核心知识
ROS基础入门教程(文档+视频)：基本概念+urdf仿真+导航仿真+实体机器人导航
qq_34761779的博客
09-11 739
ROS基础入门教程(文档+视频)：基本概念+urdf仿真+导航仿真+实体机器人导航
【Autolabor初级教程】ROS机器人入门 第1章 环境搭建 个人学习笔记
qq_51247800的博客
03-18 1052
OS中涉及的编程语言以C++和Python为主，ROS中的大多数程序两者都可以实现，C++运行效率高但是编码效率低，Python则反之。基于二者互补的特点，ROS设计者分别设计了roscpp与rospy库，roscpp旨在成为ROS的高性能库，而rospy则一般用于对性能无要求的场景，旨在提高开发效率。创建工作空间并初始化工作空间：一般形式为xxx_ws/src（意思是项目_工作空间workspace），下级目录src用于存放源码执行编译会在xxx_ws下生成两个文件夹build和devel。
ROS学习笔记之——多机器人探索环境
01-06
本博文是基于这个ROS软件包（https://github.com/hrnr/m-explore）的学习笔记 目录 multi robot exploration nav_msgs/OccupancyGrid  map_msgs/OccupancyGridUpdate move_base multirobot_map_merge 参考资料 ...
基于ros的多机器人仿真项目（导航、编队）
06-06
基于ros的多机器人仿真（导航+编队）包含urdf文件，详细请参考项目笔记（包含导航、编队原理介绍，详细配置过程）： 1、《如何在Gazebo中实现多机器人仿真》 ： https://www.guyuehome.com/4889 2、《基于ROS的多...
ROS与SLAM从零开始学习笔记（一）——ROS概述与环境搭建
01-20
写在前面：笔者最近在做一个基于ROS平台的小项目，也算是从零开始学ROS，在这里写下一些学习时的笔记。 笔者学习参考：古月居 一、ROS环境安装 ROS历经多个版本的升级，目前正不断适用于机器人领域的研究与控制，ROS...
ROS2一些学习笔记仅个人记录
02-25
ROS2 学习笔记 ROS2 是一个开源的机器人操作系统，提供了一个灵活的框架来构建机器人应用程序。下面是 ROS2 的一些学习笔记，涵盖了从安装到使用的一些基本概念和命令。 安装和环境变量设置 为了使用 ROS2，需要...
ROS机器人程序设计
11-22
, 第3章进一步展示ROS强大的调试工具，以及通过对节点主题的图形化将节点间的通信数据可视化。ROS提供了一个日志记录API来轻松地诊断节点的问题。事实上，在使用过程中，我们会看到一些功能强大的图形化工具（如rqt_...
ROS学习6：ROS机器人系统仿真
qq_42994487的博客
04-27 4661
ROS学习6：ROS机器人系统仿真
ROS理论与实践——赵虚左Autolabor
zcgygs的博客
06-11 3581
ROS理论与实践
使用urdf建立ROS机器人Autolabor2.5机器人模型
autolabor的博客
12-20 1982
本文介绍如何在ROS中使用urdf创建机器人3D模型。机器人的3D模型在ROS中是通过URDF文件实现，URDF（Unified Robot Description Format）就是描述机器人硬件尺寸布局的模型语言。它是同ROS通信的渠道，通过机器人的物理尺寸来配置机器人模型，ROS就可以有效的进行自主导航（Navagation）和碰撞检测(collision detect)了。
(11)ROS学习-常用API-系列学习于Autolabor
weixin_52734156的博客
11-20 225
ros常用api
【Autolabor初级教程】ROS机器人入门 第 2 章 ROS通信机制 个人学习笔记
最新发布
qq_51247800的博客
03-21 893
作用：类似于C语言的结构体在自定义msg时，可以适用的字段类型有自定义msg实现功能包下新建msg目录，添加文件xxx.msg（注意后缀）内容每行定义字段类型和字段名即可，回车换行uint16 age修改，添加以下内容修改（没有的内容增加，被注释的解开）编译编译后会在devel/include生成对应的头文件后续代码使用自定义msg的准备工作配置将自定义msg的头文件所在路径添加到即可发布者// 1.包含头文件 #include "demo_pub_sub/person.h"
Ubuntu22.04上入门ROS
weixin_46646569的博客
03-30 508
Ubuntu22.04入门学习ROS
(9)ROS学习-服务调用实操-系列学习于Autolabor
weixin_52734156的博客
11-18 559
ros实操-服务调用
Chapter5 ROS常用组件(Ⅱ)----rosbag&rqt工具箱
qq_41694024的博客
04-17 1352
本章主要介绍rosbag和rqt功能箱的使用
学习ROS机器人需要哪些硬件基础
03-11
学习ROS机器人需要具备一定的计算机基础和编程基础，同时需要一台能够运行ROS的计算机，如笔记本电脑或单板计算机，还需要一些基本的硬件设备，如传感器、执行器、摄像头等。具体需要哪些硬件基础，需要根据具体的ROS应用场景来确定。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

咕噜咕噜咕噜噜噜噜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值