Chapter 2: Simulating with Gazebo

Building and testing physical robots can be expensive and time-consuming. This is where robot simulators come into play. A robot simulator allows you to test your robot's software and hardware designs in a virtual environment, saving time and resources. In this chapter, we will focus on Gazebo, one of the most widely used open-source robot simulators, especially within the ROS ecosystem.

What is Gazebo?

Gazebo is a powerful 3D robot simulator that allows you to accurately and efficiently test your robot in complex indoor and outdoor environments. It provides:

• Physics Engine: High-fidelity physics engine (e.g., ODE, Bullet, Simbody, DART) for realistic interactions between objects.
• 3D Graphics: Rendered environments and robot models with realistic lighting, shadows, and textures.
• Sensor Simulation: Accurate simulation of various sensors, including cameras, LIDARs, depth sensors, and IMUs.
• ROS Integration: Seamless integration with ROS 2, allowing you to use your ROS 2 nodes to control robots in Gazebo and receive sensor data.

Launching Gazebo with a URDF Model

To launch Gazebo and load a robot described by a URDF file (like our simple_arm.urdf), you typically use a ROS 2 launch file. A launch file is an XML or Python file that defines how to start and configure multiple ROS 2 nodes and applications.

Here's a conceptual example of a Python launch file to spawn our simple_arm in Gazebo:

import os
from ament_index_python.packages import get_package_share_directory
from launch import LaunchDescription
from launch_ros.actions import Node
from launch.actions import IncludeLaunchDescription
from launch.launch_description_sources import PythonLaunchDescriptionSource

def generate_launch_description():
    # Get the URDF file path
    urdf_file_name = 'simple_arm.urdf'
    urdf_path = os.path.join(
        get_package_share_directory('my_robot_pkg'), # Assuming 'my_robot_pkg' is where simple_arm.urdf lives
        'urdf',
        urdf_file_name
    )

    # Robot State Publisher node
    robot_state_publisher_node = Node(
        package='robot_state_publisher',
        executable='robot_state_publisher',
        name='robot_state_publisher_node',
        output='screen',
        parameters=[{'robot_description': open(urdf_path).read()}],
        arguments=[urdf_path]
    )

    # Gazebo launch
    gazebo_launch = IncludeLaunchDescription(
        PythonLaunchDescriptionSource([os.path.join(
            get_package_share_directory('gazebo_ros'), 'launch', 'gazebo.launch.py')]),
        launch_arguments={'gazebo_args': '-s libgazebo_ros_factory.so'}.items()
    )

    # Spawn the robot in Gazebo
    spawn_entity_node = Node(
        package='gazebo_ros',
        executable='spawn_entity.py',
        arguments=['-topic', 'robot_description', '-entity', 'simple_arm'],
        output='screen'
    )

    return LaunchDescription([
        gazebo_launch,
        robot_state_publisher_node,
        spawn_entity_node
    ])

Basic Simulation Controls

Once your robot is loaded in Gazebo, you can interact with it using the Gazebo GUI:

• Camera Control: Pan, tilt, and zoom the camera to view your robot from different angles.
• Object Manipulation: Move, rotate, and resize objects in the environment, including your robot.
• Physics Control: Pause, resume, and step through the simulation to observe your robot's behavior in detail.
• Sensors: Visualize sensor data directly in the Gazebo GUI or process it through ROS 2 topics.

In the next chapter, we will explore how to integrate our digital twin with Unity, offering another powerful simulation and visualization platform.