3 ROS1通讯编程提高(1)

最新推荐文章于 2023-03-22 22:53:06 发布
最新推荐文章于 2023-03-22 22:53:06 发布
阅读量243 收藏 2
点赞数
分类专栏： ROS1学习笔记 文章标签： vscode ROS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42727752/article/details/129716124
版权

3 ROS1通讯编程提高

3.1 使用VS Code编译ROS1

3.1.1 VS Code的安装和配置

3.1.1.1 VS Code以及插件安装

  1. VS Code的下载安装：

VS Code的下载链接：VS Code 官网连接；历史版本下载链接：VS Code历史版本，选择合适的版本，对于Linux系统下载deb文件双击运行，或者输入命令sudo dpkg -i vscode安装包名.deb即可。

  1. VS Code的插件配置：
    1. VS Code编译ROS需要的插件主要包括：ROS、C/C++、Python、CMake、CMake Tools以及中文汉化插件Chinese(simplified) Language Pack for Visual Studio Code，如图所示：

在这里插入图片描述

    1. 其中Python可能需要设置解析器的位置即usr/bin/python2.7，重启VS Code，配置好的插件环境如图所示：

在这里插入图片描述

3.1.1.2 VS Code配置ROS1工作空间

  1. VS Code打开工作空间：
    1. 在终端进入到工作空间即cd catkin_ws
    1. 输入命令code .直接在VS Code打开工作空间，如图所示

在这里插入图片描述

  1. 配置工作空间下的json文件：在VS Code打开的工作空间，会出现一个.vscode文件夹，里面存放了三个json文件，用于配置C++和Python编译ROS，下面依次介绍：
    1. task.json文件：用于配置C++和Python编译ROS任务，配置好之后，可基本上后续不需要进行改动。
// /home/ubuntu/catkin_ws/.vscode/tasks.json
{
	"version": "2.0.0",
	"tasks": [
		{
			"type": "shell",
			"args": [
				"--directory",
				"/home/ubuntu/catkin_ws"
			],
			"problemMatcher": ["$catkin-gcc"],
			"command":"catkin_make",
			"group": "build",
			"label": "catkin_make: build_by_vscode",
			"presentation": {"reveal": "always"}
		}
	]
}
    1. c_cpp_properties.json：用于配置C++编译ROS时的一些C++特有的路径和代码规范，配置本次配置好，后续可能出现修改地方主要在于这些路径位置。
// /home/ubuntu/catkin_ws/.vscode/c_cpp_properties.json
{
  "configurations": [
    {
      "browse": {
        "databaseFilename": "",
        "limitSymbolsToIncludedHeaders": true
      },
      "includePath": [
        "/opt/ros/melodic/include/**",
        "${workspaceFolder}/devel/include/**",//配置成自身工作空间的devel文件夹的路径;
                                                  //目的是指向自定义msg/action/srv等路径.
        "/usr/include/**"
      ],
      "name": "ROS",
      "cppStandard":"c++17",
      "intelliSenseMode": "gcc-x64",
      "compilerPath": "/usr/bin/gcc",
      "cStandard": "c11"
    }
  ],
  "version": 4
}
    1. settings.json：用于配置Python编译ROS时的一些Python包路径和规范，配置好之后，可能出现变换的地方也在这些路径位置。
// /home/ubuntu/catkin_ws/.vscode/settings.json
{
    "python.autoComplete.extraPaths": [
        "/opt/ros/melodic/lib/python2.7/dist-packages",
        "${workspaceFolder}/devel/lib/python2.7/dist-packages"
        // 如果是高版本ROS可能是Python3，按照自定义消息一样查看中间文件位置确定
    ],
    "cmake.configureOnOpen": true,
    "cmake.sourceDirectory": "${workspaceFolder}/src"
}

3.1.1.3 VS Code运行ROS1的方法

  1. 编译运行：
  • 方法一：使用快捷键或者在VS Code的编译器【终端】–【运行生成任务】即Crtl+Shift+B，点击之后选择catkin_make: build_by_vscode（在task.json的label名字）即可编译整个工作空间。
  • 方法二：在VS Code下面的终端（或者在【终端】–【新终端】即Crtl+Shift+`）cd 到catkin_ws下进行catkin_make编译

3.1.1.3 参考资料

  1. 参考文献：
    VS Code的tast.json查考文件；
    VS Code的C++查考文件；
    VS Code的Python查考文件；
    【奥特学园】ROS机器人入门课程《ROS理论与实践》零基础教程

3.1.2 使用VScode编译C++文件

  1. 在catkin_ws/src/目录下右键create catkin package创建包，然后按照提示命名如test，然后输入依赖项roscpp rospy std_msgs等

  2. 在catkin_ws/src/test/src下右键新建test_c.cpp文件，编辑test_c.cpp文件。

// test_c.cpp文件用于测试ROS1环境
#include "ros/ros.h"
int main(int argc, char* argv[])
{
    ros::init(argc,argv,"i_am_nodename");
    ROS_INFO("HELLO");
    return 0;
}
  1. 配置catkin_ws/src/test/src/CMakeLists.txt文件，然后编译运行。
    1. 在136行，取消 add_executable(${PROJECT_NAME}_node src/test_node.cpp)的注释，修改为 add_executable(i_am_nodename src/test_c.cpp)
    1. 其次在149-151行的target_link_libraries(${PROJECT_NAME}_node…) 修改为 target_link_libraries(i_am_nodename…)即可
    1. 编译运行（直接在VScode的终端下的+号新建终端，输入roscore，新建终端输入rosrun test i_am_nodename即可查看INFO的消息）。

3.1.3使用VScode编译Python文件

  1. 之前同编译C++是Step1-Step3，此时在catkin_ws/src/test/文件夹下创建Python文件夹scripts，在scripts文件夹里新建Python文件test_p.py
  2. 编写Python程序，赋予可执行权限，然后运行客户端roscore，最后rosrun test test_p.py即可。
#! /usr/bin/env python
import rospy
if __name__ =='__main__':
    rospy.init_node("test_p")
    rospy.loginfo("ok")

Tips：
在Ubuntu20.04版本的ROS需要配置CMakeLists文件，大约在161行处，类似C++一样添加Python文件的位置。同时对于高版本的Python编译ROS在Python文件头部是没有#!/usr/bin/env
python，采用命令:sudo ln -s /usr/bin/python3 /usr/bin/python创建Python的连接。

3.2 ROS1动作编程

3.2.1 动作编程模型

在任何ROS的大型系统中，如果向节点发送请求以执行某些任务，最后收到对请求的回复，这一操作主要是通过ROS的服务编程实现，但是如果服务需要很长时间来执行，用户可能希望能够在执行期间取消请求或获得有关请求进展情况的定期反馈，基本的服务编程的应答模式是满足不了的，因此ROS提供actionlib即动作编程完成这些操作。

  • 动作编程的作用：针对服务编程的应答模式的提升，在服务端执行过程中能够取消或者获得服务器状态，动作编程一般适用于耗时的请求响应场景,用以获取连续的状态反馈。

  • 动作编程的例子：如巡检机器人导航过程中，从A到B的导航过程，应该是一个动作编程，即目标是B，在A到B时，提供导航状态。

在这里插入图片描述
在动作编程中，客户端发送目标（goal）或者取消指令（cancel）给服务端，服务端提供状态（status）、实时反馈（feedback）和结果（result）。

官方以移动机器人为例解释goal、feedback和result，即

  • 1）目标（goal）：为了使用动作完成任务，引入了可以由 ActionClient 发送到 ActionServer 的目标的概念。在移动基地的情况下，目标是 PoseStamped 消息，其中包含有关机器人应移动到世界何处的信息，在官方洗碗例子中对目标的描述也是需要选择的那个洗碗工是谁。
  • 2）回馈（feedback）：服务器持续反馈 ActionClient目标的增量进度。对于移动机器人，这可能是机器人沿路径的当前位置。
  • 3）结果（result）：目标完成后，结果从 ActionServer 发送到 ActionClient，这与反馈不同，因为它只发送一次。当客户端请求的目的（goal）是提供某种信息时，这就非常有用。对于移动机器人，结果不是很重要，但它可以是机器人的最终位置（不代表就是目的地）。

3.2.2 动作编程基础示例

动作编程的基本思想和自定义的消息话题编程是一致的。

动作编程内容：洗盘子动作编程，两个节点，一个为客户端一个为服务端，客户端发送数字1（代码实现）给给服务端，作为选择哪个洗碗工，服务端接收到之后持续反馈进度给客户端，最后发送数字100（代码实现）作为结果返回。

3.2.2.1 使用VS Code创建动作编程项目

（一）使用VS Code新建功能包：

  1. 打开VS Code和工作空间，新建动作编程功能包并创建ROS文件夹结构。
    1. 打开VS Code和工作空间，在工作空间catkin_ws下输入命令code .打开VS Code，打开后如果出现提示Select a kit for catkin_ws，则选择第一项Scan for kit即可。

在这里插入图片描述

    1. 新建动作编程功能包，右键工作空间catkin_ws的src目录，选择create catkin package然后在VS Code的提示下输入包名action_communication，回车之后输入依赖项roscpp rospy std_msgs即可

在这里插入图片描述

    1. 新建ROS结构的文件夹，即在功能包下新建action文件夹和scripts文件夹。

3.2.2.2 配置action动作文件

（二）定义action动作文件：

  1. 定义动作文件。在action_communication/action下创建自定义动作文件.action，这里为DoDishes.action文件。其中的内容分为三个部分：
  • 第一部分goal对应目标数据，即客户端发布数据。
  • 第二部分result定义结果，服务端应答给客户端的结果。
  • 第三部分是反馈部分，服务端反馈一些信息给客户端。
# catkin_ws/src/action_communication/action/DoDishes.action
# Define the goal
uint32 dishwasher_id  # Specify which dishwasher we want to use
---
# Define the result
uint32 total_dishes_cleaned
---
# Define a feedback message
float32 percent_complete

（三）配置action文件

  • 配置msg文件包括在package.xml和CMakeList.txt配置两部分。
  1. 在package.xml添加依赖项actionlib和actionlib_msgs四项，二者都是依赖项和执行依赖项。
// /catkin_ws/src/action_communication/package.xml
  <build_depend>actionlib</build_depend>
  <build_depend>actionlib_msgs</build_depend>

  <exec_depend>actionlib</exec_depend>
  <exec_depend>actionlib_msgs</exec_depend>
  1. 在功能包的CmakeLists.txt添加编译选项，包括四部分。
    1. 添加编译依赖项功能包：find_package(catkin REQUIRED COMPONENTS ..+ 依赖项功能包)，大约在第10行，添加actionlib和actionlib_msgs两项：
# /catkin_ws/src/action_communication/CMakeLists.txt
find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  std_msgs
  actionlib
  actionlib_msgs
)
    1. 添加自定义action文件：add_action_files(FILES 文件名)，大约在第66行，如此时的文件名为DoDishes.action：
# /catkin_ws/src/action_communication/CMakeLists.txt
add_action_files(
  FILES
  DoDishes.action
)
    1. 添加action的编译依赖项std_msgs和actionlib_msgs：generate_messages(DEPENDENCIES 依赖项名)，大约在第71行，即表示在编译msg时候得依赖于std_msgs：
# /catkin_ws/src/action_communication/CMakeLists.txt
generate_messages(
  DEPENDENCIES
  std_msgs
  actionlib_msgs
)
    1. 添加执行时的依赖：catkin_package的关键字CATKIN_DEPENDS后+包，大约在106行，添加actionlib和actionlib_msgs如：
# /catkin_ws/src/action_communication/CMakeLists.txt
catkin_package(
#  INCLUDE_DIRS include
#  LIBRARIES action_communication
 CATKIN_DEPENDS roscpp rospy std_msgs actionlib actionlib_msgs
#  DEPENDS system_lib
)

（四）编译action文件，查看中间文件：

  1. 在工作空间下编译，此时在工作空间的devel目录会多出几个文件，如C++的中间文件在/home/ubuntu/catkin_ws/devel/include/功能包名/文件夹下，Python的中间文件在/home/ubuntu/catkin_ws/devel/lib/python2.7/dist-packages/功能包名/msg

3.2.2.3 C++实现action基本编程

（五）C++实现action基本编程：

  1. 实现动作服务器
    1. 首先在工作空间的根目录的src文件夹里创建服务程序DoDishes_server_cpp.cpp。
# catkin_ws/src/action_communication/src/DoDishes_server_cpp.cpp
#include <ros/ros.h>
#include <actionlib/server/simple_action_server.h>
#include "action_communication/DoDishesAction.h"

typedef actionlib::SimpleActionServer<action_communication::DoDishesAction> Server;

// 收到action的goal后调用该回调函数
void callback(const action_communication::DoDishesGoalConstPtr& goal, Server* server)
{
    ros::Rate r(1);
    action_communication::DoDishesFeedback feedback;
    ROS_INFO("收到客户端的goal,洗碗工 %d 开始洗盘子.", goal->dishwasher_id);
    // 假设洗盘子的进度，并且按照1hz的频率发布进度feedback
    for(int i=1; i<=10; i++)
    {
        feedback.percent_complete = i * 10;
        server->publishFeedback(feedback);
        ROS_INFO("feedback ing ...");
        r.sleep();
    }

    // 当action完成后，向客户端返回结果
    ROS_INFO("洗碗工完成了工作，发送result(100个)给客户端.");
    action_communication::DoDishesResult res;
    res.total_dishes_cleaned = 100;
    server->setSucceeded(res);
}

int main(int argc, char** argv)
{
    setlocale(LC_ALL,"");
    ros::init(argc, argv, "do_dishes_server");
    ros::NodeHandle nh;
    // 定义一个服务器
    Server server(nh, "do_dishes", boost::bind(&callback, _1, &server), false);
    // 服务器开始运行
    ROS_INFO("action服务端启动,等待指令");
    server.start();
    ros::spin();
    return 0;
}
    1. 创建客户端文件DoDishes_client_cpp.cpp
# catkin_ws/src/l_t/src/DoDishes_client_cpp.cpp
#include <actionlib/client/simple_action_client.h>
#include "action_communication/DoDishesAction.h"

typedef actionlib::SimpleActionClient<action_communication::DoDishesAction> Client;

// 当action完成后会调用该回调函数一次
void doneCb(const actionlib::SimpleClientGoalState& state,
        const action_communication::DoDishesResultConstPtr& result){
    ROS_INFO("result:洗碗工把盘子已经洗完啦!洗了%d个",result->total_dishes_cleaned);
    ros::shutdown();
}

// 当action激活后会调用该回调函数一次
void activeCb(){
    ROS_INFO("服务器已经打开，可以执行任务");
}

// 收到feedback后调用该回调函数
void feedbackCb(const action_communication::DoDishesFeedbackConstPtr& feedback)
{
    ROS_INFO("feedback:洗盘子的进度:%f", feedback->percent_complete);
}

int main(int argc, char** argv)
{
    setlocale(LC_ALL,"");
    ros::init(argc, argv, "do_dishes_client");
    // 定义一个客户端
    Client client("do_dishes", true);

    // 等待服务器端
    client.waitForServer();
    ROS_INFO("goal:选择员工1洗盘子:");
    // 创建一个action的goal
    action_communication::DoDishesGoal goal;
    goal.dishwasher_id = 1;
    // 发送action的goal给服务器端，并且设置回调函数
    client.sendGoal(goal,  &doneCb, &activeCb, &feedbackCb);

    ros::spin();
    return 0;
}
    1. 配置动作的服务端和客户端代码的编译选项。在功能包的目录下，打开其CMakeLists.txt文件。
# catkin_ws/src/action_communication/CMakeLists.txt
add_executable(dodisher_server_cpp src/DoDishes_server_cpp.cpp)
add_executable(dodisher_client_cpp src/DoDishes_client_cpp.cpp)

add_dependencies(dodisher_server_cpp ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
add_dependencies(dodisher_client_cpp ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})

target_link_libraries(dodisher_server_cpp ${catkin_LIBRARIES})
target_link_libraries(dodisher_client_cpp ${catkin_LIBRARIES})
    1. 在工作空间的根目录下进行编译操作。
    1. 运行服务编程。首先打开一个终端输入roscore，打开ROS，再新建一个终端输入rosrun action_communication DoDishes_server运行服务程序。最后新建终端输入rosrun action_communication DoDishes_client即运行客户端并执行动作操作。

在这里插入图片描述

3.2.2.4 Python实现action基本编程\

（六）Python实现action基本编程：

  1. 在scripts文件夹创建Python服务端文件
    1. DoDishes_server_py.py，代码见注释

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

# catkin_ws/src/action_communication/scripts/DoDishes_server_py.py

import rospy
import actionlib
from action_communication.msg import *


class myActionServer:
    def __init__(self):
        # 1.创建服务器,执行服务器回调函数
        self.server = actionlib.SimpleActionServer("dodishes", DoDishesAction, self.serverCb, False)
        self.server.start()
        rospy.loginfo("服务端启动")

    def serverCb(self,goal):
        id = goal.dishwasher_id
        rospy.loginfo("收到来自客户端的goal，洗碗工 %d 开始工作",id)
        rate = rospy.Rate(1)

        for i in range(1, 10):
            rospy.loginfo("feedback ing...")
            feedBack_obj = DoDishesFeedback()
            feedBack_obj.percent_complete = i
            self.server.publish_feedback(feedBack_obj)
            rate.sleep()

        res = DoDishesResult()
        res.total_dishes_cleaned = 100
        rospy.loginfo("洗碗工完成了工作，发送result(100个)给客户端.")
        self.server.set_succeeded(res)


if __name__ == "__main__":
    rospy.init_node("action_server_py")
    server = myActionServer()
    rospy.spin()
    1. 编写客户端DoDishes_client_py.py文件
#!/usr/bin/env python
# -*- coding: utf-8 -*-

# catkin_ws/src/action_communication/scripts/DoDishes_client_py.py

import rospy
import actionlib
from action_communication.msg import *

def result_cb(state,result):
    if state == actionlib.GoalStatus.SUCCEEDED:
        rospy.loginfo("result:洗碗工把盘子已经洗完啦!洗了%d个",result.total_dishes_cleaned)

def active_cb():
    rospy.loginfo("服务被激活....")

def feedback_cb(f):
    rospy.loginfo("当前进度:%.2f",f.percent_complete)

if __name__ == "__main__":
    # 2.初始化 ROS 节点
    rospy.init_node("action_client_py")
    # 3.创建 action Client 对象
    client = actionlib.SimpleActionClient("dodishes",DoDishesAction)
    # 4.等待服务
    client.wait_for_server()
    # 5.组织目标对象并发送
    goal_obj = DoDishesGoal()
    goal_obj.dishwasher_id = 1
    rospy.loginfo("goal:选择员工1洗盘子:")
    client.send_goal(goal_obj,result_cb,active_cb,feedback_cb)
    # 6.编写回调, 激活、连续反馈、最终响应
    # 7.spin
    rospy.spin()
    1. 给Python文件赋予可执行权限，在script文件夹下输入命令sudo chmod +x *.py即可赋予所有Python可执行权限。
    1. 运行py文件

在这里插入图片描述

3.2.3 动作编程总结

3.2.3.1 动作编程的顺序流程

  1. 动作编程的顺序流程：
    1. 在action文件夹编写自定义action文件，配置package.xml文件包括actionlib和actionlib_msg，分别包括<build_depend>和<exec_depend>四项；
    1. 配置CMakeList.txt文件包括
      1. 添加编译依赖项功能包：find_package；
      1. 添加自定义action文件：add_action_files；
      1. 添加action的编译依赖项：generate_messages里添加std_msgs和actionlib_msgs；
      1. 添加执行时的依赖：catkin_package里添加actionlib actionlib_msgs；
    1. C++代码：
      1. 添加头文件（头文件为功能包名字/自定义动作.h）；
      1. 正常编写代码；
      1. CMakeList.txt进行配置(不仅有add_executable和target_link_libraries还包括add_dependencies）；
      1. 编译运行；
    1. Python代码：
      1. 添加包，from 功能包名.msg import *；
      1. 正常代码编写；②CMakeList.txt进行配置(目前配置不配置影响不大）；
      1. 赋予py文件可执行权限；
      1. 编译运行。

3.2.3.2 动作编程逻辑

  1. 编程逻辑顺序:

在这里插入图片描述

3.2.4 参考

爬楼的猪
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
foxglove中的 ros1 的schema消息文件 - python3版本 - 免费下载
03-14
foxglove中的 ros1 的schema消息文件 -- python3版本. 还在自己找foxglove的消息的python3的结构吗? 拿走不谢 免费的,不要积分便可下载哦,需要就拿走把. 使用的时候,直接解压,把foxglove_msgs直接复制到你的项目中...
ROS多机通信步骤与测验
I_meditation的博客
12-19 238
主机上的小乌龟，可以通过从机上的键盘控制
3 ROS1通讯编程提高(2)
最新发布
爬楼的猪的博客
03-22 244
ROS1通讯编程提高(2)，学习简单的动态参数，和launch文件的简单知识
2 ROS1通讯编程基础(3)
爬楼的猪的博客
03-21 125
ROS1通讯编程基础学习笔记，主要针对参数服务器的编程简单学习
ROS笔记（1） ROS简介
热门推荐
氢键H-H
05-20 2万+
ROS的起源、概述、目的、特点和版本
机器人 ros1 noetic debian
03-02
Debian系统上进行ROS1（noetic）源码编译，源码包含了ros1的核心代码和编译简要步骤。
ros1 indigo 命令行工具手册
08-10
ros1 indigo 命令行工具手册
[bag] ros1-bag
06-30
ros1bag 测试
ROS2编程基础课程文档.pdf
09-12
ROS2编程基础课程文档 ...与ROS1的互操作性 ROS 2包括到ROS 1的桥接器，处理两个系统之间的双向通信。如果有一个现有的ROS 1应用程序， 可 以通过桥接器开始尝试使用ROS 2，并根据要求和可用资源逐步移植应用程序。
1 Ubuntu版本和ROS1系统
爬楼的猪的博客
09-02 4031
ROS1的安装和Ubuntu的配置基本知识
5 ROS仿真建模（4- Navigation导航仿真)
爬楼的猪的博客
07-29 3662
5 ROS仿真建模5.7 Navigation导航预期准备5.7.1 导航功能实现框图5.7.2 安装导航功能包5.7.3 导航仿真条件5.8 键盘控制机器人并利用SLAM绘制地图5.8.1 新建功能包5.8.2 在launch文件夹编写SLAM建图文件5.8.3 新编启动的launch文件5.8.4 启动SLAM仿真5.8.5 保存SLAM的地图5.9 AMCL机器人自身定位仿真5.9.1 AMCL定位基础5.9.2 新建AMCL启动文件5.9.3 控制机器人运动并查看定位话题5.10 路径规划导航5.1
3 ROS人机交互界面的搭建
爬楼的猪的博客
09-21 3266
3 ROS人机交互界面的搭建3.1 Qt安装和配置二级标题 3.1 Qt安装和配置 前提条件，虚拟机运行ROS-melodic和Qt5.9.9。其他版本很容易报错。 安装----- 在http://download.qt.io/archive/qt/下载Qt5(linux对于.run文件这里下载的是Qt5.9.9) ，下载完后在改文件夹打开终端，输入sudo chmod a+x /给安装包赋予权限，之后双击安装，安装时，没有Qt账户的需要注册，然后在安装组件那一步勾选gcc，其他都按照默认的安装(即安装在h
5 ROS仿真建模（1- urdf和rviz、gazebo的基础操作）
爬楼的猪的博客
07-06 2349
5 ROS仿真建模5.1初识urdf和rviz的操作5.1.1实现效果5.1.2 Rviz和Urdf的显示实现5.1.3 常见报错问题和解决 5.1初识urdf和rviz的操作 5.1.1实现效果 在启动rviz时，能够看到带有编写的urdf模型文件的模型。 启动roslaunch时候，得到如图所示的画面 5.1.2 Rviz和Urdf的显示实现 1、新建功能包，导入依赖包:urdf与xacro 2、编写 urdf 文件 3、在 launch 文件集成 URDF 与 Rviz 4、在 Rviz 中显示机
5 ROS仿真建模（2- urdf文件的编写和场景搭建）
爬楼的猪的博客
07-07 1855
5 ROS仿真建模5.3 Urdf文件的编写5.3.1 实现效果5.3.2 代码编写 5.3 Urdf文件的编写 5.3.1 实现效果 在rviz中，能够显示的小车模型如下所示。 5.3.2 代码编写 1、创建功能包添加依赖项 创建一个新的功能包，名称自定义然后导入依赖urdf xacro gazebo_ros gazebo_ros_control gazebo_plugins，然后在当前功能包下，再新建几个目录: urdf：存储 urdf 文件的目录 meshes：机器人模型渲染文件(暂不使用) co
5 ROS仿真建模（3- rviz+gazebo+控制仿真机器人)
爬楼的猪的博客
07-07 1790
5 ROS仿真建模5.5 赋予模型传感器信息控制仿真机器人5.5.1 实现效果5.5.2 在urdf文件添加gazebo传感器信息5.5.3 存在问题5.6 参考内容5.7 资源连接 5.5 赋予模型传感器信息控制仿真机器人 5.5.1 实现效果 在通过键盘控制机器人运动，同时可以订阅雷达信息。 5.5.2 在urdf文件添加gazebo传感器信息 1、添加差速驱动轮的信息 <gazebo> <plugin name="differential_drive_con
2 ROS1通讯编程基础(1)
爬楼的猪的博客
09-02 514
ROS1通讯编程基础，针对话题通讯内容
2 ROS1通讯编程基础(2)
爬楼的猪的博客
03-21 431
ROS1通讯编程基础，主要对cmakelist的文件解读和服务通讯编程
4 ROS-Arduino
爬楼的猪的博客
11-01 427
4 ROS-Arduino4.1 Arduino IDE和rosserial_arduino安装4.2 Arduino发布ros话题“hello world”测试功能包4.3 Arduino通过红外遥控器发布速度话题控制乌龟运动 4.1 Arduino IDE和rosserial_arduino安装 Arduino IDE----- 在arduino官网下载linux 64位的压缩包，然后放到Ubuntu中解压，在解压好的文件中输入sudo ./install.sh即可安装。安装完后只是会在home/用户名
3、ros1和ros2的区别
03-14
Ros1和Ros2的区别在于以下几个方面： 1. 通信机制：Ros1使用的是TCPROS，而Ros2使用的是DDS。 2. 支持平台：Ros1只支持Linux操作系统，而Ros2支持多种操作系统，包括Linux、Windows和macOS等。 3. 实时性：Ros2在实时性方面有所提升，支持更高的实时性需求。 4. 安全性：Ros2在安全性方面有所提升，支持更好的安全性需求。 5. 开发体验：Ros2在开发体验方面有所提升，支持更好的模块化开发和测试。 以上是Ros1和Ros2的主要区别，希望能对您有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值