ROS provides some good packages that can be used to build 3D robot models. In this section, we will discuss some of the important ROS packages that are commonly used to build robot models:

We have discussed the urdf package. In this section, we will look further at the URDF XML tags, which help to model the robot. We have to create a file and write the relationship between each link and joint in the robot and save the file with the .urdf extension.

The URDF can represent the kinematic and dynamic description of the robot, visual representation of the robot, and the collision model of the robot.

The following tags are the commonly used URDF tags to compose a URDF robot model:

Before creating the URDF file for the robot, let's create a ROS package in the catkin workspace so that the robot model keeps using the following command:

$ catkin_create_pkg mastering_ros_robot_description_pkg roscpp tf geometry_msgs urdf rviz xacro 

The package mainly depends on the urdf and xacro packages, and we can create the urdf file of the robot inside this package and create launch files to display the created urdf in RViz. The full package is available on the following Git repository, you can clone the repository for a reference to implement this package or you can get the package from the book's source code:

$ git clone https://github.com/qboticslabs/mastering_ros_robot_description_pkg.git

Before creating the urdf file for this robot, let's create three folders called urdf, meshes, and launch inside the package folder. The urdf folder can be used to keep the urdf/xacro files that we are going to create. The meshes folder keeps...

After learning about URDF and its important tags, we can start some basic modeling using URDF. The first robot mechanism that we are going to design is a pan and tilt mechanism as shown in the following figure.

There are three links and two joints in this mechanism. The base link is static, in which all other links are mounted. The first joint can pan on its axis and the second link is mounted on the first link and it can tilt on its axis. The two joints in this system are of a revolute type.

Figure 4 : Visualization of a pan and tilt mechanism in RViz

Let's see the URDF code of this mechanism. Navigate to chapter_2_code/mastering_ros_robot_description_pkg/urdf and open pan_tilt.urdf. The code indentation in URDF is not mandatory for URDF but it keeping indentation can improve code readability:

<?xml version="1.0"?>
<robot name="pan_tilt">

  <link name="base_link">
    <visual>
      <geometry>
      <cylinder length="0.01" radius...

When we check the code, we can add a <robot> tag at the top of the description:

<?xml version="1.0"?>
<robot name="pan_tilt">

The <robot> tag defines the name of the robot that we are going to create. Here, we named the robot pan_tilt.

If we check the sections after the <robot> tag definition, we can see link and joint definitions of the pan and tilt mechanism:

  <link name="base_link">
    <visual>
      <geometry>
      <cylinder length="0.01" radius="0.2"/>
      </geometry>
      <origin rpy="0 0 0" xyz="0 0 0"/>
      <material name="yellow">
        <color rgba="1 1 0 1"/>
      </material>
    </visual>
  </link>

The preceding code snippet is the base_link definition of the pan and tilt mechanism. The <visual> tag can describe the visual appearance of the link, which is shown on the robot simulation. We can define the link geometry (cylinder, box, sphere, or mesh...

After designing URDF, we can view it on RViz. We can create a view_demo.launch launch file and put the following code into the launch folder. Navigate to chapter_2_code/mastering_ros_robot_description_pkg/launch for the same code:

<launch>
  <arg name="model" />
  <param name="robot_description" textfile="$(find mastering_ros_robot_description_pkg)/urdf/pan_tilt.urdf" />
  <param name="use_gui" value="true"/>

  <node name="joint_state_publisher" pkg="joint_state_publisher" type="joint_state_publisher" />
  <node name="robot_state_publisher" pkg="robot_state_publisher" type="state_publisher" />
  <node name="rviz" pkg="rviz" type="rviz" args="-d $(find mastering_ros_robot_description_pkg)/urdf.rviz" required="true" />

</launch>

We can launch the model using the following command:

$ roslaunch mastering_ros_robot_description_pkg view_demo.launch

If everything works fine, we will get a pan and tilt mechanism...

Before simulating a robot in a robot simulator, such as Gazebo, V-REP, and so on, we need to define the robot link's physical properties such as geometry, color, mass, and inertia, and the collision properties of the link.

We will only get good simulation results if we define all these properties inside the robot model. URDF provides tags to include all these parameters and code snippets of base_link contained in theses properties as given here:

<link>
......    
<collision>
      <geometry>
      <cylinder length="0.03" radius="0.2"/>
      </geometry>
      <origin rpy="0 0 0" xyz="0 0 0"/>
    </collision>

    <inertial>
    <mass value="1"/>
    <inertia ixx="1.0" ixy="0.0" ixz="0.0" iyy="1.0" iyz="0.0" izz="1.0"/>
    </inertial>
...........
</link>

Here, we define the collision geometry as cylinder and the mass as 1 Kg, and we also set the inertial matrix of...

The flexibility of URDF reduces when we work with complex robot models. Some of the main features that URDF is missing are the simplicity, reusability, modularity, and programmability.

If someone wants to reuse a URDF block ten times in his robot description, he can copy and paste the block ten times. If there is an option to use this code block and make multiple copies with different settings, it will be very useful while creating the robot description.

The URDF is single file and we can't include other URDF files inside it. This reduces the modular nature of the code. All code should be in a single file, which reduces the code simplicity too.

Also, if there is some programmability, such as adding variable, constants, mathematical expressions, conditional statement, and so on, in the description language, it will be more user friendly.

The robot modeling using xacro meets all these conditions and some of the main features of xacro are as follows:

After designing the xacro file, we can use the following command to convert it into a UDRF file:

$ rosrun xacro xacro.py pan_tilt.xacro > pan_tilt_generated.urdf

We can use the following line in the ROS launch file for converting xacro to UDRF and use it as a robot_description parameter:

  <param name="robot_description" command="$(find xacro)/xacro.py $(find mastering_ros_robot_description_pkg)/urdf/pan_tilt.xacro" />

We can view the xacro of pan and tilt by making a launch file, and it can be launched using the following command:

$ roslaunch mastering_ros_robot_description_pkg view_pan_tilt_xacro.launch