Lab 1: Run in Gazebo and RViz

Due: Monday, January 27

Overview

In this lab, we are going to create a ROS workspace, a ROS package, launch a Turtlebot and play with it. We also investigate the reasons for using coordinate systems in nowadays robotic systems, and introduce the ROS frames and the integrated tf library. Having that, we will demonstrate the existing coordinate systems on our Turtlebot inside the simulated world of Gazebo, we will create a new static transform and will try to spatially georeference each LiDAR measurement with respect to the newly created ROS frame.

ROS Basics

From now on, we assume that you have already installed Ubuntu 20.04 and ROS Noetic.

Please open a new terminal, and create a new ROS workspace by the following commands (run them line by line).

mkdir -p ~/catkin_ws/src

cd ~/catkin_ws

catkin_make

echo "source ~/catkin_ws/devel/setup.bash" >> ~/.bashrc

source ~/catkin_ws/devel/setup.bash

Take a look at catkin_ws directory and see what happens. You can use ls command to see the files in this directory, or use ls -a to see all files including hidden files. Alternatively, you can open File Explorer and navigate to this folder, and use Ctrl + H to see hidden files. The file .catkin_workspace was created to tell the system that this current directory is a ROS workspace.

Note: If you are fresh new to Linux, the instructions might be a bit hard to understand at this moment. No worries. Please just try it for the time being and you will have a better understanding as we move on. You can always ask us any question you want during lab sessions to help you better understand lab materials. (Remember that there is no stupid question; even for those “too simple to ask” questions, We are always happy to answer.)

Next let’s create a new ROS package.

cd ~/catkin_ws/src

catkin_create_pkg ee144w25 std_msgs rospy

Take a look at your new package ee144w25 and see what happens. You should be able to see a package.xml file and a CMakeLists.txt file. Open them and take a quick look. You may use Google to help you build up a high-level understanding.
After creating a new package, we can go back to our workspace and build this package. This is to tell ROS that “Hey, we have a new package here. Please register it into the system.”

cd ~/catkin_ws

catkin_make

Now the system knows this ROS package, so that you can have access to it anywhere. Try navigating to different directories first, and then go back to this ROS package by roscd command. See what happens when running the following commands.

roscd ee144w25

cd ~/catkin_ws

roscd ee144w25

cd ~/Documents

roscd ee144w25

Congratulations! You have completed the basic ROS tutorials. Take some time to think about how the above steps work.

Set up Turtlebot3 in Gazebo

First let’s upgrade existing packages and install some dependencies for Turtlebot.

sudo apt-get update

sudo apt-get upgrade

Clone and install the turtlebot3 ROS packages in our ROS workspace,

cd ~/catkin_ws/src/

git clone -b noetic-devel https://github.com/ROBOTIS-GIT/turtlebot3.git

git clone -b noetic-devel https://github.com/ROBOTIS-GIT/turtlebot3_msgs.git

git clone -b noetic-devel https://github.com/ROBOTIS-GIT/turtlebot3_simulations.git

cd ../

Gazebo and Turtlebot3 Simulation

In order to spawn the Gazebo inside the simulated world, first we define the type of its model (burger, waffle, waffle_pi), and then we execute the ROS launch script,

export TURTLEBOT3_MODEL=burger

roslaunch turtlebot3_gazebo turtlebot3_empty_world.launch

The turtlebot3 supports teleoperation through geometry_msgs/Twist commands, via the corresponding ROS topic. To use a developed teleoperation script you can execute in a separate terminal,

rosrun turtlebot3_teleop turtlebot3_teleop_key

Note: we will use Turtlebot2 in later labs that involve physical robots. We DO NOT use Turtlebot 3!

Note: If you get this error message /usr/bin/env: ‘python’: No such file or directory, follow these commands.

cd ~/catkin_ws/src/turtlebot3/turtlebot3_teleop/nodes

gedit turtlebot3_teleop_key

# edit line 1 to be #!/usr/bin/env python3

Save and exit.

RViz and TF Visualisation

Initially, we start the Gazebo simulator with the simulated Turtlebot 3 robot. For Turtlebot 3 in rviz, in a separate terminal execute,

roslaunch turtlebot3_gazebo turtlebot3_gazebo_rviz.launch

ROS Frames and TF Listener

ROS frames are fundamental entities in ROS, as they represent the existing coordinate systems of the robotic setup. Particularly, ROS frames can be assigned on any part of the robot, which can be considered rigid, as well as, on any onboard sensor. Thus, each captured measurement can be spatially described in the corresponding ROS frame of the capturing sensor, while multiple frames can be connected to each other spatially and form the ROS frame tree of the ROS setup.
In rviz, on the upper left select Panels and make sure that Views is checked. The Views panel should show up on the right of the rviz window. For Type, select Orbit (rviz).
For our setup, we set Global Options/Fixed Frame to base_link, as it represents the base coordinate system of the Turtlebot3 robot. Also, we by using the Add button of the bottom left panel of RViz, we add the visualization of the TF.

To see the current frames, type rqt in a new terminal, and add TF Tree from Plugins > Visualization from the pop up window.

In order to publish a transformation between two ROS frames that remains static over time, you can use the tool static_transform_publisher from the tf ROS package. For example in our case, it would be ideal to create a frame for the front_bumper of the Turtlebot3, so we can spatially describe all captured ranging measurements in respect to it to avoid any potential collisions as it moves forward.
To do that, we can describe the new front_bumper frame, with respect to the base_link frame of the robot, by executing in a new terminal,

rosrun tf static_transform_publisher 0.069 0 0.01 0 0 0 1 base_link front_bumper 100

Explanation:

x = 0.069: Half the length of the TurtleBot3 Burger (0.138 m total length).
y = 0: Centered on the y-axis.
z = 0.01: Approximate height of the base from the ground.
roll, pitch, yaw = 0 0 0: No rotation between base_link and front_bumper.
After running the command, you can check the transform in RViz. Here is an example command on how to see the changes using the terminal (not the front_bumper):

rosrun tf tf_echo base_link base_scan

This information can be captured also inside a ROS node by using the tf.TransformListener() module. To test it, please initialize a new ROS node inside the ee144w25 ROS package, under the name of tf_listener.py.

cd ~/catkin_ws/src/ee144w25/src/

touch tf_listener.py

gedit tf_listener.py

which will contain,

#!/usr/bin/env python3

import roslib

roslib.load_manifest('ee144w25')

import rospy

import math

import tf

import geometry_msgs.msg

import numpy as np

# initialization of the ROS tf listener

rospy.init_node('tf_listener')

listener = tf.TransformListener()

rate = rospy.Rate(10.0)

# The goal of this node is to continuously listen to the transformation relation

# between the base_link and base_scan ROS frames and print the Translation and Rotation

# of the captured transformation matrix.

while not rospy.is_shutdown():

try:

# Capture the tf of the two frames at the exact moment of the command execution (rospy.Time(0))

(trans, rot) = listener.lookupTransform('/base_link', '/base_scan', rospy.Time(0))

except (tf.LookupException, tf.ConnectivityException, tf.ExtrapolationException):

continue

# Print the Translation and Rotation information, demonstrating Quaternion, Euler, and Rotation Matrix representations

print("The translation is (x,y,z) = " + str(trans))

print("The rotation (quaternion) is (x,y,z,w) = " + str(rot))

print("The rotation (euler) is (r,p,y) = " + str(tf.transformations.euler_from_quaternion(rot)))

rot_mat = tf.transformations.quaternion_matrix(rot)

print("The rotation (rotation matrix) is = \n" + str(rot_mat))

# Assume that a Lidar point is detected, relative to the Lidar's frame

laser_point_detected = [1, 0, 0, 1]

# Update the tf matrix to describe it in the /base_link fram

rot_mat[0, 3] = trans[0]

rot_mat[1, 3] = trans[1]

rot_mat[2, 3] = trans[2]

print("laser_point_detected in base_link frame is: ", np.dot(rot_mat, laser_point_detected))

rate.sleep()

We have to make our Node tf_listener.py executable:

cd ~/catkin_ws/src/ee144w25/src

chmod +x tf_listener.py

Execute the script: (Make sure gazebo and rviz is running)

rosrun ee144w25 tf_listener.py

Programming Tips

We follow ROS conventions to use SI units. (i.e. length in meter, time in second, angle in radian). See ROS Wiki article REP 103 Standard Units of Measure and Coordinate Conventions for more information.
When a new robot is spawned, the forward heading direction is the positive x axis; the leftward direction is the positive y axis; and by right-hand rule, z axis upward. This is also specified in REP 103.
In Gazebo, you can use Ctrl + R to set the robot back to the origin without the need to relaunch. 🤖

Reading Material

ROS Nodes

ROS Topics and Messages

ROS Conventions

Submission

Submission: individual submission via Gradescope (available via Canvas)
Due time: 11:59pm, January 27, Monday
Demo: required
lab1_report.pdf (A template for the report is provided here.) Please include screenshots were possible and describe in detail all followed steps by showing the reasoning and any important remarks. The developed Python code can be included in the end of your report, along with comments for describing the code parts.
Grading rubric:
- + 10% Have the ROS workspace and the ROS package ready.
- + 10% Launch a Turtlebot robot in Gazebo and demo to TAs how you play with it.
- + 10% Create the new front_bumper frame, as described above.
- + 10% Showcase how you can print the transformation matrix between the base_scan frame and the frame of the front bumper front_bumper by using the tf_echo command of the terminal.
- + 10% Create a new ROS node that contains a ROS listener and obtain the transformation the base_scan and the front_bumper frames.
- + 10% Print the translation and rotation matrices from the captured transformation and form the transformation matrix T [4x4].
- + 10% Transform all the ranged positions of the base_scan frame to the front_bumper frame, with the use of transformation matrix T.
- + 15% Teleoperate the robot inside the world and print the transformed non inf ranges. Include a screenshot of the terminal including the robot, the base scan, and the terminal output (print) of the ROS node.
- + 15% Write down what you have learned, your findings and thoughts in lab report (See template here).
- - 10% Penalty applies for each late day. No submission will be accepted beyond four (4) days from the due date.