Mastering ROS for Robotics Programming: Design, build, and simulate complex robots using the Robot Operating System

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

Now, we can create some complex robots using URDF and xacro. The first robot we are going to deal with is a seven DOF robotic arm, which is a serial link manipulator having multiple serial links. The seven DOF arm is kinematically redundant, which means it has more joints and DOF than required to achieve its goal position and orientation. The advantage of redundant manipulators are, we can have more joint configuration for a particular goal position and orientation. It will improve the flexibility and versatility of the robot movement and can implement effective collision free motion in a robotic workspace.

Let's start creating the seven DOF arm; the final output model of the robot arm is shown here (the various joints and links in the robot are also marked on the image):

Figure 8 : Joints and Links of seven dof arm robot

The preceding robot is described using xacro. We can take the actual description file from the cloned repository...

We will define 10 links and 9 joints on this robot and 2 links and 2 joints in the robot gripper.

Let's start by discussing the xacro definition:

<?xml version="1.0"?>
<robot name="seven_dof_arm" xmlns:xacro="http://www.ros.org/wiki/xacro">

Because we are writing a xacro file, we should mention the xacro namespace to parse the file.

  <property name="deg_to_rad" value="0.01745329251994329577"/>
  <property name="M_PI" value="3.14159"/>

  <property name="elbow_pitch_len" value="0.22" />
  <property name="elbow_pitch_width" value="0.04" />
  <property name="elbow_pitch_height" value="0.04" />

A differential wheeled robot will have two wheels connected on opposite sides of the robot chassis which is supported by one or two caster wheels. The wheels will control the speed of the robot by adjusting individual velocity. If the two motors are running at the same speed it will move forward or backward. If a wheel is running slower than the other, the robot will turn to the side of the lower speed. If we want to turn the robot to the left side, reduce the velocity of the left wheel compared to the right and vice versa.

There are two supporting wheels called caster wheels that will support the robot and freely rotate according to the movement of the main wheels.

The UDRF model of this robot is present in the cloned ROS package. The final robot model is shown as follows:

Figure 12 : 3D model of differential drive mobile robot

The preceding robot has five joints and five links. The two main joints are two wheel joints and the other...

In this chapter, we mainly discussed the importance of robot modeling and how we can model a robot in ROS. We discussed more on the robot_model meta package and the packages inside robot_model such as urdf, xacro, joint_state_publisher, and so on. We discussed URDF, xacro, and the main URDF tags that we are going to use. We also created a sample model in URDF and xacro and discussed the difference between the two. After that, we created a complex robotic manipulator with seven DOF and saw the usage of the joint state publisher and robot state publisher packages. At the end of the chapter, we saw the designing procedure of a differential drive mobile robot using xacro. In the next chapter, we will look at the simulation of these robot using Gazebo.