In this video we are going to insert inertia property to each link of our robotic manipulator. At the end of the video we’ll be able to simulate this robot using Gazebo, due to having complete physic properties defined to the robot.
Step1. Create Project
Let’s start with creating a new project in ROS development studio.
Notice: If you haven’t had an account yet. You can register one here for free.
Open a shell and clone the package from bitbucket repo(https://goo.gl/1Kbt5v). You’ll have to register a bitbucket account to do that.
Since the repo is a simulation, we’ll clone it into the ~/simulation_ws/src folder.
Then the source tree should look similar like this.
Then we type the following command to compile the package.
cd ~/simulation_ws
catkin_make
source devel/setup.bash
Step2. Add physical properties in the URDF
Open the links_joints.xacro file under the urdf folder of the package and add the following tag in the link tag under the m_link_cylinder tag.
By adding this part, the link can have a more realistic physical behavior in the simulation, you also have to add the parameters for the inertia(ixx ixy ixz iyy iyz izz) in the pramas part.
We also need a collision tag to define the collision behavior when the robot collides with something in the simulation. We define the collision shape same as the visual shape here.
Now we have to define all the values for the parameters in the mrm.xacro file under the urdf folder. You can copy and replace the following code into it.
Locomotion is one of the most challenging topics in robotics. Creating the hard-coded algorithms and the kinematics models is not an easy task. Therefore, its no surprise that AI has been used to try and make robots learn how to move by themselves. In this project you will learn step by step, how to create a Monopod robot simulation working in Gazebo and then set up everything to use OpenAI-Gym infrastructure. OpenAI-Gym allows you to separate learning algorithms from the physical/simulated robot, so that you can test different learning algorithms easily. It also allows you to compare your results with other people in the same conditions.
Part 1
In this first video of a new ROS Development Studio video series, you are going to learn step by step
how to create your own hopper simulation, and may be a real version if there is high support to this videos.
You will learn in this video how to create your ROS packages, modify a URDF given by Alexander W. Winkler, https://github.com/leggedrobotics/xpp to give it control and physics and add all the needed sensors like IMU, odometry and contact sensor.
Here are the steps to create the hopper robot as shown in the video:
Step 1
Head to Robot Development Studio and create a new project.
Provide a suitable project name and some useful description.
Open the project (this will take few seconds)
Once the project is loaded run the IDE from the tools menu. Also verify that the initial directory structure should look like following:
Note that we use simulation_ws to contain all the files related to simulations. Those files not related to simulations will go to catkin_ws (like python scripts, launch files etc)
Step 2
Now we create two catkin packages with names my_legged_robots_description and my_legged_robots_sims. We will add rospy as dependency for both of them.
Start a SHELL from tools menu and navigate to ~simulation_ws/src directory as follows
$ cd simulation_ws/src
Now we create the first catkin package with following command
Once the cloning is complete, we should have a new directory with name xpp inside the ~simulation_ws/src directory
This new directory contains the mesh models for various robots such as biped, quadruped etc. We only need the mesh for monoped so we will do following
copy the meshes folder from ~simulation_ws/src/xpp/robots/xpp_hyq/ to ~simulation_ws/src/my_legged_robots_description/ directory
copy the urdf folder from ~simulation_ws/src/xpp/robots/xpp_hyq/ to ~simulation_ws/src/my_legged_robots_sims/ directory
delete the files in ~simulation_ws/src/my_legged_robots_sims/urdf/ directory except the file monoped.urdf
Step 4
Lets analyze the urdf file for the monoped.
Open the monoped.urdf file in the IDE. The file contains 4links and 3joints. Moreover the links have only visual properties which means we can’t yet simulate it. However we can load it in rviz for display.
For simulation ability we need to define inertia and collision properties into the monoped.urdf file.
We will add these properties to the monoped.urdf file. Now before we make any changes, its a good idea that we create a copy of monoped.urdf with name monoped_controlled.urdf
Here is the monoped_controlled.urdf file content after editing
In addition to the inertia and collision tags we have added a few tags.
First is the gazebo tag, this tag is required to simulate the block in gazebo, it contains information about the material hardness (whether the material is easily deformable or not) and friction values (static and dynamic).
The Second tag that was added is a link tag with name lowerleg_contactsensor_link. This link will help us detect the contact with ground in later part of this project.
Another added tag is a joint tag by name lowerleg_contactsensor_link_joint, this combined with previous link tag completes the contact sensor positioning on the robot.
Note : In the above code the values used for various inertia is calculated using inertial_calculator tool ( it is a part of ROS). Moreover, to simplify calculation of inertia of different blocks with different shapes, a bounding box approximation is applied i.e. we compute the inertia with respect to the dimensions of the bounding box. Though such value might not be perfect, it is reasonably good to work with.
Step 5
Now we will simulate this robot.
To do so first we need to create a world file. Create a directory named worlds inside ~simulation_ws/src/my_legged_robots_sims/ directory.
Using the IDE create a file low_gravity.world inside worlds directory. This is our world file. Write the following content to it:
In this file the tag gravity helps us to manipulate the gravity inside the gazebo world.
Next, to launch the world we need to create a launch file main.launch. Before creating this file we create a launch directory inside ~simulation_ws/src/my_legged_robots_sims/ directory.
Using the IDE we add the following code to main.launch file
Notice in line 9 we have provided the name of our world file low_gravity.world.
This launch file will only launch an empty world in gazebo with zero gravity. To launch it click on the Simulation menu and select Select launch file option and choose the main.launch item.
To spawn the monoped we need to create another launch file inside the ~simulation_ws/src/my_legged_robots_sims/launch/ directory.
Use IDE to create a new file named spawn_monoped.launch and add following content:
You should see the monoped load in the gazebo world.
We can change the gravity settings in low_gravity.world file and relaunch the robot to see the effect of gravity. Since we have not actuated the robot the robot will fall under the influence of gravity, which is totally fine. This finishes the steps to create the hopper robot using Robot Development Studio as shown in the video.
Checkout the URDF robot creation course in RobotIgniteAcademy: https://goo.gl/NJHwq3
[irp posts=”8194″ name=”All about Gazebo 9 with ROS”]
Part 2
In this second video of a new ROS Development Studio video series, you are going to continue to learn step by step how to create your own hopper simulation, and may be a real version if there is high support to this videos.
In this video we’ll improve our URDF code of the robotic manipulator using XACRO. From the URDF model, finish the robot, creating all joints and links and visualize it using RViz. Up to the end of the video, we will have the model finished, a launch file to visualize it and a RViz and some MACROs to help you in the development of the robot.
From the URDF model, we’re going to define the first two links and visualize them in RViz. Up to the end of the video, we’ll have a basic model, a launch file to visualize it and a RViz configuration file for this specific project.
ROS Inside!
ROS Inside
Before anything else, if you want to use the logo above on your own robot or computer, feel free to download it and attach it to your robot. It is really free. Find it in the link below:
In order to follow this tutorial, we need to have ROS installed in our system, and ideally a ROS Workspace (it can be named simulation_ws). To make your life easier, we have already prepared a rosject with a simulation for that: https://app.theconstructsim.com/l/5a5b6f9f/.
You can download the rosject on your own computer if you want to work locally, but just by copying the rosject (clicking the link), you will have a setup already prepared for you.
After the rosject has been successfully copied to your own area, you should see a Run button. Just click that button to launch the rosject (below you have a rosject example).
My Robotic Manipulator #1: Basic URDF & RViz – Run rosject (example of the RUN button)
After pressing the Run button, you should have the rosject loaded. Now, let’s head to the next section to get some real practice.
Compiling the workspace
As you may already know, instead of using a real robot, we are going to use a simulation. In order to see that simulated robot, we need to have our workspace compiled, and for that, we need a terminal.
Let’s open a terminal by clicking the Open a new terminal button.
Open a new Terminal
Once inside the first terminal, let’s run the commands below, to compile the workspace
cd ~/simulation_ws/
catkin_make
source devel/setup.bash
How the mrm_description package was created
If you check the contents of the ~/simulation_ws/src folder using the Code Editor or the terminal, you will see that it already contains a package named mrm_description there (mrm stands for My Robotic Manipulator). In case you want to know the commands we used to create that package, the commands were the following (you don’t need to run these commands if you already have the rosject).
To create the package that has the urdf package as a dependency, the commands were the following after opening a terminal:
cd ~/simulation_ws/src
catkin_create_pkg mrm_description urdf
We then created a urdf folder inside the mrm_description package with:
cd mrm_description/
mkdir urdf
After the folder was created, we created a file named mrm.xacro using these commands:
cd urdf/
touch mrm.xacro
and we also created the rviz.launch file, used for launching RViz (Robot Visualization tool) with the following commands:
cd ~/simulation_ws/src/mrm_description/
mkdir launch
touch rviz.xacro
You can see the content of these files using the Code Editor, also known as IDE (Integraded Development Environment). In order to open the IDE, just click the Code Editor button, as we can see in the image below:
Open the IDE – Code Editor
Once the Code Editor is open, just navigate to simulation_ws/src/mrm_description/launch/rviz.launhc and simulation_ws/src/mrm_description/urdf/mrm.xacro to see the content of those files.
After opening the IDE, you can browse through folders by double-clicking them. In case you want to create a new folder, right click on the parent folder and choose the option New Folder and type in the name you want to give to the folder.
The mrm.xacro file (My Robot Manipulator xacro file)
If we check the content of the mrm.xacro file, be it using the Code Editor or using the terminal (cat ~/simulation_ws/src/mrm_description/urdf/mrm.xacro), we will find the following:
Then we define a link named base_link , with his visual being a box of width, depth, and height of 1 meter. The origin of the base_link is at the center of the simulated world, at position 0 0 0:
Then we create a joint to connect the base_link we just created, with a link named link_01 that we are about to create. The joint was defined with this code:
In summary, this xacro file is a description of our robot in xml language. The robot is composed of various links and joints. In the above xacro we have two links base_link and link1. The base_link is fixed to the ground. It is connected to the link1 with a revolute joint. The joint allows the link1 to rotate about z-axis. We are defining the visual properties in this file.
The geometry property controls the appearance and origin property controls the positioning of the elements.
The joint element has an axis property which defines the degree of freedom of the links connected with joint. In addition to the axis property, the joint element has limit property to control the range of motion, parent and child property to control the relative motion (the child link moves with respect to the parent link).
Now that we have our robot defined, we need a way of launhcing it. For that, we have the rviz.launch file mentioned earlier. Let understand it:
The rviz.launch file
The content of the rviz.launch file that we created in the previous sections can be seen either using the Code Editor or through the terminal using this command:
In the fist line we start the definition of the launch file using the <launch> tag.
In the second line, we load a ROS parameter called robot_description using the content of of the urdf/mrm.xacro file that is found on the mrm_description package. It is basically the xacro file explained in the previous section.
In order to “put the robot pieces together“, we use the robot_state_publisher:
We also launch RViz in that launch file, and tell it to load the launch/config.rviz file that is also inside our package. Having that config.rviz file, we don’t have to reconfigure the RViz displays each time we open RViz.
Finally, we load the Joint State Publisher that allows us to move/rotate the links of our robot using a Graphical Tool:
To summarize, this launch file helps in the task of launching different nodes together. The rviz.launch file above creates three nodes. The first node is for publishing the robot state, the second node starts RViz and the last node starts a GUI tool that helps in manipulating the joint angle of the robot. The first line (param) helps in locating and loading the xacro file that contains the robot description.
Compiling the workspace
Now that we have everything in place, we need to compile our workspace. For that, we use the following commands:
cd ~/simulation_ws/
catkin_make
If everything went well, you should have an output similar to the following:
...
-- catkin 0.8.10
-- BUILD_SHARED_LIBS is on
-- BUILD_SHARED_LIBS is on
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- ~~ traversing 1 packages in topological order:
-- ~~ - mrm_description
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- +++ processing catkin package: 'mrm_description'
-- ==> add_subdirectory(mrm_description)
-- Configuring done
-- Generating done
-- Build files have been written to: /home/user/simulation_ws/build
####
#### Running command: "make -j8 -l8" in "/home/user/simulation_ws/build"
####
Lauching RViz to see our robot model
In the previous sections we already learned how to open a terminal.
Now, in order to launch RViz, let’s run the following commands in the first terminal:
After running this launch file, you should have seen RViz and the Joint State Publisher. If RViz does not open automatically, just click the Graphical Tools button on the bottom bar of The Construct Desktop. If you don’t know which button is, just hover your mouse over the buttons to know which one opens the Graphical Tools.
After having the Graphical Tools open, feel free to move the joining using the Joint State Publisher. It is going to be difficult to see the joint moving because it has the same red color as the base link, but if you look at RViz closely, you will see it moving.
The GUI tool is like a remote desktop, when it starts you can see there are two tabs at the bottom. One is the RViz tool, and the other is the joint_state_publisher GUI as shown below:
In the RViz window, we should have everything in place. We shouldn’t have the red errors like in the image above, because in the rosject we already provided the config.rviz in the launch file, if you remember well.
What we did for creating that config.rviz file was the following, in RViz:
Changed Fixed Frame to base_link
Added an Axis element
Added a RobotModel element
The images below show the operations described above:
Congratulations. Now you know how to create a basic robot with two links and a joint using Xacro files.
We hope this post was really helpful to you. If you want a live version of this post with more details, please check the video in the next section. Although the video was recorded in a previous version of The Construct platform, it still adds a lot of value:
Youtube video
So this is the post for today. Remember that we have the live version of this post on YouTube. If you liked the content, please consider subscribing to our youtube channel. We are publishing new content ~every day.
Keep pushing your ROS Learning.
Related Courses & Training
If you want to learn more about ROS and ROS2, we recommend the following courses:
![[ROS Projects] – My Robotic Manipulator – #Part 3 – URDF Inertia](https://www.theconstruct.ai/wp-content/uploads/2018/05/My-Robotic-Manipulator-Part-3-URDF-Inertia.png)
![[ROS Projects] Create a Hopper Robot in Gazebo Step-by-Step](https://www.theconstruct.ai/wp-content/uploads/2018/05/Create-a-Hopper-Robot-in-Gazebo-Step-by-Step-Part1.png)
![[ROS Projects] – ROS with Raspberry Pi 3 using Gazebo Face Simulation #Part 4](https://www.theconstruct.ai/wp-content/uploads/2018/04/ROS-Projects-ROS-with-Raspberry-Pi-3-using-Gazebo-Face-Simulation-Part4.png)