11机器人系统仿真
机器人系统仿真
对于ROS新手而言，可能会有疑问:学习机器人操作系统，实体机器人是必须的吗？答案是否定的，机器人一般价格不菲，为了降低机器人学习、调试成本，在ROS中提供了系统的机器人仿真实现，通过仿真，可以实现大部分需求，本章主要就是围绕“仿真”展开的，比如，本章会介绍:
- 如何创建并显示机器人模型；
- 如何搭建仿真环境；
- 如何实现机器人模型与仿真环境的交互。
本章预期的学习目标如下:
- 能够独立使用URDF创建机器人模型，并在Rviz和Gazebo中分别显示；
- 能够使用Gazebo搭建仿真环境；
- 能够使用机器人模型中的传感器(雷达、摄像头、编码器...)获取仿真环境数据。
概述
机器人操作系统学习、开发与测试过程中，会遇到诸多问题，比如:
场景1:机器人一般价格不菲，学习ROS要购买一台机器人吗？
场景2:机器人与之交互的外界环境具有多样性，如何实现复杂的环境设计？
场景3:测试时，直接将未经验证的程序部署到实体机器人运行，安全吗？
...
在诸如此类的场景中，ROS中的仿真就显得尤为重要了。
概念
机器人系统仿真：是通过计算机对实体机器人系统进行模拟的技术，在 ROS 中，仿真实现涉及的内容主要有三:对机器人建模(URDF)、创建仿真环境(Gazebo)以及感知环境(Rviz)等系统性实现。
作用
仿真优势:
仿真在机器人系统研发过程中占有举足轻重的地位，在研发与测试中较之于实体机器人实现，仿真有如下几点的显著优势:
- 低成本:当前机器人成本居高不下，动辄几十万，仿真可以大大降低成本，减小风险
- 高效:搭建的环境更为多样且灵活，可以提高测试效率以及测试覆盖率
- 高安全性:仿真环境下，无需考虑耗损问题
仿真缺陷:
机器人在仿真环境与实际环境下的表现差异较大，换言之，仿真并不能完全做到模拟真实的物理世界，存在一些"失真"的情况，原因:
- 仿真器所使用的物理引擎目前还不能够完全精确模拟真实世界的物理情况
- 仿真器构建的是关节驱动器（电机&齿轮箱）、传感器与信号通信的绝对理想情况，目前不支持模拟实际硬件缺陷或者一些临界状态等情形
相关组件
1.URDF
URDF是 Unified Robot Description Format 的首字母缩写，直译为统一(标准化)机器人描述格式，可以以一种 XML 的方式描述机器人的部分结构，比如底盘、摄像头、激光雷达、机械臂以及不同关节的自由度.....,该文件可以被 C++ 内置的解释器转换成可视化的机器人模型，是 ROS 中实现机器人仿真的重要组件
2.rviz
RViz 是 ROS Visualization Tool 的首字母缩写，直译为ROS的三维可视化工具。它的主要目的是以三维方式显示ROS消息，可以将 数据进行可视化表达。例如:可以显示机器人模型，可以无需编程就能表达激光测距仪（LRF）传感器中的传感 器到障碍物的距离，RealSense、Kinect或Xtion等三维距离传感器的点云数据（PCD， Point Cloud Data），从相机获取的图像值等
以“ros- [ROS_DISTRO] -desktop-full”命令安装ROS时，RViz会默认被安装。
运行使用命令rviz或rosrun rviz rviz
*如果rviz没有安装，请调用如下命令自行安装:*
sudo apt install ros-[ROS_DISTRO]-rviz
3.gazebo
Gazebo是一款3D动态模拟器，用于显示机器人模型并创建仿真环境,能够在复杂的室内和室外环境中准确有效地模拟机器人。与游戏引擎提供高保真度的视觉模拟类似，Gazebo提供高保真度的物理模拟，其提供一整套传感器模型，以及对用户和程序非常友好的交互方式。
以“ros- [ROS_DISTRO] -desktop-full”命令安装ROS时，gzebo会默认被安装。
运行使用命令gazebo或rosrun gazebo_ros gazebo
**注意1:**在 Ubuntu20.04 与 ROS Noetic 环境下，gazebo 启动异常以及解决
-
问题1:VMware: vmw_ioctl_command error Invalid argument(无效的参数)
解决:
echo "export SVGA_VGPU10=0" >> ~/.bashrcsource .bashrc -
问题2:[Err] [REST.cc:205] Error in REST request
解决:
sudo gedit ~/.ignition/fuel/config.yaml然后将
url : https://api.ignitionfuel.org使用 # 注释再添加
url: https://api.ignitionrobotics.org -
问题3:启动时抛出异常:
[gazebo-2] process has died [pid xxx, exit code 255, cmd.....解决:
killall gzserver和killall gzclient
**注意2:**如果 gazebo没有安装，请自行安装:
1.添加源:
sudo sh -c 'echo "deb http://packages.osrfoundation.org/gazebo/ubuntu-stable `lsb_release -cs` main"
>
/etc/apt/sources.list.d/gazebo-stable.list'
wget http://packages.osrfoundation.org/gazebo.key -O - | sudo apt-key add -
2.安装：
sudo apt update
sudo apt install gazebo11
sudo apt install libgazebo11-dev
另请参考:
课程说明:
机器人的系统仿真是一种集成实现，主要包含三部分:
- URDF 用于创建机器人模型
- Gzebo 用于搭建仿真环境
- Rviz 图形化的显示机器人各种传感器感知到的环境信息
三者应用中，只是创建 URDF 意义不大，一般需要结合 Gazebo 或 Rviz 使用，在 Gazebo 或 Rviz 中可以将 URDF 文件解析为图形化的机器人模型，一般的使用组合为:
- 如果非仿真环境，那么使用 URDF 结合 Rviz 直接显示感知的真实环境信息
- 如果是仿真环境，那么需要使用 URDF 结合 Gazebo 搭建仿真环境，并结合 Rviz 显示感知的虚拟环境信息
后续课程安排:
- 先介绍 URDF 与 Rviz 集成使用，在 Rviz 中只是显示机器人模型，主要用于学习 URDF 语法
- 再介绍 URDF 与 Gazebo 集成，主要学习 URDF 仿真相关语法以及仿真环境搭建
- 最后集成 URDF 与 Gazebo 与 Rviz，实现综合应用
机器外形素材链接:
- https://github.com/zx595306686/sim_demo.git[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7ke7ML58-1649728244959)(D:\Linux交互\Picture\屏幕截图.png)]
URDF集成Rviz基本流程
前面介绍过，URDF 不能单独使用，需要结合 Rviz 或 Gazebo，URDF 只是一个文件，需要在 Rviz 或 Gazebo
中渲染成图形化的机器人模型，当前，首先演示URDF与Rviz的集成使用，因为URDF与Rviz的集成较之于URDF与Gazebo的集成更为简单，后期，基于Rviz的集成实现，我们再进一步介绍URDF语法。
需求描述:
在 Rviz 中显示一个盒状机器人
实现流程：
- 准备:新建功能包，导入依赖
- 核心:编写 urdf 文件
- 核心:在 launch 文件集成 URDF 与 Rviz
- 在 Rviz 中显示机器人模型
创建功能包，导入依赖
创建一个新的功能包，名称自定义，导入依赖包:urdf与xacro
在当前功能包下，再新建几个目录:
urdf: 存储 urdf 文件的目录
meshes:机器人模型渲染文件(暂不使用)
config: 配置文件
launch: 存储 launch 启动文件
编写 URDF 文件
新建一个子级文件夹:urdf(可选)，文件夹中添加一个.urdf文件,复制如下内容:
<robot name="mycar">
<link name="base_link">
<visual>
<geometry>
<box size="0.5 0.2 0.1" />
</geometry>
</visual>
</link>
</robot>
在 launch 文件中集成 URDF 与 Rviz
在launch目录下，新建一个 launch 文件，该 launch 文件需要启动 Rviz，并导入 urdf 文件，Rviz 启动后可以自动载入解析urdf文件，并显示机器人模型，核心问题:如何导入 urdf 文件? 在 ROS 中，可以将 urdf 文件的路径设置到参数服务器，使用的参数名是:robot_description,示例代码如下:
<launch>
<!-- 设置参数 -->
<param name="robot_description" textfile="$(find 包名)/urdf/urdf/urdf01_HelloWorld.urdf" />
<!-- 启动 rviz -->
<node pkg="rviz" type="rviz" name="rviz" />
</launch>
在 Rviz 中显示机器人模型
rviz 启动后，会发现并没有盒装的机器人模型，这是因为默认情况下没有添加机器人显示组件，需要手动添加，添加方式如下:
设置完毕后，可以正常显示了
优化 rviz 启动
重复启动launch文件时，Rviz 之前的组件配置信息不会自动保存，需要重复执行步骤4的操作，为了方便使用，可以使用如下方式优化:
首先，将当前配置保存进config目录
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m9qjC2I5-1649728244963)(D:\Linux交互\Picture\屏幕截图_2.png)]
然后，launch文件中 Rviz 的启动配置添加参数:args,值设置为-d 配置文件路径
<launch>
<param name="robot_description" textfile="$(find 包名)/urdf/urdf/urdf01_HelloWorld.urdf" />
<node pkg="rviz" type="rviz" name="rviz" args="-d $(find 包名)/config/rviz/show_mycar.rviz" />
</launch>
再启动时，就可以包含之前的组件配置了，使用更方便快捷。
URDF语法详解
URDF 文件是一个标准的 XML 文件，在 ROS 中预定义了一系列的标签用于描述机器人模型，机器人模型可能较为复杂，但是 ROS 的 URDF 中机器人的组成却是较为简单，可以主要简化为两部分:连杆(link标签) 与 关节(joint标签)，接下来我们就通过案例了解一下 URDF 中的不同标签:
- robot 根标签，类似于 launch文件中的launch标签
- link 连杆标签
- joint 关节标签
- gazebo 集成gazebo需要使用的标签
关于gazebo标签，后期在使用 gazebo 仿真时，才需要使用到，用于配置仿真环境所需参数，比如: 机器人材料属性、gazebo插件等，但是该标签不是机器人模型必须的，只有在仿真时才需设置
另请参考:
URDF语法详解01_robot
robot
urdf 中为了保证 xml 语法的完整性，使用了robot标签作为根标签，所有的 link 和 joint 以及其他标签都必须包含在 robot 标签内,在该标签内可以通过 name 属性设置机器人模型的名称
属性
name: 指定机器人模型的名称
子标签
其他标签都是子级标签
URDF语法详解02_link
link
urdf 中的 link 标签用于描述机器人某个部件(也即刚体部分)的外观和物理属性，比如: 机器人底座、轮子、激光雷达、摄像头...每一个部件都对应一个 link, 在 link 标签内，可以设计该部件的形状、尺寸、颜色、惯性矩阵、碰撞参数等一系列属性
属性
- name ---> 为连杆命名
子标签
- visual ---> 描述外观(对应的数据是可视的)
- geometry 设置连杆的形状
- 标签1: box(盒状)
- 属性:size=长(x) 宽(y) 高(z)
- 标签2: cylinder(圆柱)
- 属性:radius=半径 length=高度
- 标签3: sphere(球体)
- 属性:radius=半径
- 标签4: mesh(为连杆添加皮肤)
- 属性: filename=资源路径(格式:package://
/ )/文件
- 属性: filename=资源路径(格式:package://
- 标签1: box(盒状)
- origin 设置偏移量与倾斜弧度
- 属性1: xyz=x偏移 y便宜 z偏移
- 属性2: rpy=x翻滚 y俯仰 z偏航 (单位是弧度)
- metrial 设置材料属性(颜色)
- 属性: name
- 标签: color
- 属性: rgba=红绿蓝权重值与透明度 (每个权重值以及透明度取值[0,1])
- geometry 设置连杆的形状
- collision ---> 连杆的碰撞属性
- Inertial ---> 连杆的惯性矩阵
在此，只演示visual使用。
案例
需求:分别生成长方体、圆柱与球体的机器人部件
link
<!-- 需求：设置不同形状的机器人属性 -->
<robot name="mycar">
<link name="base_link">
<!-- 可视化标签 -->
<visual>
<!-- 1.形状 -->
<geometry>
<!-- 1.长方体的长宽高 -->
<!-- <box size="0.3 0.2 0.1" /> -->
<!-- 2.圆柱体 ，半径和长度-->
<!-- <cylinder radius="0.5" length="0.1" /> -->
<!-- 3.球体，半径 -->
<!-- <sphere radius="0.5" /> -->
<!-- 4.皮肤 -->
<mesh filename="package://urdt01_rviz/meshes/autolabor_mini.stl" />
</geometry>
<!-- 2.偏移量与倾斜幅度rpy翻滚俯仰与偏航角度(3.14=180度 1.57=90度)-->
<origin xyz="0 0 0" rpy="1.57 0 1.57" />
<!-- 3.颜色 -->
<material name="black">
<!--
r=red
g=green
b=black
a=透明度
四者取值在【0，1】
-->
<color rgba="0.7 0.5 0 0.5" />
</material>
</visual>
</link>
</robot>
URDF语法详解03_joint
joint
urdf 中的 joint 标签用于描述机器人关节的运动学和动力学属性，还可以指定关节运动的安全极限，机器人的两个部件(分别称之为 parent link 与 child link)以"关节"的形式相连接，不同的关节有不同的运动形式: 旋转、滑动、固定、旋转速度、旋转角度限制....,比如:安装在底座上的轮子可以360度旋转，而摄像头则可能是完全固定在底座上。
joint标签对应的数据在模型中是不可见的
属性
- name ---> 为关节命名
- type ---> 关节运动形式
- continuous: 旋转关节，可以绕单轴无限旋转
- revolute: 旋转关节，类似于 continues,但是有旋转角度限制
- prismatic: 滑动关节，沿某一轴线移动的关节，有位置极限
- planer: 平面关节，允许在平面正交方向上平移或旋转
- floating: 浮动关节，允许进行平移、旋转运动
- fixed: 固定关节，不允许运动的特殊关节
子标签
-
parent(必需的)
parent link的名字是一个强制的属性：
- link:父级连杆的名字，是这个link在机器人结构树中的名字。
-
child(必需的)
child link的名字是一个强制的属性：
- link:子级连杆的名字，是这个link在机器人结构树中的名字。
-
origin
- 属性: xyz=各轴线上的偏移量 rpy=各轴线上的偏移弧度。
-
axis
- 属性: xyz用于设置围绕哪个关节轴运动。
案例
需求:创建机器人模型，底盘为长方体，在长方体的前面添加一摄像头，摄像头可以沿着 Z 轴 360 度旋转。
URDF文件示例如下:
注意：(此代码真实应用时要把中文注释删除不然会报错)
<!--
需求: 创建机器人模型，底盘为长方体，
在长方体的前面添加一摄像头，
摄像头可以沿着 Z 轴 360 度旋转
-->
<robot name="mycar">
<!-- 1.底盘link -->
<link name="base_link">
<visual>
<geometry>
<box size="0.5 0.2 0.1" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="blue">
<color rgba="0 0 1.0 0.5" />
</material>
</visual>
</link>
<!-- 2.摄像头link -->
<link name="camera">
<visual>
<geometry>
<box size="0.02 0.05 0.05" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="red">
<color rgba="1 0 0 0.5" />
</material>
</visual>
</link>
<!-- 3.关节 -->
<joint name="camera2baselink" type="continuous">
<!-- 父级link -->
<parent link="base_link" />
<!-- 子级link -->
<child link="camera" />
<!-- 设置偏移量 -->
<origin xyz="0.2 0 0.075" rpy="0 0 0" />
<!-- 设置关节旋转参考的坐标轴 -->
<axis xyz="0 0 1" />
</joint>
</robot>
使用joint_state_publisher_gui之前需要安装。
sudo apt-get install ros-melodic-joint-state-publisher-gui
--------------------------------------------------------------------------------
sudo apt-get install ros-kinetic-joint-state-publisher-gui
launch文件示例如下:
<launch>
<!-- 设置参数 -->
<param name="robot_description" textfile="$(find urdt01_rviz)/urdf/urdf/demo03_joint.urdf" />
<!-- 启动 rviz -->
<node pkg="rviz" type="rviz" name="rviz" args="-d $(find urdt01_rviz)/config/show_mycar.rviz" />
<!-- 添加关节状态发布节点 -->
<node pkg="joint_state_publisher" type="joint_state_publisher" name="joint_state_publisher" />
<!-- 添加机器人状态发布节点 -->
<node pkg="robot_state_publisher" type="robot_state_publisher" name="robot_state_publisher" />
<!-- 可选:用于控制关节运动的节点 -->
<node pkg="joint_state_publisher_gui" type="joint_state_publisher_gui" name="joint_state_publisher_gui" />
</launch>
PS:
1.状态发布节点在此是必须的:
<!-- 添加关节状态发布节点 -->
<node pkg="joint_state_publisher" type="joint_state_publisher" name="joint_state_publisher" />
<!-- 添加机器人状态发布节点 -->
<node pkg="robot_state_publisher" type="robot_state_publisher" name="robot_state_publisher" />
2.关节运动控制节点(可选)，会生成关节控制的UI，用于测试关节运动是否正常。
<!-- 可选:用于控制关节运动的节点 -->
<node pkg="joint_state_publisher_gui" type="joint_state_publisher_gui
base_footprint优化urdf
前面实现的机器人模型是半沉到地下的，因为默认情况下: 底盘的中心点位于地图原点上，所以会导致这种情况产生，可以使用的优化策略，将初始 link 设置为一个尺寸极小的 link(比如半径为 0.001m 的球体，或边长为 0.001m 的立方体)，然后再在初始 link 上添加底盘等刚体，这样实现，虽然仍然存在初始link半沉的现象，但是基本可以忽略了。这个初始 link 一般称之为 base_footprint
<robot name="mycar">
<!-- Add a link with a very small size,
and then de associate the initial link with the base_ Link,
the height of the joint is just the same as that of the base_ The sinking height is the same
-->
<link name="base_footprint">
<visual>
<geometry>
<box size="0.01 0.01 0.01" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="blue">
<color rgba="0 0 1.0 0.5" />
</material>
</visual>
</link>
<link name="base_link">
<visual>
<geometry>
<box size="0.3 0.2 0.1" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="blue">
<color rgba="0.8 0.5 0 0.5" />
</material>
</visual>
</link>
<joint name="base_link2base_footprint" type="fixed">
<parent link="base_footprint" />
<child link="base_link" />
<origin xyz="0 0 0.05" />
</joint>
<link name="camera">
<visual>
<geometry>
<box size="0.02 0.05 0.05" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="red">
<color rgba="0 0 1 0.5" />
</material>
</visual>
</link>
<!-- association base_footprint and base_link -->
<joint name="camera2baselink" type="continuous">
<parent link="base_link"/>
<child link="camera" />
<origin xyz="0.12 0 0.075" rpy="0 0 0" />
<axis xyz="0 0 1" />
</joint>
</robot>
遇到问题以及解决
问题1:
命令行输出如下错误提示
UnicodeEncodeError: 'ascii' codec can't encode characters in position 463-464: ordinal not in range(128)
[joint_state_publisher-3] process has died [pid 4443, exit code 1, cmd /opt/ros/melodic/lib/joint_state_publisher/joint_state_publisher __name:=joint_state_publisher __log:=/home/rosmelodic/.ros/log/b38967c0-0acb-11eb-aee3-0800278ee10c/joint_state_publisher-3.log].
log file: /home/rosmelodic/.ros/log/b38967c0-0acb-11eb-aee3-0800278ee10c/joint_state_publisher-3*.log
rviz中提示坐标变换异常，导致机器人部件显示结构异常
原因:编码问题导致的
解决:去除URDF中的中文注释
问题2:[ERROR] [1584370263.037038]: Could not find the GUI, install the 'joint_state_publisher_gui' package
解决:sudo apt-get install ros-kinetic-joint-state-publisher-gui
URDF练习
需求描述:
创建一个四轮圆柱状机器人模型，机器人参数如下,底盘为圆柱状，半径 10cm，高 8cm，四轮由两个驱动轮和两个万向支撑轮组成，两个驱动轮半径为 3.25cm,轮胎宽度1.5cm，两个万向轮为球状，半径 0.75cm，底盘离地间距为 1.5cm(与万向轮直径一致)
实现流程:
创建机器人模型可以分步骤实现
- 新建 urdf 文件，并与 launch 文件集成
- 搭建底盘
- 在底盘上添加两个驱动轮
- 在底盘上添加两个万向轮
<robot name="mycar">
<!-- set base_footprint -->
<link name="base_footprint">
<visual>
<geometry>
<sphere radius="0.001" />
</geometry>
</visual>
</link>
<!-- Add chassis -->
<!--
shape: cylinder
radius: 0.1m
length: 0.08m
-->
<link name="base_link">
<visual>
<geometry>
<cylinder radius="0.1" length="0.08" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="yellow">
<color rgba="0.8 0.5 0 0.5" />
</material>
</visual>
</link>
<!-- Add drive wheel -->
<!--
shape: cyliner
radius: 0.035
length: 0.015
-->
<link name="left_drive_wheel">
<visual>
<geometry>
<cylinder radius="0.0325" length="0.015" />
</geometry>
<origin xyz="0 0 0" rpy="1.5708 0 0" />
<material name="black">
<color rgba="0 0 0 1" />
</material>
</visual>
</link>
<link name="right_drive_wheel">
<visual>
<geometry>
<cylinder radius="0.035" length="0.015" />
</geometry>
<origin xyz="0 0 0" rpy="1.5708 0 0" />
<material name="black">
<color rgba="0 0 0 1" />
</material>
</visual>
</link>
<!-- Add Cardan wheel -->
<!--
shape: ball
radius: 0.0075m
-->
<link name="front_cardan_ball">
<visual>
<geometry>
<sphere radius="0.0075" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="black">
<color rgba="0 0 0 1" />
</material>
</visual>
</link>
<link name="back_cardan_ball">
<visual>
<geometry>
<sphere radius="0.0075" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="black">
<color rgba="0 0 0 1" />
</material>
</visual>
</link>
<!-- joint -->
<!-- joint base_footprint and base_link-->
<!--
chassis height 0.015m
z = length/2 + 0.015
-->
<joint name="base_link2base_footprint" type="fixed">
<parent link="base_footprint" />
<child link="base_link" />
<origin xyz="0 0 0.055" />
</joint>
<!-- joint base_link and whell -->
<!--
left
x= 0
y=0.1
z=0.055-0.0325=0.0225
-->
<joint name="left_drive_wheel2base_link" type="continuous">
<parent link="base_link" />
<child link="left_drive_wheel" />
<origin xyz="0 0.1 -0.0225" />
<axis xyz="0 1 0" />
</joint>
<joint name="right_drive_wheel2base_link" type="continuous">
<parent link="base_link" />
<child link="right_drive_wheel" />
<origin xyz="0 -0.1 -0.0225" />
<axis xyz="0 1 0" />
</joint>
<!-- joint base_link and whell -->
<!--
left
x= 0.08
y= 0
z=0.055-0.0075=0.0475
-->
<joint name="front_cardan_ball2base_link" type="continuous">
<parent link="base_link" />
<child link="front_cardan_ball" />
<origin xyz="0.08 0 -0.0475" />
<axis xyz="0 1 0" />
</joint>
<joint name="back_cardan_ball2base_link" type="continuous">
<parent link="base_link" />
<child link="back_cardan_ball" />
<origin xyz="-0.08 0 -0.0475" />
<axis xyz="0 1 0" />
</joint>
</robot>
URDF工具
在 ROS 中，提供了一些工具来方便 URDF 文件的编写，比如:
check_urdf命令可以检查复杂的 urdf 文件是否存在语法问题urdf_to_graphiz命令可以查看 urdf 模型结构，显示不同 link 的层级关系
当然，要使用工具之前，首先需要安装，安装命令:sudo apt install liburdfdom-tools
sudo apt autoremove'来卸载它(它们)。
check_urdf 语法检查
进入urdf文件所属目录，调用:check_urdf urdf文件，如果不抛出异常，说明文件合法,否则非法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YKnu72nV-1649728244969)(/media/zjh/48FD1B0C4A4CA998/交互_移动硬盘/ROS笔记/p/04_URDF文件检查_异常.png)]
urdf_to_graphiz 结构查看
进入urdf文件所属目录，调用:urdf_to_graphiz urdf文件，当前目录下会生成 pdf 文件
URDF优化_xacro
前面 URDF 文件构建机器人模型的过程中，存在若干问题。
问题1:在设计关节的位置时，需要按照一定的公式计算，公式是固定的，但是在 URDF 中依赖于人工计算，存在不便，容易计算失误，且当某些参数发生改变时，还需要重新计算。
问题2:URDF 中的部分内容是高度重复的，驱动轮与支撑轮的设计实现，不同轮子只是部分参数不同，形状、颜色、翻转量都是一致的，在实际应用中，构建复杂的机器人模型时，更是易于出现高度重复的设计，按照一般的编程涉及到重复代码应该考虑封装。
......
如果在编程语言中，可以通过变量结合函数直接解决上述问题，在 ROS 中，已经给出了类似编程的优化方案，称之为:Xacro
概念
Xacro 是 XML Macros 的缩写，Xacro 是一种 XML 宏语言，是可编程的 XML。
原理
Xacro 可以声明变量，可以通过数学运算求解，使用流程控制控制执行顺序，还可以通过类似函数的实现，封装固定的逻辑，将逻辑中需要的可变的数据以参数的方式暴露出去，从而提高代码复用率以及程序的安全性。
作用
较之于纯粹的 URDF 实现，可以编写更安全、精简、易读性更强的机器人模型文件，且可以提高编写效率。
另请参考:
Xacro_快速体验
目的:简单了解 xacro 的基本语法。
需求描述:
使用xacro优化上一节案例中驱动轮实现，需要使用变量封装底盘的半径、高度，使用数学公式动态计算底盘的关节点坐标，使用 Xacro 宏封装轮子重复的代码并调用宏创建两个轮子(注意: 在此，演示 Xacro 的基本使用，不必要生成合法的 URDF )。
准备:
创建功能包，导入 urdf 与 xacro。
Xacro文件编写
编写 Xacro 文件，以变量的方式封装属性(常量半径、高度、车轮半径...)，以函数的方式封装重复实现(车轮的添加)。
<robot name="mycar" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- 属性封装 -->
<xacro:property name="wheel_radius" value="0.0325" />
<xacro:property name="wheel_length" value="0.0015" />
<xacro:property name="PI" value="3.1415927" />
<xacro:property name="base_link_length" value="0.08" />
<xacro:property name="lidi_space" value="0.015" />
<!-- 宏 -->
<xacro:macro name="wheel_func" params="wheel_name flag" >
<link name="${wheel_name}_wheel">
<visual>
<geometry>
<cylinder radius="${wheel_radius}" length="${wheel_length}" />
</geometry>
<origin xyz="0 0 0" rpy="${PI / 2} 0 0" />
<material name="wheel_color">
<color rgba="0 0 0 0.3" />
</material>
</visual>
</link>
<!-- 3-2.joint -->
<joint name="${wheel_name}2link" type="continuous">
<parent link="base_link" />
<child link="${wheel_name}_wheel" />
<!--
x 无偏移
y 车体半径
z z= 车体高度 / 2 + 离地间距 - 车轮半径
-->
<origin xyz="0 ${0.1 * flag} ${(base_link_length / 2 + lidi_space - wheel_radius) * -1}" rpy="0 0 0" />
<axis xyz="0 1 0" />
</joint>
</xacro:macro>
<xacro:wheel_func wheel_name="left" flag="1" />
<xacro:wheel_func wheel_name="right" flag="-1" />
</robot>
Xacro文件转换成 urdf 文件
前提是打开roscre
命令行进入 xacro文件 所属目录，执行:rosrun xacro xacro xxx.xacro > xxx.urdf, 会将 xacro 文件解析为 urdf 文件，内容如下:
例如：
rosrun xacro xacro demo01_helloworld.xacro > demo01_helloworld.urdf
<?xml version="1.0" encoding="utf-8"?>
<!-- =================================================================================== -->
<!-- | This document was autogenerated by xacro from demo01_helloworld.xacro | -->
<!-- | EDITING THIS FILE BY HAND IS NOT RECOMMENDED | -->
<!-- =================================================================================== -->
<robot name="mycar">
<link name="left_wheel">
<visual>
<geometry>
<cylinder length="0.0015" radius="0.0325"/>
</geometry>
<origin rpy="1.57079635 0 0" xyz="0 0 0"/>
<material name="wheel_color">
<color rgba="0 0 0 0.3"/>
</material>
</visual>
</link>
<!-- 3-2.joint -->
<joint name="left2link" type="continuous">
<parent link="base_link"/>
<child link="left_wheel"/>
<!--
x 无偏移
y 车体半径
z z= 车体高度 / 2 + 离地间距 - 车轮半径
-->
<origin rpy="0 0 0" xyz="0 0.1 -0.0225"/>
<axis xyz="0 1 0"/>
</joint>
<link name="right_wheel">
<visual>
<geometry>
<cylinder length="0.0015" radius="0.0325"/>
</geometry>
<origin rpy="1.57079635 0 0" xyz="0 0 0"/>
<material name="wheel_color">
<color rgba="0 0 0 0.3"/>
</material>
</visual>
</link>
<!-- 3-2.joint -->
<joint name="right2link" type="continuous">
<parent link="base_link"/>
<child link="right_wheel"/>
<!--
x 无偏移
y 车体半径
z z= 车体高度 / 2 + 离地间距 - 车轮半径
-->
<origin rpy="0 0 0" xyz="0 -0.1 -0.0225"/>
<axis xyz="0 1 0"/>
</joint>
</robot>
Xacro_语法详解
xacro 提供了可编程接口，类似于计算机语言，包括变量声明调用、函数声明与调用等语法实现。在使用 xacro 生成 urdf 时，根标签robot中必须包含命名空间声明:xmlns:xacro="http://wiki.ros.org/xacro"
属性与算数运算
用于封装 URDF 中的一些字段，比如: PI 值，小车的尺寸，轮子半径 ....
属性定义
属性定义后必须调用才能生成urdf文件
<xacro:property name="xxxx" value="yyyy" />
属性调用
${属性名称}
算数运算
${数学表达式}
例子:
**属性定义**
<xacro:property name="PI" value="3.1415926" />
**属性调用**
<myexample name="${PI}" />
**算数运算**
<myexampleresult result="${PI/2}" />
宏
类似于函数实现，提高代码复用率，优化代码结构，提高安全性
宏定义
<xacro:macro name="宏名称" params="参数列表(多参数之间使用空格分隔)">
.....
参数调用格式: ${参数名}
</xacro:macro>
宏调用
<xacro:宏名称 参数1=xxx 参数2=xxx/>
例子：
<robot name="mycar" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- 1.宏的定义 -->
<xacro:macro name="getSum" params="num1 num2">
<result value="${num1+num2}" />
</xacro:macro>
<!-- 2.宏调用 -->
<xacro:getSum num1="1" num2="2" />
</robot>
生成的urdf文件:
<robot name="mycar">
<result value="3"/>
</robot>
文件包含
机器人由多部件组成，不同部件可能封装为单独的 xacro 文件，最后再将不同的文件集成，组合为完整机器人，可以使用文件包含实现
文件包含
<robot name="xxx" xmlns:xacro="http://wiki.ros.org/xacro">
<xacro:include filename="my_base.xacro" />
<xacro:include filename="my_camera.xacro" />
<xacro:include filename="my_laser.xacro" />
....
</robot>
Xacro_完整使用流程示例
需求描述:
使用 Xacro 优化 URDF 版的小车底盘模型实现
编写 Xacro 文件
<robot name="mycar" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- set base_footprint -->
<xacro:property name="footprint_radius" value="0.001" />
<link name="base_footprint">
<visual>
<geometry
<sphere radius="${footprint_radius}" />
</geometry>
</visual>
</link>
<!-- Add chassis -->
<!-- define property -->
<xacro:property name="base_radius" value="0.1" />
<xacro:property name="base_length" value="0.08" />
<xacro:property name="lidi" value="0.015" />
<xacro:property name="base_joint" value="${base_length/2+lidi}" />
<link name="base_link">
<visual>
<geometry>
<cylinder radius="${base_radius}" length="${base_length}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="yellow">
<color rgba="0.8 0.5 0 0.5" />
</material>
</visual>
</link>
<!-- joint -->
<joint name="base_link2base_footprint" type="fixed">
<parent link="base_footprint" />
<child link="base_link" />
<origin xyz="0 0 ${base_joint}" />
</joint>
<!-- Add drive wheel -->
<!--
shape: cyliner
radius: 0.035
length: 0.015
-->
<xacro:property name="wheel_radius" value="0.0325" />
<xacro:property name="wheel_length" value="0.015" />
<xacro:property name="PI" value="${3.1415926/2}" />
<xacro:property name="base_rjoint_z" value="${-(base_length/2 + lidi - wheel_radius) }" />
<!-- define macro
wheel_name: left or right
flag: -1 or 1
-->
<xacro:macro name="wheel_func" params="wheel_name flag">
<link name="${wheel_name}_wheel">
<visual>
<geometry>
<cylinder radius="${wheel_radius}" length="${wheel_length}" />
</geometry>
<origin xyz="0 0 0" rpy="${PI} 0 0" />
<material name="black">
<color rgba="0 0 0 1" />
</material>
</visual>
</link>
<!-- joint base_link and whell -->
<joint name="${wheel_name}2base_link" type="continuous">
<parent link="base_link" />
<child link="${wheel_name}_wheel" />
<origin xyz="0 ${0.1*flag} ${base_rjoint_z}" />
<axis xyz="0 1 0" />
</joint>
</xacro:macro>
<!-- call macro-->
<xacro:wheel_func wheel_name="left" flag="1" />
<xacro:wheel_func wheel_name="right" flag="-1" />
<!-- Add Cardan wheel -->
<!-- define property -->
<xacro:property name="ball_radius" value="0.0075" />
<xacro:property name="ball_distance" value="0.08" />
<xacro:property name="ball_hight" value="${-(base_length/2+lidi-ball_radius)}" />
<!-- define macro
cardan_ball_name: front or back
flag: 1 or -1
-->
<xacro:macro name="cardan_ball_func" params="cardan_ball_name flag">
<link name="${cardan_ball_name}_cardan_ball">
<visual>
<geometry>
<sphere radius="${ball_radius}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="black">
<color rgba="0 0 0 1" />
</material>
</visual>
</link>
<!-- joint base_link and whell -->
<joint name="${cardan_ball_name}2base_link" type="continuous">
<parent link="base_link" />
<child link="${cardan_ball_name}_cardan_ball" />
<origin xyz="${flag*ball_distance} 0 ${ball_hight}" />
<axis xyz="0 1 0" />
</joint>
</xacro:macro>
<!-- call macro -->
<xacro:cardan_ball_func cardan_ball_name="front" flag="1" />
<xacro:cardan_ball_func cardan_ball_name="back" flag="-1" />
</robot>
集成launch文件
方式1:先将 xacro 文件转换出 urdf 文件，然后集成
先将 xacro 文件解析成 urdf 文件:rosrun xacro xacro xxx.xacro > xxx.urdf然后再按照之前的集成方式直接整合 launch 文件,内容示例:
核心代码:
<launch>
<param name="robot_description" textfile="$(find demo01_urdf_helloworld)/urdf/xacro/my_base.urdf" />
<node pkg="rviz" type="rviz" name="rviz" args="-d $(find demo01_urdf_helloworld)/config/helloworld.rviz" />
<node pkg="joint_state_publisher" type="joint_state_publisher" name="joint_state_publisher" output="screen" />
<node pkg="robot_state_publisher" type="robot_state_publisher" name="robot_state_publisher" output="screen" />
<node pkg="joint_state_publisher_gui" type="joint_state_publisher_gui" name="joint_state_publisher_gui" output="screen" />
</launch>
方式2:在 launch 文件中直接加载 xacro(建议使用)
<launch>
<!-- 设置参数 -->
<param name="robot_description" command="$(find xacro)/xacro $(find urdt01_rviz)/urdf/xacro/demo02_car.urdf.xacro" />
<!-- 启动 rviz -->
<node pkg="rviz" type="rviz" name="rviz" args="-d $(find urdt01_rviz)/config/show_mycar.rviz" />
<!-- 添加关节状态发布节点 -->
<node pkg="joint_state_publisher" type="joint_state_publisher" name="joint_state_publisher" />
<!-- 添加机器人状态发布节点 -->
<node pkg="robot_state_publisher" type="robot_state_publisher" name="robot_state_publisher" />
<!-- 添加控制关节运动节点 -->
<node pkg="joint_state_publisher_gui" type="joint_state_publisher_gui" name="joint_state_publisher_gui" />
</launch>
核心代码:
<param name="robot_description" command="$(find xacro)/xacro $(find urdt01_rviz)/urdf/xacro/demo02_car.urdf.xacro" />
加载robot_description时使用command属性，属性值就是调用 xacro 功能包的 xacro 程序直接解析 xacro 文件。
Xacro_实操
需求描述:
在前面小车底盘基础之上，添加摄像头和雷达传感器。
实现分析:
机器人模型由多部件组成，可以将不同组件设置进单独文件，最终通过文件包含实现组件的拼装。
实现流程:
- 首先编写摄像头和雷达的 xacro 文件
- 然后再编写一个组合文件，组合底盘、摄像头与雷达
- 最后，通过 launch 文件启动 Rviz 并显示模型
摄像头 xacro 文件:
<robot name="mycamera" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- Add chassis -->
<!-- define property -->
<xacro:property name="camera_length" value="0.01" />
<xacro:property name="camera_width" value="0.025" />
<xacro:property name="camera_height" value="0.025" />
<xacro:property name="camera_x" value="0.08" />
<xacro:property name="camera_y" value="0.0" />
<xacro:property name="camera_z" value="${base_length/2 + camera_height/2}" />
<link name="camera">
<visual>
<geometry>
<box size="${camera_length} ${camera_width} ${camera_height}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="black">
<color rgba="0 0 0 1" />
</material>
</visual>
</link>
<!-- joint -->
<joint name="camera2base_footprint" type="fixed">
<parent link="base_link" />
<child link="camera" />
<origin xyz="${camera_x} ${camera_y} ${camera_z}" />
</joint>
</robot>
雷达 xacro 文件:
组合底盘摄像头与雷达的 xacro 文件
<robot name="mycar" xmlns:xacro="http://wiki.ros.org/xacro">
<xacro:include filename="demo02_car.urdf.xacro" />
<xacro:include filename="demo02_camera.urdf.xacro" />
<xacro:include filename="demo02_laser.urdf.xacro" />
</robot>
launch 文件
<launch>
<!-- 设置参数 -->
<param name="robot_description" command="$(find xacro)/xacro $(find urdt01_rviz)/urdf/xacro/merge.urdf.xacro" />
<!-- 启动 rviz -->
<node pkg="rviz" type="rviz" name="rviz" args="-d $(find urdt01_rviz)/config/show_mycar.rviz" />
<!-- 添加关节状态发布节点 -->
<node pkg="joint_state_publisher" type="joint_state_publisher" name="joint_state_publisher" />
<!-- 添加机器人状态发布节点 -->
<node pkg="robot_state_publisher" type="robot_state_publisher" name="robot_state_publisher" />
<!-- 添加控制关节运动节点 -->
<node pkg="joint_state_publisher_gui" type="joint_state_publisher_gui" name="joint_state_publisher_gui" />
</launch>
Rviz中控制机器人模型运动
通过 URDF 结合 rviz 可以创建并显示机器人模型，不过，当前实现的只是静态模型，如何控制模型的运动呢？在此，可以调用 Arbotix 实现此功能。
简介
Arbotix:Arbotix 是一款控制电机、舵机的控制板，并提供相应的 ros 功能包，这个功能包的功能不仅可以驱动真实的 Arbotix 控制板，它还提供一个差速控制器，通过接受速度控制指令更新机器人的 joint 状态，从而帮助我们实现机器人在 rviz 中的运动。
这个差速控制器在 arbotix_python 程序包中，完整的 arbotix 程序包还包括多种控制器，分别对应 dynamixel 电机、多关节机械臂以及不同形状的夹持器。
Arbotix使用流程
接下来，通过一个案例演示 arbotix 的使用。
需求描述:
控制机器人模型在 rviz 中做圆周运动
实现流程:
- 安装 Arbotix
- 创建新功能包，准备机器人 urdf、xacro 文件
- 添加 Arbotix 配置文件
- 编写 launch 文件配置 Arbotix
- 启动 launch 文件并控制机器人模型运动
安装 Arbotix
方式1:命令行调用
sudo apt-get install ros-<<VersionName()>>-arbotix
将 <<VsersionName()>> 替换成当前 ROS 版本名称，如果提示功能包无法定位，请采用方式2。
方式2:源码安装
先从 github 下载源码，然后调用 catkin_make 编译
git clone https://github.com/vanadiumlabs/arbotix_ros.git
下载好的arbotix_ros文件夹 复制到 工作空间src目录中
创建新功能包，准备机器人 urdf、xacro
urdf 和 xacro 调用上一讲实现即可
添加 arbotix 所需的配置文件
添加 arbotix 所需配置文件.yaml文件
# 该文件是控制器配置,一个机器人模型可能有多个控制器，比如: 底盘、机械臂、夹持器(机械手)....
# 因此，根 name 是 controller
controllers: {
# 单控制器设置
base_controller: {
#类型: 差速控制器
type: diff_controller,
#参考坐标
base_frame_id: base_footprint,
#两个轮子之间的间距
base_width: 0.2,
#控制频率
ticks_meter: 2000,
#PID控制参数，使机器人车轮快速达到预期速度
Kp: 12,
Kd: 12,
Ki: 0,
Ko: 50,
#加速限制
accel_limit: 1.0
}
}
launch 文件中配置 arbotix 节点
launch 示例代码
<node name="arbotix" pkg="arbotix_python" type="arbotix_driver" output="screen">
<rosparam file="$(find my_urdf05_rviz)/config/hello.yaml" command="load" />
<param name="sim" value="true" />
</node>
代码解释:
启动 launch 文件并控制机器人模型运动
**启动launch: oslaunch xxxx ....launch
配置 rviz:
控制小车运动:
此时调用 rostopic list 会发现一个熟悉的话题: /cmd_vel
也就说我们可以发布 cmd_vel 话题消息控制小陈运动了，该实现策略有多种，可以另行编写节点，或者更简单些可以直接通过如下命令发布消息:
rostopic pub -r 10 /cmd_vel geometry_msgs/Twist '{linear: {x: 0.2, y: 0, z: 0}, angular: {x: 0, y: 0, z: 0.5}}'
现在，小车就可以运动起来了。
另请参考:
URDF集成Gazebo
URDF 需要集成进 Rviz 或 Gazebo 才能显示可视化的机器人模型，前面已经介绍了URDF 与 Rviz 的集成，本节主要介绍:
- URDF 与 Gazebo 的基本集成流程；
- 如果要在 Gazebo 中显示机器人模型，URDF 需要做的一些额外配置；
- 关于Gazebo仿真环境的搭建。
URDF与Gazebo基本集成流程
URDF 与 Gazebo 集成流程与 Rviz 实现类似，主要步骤如下:
- 创建功能包，导入依赖项
- 编写 URDF 或 Xacro 文件
- 启动 Gazebo 并显示机器人模型
创建功能包
创建新功能包，导入依赖包: urdf、xacro、gazebo_ros、gazebo_ros_control、gazebo_plugins
编写URDF文件
<robot name="mycar">
<link name="base_link">
<visual>
<geometry>
<box size="0.5 0.3 0.1" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
<material name="yellow">
<color rgba="0.5 0.3 0 0.5" />
</material>
</visual>
<!-- set collision -->
<!-- if it is standard geometry, copy geometry and origin of visual directly-->
<collision>
<geometry>
<box size="0.5 0.3 0.1" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
</collision>
<!-- set inertial -->
<inertial>
<origin xyz="0 0 0" />
<mass value="2" />
<inertia ixx="1" ixy="0" ixz="0" iyy="1" iyz="0" izz="1" />
</inertial>
</link>
<!-- gazebo has its own color setting label -->
<gazebo reference="base_link">
<material>Gazebo/Red</material>
</gazebo>
</robot>
注意， 当 URDF 需要与 Gazebo 集成时，和 Rviz 有明显区别:
1.必须使用 collision 标签，因为既然是仿真环境，那么必然涉及到碰撞检测，collision 提供碰撞检测的依据。
2.必须使用 inertial 标签，此标签标注了当前机器人某个刚体部分的惯性矩阵，用于一些力学相关的仿真计算。
3.颜色设置，也需要重新使用 gazebo 标签标注，因为之前的颜色设置为了方便调试包含透明度，仿真环境下没有此选项。
启动Gazebo并显示模型
launch 文件实现:
<launch>
<!-- 将 Urdf 文件的内容加载到参数服务器 -->
<param name="robot_description" textfile="$(find urdf02_gazebo)/urdf/demo01_helloworld.urdf" />
<!-- 启动 gazebo -->
<include file="$(find gazebo_ros)/launch/empty_world.launch" />
<!-- 在 gazebo 中显示机器人模型 -->
<node pkg="gazebo_ros" type="spawn_model" name="model" args="-urdf -model mycar -param robot_description" />
</launch>
代码解释:
<include file="$(find gazebo_ros)/launch/empty_world.launch" />
<!-- 启动 Gazebo 的仿真环境，当前环境为空环境 -->
<node pkg="gazebo_ros" type="spawn_model" name="model" args="-urdf -model mycar -param robot_description" />
<!--
在 Gazebo 中加载一个机器人模型，该功能由 gazebo_ros 下的 spawn_model 提供:
-urdf 加载的是 urdf 文件
-model mycar 模型名称是 mycar
-param robot_description 从参数 robot_description 中载入模型
-x 模型载入的 x 坐标
-y 模型载入的 y 坐标
-z 模型载入的 z 坐标
-->
URDF集成Gazebo相关设置
较之于 rviz，gazebo在集成 URDF 时，需要做些许修改，比如:必须添加 collision 碰撞属性相关参数、必须添加 inertial 惯性矩阵相关参数，另外，如果直接移植 Rviz 中机器人的颜色设置是没有显示的，颜色设置也必须做相应的变更。
collision
如果机器人link是标准的几何体形状，和link的 visual 属性设置一致即可。
inertial
惯性矩阵的设置需要结合link的质量与外形参数动态生成，标准的球体、圆柱与立方体的惯性矩阵公式如下(已经封装为 xacro 实现):
球体惯性矩阵
<!-- Macro for inertia matrix -->
<xacro:macro name="sphere_inertial_matrix" params="m r">
<inertial>
<mass value="${m}" />
<inertia ixx="${2*m*r*r/5}" ixy="0" ixz="0"
iyy="${2*m*r*r/5}" iyz="0"
izz="${2*m*r*r/5}" />
</inertial>
</xacro:macro>
圆柱惯性矩阵
<xacro:macro name="cylinder_inertial_matrix" params="m r h">
<inertial>
<mass value="${m}" />
<inertia ixx="${m*(3*r*r+h*h)/12}" ixy = "0" ixz = "0"
iyy="${m*(3*r*r+h*h)/12}" iyz = "0"
izz="${m*r*r/2}" />
</inertial>
</xacro:macro>
立方体惯性矩阵
<xacro:macro name="Box_inertial_matrix" params="m l w h">
<inertial>
<mass value="${m}" />
<inertia ixx="${m*(h*h + l*l)/12}" ixy = "0" ixz = "0"
iyy="${m*(w*w + l*l)/12}" iyz= "0"
izz="${m*(w*w + h*h)/12}" />
</inertial>
</xacro:macro>
需要注意的是，原则上，除了 base_footprint 外，机器人的每个刚体部分都需要设置惯性矩阵，且惯性矩阵必须经计算得出，如果随意定义刚体部分的惯性矩阵，那么可能会导致机器人在 Gazebo 中出现抖动，移动等现象。
颜色设置
在 gazebo 中显示 link 的颜色，必须要使用指定的标签:
<gazebo reference="link节点名称">
<material>Gazebo/Blue</material>
</gazebo>
PS：material 标签中，设置的值区分大小写，颜色可以设置为 Red Blue Green Black .....
URDF集成Gazebo实操
需求描述:
将之前的机器人模型(xacro版)显示在 gazebo 中
实现流程:
- 需要编写封装惯性矩阵算法的 xacro 文件
- 为机器人模型中的每一个 link 添加 collision 和 inertial 标签，并且重置颜色属性
- 在 launch 文件中启动 gazebo 并添加机器人模型
编写封装惯性矩阵算法的 xacro 文件head.xacro
<robot name="base" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- Macro for inertia matrix -->
<xacro:macro name="sphere_inertial_matrix" params="m r">
<inertial>
<mass value="${m}" />
<inertia ixx="${2*m*r*r/5}" ixy="0" ixz="0"
iyy="${2*m*r*r/5}" iyz="0"
izz="${2*m*r*r/5}" />
</inertial>
</xacro:macro>
<xacro:macro name="cylinder_inertial_matrix" params="m r h">
<inertial>
<mass value="${m}" />
<inertia ixx="${m*(3*r*r+h*h)/12}" ixy = "0" ixz = "0"
iyy="${m*(3*r*r+h*h)/12}" iyz = "0"
izz="${m*r*r/2}" />
</inertial>
</xacro:macro>
<xacro:macro name="Box_inertial_matrix" params="m l w h">
<inertial>
<mass value="${m}" />
<inertia ixx="${m*(h*h + l*l)/12}" ixy = "0" ixz = "0"
iyy="${m*(w*w + l*l)/12}" iyz= "0"
izz="${m*(w*w + h*h)/12}" />
</inertial>
</xacro:macro>
</robot>
复制相关 xacro 文件，并设置 collision inertial 以及 color 等参数
A.底盘 Xacro 文件demo02_car.urdf.xacro
<robot name="mycar" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- set base_footprint -->
<xacro:property name="footprint_radius" value="0.001" />
<link name="base_footprint">
<visual>
<geometry>
<sphere radius="${footprint_radius}" />
</geometry>
</visual>
</link>
<!-- Add chassis -->
<!-- define property -->
<xacro:property name="base_radius" value="0.1" />
<xacro:property name="base_length" value="0.08" />
<xacro:property name="base_mass" value="3" />
<xacro:property name="lidi" value="0.015" />
<xacro:property name="base_joint" value="${base_length/2+lidi}" />
<link name="base_link">
<visual>
<geometry>
<cylinder radius="${base_radius}" length="${base_length}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
</visual>
<!-- gazebo...collosion -->
<collision>
<geometry>
<cylinder radius="${base_radius}" length="${base_length}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
</collision>
<!-- gazebo...call inertia matrix function -->
<xacro:cylinder_inertial_matrix m="${base_mass}" r="${base_radius}" h="${base_length}" />
</link>
<!--gazebo...set color -->
<gazebo reference="base_link">
<material>Gazebo/Yellow</material>
</gazebo>
<!-- joint -->
<joint name="base_link2base_footprint" type="fixed">
<parent link="base_footprint" />
<child link="base_link" />
<origin xyz="0 0 ${base_joint}" />
</joint>
<!-- Add drive wheel -->
<!--
shape: cyliner
radius: 0.035
length: 0.015
mass:0.5
-->
<xacro:property name="wheel_radius" value="0.0325" />
<xacro:property name="wheel_length" value="0.015" />
<xacro:property name="wheel_mass" value="0.05" />
<xacro:property name="PI" value="${3.1415926/2}" />
<xacro:property name="base_rjoint_z" value="${-(base_length/2 + lidi - wheel_radius) }" />
<!-- define macro
wheel_name: left or right
flag: -1 or 1
-->
<xacro:macro name="wheel_func" params="wheel_name flag">
<link name="${wheel_name}_wheel">
<visual>
<geometry>
<cylinder radius="${wheel_radius}" length="${wheel_length}" />
</geometry>
<origin xyz="0 0 0" rpy="${PI} 0 0" />
<material name="black">
<color rgba="0 0 0 1" />
</material>
</visual>
<!-- gazebo...collosion -->
<collision>
<geometry>
<cylinder radius="${wheel_radius}" length="${wheel_length}" />
</geometry>
<origin xyz="0 0 0" rpy="${PI} 0 0" />
</collision>
<!-- gazebo...call inertia matrix function -->
<xacro:cylinder_inertial_matrix m="${wheel_mass}" r="${wheel_radius}" h="${wheel_length}" />
</link>
<!--gazebo...set color -->
<gazebo reference="${wheel_name}_wheel">
<material>Gazebo/Red</material>
</gazebo>
<!-- joint base_link and whell -->
<joint name="${wheel_name}2base_link" type="continuous">
<parent link="base_link" />
<child link="${wheel_name}_wheel" />
<origin xyz="0 ${0.1*flag} ${base_rjoint_z}" />
<axis xyz="0 1 0" />
</joint>
</xacro:macro>
<!-- call macro-->
<xacro:wheel_func wheel_name="left" flag="1" />
<xacro:wheel_func wheel_name="right" flag="-1" />
<!-- Add Cardan wheel -->
<!-- define property -->
<xacro:property name="ball_radius" value="0.0075" />
<xacro:property name="ball_distance" value="0.08" />
<xacro:property name="ball_mass" value="0.1" />
<xacro:property name="ball_hight" value="${-(base_length/2+lidi-ball_radius)}" />
<!-- define macro
cardan_ball_name: front or back
flag: 1 or -1
-->
<xacro:macro name="cardan_ball_func" params="cardan_ball_name flag">
<link name="${cardan_ball_name}_cardan_ball">
<visual>
<geometry>
<sphere radius="${ball_radius}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
</visual>
<!-- gazebo...collision -->
<collision>
<geometry>
<sphere radius="${ball_radius}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
</collision>
<!-- gazebo...call inertia matrix function -->
<xacro:sphere_inertial_matrix m="${ball_mass}" r="${ball_radius}" />
</link>
<!--gazebo...set color -->
<gazebo reference="${cardan_ball_name}_cardan_ball">
<material>Gazebo/Red</material>
</gazebo>
<!-- joint base_link and whell -->
<joint name="${cardan_ball_name}2base_link" type="continuous">
<parent link="base_link" />
<child link="${cardan_ball_name}_cardan_ball" />
<origin xyz="${flag*ball_distance} 0 ${ball_hight}" />
<axis xyz="0 1 0" />
</joint>
</xacro:macro>
<!-- call macro -->
<xacro:cardan_ball_func cardan_ball_name="front" flag="1" />
<xacro:cardan_ball_func cardan_ball_name="back" flag="-1" />
</robot>
注意: 如果机器人模型在 Gazebo 中产生了抖动，滑动，缓慢位移 .... 诸如此类情况，请查看
- 惯性矩阵是否设置了，且设置是否正确合理
- 车轮翻转需要依赖于 PI 值，如果 PI 值精度偏低，也可能导致上述情况产生
B.摄像头 Xacro 文件demo02_camera.urdf.xacro
<robot name="mycamera" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- Add chassis -->
<!-- define property -->
<xacro:property name="camera_mass" value="0.1" />
<xacro:property name="camera_length" value="0.01" />
<xacro:property name="camera_width" value="0.025" />
<xacro:property name="camera_height" value="0.025" />
<xacro:property name="camera_x" value="0.08" />
<xacro:property name="camera_y" value="0.0" />
<xacro:property name="camera_z" value="${base_length/2 + camera_height/2}" />
<link name="camera">
<visual>
<geometry>
<box size="${camera_length} ${camera_width} ${camera_height}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
</visual>
<!-- gazebo...collision -->
<collision>
<geometry>
<box size="${camera_length} ${camera_width} ${camera_height}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
</collision>
<!-- gazebo...call inertia matrix function -->
<xacro:Box_inertial_matrix m="${camera_mass}" l="${camera_length}" w="${camera_width}" h="${camera_height}" />
</link>
<!--gazebo...set color -->
<gazebo reference="camera">
<material>Gazebo/Blue</material>
</gazebo>
<!-- joint -->
<joint name="camera2base_footprint" type="fixed">
<parent link="base_link" />
<child link="camera" />
<origin xyz="${camera_x} ${camera_y} ${camera_z}" />
</joint>
</robot>
C.雷达 Xacro 文件demo02_laser.urdf.xacro
<robot name="mylaser" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- Add support -->
<!-- define property -->
<xacro:property name="support_radius" value="0.01" />
<xacro:property name="support_length" value="0.15" />
<xacro:property name="support_mass" value="0.05" />
<xacro:property name="support_x" value="0.0" />
<xacro:property name="support_y" value="0.0" />
<xacro:property name="support_z" value="${base_length/2 + support_length/2}" />
<link name="support">
<visual>
<geometry>
<cylinder radius="${support_radius}" length="${support_length}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
</visual>
<!-- gazebo...collision -->
<collision>
<geometry>
<cylinder radius="${support_radius}" length="${support_length}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
</collision>
<!-- gazebo...call inertia matrix function -->
<xacro:cylinder_inertial_matrix m="${support_mass}" r="${support_radius}" h="${support_length}" />
</link>
<!-- joint -->
<joint name="support2base_link" type="fixed">
<parent link="base_link" />
<child link="support" />
<origin xyz="${support_x} ${support_y} ${support_z}" />
</joint>
<!-- Add laser -->
<!-- define property -->
<xacro:property name="laser_radius" value="0.03" />
<xacro:property name="laser_length" value="0.05" />
<xacro:property name="laser_mass" value="0.05" />
<xacro:property name="laser_x" value="0.0" />
<xacro:property name="laser_y" value="0.0" />
<xacro:property name="laser_z" value="${support_length + laser_length/2}" />
<link name="laser">
<visual>
<geometry>
<cylinder radius="${laser_radius}" length="${laser_length}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
</visual>
<!-- gazebo...collision -->
<collision>
<geometry>
<cylinder radius="${laser_radius}" length="${laser_length}" />
</geometry>
<origin xyz="0 0 0" rpy="0 0 0" />
</collision>
<!-- gazebo...call inertia matrix function -->
<xacro:cylinder_inertial_matrix m="${laser_mass}" r="${laser_radius}" h="${laser_length}" />
</link>
<!--gazebo...set color -->
<gazebo reference="laser">
<material>Gazebo/Black</material>
</gazebo>
<!-- joint -->
<joint name="laser2base_link" type="fixed">
<parent link="base_link" />
<child link="laser" />
<origin xyz="${laser_x} ${laser_y} ${laser_z}" />
</joint>
</robot>
D.组合底盘、摄像头与雷达的 Xacro 文件
<robot name="mycar" xmlns:xacro="http://wiki.ros.org/xacro">
<xacro:include filename="head.xacro" />
<xacro:include filename="demo02_car.urdf.xacro" />
<xacro:include filename="demo02_camera.urdf.xacro" />
<xacro:include filename="demo02_laser.urdf.xacro" />
</robot>
在 gazebo 中执行
launch 文件:
<launch>
<!-- 将 Urdf 文件的内容加载到参数服务器 -->
<param name="robot_description" command="$(find xacro)/xacro $(find urdf02_gazebo)/urdf/merge.urdf.xacro" />
<!-- 启动 gazebo -->
<include file="$(find gazebo_ros)/launch/empty_world.launch" />
<!-- 在 gazebo 中显示机器人模型 -->
<node pkg="gazebo_ros" type="spawn_model" name="model" args="-urdf -model mycar -param robot_description" />
</launch>
Gazebo仿真环境搭建
到目前为止，我们已经可以将机器人模型显示在 Gazebo 之中了，但是当前默认情况下，在 Gazebo 中机器人模型是在 empty world 中，并没有类似于房间、家具、道路、树木... 之类的仿真物，如何在 Gazebo 中创建仿真环境呢？
Gazebo 中创建仿真实现方式有两种:
- 方式1: 直接添加内置组件创建仿真环境
- 方式2: 手动绘制仿真环境(更为灵活)
也还可以直接下载使用官方或第三方提高的仿真环境插件。
添加内置组件创建仿真环境
1.1启动 Gazebo 并添加组件
保存仿真环境
添加完毕后，选择 file ---> Save World as 选择保存路径(功能包下: worlds 目录)，文件名自定义，后缀名设置为 .world
加载已经建好的.world文件
1.在工程中创建world文件夹，将创建好的world文件放入文件夹中
2.编辑launch文件demo03_environment.launch
<launch>
<!-- 将 Urdf 文件的内容加载到参数服务器 -->
<param name="robot_description" command="$(find xacro)/xacro $(find urdf02_gazebo)/urdf/merge.urdf.xacro" />
<!-- 启动 gazebo -->
<include file="$(find gazebo_ros)/launch/empty_world.launch" >
<arg name="world_name" value="$(find urdf02_gazebo)/worlds/box_house.world" />
</include>
<!-- 在 gazebo 中显示机器人模型 -->
<node pkg="gazebo_ros" type="spawn_model" name="model" args="-urdf -model mycar -param robot_description" />
</launch>
注意：arg name="world_name" ,此处名字不能随便命名，要与已经创建好的.world文件里面的名字一致
<arg name="world_name" value="$(find urdf02_gazebo)/worlds/box_house.world" />
3.运行launch文件并查看gazebo
核心代码: 启动 empty_world 后，再根据arg加载自定义的仿真环境
<!-- 启动 gazebo -->
<include file="$(find gazebo_ros)/launch/empty_world.launch" >
<arg name="world_name" value="$(find urdf02_gazebo)/worlds/box_house.world" />
自定义仿真环境
启动 gazebo 打开构建面板，绘制仿真环境
保存构建的环境
点击: 左上角 file ---> Save (保存路径功能包下的: models)
然后 file ---> Exit Building Editor
保存为 world 文件
可以像方式1一样再添加一些插件，然后保存为 world 文件(保存路径功能包下的: worlds)
启动
同方式1
使用官方提供的插件
当前 Gazebo 提供的仿真道具有限，还可以下载官方支持，可以提供更为丰富的仿真实现，具体实现如下:
下载官方模型库
git clone https://github.com/osrf/gazebo_models
之前是:hg clone https://bitbucket.org/osrf/gazebo_models但是已经不可用
注意: 此过程可能比较耗时
将模型库复制进 gazebo
将得到的gazebo_models文件夹内容复制到 /usr/share/gazebo-*/models
应用
重启 Gazebo，选择左侧菜单栏的 insert 可以选择并插入相关道具了
URDF、Gazebo与Rviz综合应用
关于URDF(Xacro)、Rviz 和 Gazebo 三者的关系，前面已有阐述: URDF 用于创建机器人模型、Rviz 可以显示机器人感知到的环境信息，Gazebo 用于仿真，可以模拟外界环境，以及机器人的一些传感器，如何在 Gazebo 中运行这些传感器，并显示这些传感器的数据(机器人的视角)呢？本节主要介绍的重点就是将三者结合:通过 Gazebo 模拟机器人的传感器，然后在 Rviz 中显示这些传感器感知到的数据。主要内容包括:
- 运动控制以及里程计信息显示
- 雷达信息仿真以及显示
- 摄像头信息仿真以及显示
- kinect 信息仿真以及显示
另请参考:
机器人运动控制以及里程计信息显示
gazebo 中已经可以正常显示机器人模型了，那么如何像在 rviz 中一样控制机器人运动呢？在此，需要涉及到ros中的组件: ros_control。
ros_control 简介
接口
场景:同一套 ROS 程序，如何部署在不同的机器人系统上，比如：开发阶段为了提高效率是在仿真平台上测试的，部署时又有不同的实体机器人平台，不同平台的实现是有差异的，如何保证 ROS 程序的可移植性？ROS 内置的解决方式是 ros_control。
ros_control:是一组软件包，它包含了控制器接口，控制器管理器，传输和硬件接口。ros_control 是一套机器人控制的中间件，是一套规范，不同的机器人平台只要按照这套规范实现，那么就可以保证 与ROS 程序兼容，通过这套规范，实现了一种可插拔的架构设计，大大提高了程序设计的效率与灵活性。
gazebo 已经实现了 ros_control 的相关接口，如果需要在 gazebo 中控制机器人运动，直接调用相关接口即可
运动控制实现流程(Gazebo)
承上，运动控制基本流程:
- 已经创建完毕的机器人模型，编写一个单独的 xacro 文件，为机器人模型添加传动装置以及控制器
- 将此文件集成进xacro文件
- 启动 Gazebo 并发布 /cmd_vel 消息控制机器人运动
为 joint 添加传动装置以及控制器
两轮差速配置
更多配置：
http://gazebosim.org/tutorials?tut=ros_gzplugins
<robot name="my_car_move" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- 传动实现:用于连接控制器与关节 -->
<xacro:macro name="joint_trans" params="joint_name">
<!-- Transmission is important to link the joints and the controller -->
<transmission name="${joint_name}_trans">
<type>transmission_interface/SimpleTransmission</type>
<joint name="${joint_name}">
<hardwareInterface>hardware_interface/VelocityJointInterface</hardwareInterface>
</joint>
<actuator name="${joint_name}_motor">
<hardwareInterface>hardware_interface/VelocityJointInterface</hardwareInterface>
<mechanicalReduction>1</mechanicalReduction>
</actuator>
</transmission>
</xacro:macro>
<!-- 每一个驱动轮都需要配置传动装置 -->
<xacro:joint_trans joint_name="left_wheel2base_link" />
<xacro:joint_trans joint_name="right_wheel2base_link" />
<!-- 控制器 -->
<gazebo>
<plugin name="differential_drive_controller" filename="libgazebo_ros_diff_drive.so">
<rosDebugLevel>Debug</rosDebugLevel>
<publishWheelTF>true</publishWheelTF>
<robotNamespace>/</robotNamespace>
<publishTf>1</publishTf>
<publishWheelJointState>true</publishWheelJointState>
<alwaysOn>true</alwaysOn>
<updateRate>100.0</updateRate>
<legacyMode>true</legacyMode>
<leftJoint>left_wheel2base_link</leftJoint> <!-- 左轮 -->
<rightJoint>right_wheel2base_link</rightJoint> <!-- 右轮 -->
<wheelSeparation>${base_link_radius * 2}</wheelSeparation> <!-- 车轮间距 -->
<wheelDiameter>${wheel_radius * 2}</wheelDiameter> <!-- 车轮直径 -->
<broadcastTF>1</broadcastTF>
<wheelTorque>30</wheelTorque>
<wheelAcceleration>1.8</wheelAcceleration>
<commandTopic>cmd_vel</commandTopic> <!-- 运动控制话题 -->
<odometryFrame>odom</odometryFrame>
<odometryTopic>odom</odometryTopic> <!-- 里程计话题 -->
<robotBaseFrame>base_footprint</robotBaseFrame> <!-- 根坐标系 -->
</plugin>
</gazebo>
</robot>
需要与配置文件进行匹配
<robot name="my_car_move" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- Transmission realization: it is used to connect the controller and the switch -->
<xacro:macro name="joint_trans" params="joint_name">
<!-- Transmission is important to link the joints and the controller -->
<transmission name="${joint_name}_trans">
<type>transmission_interface/SimpleTransmission</type>
<joint name="${joint_name}">
<hardwareInterface>hardware_interface/VelocityJointInterface</hardwareInterface>
</joint>
<actuator name="${joint_name}_motor">
<hardwareInterface>hardware_interface/VelocityJointInterface</hardwareInterface>
<mechanicalReduction>1</mechanicalReduction>
</actuator>
</transmission>
</xacro:macro>
<!-- Each drive wheel needs to be equipped with a transmission device -->
<!-- Modify match -->
<xacro:joint_trans joint_name="left2base_link" />
<xacro:joint_trans joint_name="right2base_link" />
<!-- controller -->
<gazebo>
<plugin name="differential_drive_controller" filename="libgazebo_ros_diff_drive.so">
<rosDebugLevel>Debug</rosDebugLevel>
<publishWheelTF>true</publishWheelTF>
<robotNamespace>/</robotNamespace>
<publishTf>1</publishTf>
<publishWheelJointState>true</publishWheelJointState>
<alwaysOn>true</alwaysOn>
<updateRate>100.0</updateRate>
<legacyMode>true</legacyMode>
<leftJoint>left2base_link</leftJoint> <!--left wheel -->
<rightJoint>right2base_link</rightJoint> <!-- right wheel -->
<wheelSeparation>${base_radius * 2}</wheelSeparation> <!-- Wheel spacing -->
<wheelDiameter>${wheel_radius * 2}</wheelDiameter> <!-- Wheel diameter -->
<broadcastTF>1</broadcastTF>
<wheelTorque>30</wheelTorque>
<wheelAcceleration>1.8</wheelAcceleration>
<commandTopic>cmd_vel</commandTopic> <!-- Motion control topics -->
<odometryFrame>odom</odometryFrame>
<odometryTopic>odom</odometryTopic> <!-- Odometer topic -->
<robotBaseFrame>base_footprint</robotBaseFrame> <!-- root coordinate system -->
</plugin>
</gazebo>
</robot>
报错：Error:Unable to convert from SDF version 1.7 to 1.6
解决：box_house.world
查看话题：
rostopic list
有/cmd_vel话题
键盘控制并设置速度与角速度：
rosrun teleop_twist_keyboard teleop_twist_keyboard.py _speed:=0.3 _turn:=0.1
Rviz查看里程计信息
在 Gazebo 的仿真环境中，机器人的里程计信息以及运动朝向等信息是无法获取的，可以通过 Rviz 显示机器人的里程计信息以及运动朝向
里程计: 机器人相对出发点坐标系的位姿状态(X 坐标 Y 坐标 Z坐标以及朝向)。
启动 Rviz
<launch>
<!-- 启动 rviz -->
<node pkg="rviz" type="rviz" name="rviz" />
<!-- 关节以及机器人状态发布节点 -->
<node name="joint_state_publisher" pkg="joint_state_publisher" type="joint_state_publisher" />
<node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" />
</launch>
添加组件
执行 launch 文件后，在 Rviz 中添加图示组件:
雷达信息仿真以及显示
通过 Gazebo 模拟激光雷达传感器，并在 Rviz 中显示激光数据。
实现流程:
雷达仿真基本流程:
- 已经创建完毕的机器人模型，编写一个单独的 xacro 文件，为机器人模型添加雷达配置；
- 将此文件集成进xacro文件；
- 启动 Gazebo，使用 Rviz 显示雷达信息。
1.Gazebo 仿真雷达
新建 Xacro 文件，配置雷达传感器信息
<robot name="my_sensors" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- 雷达 -->
<gazebo reference="laser"> <!-- 此处name参考 link name -->
<sensor type="ray" name="rplidar">
<pose>0 0 0 0 0 0</pose>
<visualize>true</visualize>
<update_rate>5.5</update_rate>
<ray>
<scan>
<horizontal>
<samples>360</samples>
<resolution>1</resolution>
<min_angle>-3</min_angle>
<max_angle>3</max_angle>
</horizontal>
</scan>
<range>
<min>0.10</min>
<max>30.0</max>
<resolution>0.01</resolution>
</range>
<noise>
<type>gaussian</type>
<mean>0.0</mean>
<stddev>0.01</stddev>
</noise>
</ray>
<plugin name="gazebo_rplidar" filename="libgazebo_ros_laser.so">
<topicName>/scan</topicName>
<frameName>laser</frameName>
</plugin>
</sensor>
</gazebo>
</robot>
xacro 文件集成
将步骤1的 Xacro 文件集成进总的机器人模型文件，代码示例如下:
<robot name="mycar" xmlns:xacro="http://wiki.ros.org/xacro">
<xacro:include filename="head.xacro" />
<xacro:include filename="demo02_car.urdf.xacro" />
<xacro:include filename="demo02_camera.urdf.xacro" />
<xacro:include filename="demo02_laser.urdf.xacro" />
<xacro:include filename="gazebo/move.xacro" />
<xacro:include filename="gazebo/laser.xacro" />
</robot>
启动仿真环境
编写launch文件，启动gazebo，此处略...
Rviz 显示雷达数据
先启动 rviz,添加雷达信息显示插件
摄像头信息仿真以及显示
通过 Gazebo 模拟摄像头传感器，并在 Rviz 中显示摄像头数据。
实现流程:
摄像头仿真基本流程:
- 已经创建完毕的机器人模型，编写一个单独的 xacro 文件，为机器人模型添加摄像头配置；
- 将此文件集成进xacro文件；
- 启动 Gazebo，使用 Rviz 显示摄像头信息。
Gazebo 仿真摄像头
新建 Xacro 文件，配置摄像头传感器信息
<robot name="my_sensors" xmlns:xacro="http://wiki.ros.org/xacro">
<!-- 被引用的link -->
<gazebo reference="camera">
<!-- 类型设置为 camara -->
<sensor type="camera" name="camera_node">
<update_rate>30.0</update_rate> <!-- 更新频率 -->
<!-- 摄像头基本信息设置 -->
<camera name="head">
<horizontal_fov>1.3962634</horizontal_fov>
<image>
<width>1280</width>
<height>720</height>
<format>R8G8B8</format>
</image>
<clip>
<near>0.02</near>
<far>300</far>
</clip>
<noise>
<type>gaussian</type>
<mean>0.0</mean>
<stddev>0.007</stddev>
</noise>
</camera>
<!-- 核心插件 -->
<plugin name="gazebo_camera" filename="libgazebo_ros_camera.so">
<alwaysOn>true</alwaysOn>
<updateRate>0.0</updateRate>
<cameraName>/camera</cameraName>
<imageTopicName>image_raw</imageTopicName>
<cameraInfoTopicName>camera_info</cameraInfoTopicName>
<frameName>camera</frameName>
<hackBaseline>0.07</hackBaseline>
<distortionK1>0.0</distortionK1>
<distortionK2>0.0</distortionK2>
<distortionK3>0.0</distortionK3>
<distortionT1>0.0</distortionT1>
<distortionT2>0.0</distortionT2>
</plugin>
</sensor>
</gazebo>
</robot>
xacro 文件集成
将步骤1的 Xacro 文件集成进总的机器人模型文件，代码示例如下:
<robot name="mycar" xmlns:xacro="http://wiki.ros.org/xacro">
<xacro:include filename="head.xacro" />
<xacro:include filename="demo02_car.urdf.xacro" />
<xacro:include filename="demo02_camera.urdf.xacro" />
<xacro:include filename="demo02_laser.urdf.xacro" />
<xacro:include filename="gazebo/move.xacro" />
<xacro:include filename="gazebo/laser.xacro" />
<xacro:include filename="gazebo/camera.xacro" />
</robot>
启动仿真环境
编写launch文件，启动gazebo，此处略...
Rviz 显示摄像头数据
执行 gazebo 并启动 Rviz,在 Rviz 中添加摄像头组件。
kinect信息仿真以及显示
通过 Gazebo 模拟kinect摄像头，并在 Rviz 中显示kinect摄像头数据。
实现流程:
kinect摄像头仿真基本流程:
- 已经创建完毕的机器人模型，编写一个单独的 xacro 文件，为机器人模型添加kinect摄像头配置；
- 将此文件集成进xacro文件；
- 启动 Gazebo，使用 Rviz 显示kinect摄像头信息。
Gazebo仿真Kinect
新建 Xacro 文件，配置 kinetic传感器信息
<robot name="my_sensors" xmlns:xacro="http://wiki.ros.org/xacro">
<gazebo reference="kinect link名称">
<sensor type="depth" name="camera">
<always_on>true</always_on>
<update_rate>20.0</update_rate>
<camera>
<horizontal_fov>${60.0*PI/180.0}</horizontal_fov>
<image>
<format>R8G8B8</format>
<width>640</width>
<height>480</height>
</image>
<clip>
<near>0.05</near>
<far>8.0</far>
</clip>
</camera>
<plugin name="kinect_camera_controller" filename="libgazebo_ros_openni_kinect.so">
<cameraName>camera</cameraName>
<alwaysOn>true</alwaysOn>
<updateRate>10</updateRate>
<imageTopicName>rgb/image_raw</imageTopicName>
<depthImageTopicName>depth/image_raw</depthImageTopicName>
<pointCloudTopicName>depth/points</pointCloudTopicName>
<cameraInfoTopicName>rgb/camera_info</cameraInfoTopicName>
<depthImageCameraInfoTopicName>depth/camera_info</depthImageCameraInfoTopicName>
<frameName>kinect link名称</frameName>
<baseline>0.1</baseline>
<distortion_k1>0.0</distortion_k1>
<distortion_k2>0.0</distortion_k2>
<distortion_k3>0.0</distortion_k3>
<distortion_t1>0.0</distortion_t1>
<distortion_t2>0.0</distortion_t2>
<pointCloudCutoff>0.4</pointCloudCutoff>
</plugin>
</sensor>
</gazebo>
</robot>
xacro 文件集成
将步骤1的 Xacro 文件集成进总的机器人模型文件，代码示例如下:
<!-- 组合小车底盘与传感器 -->
<robot name="my_car_camera" xmlns:xacro="http://wiki.ros.org/xacro">
<xacro:include filename="my_head.urdf.xacro" />
<xacro:include filename="my_base.urdf.xacro" />
<xacro:include filename="my_camera.urdf.xacro" />
<xacro:include filename="my_laser.urdf.xacro" />
<xacro:include filename="move.urdf.xacro" />
<!-- kinect仿真的 xacro 文件 -->
<xacro:include filename="my_sensors_kinect.urdf.xacro" />
</robot>
启动仿真环境
编写launch文件，启动gazebo，此处略...
Rviz 显示 Kinect 数据
启动 rviz,添加摄像头组件查看数据
kinect 点云数据显示
在kinect中也可以以点云的方式显示感知周围环境，在 rviz 中操作如下:
问题:在rviz中显示时错位。
原因:在kinect中图像数据与点云数据使用了两套坐标系统，且两套坐标系统位姿并不一致。
解决:
相当于新建一个子坐标系kinect_depth
1.在插件中为kinect设置坐标系，修改配置文件的<frameName>标签内容：
<frameName>kinect_depth</frameName>
2.发布新设置的坐标系到kinect连杆的坐标变换关系，在启动rviz的launch中，添加:
<node pkg="tf2_ros" type="static_transform_publisher" name="static_transform_publisher" args="0 0 0 -1.57 0 -1.57 /kinect /kinect_depth" />
3.启动rviz，重新显示。
本章小结
本章主要介绍了ROS中仿真实现涉及的三大知识点:
- URDF(Xacro)
- Rviz
- Gazebo
URDF 是用于描述机器人模型的 xml 文件，可以使用不同的标签具代表不同含义，URDF 编写机器人模型代码冗余，xacro 可以优化 URDF 实现，代码实现更为精简、高效、易读。容易混淆的是Rviz与Gazebo，在此我们着重比较以下二者的区别:
```rviz是三维可视化工具，强调把已有的数据可视化显示；
gazebo是三维物理仿真平台，强调的是创建一个虚拟的仿真环境。
rviz需要已有数据。
rviz提供了很多插件，这些插件可以显示图像、模型、路径等信息，但是前提都是这些数据已经以话题、参数的形式发布，rviz做的事情就是订阅这些数据，并完成可视化的渲染，让开发者更容易理解数据的意义。
gazebo不是显示工具，强调的是仿真，它不需要数据，而是创造数据。
我们可以在gazebo中免费创建一个机器人世界，不仅可以仿真机器人的运动功能，还可以仿真机器人的传感器数据。而这些数据就可以放到rviz中显示，所以使用gazebo的时候，经常也会和rviz配合使用。当我们手上没有机器人硬件或实验环境难以搭建时，仿真往往是非常有用的利器。
综上，如果你手上已经有机器人硬件平台，并且在上边可以完成需要的功能，用rviz应该就可以满足开发需求。
如果你手上没有机器人硬件，或者想在仿真环境中做一些算法、应用的测试，gazebo+rviz应该是你需要的。
另外，rviz配合其他功能包也可以建立一个简单的仿真环境，比如rviz+ArbotiX。
opicName>
depth/camera_info
kinect link名称
0.1
<distortion_k1>0.0</distortion_k1>
<distortion_k2>0.0</distortion_k2>
<distortion_k3>0.0</distortion_k3>
<distortion_t1>0.0</distortion_t1>
<distortion_t2>0.0</distortion_t2>
0.4
xacro 文件集成
将步骤1的 Xacro 文件集成进总的机器人模型文件，代码示例如下:
<!-- 组合小车底盘与传感器 -->
<robot name="my_car_camera" xmlns:xacro="http://wiki.ros.org/xacro">
<xacro:include filename="my_head.urdf.xacro" />
<xacro:include filename="my_base.urdf.xacro" />
<xacro:include filename="my_camera.urdf.xacro" />
<xacro:include filename="my_laser.urdf.xacro" />
<xacro:include filename="move.urdf.xacro" />
<!-- kinect仿真的 xacro 文件 -->
<xacro:include filename="my_sensors_kinect.urdf.xacro" />
</robot>
启动仿真环境
编写launch文件，启动gazebo，此处略...
Rviz 显示 Kinect 数据
启动 rviz,添加摄像头组件查看数据
[外链图片转存中...(img-eFtObIky-1649728244993)]
[外链图片转存中...(img-t0EOpXOu-1649728244995)]
kinect 点云数据显示
在kinect中也可以以点云的方式显示感知周围环境，在 rviz 中操作如下:
[外链图片转存中...(img-Vvuddrrz-1649728244997)]
问题:在rviz中显示时错位。
原因:在kinect中图像数据与点云数据使用了两套坐标系统，且两套坐标系统位姿并不一致。
解决:
相当于新建一个子坐标系kinect_depth
1.在插件中为kinect设置坐标系，修改配置文件的<frameName>标签内容：
<frameName>kinect_depth</frameName>
2.发布新设置的坐标系到kinect连杆的坐标变换关系，在启动rviz的launch中，添加:
<node pkg="tf2_ros" type="static_transform_publisher" name="static_transform_publisher" args="0 0 0 -1.57 0 -1.57 /kinect /kinect_depth" />
3.启动rviz，重新显示。
[外链图片转存中...(img-NJ8NJ3Ld-1649728244999)]
本章小结
本章主要介绍了ROS中仿真实现涉及的三大知识点:
- URDF(Xacro)
- Rviz
- Gazebo
URDF 是用于描述机器人模型的 xml 文件，可以使用不同的标签具代表不同含义，URDF 编写机器人模型代码冗余，xacro 可以优化 URDF 实现，代码实现更为精简、高效、易读。容易混淆的是Rviz与Gazebo，在此我们着重比较以下二者的区别:
rviz是三维可视化工具，强调把已有的数据可视化显示；
gazebo是三维物理仿真平台，强调的是创建一个虚拟的仿真环境。
rviz需要已有数据。
rviz提供了很多插件，这些插件可以显示图像、模型、路径等信息，但是前提都是这些数据已经以话题、参数的形式发布，rviz做的事情就是订阅这些数据，并完成可视化的渲染，让开发者更容易理解数据的意义。
gazebo不是显示工具，强调的是仿真，它不需要数据，而是创造数据。
我们可以在gazebo中免费创建一个机器人世界，不仅可以仿真机器人的运动功能，还可以仿真机器人的传感器数据。而这些数据就可以放到rviz中显示，所以使用gazebo的时候，经常也会和rviz配合使用。当我们手上没有机器人硬件或实验环境难以搭建时，仿真往往是非常有用的利器。
综上，如果你手上已经有机器人硬件平台，并且在上边可以完成需要的功能，用rviz应该就可以满足开发需求。
如果你手上没有机器人硬件，或者想在仿真环境中做一些算法、应用的测试，gazebo+rviz应该是你需要的。
另外，rviz配合其他功能包也可以建立一个简单的仿真环境，比如rviz+ArbotiX。
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？