Gazebo 上手 wsl

Posted on | In , |

学习计划

在一小时内基本掌握Gazebo可能是很具挑战的，但可以通过以下步骤尽快上手，尤其是以项目实践为目的：

环境搭建和安装

  • 下载并安装Gazebo
  • 设置基本的环境变量和配置

基本概念和界面熟悉

  • 快速浏览Gazebo的基本概念，如模型、世界、插件等
  • 熟悉Gazebo的用户界面和基本功能

载入和探索现有模型

  • 从Gazebo的模型库中载入一些基本模型
  • 熟悉模型的基本操作和属性设置

创建简单的场景

  • 创建一个简单的Gazebo世界，包括地面、一些障碍物和一个机器人模型
  • 保存和载入你创建的场景

运行基本的仿真

  • 启动仿真，观察场景中的物理交互
  • 使用基本的控制命令，如移动机器人等

以上步骤可能需要适当的预先知识和快速的学习能力。为了确保在短时间内获得最好的学习效果，建议选择具有明确目标和范围的项目实践。在实践过程中，你可能会遇到一些问题，记得利用网络资源如社区论坛和Stack Overflow来寻找解决方案。通过快速实践和解决问题，你将能够在较短的时间内掌握Gazebo的基本应用。

环境搭建 安装

docker安装

  • 此处省略

创建Dockerfile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 使用官方的ROS镜像作为基础镜像
FROM ros:noetic-ros-base

# 添加ROS源
RUN echo "deb http://packages.ros.org/ros/ubuntu focal main" > /etc/apt/sources.list.d/ros1-latest.list

# 导入ROS的公钥
RUN apt-key adv --keyserver 'hkp://keyserver.ubuntu.com:80' --recv-key C1CF6E31E6BADE8868B172B4F42ED6FBAB17C654

# 更新apt包列表
RUN apt-get update

# 安装 RViz 和其他 ROS 工具
RUN apt-get install -y \
    ros-noetic-rviz \
    ros-noetic-xacro \
    ros-noetic-joint-state-publisher-gui \
    ros-noetic-robot-state-publisher

# 安装 Gazebo 11 和相关的开发包
RUN apt-get install -y \
    gazebo11 \
    libgazebo11-dev

# 安装 Gazebo ROS 包
RUN apt-get install -y \
    ros-noetic-gazebo-ros-pkgs \
    ros-noetic-gazebo-ros-control

# 设置容器的主命令为bash终端
CMD ["/bin/bash"]

创建并运行 Docker 容器:

在 Dockerfile 的同一目录中打开终端，运行以下命令以构建 Docker 映像:

1
docker build -t gazebo11:latest .

配置 X11 服务器:

我使用 VcXsrv 来作为可视化服务器。

启动 X11 服务器，并允许来自所有网络的连接。

  1. 安装 VcXsrv：首先需要下载并安装 VcXsrv。安装过程中可能需要选择完整安装，并指定目标文件夹​1​。
  2. 运行 XLaunch：通过运行 VcXsrv 中的 XLaunch 程序来启动 X 服务器。在显示设置中，选择“多窗口”选项，并点击下一步。在客户端启动中，检查“不启动客户端”选项，并点击下一步。在额外设置中，确保启用“禁用访问控制”，并点击下一步​3​，直到完成。

启动容器:

一旦映像构建完成，运行以下命令以启动 Docker 容器，并连接到 X server:

我这里挂载了 F:\DockerFile\gazebo 目录，进行数据的保存和读取。

1
docker run -v F:\DockerFile\gazebo:/data -it --name gazebo11-container -e DISPLAY=host.docker.internal:0 gazebo11:latest

这时容器应该运行了。

其他终端：

现在，你可以通过 Docker desktop 中的 Exec 界面来执行其他命令。

或者通过 Docker 的 exec 命令附加一个新的终端到正在运行的容器：

1
docker exec -it gazebo11-container /bin/bash

这条命令会打开一个新的 Bash 终端，你可以在这个终端中执行任何你想要的命令，就像在一个常规的 Linux 系统中那样。

启动gazebo：

执行 gazebo &

一旦你的 X11 服务器配置完成，你应该能够看到 Gazebo 的图形界面从 Docker 容器中显示出来。

这种方法应该能够让你在 Docker 容器中运行 Gazebo，同时在主机系统上显示其图形界面。请注意，可能还需要进行一些额外的配置和调整以确保所有功能都能正确运行，特别是如果你的网络环境比较复杂或有特殊的安全配置。

基本概念和界面熟悉

Gazebo的基本概念，如模型，世界，插件等

  • 模型

  • 世界

  • 插件

  • 传感器：模拟真实世界传感器的虚拟设备，例如相机，雷达，激光雷达，它们可以感知仿真世界种的其它模型和环境

  • 视觉和物理属性

  • 通信接口

熟悉Gazebo的用户解码和基本功能

  • 主界面

  • 工具栏

  • 模型库

  • 插件和控件

  • 属性面板

  • 主题和布局

  • 日志和错误输出

模型载入

  • 打开模型库

  • 加载模型

  • 保存世界

模型操作和属性设置

  • 选择模型

  • 移动，旋转，缩放

  • 打开属性面板

  • 添加/删除链接和关节

  • 保存模型

创建场景

simple_world.world

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
<?xml version="1.0" ?>
<sdf version="1.6">
  <world name="simple_world">

    <!-- Ground plane -->
    <include>
      <uri>model://ground_plane</uri>
    </include>

    <!-- Obstacles -->
    <model name="obstacle1">
      <pose>2 0 0.5 0 0 0</pose>
      <static>true</static>
      <link name="link">
        <collision name="collision">
          <geometry>
            <box>
              <size>1 1 1</size>
            </box>
          </geometry>
        </collision>
        <visual name="visual">
          <geometry>
            <box>
              <size>1 1 1</size>
            </box>
          </geometry>
        </visual>
      </link>
    </model>

    <model name="obstacle2">
      <pose>-2 0 0.5 0 0 0</pose>
      <static>true</static>
      <link name="link">
        <collision name="collision">
          <geometry>
            <box>
              <size>1 1 1</size>
            </box>
          </geometry>
        </collision>
        <visual name="visual">
          <geometry>
            <box>
              <size>1 1 1</size>
            </box>
          </geometry>
        </visual>
      </link>
    </model>

<!-- Simple Robot -->
<model name="simple_robot">
  <pose>0 0 0.1 1.57079632679 0 0</pose>
  <link name="base_link">
    <collision name="collision">
      <geometry>
        <cylinder>
          <radius>0.2</radius>
          <length>0.1</length>
        </cylinder>
      </geometry>
    </collision>
    <visual name="visual">
      <geometry>
        <cylinder>
          <radius>0.2</radius>
          <length>0.1</length>
        </cylinder>
      </geometry>
    </visual>
    <inertial>
      <mass>10</mass>
      <inertia>
        <ixx>0.0175</ixx>
        <iyy>0.0175</iyy>
        <izz>0.0175</izz>
      </inertia>
    </inertial>
  </link>
  <plugin name="force_controller" filename="libgazebo_ros_force.so">
    <updateRate>100.0</updateRate>
    <robotNamespace>/my_robot</robotNamespace>
    <bodyName>base_link</bodyName>
    <topicName>/force</topicName>
  </plugin>
</model>

  </world>
</sdf>

在这个 simple_world.world 文件中，我们创建了以下元素：

  1. 地面平面 (ground_plane): 使用 <include> 标签从模型库中包含了一个基本的地面平面模型。
  2. 障碍物 (obstacle1 和 obstacle2): 创建了两个静态的箱形障碍物，并通过 <pose> 标签设置了它们的位置。
  3. 简单的机器人 (simple_robot): 创建了一个简单的机器人模型，该模型包含一个基本的圆柱形体。

你可以通过将这个文件保存到你的系统中，然后使用 Gazebo 命令行工具打开它来查看和交互这个简单的世界：

1
gazebo /data/worlds/simple_world.world

运行基本的仿真

启动仿真，观察场景中的物理交互

在 Gazebo 中启动仿真并观察场景中的物理交互是一个很直观的过程。你可以看到模型如何在受到物理规则（如重力、摩擦和碰撞）影响下运动和互动。以下是如何执行此操作的步骤：

  1. 启动 Gazebo: 首先，你需要启动 Gazebo 并加载你创建的世界。你可以通过命令行使用以下命令来做到这一点：gazebo /path/to/your/my_scene.world 其中 /path/to/your/ 是你保存 my_scene.world 文件的路径。
  2. 启动仿真: 在 Gazebo 的用户界面顶部，你会看到一个“播放”按钮（Play），点击它来启动仿真。现在，你应该能看到你的场景中的模型开始按照物理规则运动。例如，如果你的场景中有一个未固定的箱子，它应该会因为重力而掉到地上。
  3. 观察物理交互: 观察你的场景中的模型如何相互交互以及如何与环境交互。例如，你可以看到碰撞效果，如模型之间的碰撞或模型与地面的碰撞。你也可以尝试移动模型，看看它们如何响应你的交互以及它们如何在物理环境中运动。
  4. 调整仿真速度 (可选): 如果需要，你可以调整仿真速度以更仔细地观察物理交互。在 Gazebo 用户界面的顶部，你会看到一个滑块，可以用它来调整仿真速度。
  5. 暂停和重置仿真 (可选): 你也可以暂停仿真或重置仿真以返回到初始状态。在 Gazebo 用户界面的顶部，你会找到“暂停”（Pause）和“重置”（Reset）按钮。

通过上述步骤，你可以启动 Gazebo 仿真，观察并理解你的场景中的物理交互。这可以帮助你理解如何配置和调整你的模型以获得所需的仿真结果。

※使用基本的控制命令，如移动机器人等

在 Gazebo 中控制机器人通常需要编写和运行一些控制代码。一个常见的做法是使用 ROS (Robot Operating System) 与 Gazebo 协同工作，以发送控制命令并接收机器人的传感器数据。在这个例子中，我们将通过 ROS 使用简单的控制命令来移动机器人。

首先，确保你已经安装了 ROS 和 Gazebo，并且你的机器人模型已经配置为接受 ROS 控制命令。

创建ROS工作空间: 在ROS容器中，你需要创建一个新的工作空间来存放你的ROS项目。首先，创建一个新的目录来作为你的工作空间：

1
2
3
mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/src
catkin_init_workspace

然后构建你的工作空间：

1
2
cd ~/catkin_ws
catkin_make

设置环境变量:

我将这个文件放到了之前加载的 F:\DockerFile\gazebo 中，然后在容器中在 /data 中可以找到该文件。

文件名：ros_environment.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/bin/bash

# Source ROS setup script
source /opt/ros/noetic/setup.bash

# Source workspace setup script
source ~/catkin_ws/devel/setup.bash

# Set ROS Master URI
# Replace 'localhost' with your ROS Master's IP if it's on a different machine
export ROS_MASTER_URI=http://localhost:11311

# Set ROS Hostname
# Replace 'localhost' with this machine's IP if this machine is not the ROS Master
export ROS_HOSTNAME=localhost

# Set ROS IP
# Replace 'localhost' with this machine's IP
export ROS_IP=localhost

# Set Gazebo Plugin Path
export GAZEBO_PLUGIN_PATH=/opt/ros/noetic/lib:$GAZEBO_PLUGIN_PATH
  • 保存上述脚本到 ros_environment.sh文件。
  • 通过以下命令使环境变量设置生效：source /data/ros_environment.sh

创建 ROS Package:

创建一个新的 ROS package 用于存放你的控制代码。在你的 catkin workspace 中，运行以下命令：

1
2
cd ~/catkin_ws/src
catkin_create_pkg my_robot_controller rospy gazebo_ros gazebo_plugins std_msgs geometry_msgs

创建控制节点:

在你的 my_robot_controller package 中创建一个新的 Python 文件，命名为 robot_controller.py。

文件名: robot_controller.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#!/usr/bin/env python3

import rospy
from geometry_msgs.msg import Wrench

def apply_force():
    # Initialize the node
    rospy.init_node('force_applier', anonymous=True)

    # Create a publisher to send force commands
    pub = rospy.Publisher('/force', Wrench, queue_size=10)

    # Create a Wrench message to send force and torque commands
    cmd = Wrench()
    cmd.force.x = 0.0
    cmd.force.y = 0.0
    cmd.force.z = 0.0
    cmd.torque.x = 0.0
    cmd.torque.y = 0.0
    cmd.torque.z = 0.6  # Apply a torque of 0.6 N*m about the z-axis

    rate = rospy.Rate(10)  # 10 Hz
    while not rospy.is_shutdown():
        # Publish the command
        pub.publish(cmd)
        rate.sleep()

if __name__ == '__main__':
    try:
        apply_force()
    except rospy.ROSInterruptException:
        pass

运行控制节点:

在终端中，导航到你的 catkin workspace，并构建你的 package：

1
2
3
cd ~/catkin_ws
catkin_make
source /data/ros_environment.sh

现在运行你的控制节点来移动机器人：

1
rosrun my_robot_controller robot_controller.py

在这个例子中，robot_controller.py 脚本创建了一个 ROS 节点，该节点发布速度命令来移动机器人。/my_robot/cmd_vel 是你的机器人模型应该监听的话题，以接收速度命令。确保将此话题名称更改为与你的机器人模型匹配的话题名称。

然后打开一个新的终端，运行：

1
rosrun my_robot_controller robot_controller.py

然后就可以看到机器人转起来了：

REF

win11+WSL2配置gazebo - 知乎 (zhihu.com)