Understanding the basic working of ROS and its terminology can help you understand existing ROS applications and build your own. This section will teach you important concepts that we are going to use in the upcoming chapters. If you find a topic missed in this chapter, it will be covered in a corresponding later chapter.

There are three different concepts in ROS. Let's take a look at them.

The filesystem level

The filesystem level explains how ROS files are organized on the hard disk:

Figure 6: The ROS filesystem level

As you can see from the figure, the filesystem in ROS can be categorized mainly as metapackages, packages, package manifest, messages, services, codes and miscellaneous files. The following is a short description of each component:

• Metapackages: Metapackages group together a list of packages for a specific application. For example, in ROS, there is a metapackage called navigation for mobile robot navigation. It can hold the information on related packages and helps install those packages during its own installation.
• Packages: The software in ROS is mainly organized as ROS packages. We can say that ROS packages are the atomic build unit of ROS. A package may consist of ROS nodes/processes, datasets, and configuration files, organized in a single module.
• Package manifest: Inside every package will be a manifest file called package.xml. This file consists of information such as the name, version, author, license, and dependencies required of the package. The package.xml file of a metapackage consists of the names of related packages.
• Messages (msg): ROS communicates by sending ROS messages. The type of message data can be defined inside a file with the .msg extension. These files are called message files. We are following a convention that the message files are kept under our_package/msg/message_files.msg.
• Service (srv): One of the computation graph level concepts is services. Similar to ROS messages, the convention is to put service definitions under our_package/srv/service_files.srv.

The computation graph level

The ROS computation graph is the peer-to-peer network of the ROS process, and it processes the data together. The ROS computation graph concepts are nodes, topics, messages, master, parameter server, services, and bags:

Figure 7: The ROS computational graph concept diagram

The preceding figure shows the various concepts in the ROS computational graph. Here is a short description of each concept:

• Nodes: ROS nodes are simply a process that is using ROS APIs to communicate with each other. A robot may have many nodes to perform its computations. For example, an autonomous mobile robot may have a node each for hardware interfacing, reading laser scans, and localization and mapping. We can create ROS nodes using ROS client libraries such as roscpp and rospy, which we will be discussing in the upcoming sections.
• Master: The ROS master works as an intermediate node that aids connections between different ROS nodes. The master has all the details about all nodes running in the ROS environment. It will exchange details of one node with another in order to establish a connection between them. After exchanging the information, communication will start between the two ROS nodes.
• Parameter server: The parameter server is a pretty useful thing in ROS. A node can store a variable in the parameter server and set its privacy too. If the parameter has a global scope, it can be accessed by all other nodes. The ROS parameter runs along with the ROS master.
• Messages: ROS nodes can communicate with each other in many ways. In all methods, nodes send and receive data in the form of ROS messages. The ROS message is a data structure used by ROS nodes to exchange data.
• Topics: One of the methods to communicate and exchange ROS messages between two ROS nodes is called ROS topics. Topics are named buses, in which data is exchanged using ROS messages. Each topic will have a specific name, and one node will publish data to a topic and an other node can read from the topic by subscribing to it.
• Services: Services are another kind of communication method, like topics. Topics use publish or subscribe interaction, but in services, a request or reply method is used. One node will act as the service provider, which has a service routine running, and a client node requests a service from the server. The server will execute the service routine and send the result to the client. The client node should wait until the server responds with the results.
• Bags: Bags are a useful utility in ROS for the recording and playback of ROS topics. While working on robots, there may be some situations where we need to work without actual hardware. Using rosbag, we can record sensor data and can copy the bag file to other computers to inspect data by playing it back.

The ROS community level

The community level comprises the ROS resources for sharing software and knowledge:

Figure 8: ROS community level diagram

Here is a brief description of each section:

• Distributions: ROS distributions are versioned collections of ROS packages, like Linux distribution.
• Repositories: ROS-related packages and files depend on a version-control system (VCS) such as Git, SVN, and Mercurial, using which developers around the world can contribute to the packages.
• The ROS Wiki: The ROS community wiki is the knowledge center of ROS, in which anyone can create documentation for their packages. You can find standard documentation and tutorials about ROS from the ROS wiki.
• Mailing lists: Subscribing to the ROS mailing lists enables users to get new updates regarding ROS packages and gives them a place to ask questions about ROS (http://wiki.ros.org/Mailing%20Lists).
• ROS Answers: The ROS Answers website is the Stack Overflow of ROS. Users can ask questions regarding ROS and related areas (http://answers.ros.org/questions/).
• Blog: The ROS blog provides regular updates about the ROS community with photos and videos (http://www.ros.org/news).

Communication in ROS

Let's see how two nodes communicate with each other using ROS topics. The following diagram shows how it happens:

Figure 9: Communication between ROS nodes using topics

As you can see, there are two nodes, named talker and listener. The talker node publishes a string message called Hello World into a topic called /talker, and the listener node is subscribed to this topic. Let's see what happens at each stage, marked (1), (2), and (3):

1. Before running any nodes in ROS, we should start the ROS Master. After it has been started, it will wait for nodes. When the talker node (publisher) starts running, it will first connect to the ROS Master and exchange the publishing topic details with the master. This includes topic name, message type, and publishing node URI. The URI of the master is a global value, and all nodes can connect to it. The master maintains tables of the publisher connected to it. Whenever a publisher's details change, the table updates automatically.
2. When we start the listener node (subscriber), it will connect to the master and exchange the details of the node, such as the topic going to be subscribed to, its message type, and the node URI. The master also maintains a table of subscribers, similar to the publisher.
3. Whenever there is a subscriber and publisher for the same topic, the master node will exchange the publisher URI with the subscriber. This will help both nodes connect with each other and exchange data. After they've connected with each other, there is no role for the master. The data is not flowing through the master; instead, the nodes are interconnected and exchange messages.

The ROS client libraries are used to write ROS nodes. All the ROS concepts are implemented in client libraries. So we can just use it without implementing everything from scratch. We can implement ROS nodes with a publisher and subscriber, we can write service callbacks, and so on using client libraries.

The main ROS client libraries are in C++ and Python. Here is a list of popular ROS client libraries:

Details of all client ROS libraries are given in the following link: http://wiki.ros.org/Client%20Libraries.

ROS has a variety of GUI and command-line tools to inspect and debug messages. Let's look at some commonly used ones.

Rviz (ROS Visualizer)

Rviz (http://wiki.ros.org/rviz) is one of the 3D visualizers available in ROS to visualize 2D and 3D values from ROS topics and parameters. Rviz helps visualize data such as robot models, robot 3D transform data (TF), point cloud, laser and image data, and a variety of different sensor data.

Figure 10: Point cloud data visualized in Rviz

rqt_plot

The rqt_plot program (http://wiki.ros.org/rqt_plot) is a tool for plotting scalar values that are in the form of ROS topics. We can provide a topic name in the Topic box.

Figure 11: rqt_plot

rqt_graph

The rqt_graph (http://wiki.ros.org/rqt_graph) ROS GUI tool can visualize the graph of interconnection between ROS nodes.

Figure 12: rqt_graph

Note

The complete list of ROS tools is available at the following link: http://wiki.ros.org/Tools

One of the open source robotic simulators tightly integrated with ROS is Gazebo (http://gazebosim.org). Gazebo is a dynamic robotic simulator with a wide variety the robot models and extensive sensor support The functionalities of Gazebo can be added via plugins. The sensor values can be accessed to ROS through topics, parameters and services. Gazebo can use when your simulation needs full compatibility with ROS. Most of the robotics simulators are proprietary and expensive; if you can't afford it, you can directly use Gazebo without any doubt.

Figure 13: Gazebo simulator

As we have discussed, there are a variety of ROS distributions available to download and install, so choosing the exact distribution for our needs may be confusing. Following are answers to some of the frequently asked questions while choosing a distribution:

In this book, we are dealing with two LTS distributions: ROS Indigo, which is a stable release, and ROS Kinetic, the latest one.

Getting started with the installation

Go to the ROS website (http://www.ros.org/), and navigate to Getting Started | Install.

You will get a screen listing the latest ROS distributions:

Figure 14: Latest ROS distributions on the website

You can get the complete installation instructions for each distribution if you click on the Install button.

We'll now step through the instructions to install the latest ROS distribution.

Configuring Ubuntu repositories

We are going to install ROS on Ubuntu from the ROS package repository. The repository will have prebuilt binaries of ROS in .deb format. To be able to use packages from the ROS repository, we have to configure the repository options of Ubuntu first.

Note

Here are the details of the different kinds of Ubuntu repositories: (https://help.ubuntu.com/community/Repositories/Ubuntu)

To configure the repository, first search for Software & Updates in the Ubuntu search bar.

Figure 15: Ubuntu Software & Updates

Click on Software and & Updates and enable all the Ubuntu repositories, as shown in the following screenshot:

Figure 16: The Ubuntu Software & Updates centre

Setting up source.list

The next step is to allow ROS packages from the ROS repository server, called packages.ros.org. The ROS repository server details have to be fed into source.list, which is in the /etc/apt/.

The following command will do this job for ROS Kinetic, Jade, and Indigo:

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

Setting up keys

When a new repository is added to Ubuntu, we should add the keys to make it trusted and to be able to validate the origin of the packages. The following key should be added to Ubuntu before starting installation:

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

Now we are sure that we are downloading from an authorized server.

Installing ROS

Now, we are ready to install ROS packages on Ubuntu. The first step is to update the list of packages on Ubuntu. You can use the following command to update the list:

$ sudo apt-get update

This will fetch all packages from the servers that are in source.list.

After getting the package list, we have to install the entire ROS package suite using the following command:

• ROS Kinect:

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

• ROS Jade:

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

• ROS Indigo:

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

This will install most of the important packages in ROS. You will need at least 15 GB of space in your root Ubuntu partition to install and work with ROS.

Initializing rosdep

The rosdep tool in ROS helps us easily install dependencies of packages that we are going to compile. This tool is also necessary for some core components of ROS.

This command launches rosdep:

$ sudo rosdep init
$ rosdep update

Setting the ROS environment

Congratulations! We are done with the ROS installation, but what next?

The ROS installation mainly consists of scripts and executables, which are mostly installed to /opt/ros/<ros_version>.

To get access to these commands and scripts, we should add ROS environment variables to the Ubuntu Terminal. It's easy to do this. To access ROS commands from inside the Terminal, we have to source the following bash file:

/opt/ros/<ros_version>/setup.bash

Here's the command to do so:

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

But in order to get the ROS environment in multiple Terminals, we should add the command to the .bashrc script, which is in the home folder. The .bashrc script will be sourced whenever a new Terminal opens.

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

We can install multiple ROS distributions on Ubuntu. If there are multiple distributions, we can switch to each ROS distribution by changing the distribution name in the preceding command.

Getting rosinstall

Last but not least, there is the ROS command-line tool, called rosinstall, for installing source trees for particular ROS packages. The tool is based on Python, and you can install it using the following command:

$ sudo apt-get install python-rosinstall

We are done with the ROS installation. Just check whether the installation is proper, by running the following commands.

Open a Terminal window and run the roscore command:

$ roscore

Run a turtlesim node in another Terminal:

$ rosrun turtlesim turtlesim_node

If everything is proper, you will get this:

Figure 17: The turtlesim node

As you know, complete ROS support is only present on Ubuntu. So what about Windows and Mac OS X users? Can't they use ROS? Yes, they can, using a tool called VirtualBox (https://www.virtualbox.org/). VirtualBox allows us to install a guest OS without affecting the host OS. The virtual OS can work along with the host OS in a given specification of a virtual computer, such as the number of processors and RAM and hard disk size.

The Following shows the screenshot of the VirtualBox GUI. You can see the virtual OS list on the left side and the virtual PC configuration on the right side. The buttons for creating a new virtual OS and starting the existing VirtualBox can be seen on the top panel. The optimal virtual PC configuration is shown in the following screenshot:

Figure 18: The VirtualBox configuration

Here are the main specifications of the virtual PC:

In order to have hardware acceleration, you should install drivers from the VirtualBox Guest add-ons disc. After booting into the Ubuntu desktop, navigate to Devices | Insert Guest Addition CD Image. This will mount the CD image in Ubuntu and ask the user to run the script to install drivers. If we allow it, it will automatically install all the drivers. After a reboot, you will get full acceleration on the Ubuntu guest.

There is no difference in ROS installation on VirtualBox .If the virtual network adapter is in NAT mode, the Internet connection of the host OS will be shared with the guest OS. So the guest can work the same as the real OS.

After setting ROS on a real PC or VirtualBox, the next step is to create a workspace in ROS. The ROS workspace is a place where we keep ROS packages. In the latest ROS distribution, we use a catkin-based workspace to build and install ROS packages. The catkin system (http://wiki.ros.org/catkin) is the official build system of ROS, which helps us build the source code into a target executable or libraries inside the ROS workspace.

Building an ROS workspace is an easy task; just open a Terminal and follow these instructions:

Now that we've installed ROS and set up our ROS workspace, we can discuss the advantages of using it. Why is learning ROS so important for robotics researchers? The reason is that ROS is becoming a generic framework to program all kinds of robots. So robots in universities and industries mainly use ROS.

Here are some famous robotics companies using ROS for their robots:

Figure 21: The companies using ROS

You can find them here:

The following is one of the job listings on Fetch Robotics for a robotics application development engineer (http://fetchrobotics.com/careers/):

Figure 22: A typical job requirement for an ROS application engineer

Knowledge of ROS will help you land a robotics application engineering job easily. If you go through the skill set of any job related to robotics, you're bound to find ROS on it.

There are independent courses and workshops in universities and industries to teach ROS development in robots. Knowing ROS will help you get an internship and MS, PhD, and postdoc opportunities from prestigious robotic institutions such as CMU's Robotics Institute (http://www.ri.cmu.edu/) and UPenn's GRAP Lab (https://www.grasp.upenn.edu/).

The following chapters will help you build a practical foundation of and core skills in ROS.

This chapter was an introductory chapter for starting with robotics application development using ROS. The main aim of this chapter was to get started with ROS by installing and understanding it. This chapter can be used as a kick-start guide for ROS application development and can help you understand the following chapters, which mainly demonstrate ROS-based applications. At the end of this chapter, we saw job and research opportunities related to ROS and also saw that lot of companies and universities are looking for ROS developers for different robotics applications. From the next chapter onward, we can discuss different ROS-based projects.