Simulation Environments in Gazebo

Gazebo is a powerful robotics simulator that provides realistic physics simulation, high-quality graphics, and convenient programmatic interfaces. It's an essential tool in robotics development for testing algorithms, robot designs, and scenarios before deploying to real hardware.

Learning Outcomes

By the end of this chapter, you will be able to:

• Set up and configure Gazebo for robot simulation
• Create and modify robot models in SDF format
• Implement sensors and actuators in simulation
• Design simulation environments that match real-world scenarios

Theoretical Foundations

Gazebo simulates realistic physics, sensors, and environments for robots. It forms part of the robot simulation ecosystem by providing:

• Advanced 3D rendering for visualization
• Physics simulation with multiple engine options
• Sensor simulation including cameras, lidar, IMU, etc.
• A plugin system for custom simulation logic

The simulator uses the SDF (Simulation Description Format) to define robot models and environments, which is compatible with ROS and other robotics frameworks.

Key Concepts

1. Physics Engines: Gazebo supports multiple physics engines including ODE, Bullet, SimBody, and DART for different simulation needs.

2. SDF Format: The Simulation Description Format is an XML-based format for describing robots and environments in simulation.

3. Sensor Simulation: Gazebo can simulate various sensors with realistic noise models and physics interactions.

Practical Simulations

Let's look at how to create a basic robot model for simulation in Gazebo.

Basic Robot Model in SDF

<?xml version="1.0" ?>
<sdf version="1.7">
  <model name="my_robot">
    <link name="chassis">
      <pose>0 0 0.1 0 0 0</pose>
      <inertial>
        <mass>5.0</mass>
        <inertia>
          <ixx>0.0341667</ixx>
          <ixy>0</ixy>
          <ixz>0</ixz>
          <iyy>0.108333</iyy>
          <iyz>0</iyz>
          <izz>0.133333</izz>
        </inertia>
      </inertial>
      <visual name="chassis_visual">
        <geometry>
          <box>
            <size>0.5 0.3 0.2</size>
          </box>
        </geometry>
      </visual>
      <collision name="chassis_collision">
        <geometry>
          <box>
            <size>0.5 0.3 0.2</size>
          </box>
        </geometry>
      </collision>
      <sensor name="camera" type="camera">
        <camera name="head">
          <horizontal_fov>1.047</horizontal_fov>
          <image>
            <width>640</width>
            <height>480</height>
          </image>
          <clip>
            <near>0.1</near>
            <far>100</far>
          </clip>
        </camera>
        <always_on>1</always_on>
        <update_rate>30</update_rate>
        <visualize>true</visualize>
      </sensor>
    </link>
  </model>
</sdf>

Launching Gazebo with Custom World

To create a simulation with a custom world file:

<?xml version="1.0" ?>
<sdf version="1.7">
  <world name="my_world">
    <include>
      <uri>model://sun</uri>
    </include>
    
    <include>
      <uri>model://ground_plane</uri>
    </include>
    
    <!-- Your custom objects can be included here -->
    <model name="my_object">
      <pose>0 0 0.5 0 0 0</pose>
      <link name="link">
        <visual name="visual">
          <geometry>
            <box><size>1 1 1</size></box>
          </geometry>
        </visual>
        <collision name="collision">
          <geometry>
            <box><size>1 1 1</size></box>
          </geometry>
        </collision>
      </link>
    </model>
    
    <!-- Include your robot -->
    <include>
      <uri>model://my_robot</uri>
    </include>
  </world>
</sdf>

Code Examples

Here's an example of how to connect a ROS 2 node to Gazebo simulation:

Controlling a Robot in Simulation

#!/usr/bin/env python3

import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Twist
from std_msgs.msg import String
import math

class GazeboController(Node):
    def __init__(self):
        super().__init__('gazebo_controller')
        self.publisher = self.create_publisher(Twist, '/cmd_vel', 10)
        timer_period = 0.1  # seconds
        self.timer = self.create_timer(timer_period, self.timer_callback)
        self.i = 0

    def timer_callback(self):
        msg = Twist()
        # Create a figure-8 motion pattern
        msg.linear.x = 1.0
        msg.angular.z = math.sin(self.i / 20.0)
        self.publisher.publish(msg)
        self.i += 1

def main(args=None):
    rclpy.init(args=args)
    gazebo_controller = GazeboController()

    try:
        rclpy.spin(gazebo_controller)
    except KeyboardInterrupt:
        pass
    finally:
        gazebo_controller.destroy_node()
        rclpy.shutdown()

if __name__ == '__main__':
    main()

Chapter Summary

This chapter introduced Gazebo as a powerful simulation environment for robotics. We covered the basics of SDF models, world creation, and how to control robots in simulation. Gazebo is essential for testing robotics algorithms before deployment on real hardware, saving time and resources while ensuring safety.