ROS Robotics By Example

A ROS distribution is a set of ROS software packages that can be downloaded to your computer. These packages are supported by the Open Source Robotics Foundation (OSRF), a nonprofit organization. The distributions are updated periodically and given different names by the ROS organization. More details about the ROS organization are available at:

http://www.ros.org/about-ros/

This book is written using Ubuntu 14.04 as the operating system and ROS Indigo as the version of the ROS distribution. Always make sure that you check for any updates for the Ubuntu or ROS versions you are using.

To begin, configure the Ubuntu repositories to allow restricted, universe, and multiverse. Click on the Ubuntu Software Center icon in the launch menu on the left side of your desktop. From the Software Center's top menu bar, navigate to Edit, then to the drop-down menu, and select Software Sources. On the Software & Updates screen, select checkboxes to match the following screenshot:

Ubuntu Software Center Screen

Open a terminal window to set up the sources.list file on your computer to accept software from the ROS software repository at http://packages.ros.org which is the authorized site for the ROS software.

At the $ command prompt, type the following command as one long command:

$ sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu
$(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'

This step allows the operating system to know where to download programs that need to be installed on your system. When updates are made to ROS Indigo, your operating system will be made aware of these updates.

Keys confirm the origin of the code and verify that unauthorized modifications to the code have not been made without the knowledge of the owner. A repository and the keys of that repository are added the operating system's trusted software list. Type the following command:

$ sudo apt-key adv --keyserver hkp://pool.sks-keyservers.net:80 --recv-key 0xB01FA116

Before you begin with the installation, the current system software must be up to date to avoid problems with libraries and wrong versions of software. To make sure your Debian package index is up-to-date, type the following command:

$ sudo apt-get update

$ sudo apt-get install xserver-xorg-dev-lts-utopic mesa-common-dev-lts-utopic libxatracker-dev-lts-utopic libopenvg1-mesa-dev-lts-utopic libgles2-mesa-dev-lts-utopic libgles1-mesa-dev-lts-utopic libgl1-mesa-dev-lts-utopic libgbm-dev-lts-utopic libegl1-mesa-dev-lts-utopic

$ sudo apt-get install libgl1-mesa-dev-lts-utopic

Install the desktop-full configuration of ROS. Desktop-full includes ROS, rqt, rviz, robot-generic libraries, 2D/3D simulators, navigation, and 2D/3D perception. In this book, we will be using rqt and rviz for visualization and also the Gazebo 3D simulator, as well as the ROS navigation and perception packages. To install, type the following command:

$ sudo apt-get install ros-indigo-desktop-full

ROS Indigo is installed on your computer system when the installation is complete!

The ROS system may depend on software packages that are not loaded initially. These software packages external to ROS are provided by the operating system. The ROS environment command rosdep is used to download and install these external packages. Type the following command:

$ sudo rosdep init
$ rosdep update

Your terminal session must now be made aware of these ROS files so that it knows what to do when you attempt to execute ROS command-line commands. Running this script will set up the ROS environment variables:

$ source /opt/ros/indigo/setup.bash

Alternately, it is convenient if the ROS environment variables are automatically added to your terminal session every time a new shell is launched. If you are using bash for your terminal shell, do this by typing the following command:

$ echo "source /opt/ros/indigo/setup.bash" >> ~/.bashrc
$ source ~/.bashrc

Now when a new terminal session is launched, the bash shell is automatically aware of the ROS environment variables.

The rosinstall command is a command-line tool in ROS that allows you to download ROS packages with one command.

To install this tool on Ubuntu, type the following command:

$ sudo apt-get install python-rosinstall

The ROS environment is set up through a number of variables that tell the system where to find ROS packages. Two main variables are ROS_ROOT and ROS_PACKAGE_PATH that enable ROS to locate packages in the filesystem.

To check whether the ROS environment variables are set correctly, use the export command in the following form that lists the ROS environment variables:

$ export | grep ROS

The output of the preceding command is as follows:

declare -x ROSLISP_PACKAGE_DIRECTORIES=""

declare -x ROS_DISTRO="indigo"

declare -x ROS_ETC_DIR="/opt/ros/indigo/etc/ros"

declare -x ROS_MASTER_URI="http://localhost:11311"

declare -x ROS_PACKAGE_PATH="/opt/ros/indigo/share:/opt/ros/indigo/stacks"

declare -x ROS_ROOT="/opt/ros/indigo/share/ros"

If the variables are not set correctly, you will need to source your setup.bash file as described in the Environment setup section of this chapter. Check whether the ROS_DISTRO= "indigo" and the ROS_PACKAGE_PATH variables are correct, as shown previously.

The tutorial that discusses the ROS environment can be found at http://wiki.ros.org/ROS/Tutorials/InstallingandConfiguringROSEnvironment.

Each package contains a manifest named package.xml that describes the package in the Extensible Markup Language (XML) format. In addition to providing a minimal specification describing the package, the manifest defines properties about the package such as the package name, version numbers, authors, maintainers, and dependencies on other packages.

Occasionally, we would like to find packages that we wish to use and display the files involved. This section introduces several useful ROS commands:

The rospack command can be used to list ROS packages, locate packages by name, and determine if a package depends on another package, among other uses. For more information use the following command with the help or -h option in the form:

$ rospack help | less

We will use the turtlesim package for the examples here. To change directories to the location of turtlesim, use the following command:

$ roscd turtlesim

This yields the location to one of the author's laptops as follows:

harman@Laptop-M1210:/opt/ros/indigo/share/turtlesim$

On your computer, the $ command prompt will be preceded by the information about your computer. Generally, that information for our computers will be deleted in our examples using ROS commands. Once you are in the turtlesim directory, the standard Linux commands can be used with the subdirectories or files, or the ROS commands can be used. To determine the directories and files in the turtlesim directory but without changing to the turtlesim directory, use the following command:

$ rosls turtlesim

Here is the result from the home directory of the author's laptop with ROS installed:

cmake  images  msg  package.xml  srv

To see the filenames of the images loaded with turtlesim, specify the images directory in the package as follows:

$ rosls turtlesim/images

The output of the preceding command is as follows:

box-turtle.png            fuerte.png       hydro.svg       palette.png          turtle.png

diamondback.png     groovy.png     indigo.png     robot-turtle.png

electric.png                 hydro.png       indigo.svg      sea-turtle.png

There are various turtle images that can be used. The rosls turtlesim command will also work to show the contents of the turtlesim subdirectories: /msg for messages and /srv for services. These files will be discussed later. To see the manifest, type the following command:

$ roscd turtlesim
$ cat package.xml

This will also show the dependencies such as roscpp for C++ programs.

$ rospack find turtlesim

$ rospack list

$ rospack list | less

$ rospack list-names

$ rospack list-names | grep turtle

Basically, nodes are processes that perform some action. The nodes themselves are really software modules but with the capability to register with the ROS Master node and communicate with other nodes in the system. The ROS design idea is that each node is an independent module that interacts with other nodes using the ROS communication capability.

The nodes can be created in various ways. From a terminal window a node can be created directly by typing a command after the command prompt, as shown in the examples to follow. Alternatively, nodes can be created as part of a program written in Python or C++. In this book, we will use both the ROS commands in a terminal window and Python programs to create nodes.

The ROS nodes are typically small and independent programs that can run concurrently on several systems. Communication is established between the nodes by the ROS Master. The ROS Master provides naming and registration services to the nodes in the ROS system. It tracks publishers and subscribers to the topics. The role of the Master is to enable individual ROS nodes to locate one another. The most often used protocol for connection is the standard Transmission Control Protocol/Internet Protocol (TCP/IP) or Internet Protocol called TCPROS in ROS. Once these nodes are able to locate one another, they can communicate with each other peer-to-peer.

One responsibility of the Master is to keep track of nodes when new nodes are executed and come into the system. Thus, the Master provides a dynamic allocation of connections. The nodes cannot communicate however, until the Master notifies the nodes of each others' existence. A simple example is shown at: http://wiki.ros.org/Master.

$ roscore

... logging to /home/harman/.ros/log/94248b4a-3f05-11e5-b5ce-00197d37ddd2/roslaunch-Laptop-M1210-2322.log
Checking log directory for disk usage. This may take awhile.
Press Ctrl-C to interrupt
Done checking log file disk usage. Usage is <1GB.
started roslaunch server http://Laptop-M1210:46614/
ros_comm version 1.11.13
SUMMARY
========
PARAMETERS
 * /rosdistro: indigo
 * /rosversion: 1.11.13
NODES
auto-starting new master
process[master]: started with pid [2334]
ROS_MASTER_URI=http://Laptop-M1210:11311/
setting /run_id to 94248b4a-3f05-11e5-b5ce-00197d37ddd2
process[rosout-1]: started with pid [2347]
started core service [/rosout]

* /rosdistro: indigo
* /rosversion: 1.11.13

Three commands used extensively in ROS are as follows:

After the roscore command is executed, the terminal window used to execute roscore must remain active, but it can be minimized. In another terminal window, the rosnode list command will cause a list of the ROS nodes that are active to be displayed on the screen. After the command for roscore is executed, only one node rosout will be listed as an active node if you type the following command:

$ rosnode list

The output of the preceding command is as follows:

/rosout

In the second terminal window, list the active topics by typing:

$ rostopic list

The output of the preceding command is as follows:

/rosout
/rosout_agg

Notice that the /rosout node and the /rosout topic have the same designation. In ROS terms, the rosout node subscribes to the /rosout topic. All the active nodes publish their debug messages to the /rosout topic. We will not be concerned with these messages here; however, they can be useful to debug a program. For some explanation, refer to the ROS wiki at http://wiki.ros.org/rosout.

The rosout node is connected to every other active node in the system. The /rosout_agg topic receives messages also, but just from the rosout node so it does not have to connect to all of the nodes and thus saves time at system startup.

The rostopic and rosnode terminal commands have a number of options that will be demonstrated by various examples in this book.

$ rosnode -h

$ rosnode list –h

There are a number of other important ROS terminal commands that you should know. They are introduced and explained using the turtlesim simulator in the upcoming section.

To start turtlesim with ROS commands, we need to open two separate terminal windows. First, issue the following command in the first window if the Master is not already running:

$ roscore

Wait for the Master to complete startup. You can minimize this window but do not close it because the Master must run to allow the nodes to communicate.

The result on your screen will resemble the output discussed previously in the Invoking the ROS Master using roscore section, where roscore was described.

rosrun command

To display the turtle on the screen, use the rosrun command. It takes the arguments [package name] [executable name] , and in this case, turtlesim as the package and turtlesim_node as the executable program.

In the second terminal window, issue the following command:

$ rosrun turtlesim turtlesim_node

You will see an output similar to this:

[ INFO] [1427212356.117628994]: Starting turtlesim with node name /turtlesim
[ INFO] [1427212356.121407419]: Spawning turtle [turtle1] at x=[5.544445], y=[5.544445], theta=[0.000000]

Wait for the display screen to appear with the image of a turtle at the center, as shown in the turtlesim screen in the following screenshot. The terminal window can be minimized, but keep the turtle display screen in view. The turtle is called turtle1 since this is the first and only turtle in our display.

After you have started turtlesim by executing the rosrun command, you will see information about the turtle's position on the screen. The /turtlesim node creates the screen image and the turtle. Here, the turtle is in the center at about x = 5.5, y = 5.5 with no rotation since angle theta is zero. The origin (0, 0) is at the lower-left corner of the screen:

Turtlesim screen

Let's study the properties of the nodes, topics, services, and messages available with the turtlesim package in another terminal window. Thus, at this point, you will have three windows active but the first two can be minimized or dragged off to the side or the bottom. They should not be closed.

In the third window, issue the rosnode command to determine information about any node. First, list the active nodes, using the following command:

$ rosnode list

The output is as follows:

/rosout
/turtlesim

We will concentrate on the /turtlesim node. Note the difference in notation between the /turtlesim node and the turtlesim package.

To see the publications, subscriptions, and services of the turtlesim node, type the following command:

$ rosnode info /turtlesim

The output of the preceding command is as follows:

---------------------------------------------------------------------
Node [/turtlesim]
Publications:
 * /turtle1/color_sensor [turtlesim/Color]
 * /rosout [rosgraph_msgs/Log]
 * /turtle1/pose [turtlesim/Pose]
Subscriptions:
 * /turtle1/cmd_vel [unknown type]
Services:
 * /turtle1/teleport_absolute
 * /turtlesim/get_loggers
 * /turtlesim/set_logger_level
 * /reset
 * /spawn
 * /clear
 * /turtle1/set_pen
 * /turtle1/teleport_relative
 * /kill
contacting node http://Laptop-M1210:38993/ ...
Pid: 2364
Connections:
 * topic: /rosout
    * to: /rosout
    * direction: outbound
    * transport: TCPROS

The following diagram represents a graphical illustration of the relationship of the turtlesim node in elliptical shapes and topics in rectangular boxes:

/turtlesim node

The graph was created using the rqt_graph command as described in the Introducing RQT tools section in Chapter 3, Driving Around with TurtleBot.

We read the output of the rosnode info command and the graph of the turtlesim node and topics in the preceding diagram as follows (ignoring the logging services and the /rosout and /rosout_agg nodes):

A ROS message is a strictly typed data structure. In fact, the message type is not associated with the message contents. For example, one message type is string, which is just text. Another type of message is uint8, which means that it is an unsigned 8-bit integer. These are part of the std_msg package or standard messages. The command form rosmsg list lists the type of messages on your system; it is a long list! There are packages for messages of the type control, type geometry, and type navigation, among others to control robot actions. There are sensor message types used with laser scanners, cameras, and joysticks to name just a few of the sensors or input devices possible with ROS. Turtlesim uses several of the message types to control its simulated robot—the turtle.

For these exercises, keep the roscore and /turtlesim windows active. Open other terminal windows as needed. We will concentrate on the turtle1/color_sensor topic first. You will be typing in the third window.

$ rostopic list

/rosout
/rosout_agg
/turtle1/cmd_vel
/turtle1/color_sensor
/turtle1/pose

$ rostopic type /turtle1/color_sensor

turtlesim/Color

$ rosmsg list | grep turtlesim

turtlesim/Color
turtlesim/Pose

$ rosmsg show turtlesim/Color

uint8 r
uint8 g
uint8 b

$ rostopic echo /turtle1/color_sensor

r: 69
g: 86
b: 255
---

The Parameter Server maintains a dictionary of the parameters that are used to configure the screen of turtlesim. We will see that these parameters are used to define the color of the background for the turtle. Thus, the turtlesim node can read and write parameters held by the Parameter Server.

$ rosparam help

rosparam is a command-line tool for getting, setting, and deleting parameters from the ROS Parameter Server.   Commands:
  rosparam set       set parameter
  rosparam get       get parameter
  rosparam list      list parameter names
<Edited>

$ rosparam list

/background_r
/background_g
/background_b
/rosdistro
/roslaunch/uris/host_d125_43873__51759
/rosversion
/run_id

$ rosparam get /

background_b: 255
background_g: 86
background_r: 69
rosdistro: 'indigo
roslaunch:
  uris: {host_d125_43873__60512: 'http://D125-43873:60512/'}
rosversion: '1.11.13
run_id: 2429b792-d23c-11e4-b9ee-3417ebbca982

$ rosparam set background_b 0
$ rosparam set background_g 0
$ rosparam set background_r 255
$ rosservice call /clear

Another capability of nodes is to provide what in ROS terms is called a service. This feature is used when a node requests information from another node. Thus, there is a two-way communication between the nodes.

You can check the turtle's pose using the /turtle1/pose topic and the message type, /turtlesim/Pose. Carefully note the different notations and meanings. To determine the the message type, run the following command:

$ rostopic type /turtle1/pose

The output is as follows:

turtlesim/Pose

$ rosmsg show turtlesim/Pose

The output is as follows:

float32 x
float32 y
float32 theta
float32 linear_velocity
float32 angular_velocity

We can find the turtle's position, orientation in angle (theta), and its velocity using the rostopic echo command:

$ rostopic echo /turtle1/pose

The output is as follows:

x: 5.544444561
y: 5.544444561
theta: 0.0
linear_velocity: 0.0
angular_velocity: 0.0

This command outputs the result continuously and is stopped by pressing the Ctrl +C keys. The result will show that the turtle is at the center of its screen with no rotation at angle zero and no movement since the velocities are zero.

rosservice call

The turtle can be moved using the rosservice teleport option. The format of the command is rosservice call <service name> <service arguments>. The arguments here will be the turtle's position and orientation as x, y, and theta. The turtle is moved to position [1,1] with theta=0 by running the following command:

$ rosservice call /turtle1/teleport_absolute 1 1 0

The result can be seen in the following screenshot:

turtle after an absolute move

The relative teleport option moves the turtle with respect to its present position. The arguments are [linear distance , angle]. Here, the rotation angle is zero. The command for relative movement is as follows:

$ rosservice call /turtle1/teleport_relative 1 0

Your turtle should now move to x=2 and y=1.