urdf_sim_tutorial

See the tutorials over at http://wiki.ros.org/urdf_tutorial

Please download the URDF simulation tutorial from github or using a package manager

sudo apt install ros-$ROS_DISTRO-urdf-sim-tutorial

Nonfunctional Gazebo Interface

We can spawn the model we already created into Gazebo using gazebo.launch.py

ros2 launch urdf_sim_tutorial gazebo.launch.py

This launch file

• Loads the urdf from the macro tutorial and publishes it as a topic (/robot_description)
• Launches an empty Gazebo world
• Runs the script to read the urdf from the topic and spawn it in Gazebo.
• By default, the Gazebo GUI will also be displayed, and look like this:

However, it doesn’t do anything, and is missing lots of key information that ROS would need to use this robot. Previously we had been using joint_state_publisher to specify the pose of each joint. However, the robot itself should provide that information in the real world or in Gazebo. Yet without specifying that, Gazebo doesn’t know to publish that information.

To get the robot to be interactive (with you and ROS), we need to specify two things: Plugins and Transmissions.

Side note: Configuring Meshes

If you are following along at home with your own robot, or something else is amiss, the meshes may be missing from your model in the Gazebo GUI (i.e. the gripper meshes are not there). This may also cause Gazebo to take several seconds to start up after the splash screen appears because it is checking the internet for missing models.

This is because your URDF package needs to explicitly tell Gazebo where to load the meshes from. We do this by modifying the package.xml of the package where our URDF meshes live to include a new export.

  <export>
    <build_type>ament_cmake</build_type>
    <gazebo_ros gazebo_model_path="${prefix}/.."/>
  </export>

The reasoning behind the exact value of the gazebo_model_path attribute is a separate issue, but suffice to say, setting it to this value will work assuming

• Your mesh filenames are specified in the URDF using the package://package_name/possible_folder/filename.ext syntax.
• The meshes are installed (via CMake) into the proper share folder.

Gazebo Plugin

To get ROS 2 to interact with Gazebo, we have to dynamically link to the ROS library that will tell Gazebo what to do. Theoretically, this allows for other Robot Operating Systems to interact with Gazebo in a generic way. In practice, its just ROS.

Specifically, Gazebo / ROS 2 interaction all happens by linking to a ROS 2 Control library, with new URDF tags.

We specify the following in the URDF, right before the closing </robot> tag:

  <ros2_control name="GazeboSystem" type="system">
    <hardware>
      <plugin>gazebo_ros2_control/GazeboSystem</plugin>
    </hardware>
    <joint name="head_swivel" />
  </ros2_control>

  <gazebo>
    <plugin filename="libgazebo_ros2_control.so" name="gazebo_ros2_control">
      <parameters>$(find urdf_sim_tutorial)/config/09a-minimal.yaml</parameters>
    </plugin>
  </gazebo>

Notes:

• The <gazebo> and <plugin> tags work the same way they did in ROS 1.
• We must specify at least one joint for the minimal example to work, but we’ll add more later.

The minimal configuration file is:

controller_manager:
  ros__parameters:
    update_rate: 100

You can see this in 09a-minimal.urdf.xacro and by running

ros2 launch urdf_sim_tutorial 09a-minimal.launch.py

This starts up a /controller_manager node and with the load_controller service, but doesn’t add any immediately useful interaction with the robot. For that we need to specify more information in the controller yaml.

Spawning Controllers

Now that we’ve linked ROS and Gazebo, we need to specify some bits of ROS code that we want to run within Gazebo, which we generically call controllers. Now we can look at a larger example based on this yaml file that specifies our first controller.

controller_manager:
  ros__parameters:
    update_rate: 100
    use_sim_time: true

    joint_state_broadcaster:
      type: joint_state_broadcaster/JointStateBroadcaster

This controller is found in the joint_state_broadcaster package and publishes the state of the robot’s joints into ROS directly from Gazebo.

In 09-joints.launch.py we also add a ros2_control command via ExecuteProcess to start this specific controller.

File truncated at 100 lines see the full file