ROS Glossary

actions

Preemptable (interruptable) services. If you have a service that takes a long time (moving a robot arm), you can use actions to make them interruptable.

bags

A bag is a file that contains recorded topic data. rosbag is the package that defines command line tools and APIs for interacting with bags.

callback

A callback is a function that gets "connected" to a particular event. The most common usage would be a function inside of a node that gets called every time a message gets published on a particular topic.

catkin

This is the primary build system of ROS. catkin is used to convert message definitions into useful code, C++ code into executables, define installation instructions for packages, and other things. More about these ideas can be read on the catkin conceptual overview page.

client libraries

these are the "glue" that tie ROS concepts together with code that you write. For example, rospy is the client library that allows a user to write Python code that interacts with the ROS world via publishing, subscribing, parameters, etc. There are several different client libraries, but the most commonly used are roscpp and rospy; rosjava and roslisp are both used occasionally.

CMakeLists.txt

This file tells catkin how and what to build in a particular package.

environment variables

ROS uses a variety of environment variables to define where packages are located, which ROS version you are using, where to look for the ROS master, to identify your machine, and more. These are typically set via setup.bash files in your workspace.

launching

A launch file along with the command line tool roslaunch allow you to do many ROS operations with a single command. You can set parameters, run nodes, include other launch files, parse command line arguments, and more.

latching

When a publisher is created, if it is set to latch, then every time a new subscriber to that publisher's topic is created, it will automatically receive a copy of the last message that was published on that topic. This can be useful for topics that are only published occasionally (like map data or status indicators).

logging

ROS has a special mechanism for storing, sorting, filtering, etc. messages that are printed to the terminal from running nodes. This is done via the rosout topic and with ROS logging instead of standard print statements. Log files can be sorted and searched in real-time via rqt_console, and they can be parsed/searched manually by looking in the '~/.ros/log/' directory.

manifest

A manifest is an XML file that must be included in the root directory of any ROS package. The file declares the package name, dependencies, version number, author, and more. In rosbuild, the old ROS build system, this file was named manifest.xml; In catkin, the new build system, the file is named package.xml.

master

The master is a ROS process that helps nodes locate each other and establish communication channels based on their publisher/ subscriber relationships and any services. The master also manages the parameter server. The master is typically started through the roscore command-line tool, or it is automatically started via a roslaunch call.

MD5

Messages are serialized to facilitate communicating their data structures between nodes that may be in different languages. For this to work, both nodes must know how and what data was serialized. ROS uses an MD5 hash calculation for verifying this information. This is one of the primary issues in interoperability between different versions of ROS i.e. different versions may have different message definitions, resulting in different MD5 hashes.

message

A .msg file defines the contents of a ROS message using a simple text description format. A message is a data structure that is communicated over a ROS topic. During a catkin_make invocation, these .msg files are used to generate language-specific implementations of these data structures for use in the client libraries e.g. a simple message definition automatically gets converted into both a Python class that can be used with import, and a C++ header that can be used with #include.

metapackage

A metapackage is a way of building a collection of ROS packages. The metapackage does not install files, contain any code, or any other common package files. Rather, it simply lists dependencies on a group of other packages. If one installs the metapackage, they typically automatically install all its dependencies (usually via apt-get). A metapackage is the catkin replacement for the rosbuild concept of a stack. Often metapackages are still referred to as stacks e.g. "the navigation stack".

names

All elements in the ROS computation graph (nodes, services, topics, parameters, etc.) must have a valid graph resource name. The master uses these names when forming connections, and they are an important part of how simple systems can scale up to complex systems through encapsulation.

node

A node is simply a process that, when run, performs some sort of computation in the ROS world. Nodes communicate with each other via topics, services, and parameters.

package

ROS software is organized into packages. A package may include nodes, configuration files, non-ROS libraries, launch files, and more. All packages must have a package.xml file defining its manifest.

parameters

Parameters are globally accessible variables (all nodes can see them). Typically these contain things like configuration or calibration data. They are set and retrieved via the parameter server run by the master.

publisher

Nodes use publishers to send data, or "publish" data, on a particular topic.

remapping

Many ROS names such as topics, services, and parameters can be "remapped" at the command line. This allows multiple nodes of the same type to be started with different configurations. It also facilitates re-use of general nodes in specific cases.

rosbuild

Up until the Fuerte version of ROS this package provided a set of CMake macros for compiling ROS packages. This has largely been replaced by catkin.

service

A service defines a request-reply communication paradigm between nodes. There are special .srv service definition files which are essentially just pairs of messages; one for the request and one for the reply.

stack

A stack is simply a collection of packages. This is a rosbuild-only concept that was replaced by a metapackage.

subscriber

Nodes use subscribers to listen to data being published on topics.

tf

This is a special package and topic for tracking transformations between coordinate frames. Many robotic systems rely heavily on geometric calculations and tf is the primary way to do these calculations within ROS.

time

ROS has built-in primitives for defining the current ROS time. Often messages are timestamped, and this can be an important way of "synchronizing" portions of your system.

timer

Timers are used to get callbacks to run at a specified frequency. This is useful for polling things like keyboard input, publishing "heartbeat" messages, and many other things.

topic

A topic is a named channel over which nodes communicate messages. Topics facilitate a one-to-many or many-to-many communication paradigm i.e. one subscriber publishing a message on a topic can have many subscribers listening to that topic. There can also be multiple publishers all publishing on the same topic; all subscribers would receive all copies of published topics regardless of which publisher the message originated from.

URDF

Stands for "Universal Robot Description Format". This is an XML schema that defines a standard for describing robot models, sensors, environments, etc.

workspace

A workspace is simply a directory where you develop, compile, and install catkin packages. Typically a user will work out of a single workspace, but workspaces do allow chaining/overlaying so that you can combine several different workspaces in varying ways to create different "effective-workspace" configurations.

xacro

Most real-world URDFs are built using xacro. xacro is a simple XML macro language. With xacro, you can write simple, easy to read XML-like files that include things like variables, basic math, and looping constructs. This simple file then gets expanded into a valid XML file once it has been processed by xacro.

YAML

YAML is a simple "markup language" for defining dictionary-like data i.e. keys pointing to values. ROS uses YAML files for defining many parameters at once, and the command line options for rostopic are based off of YAML syntax.

This is not a comprehensive list, but rather the command line tools I find myself using the most often.

catkin_create_pkg

Automatically create a new directory with a template CMakeLists.txt and package.xml – the two files required by all ROS packages. Allows you to list dependencies and have them automatically be filled out in the package.xml.

catkin_init_workspace

Creates a symlink from your workspace src directory to a CMake file located in your current ROS install. This is a required step for catkin to function properly.

catkin_make

Builds targets contained in a workspace. Must be executed from the root of the workspace.

catkinize

This command calls several scripts that are designed to help the transition from rosbuild to catkin.

catkin_lint

This is a relatively new package designed for finding issues with catkin package.xml and CMakeLists.txt files.

rosinstall

This command/package is used for updating and installing source-code-based packages. It is an important tool for building ROS from source. Often large collections of associated packages can be cloned from source repositories automatically using rosinstall e.g. all of Baxter's required source code is added to a workspace by cloning a rosinstall file, and then using the rosinstall command line utility to clone all of the required Git repositories into your workspace.

rosmaster

This is an executable that actually implements the master by importing and executing a Python module called rosmaster. You should never need to interact with this command, users use roscore to start the master.

rosservice

This can be used for listing and calling services

rosbag

This is a command line tool for creating, analyzing, playing, etc., bag files

rosinstall_generator

Used for creating rosinstall files

rosmsg

Tool for displaying information about messages including message definitions, packages using a message, messages defined in a package, and more.

rossrv

This is basically the same as rosmsg, but for services

rosdep

Used for installing system dependencies for ROS packages. Can be used across many different linux/unix distributions

roslaunch

When called with a .launch file, this tool can start many nodes at once, set parameters, automatically respawn crashed nodes, and automatically start master.

roscd

Change directory to the location of a package/metapackage using just the package name.

rosnode

This is used to control and display information about running nodes. It can list nodes, kill nodes, display topic and parameter information for a particular node, and more.

rosclean

Used for checking disk usage and clearing out ROS log files.

rospack

Displays information about packages, and it is used by catkin for determining information about packages.

rostopic

Display debug information about ROS topics including publishers, subscribers, frequency, raw values, etc.

rosparam

Tool for listing, getting, and setting parameters

roscore

This is used for starting the master

roscp

Copy files from ROS packages

rosed

Used to automatically open ROS files in a text editor

rosls

View contents of a package/metapackage or location

rosrun

This the command for starting nodes.

roswtf

A tool for diagnosing common issues with a ROS system.

rqt

rqt is a Qt-based framework for GUI development in ROS. The rqt_common_plugins metapackage provides many pre-made ROS GUIs that are great for working with ROS. Built in tools include bagfile plotting, playing, and recording, visualization of the /tf tree, image stream viewers, and more.

rviz

rviz is the primary 3D visualization tool used in ROS.

This is a brief listing of some common packages/metapackages that you are likely to encounter this year.

bullet

Bullet is a non-ROS physics library that is a system dependency of ROS because it is used in many of the geometric calculations done in tf.

camera_calibration

This is a ROS package that allows easy calibration of monocular and stereo cameras using a checkerboard pattern.

cv_bridge

cv_bridge is part of the vision_opencv metapackage. It allows easy conversions between ROS image formats and OpenCV image formats.

dynamic_reconfigure

This package provides a mechanism for changing a variety of node configurations without having to restart the node. Essentially you setup the node to have a special callback that gets executed when the value of a reconfigurable quantity is changed.

eigen

Eigen is a C++ template library for linear algebra, matrix math, etc. It is a system dependency of ROS, and many core ROS packages use Eigen for computation.

gazebo

Gazebo is a standalone robotics simulation tool that is developed by OSRF. It is designed to integrate nicely with ROS, and ROS provides several tools for the interface.

geometry_msgs

This is a package that contains a collection of ROS message definitions for common geometric primitives such as points, vectors, and quaternions.

image_pipeline

The packages contained in this metapackage are designed to fill in the gap between a camera driver and an image processing node. The nodes in these packages implement algorithms that are extremely common in image processing so that you don't have to do it. Capabilities include rectifying distorted images, generating disparity maps, and converting color images to grayscale. The idea is that you setup these nodes to subscribe to the topics produced by a camera driver, and then your image processing nodes can subscribe to the topics published by these nodes and skip performing these common steps. Packages include image_proc, image_view, and camera_calibration

image_transport

This package supports transparent compression of images. Quoting from their Overview: When working with images we often want specialized transport strategies, such as using image compression or streaming video codecs. image_transport provides classes and nodes for transporting images in arbitrary over-the-wire representations, while abstracting this complexity so that the developer only sees sensor_msgs/Image messages.

joystick_drivers

A metapackage that provides tools for working with a variety of joysticks and game controllers (PS3, XBox, wiimote, etc.).

kdl

KDL stands for "Kinematics and Dynamics Library" and is part of the Orocos project. Several ROS tools, most notably MoveIt!, rely heavily on KDL for geometric computation.

libuvc_camera

Package providing a ROS interface to USB cameras.

MoveIt!

MoveIt! is, quote, MoveIt! is state of the art software for mobile manipulation, incorporating the latest advances in motion planning, manipulation, 3D perception, kinematics, control and navigation. It provides an easy-to-use platform for developing advanced robotics applications, evaluating new robot designs and building integrated robotics products for industrial, commercial, R&D and other domains.

navigation

This is a metapackage that enables safe 2D navigation of mobile robots. It includes tools for estimation, localization, and planning.

nodelet

This package is designed to allow two nodes to share memory with a zero copy transport between them. Essentially this is accomplished by actually starting both nodes in the same process and using zero copy pointers to share the memory between the nodes. Nodelets are extremely important when working with message types that have a significant memory footprint such as sensor_msgs/Image and sensor_msgs/PointCloud2.

ompl

The Open Motion Planning Library is used within ROS for motion planning. Notably, MoveIt! uses OMPL for its default planners.

OpenCV

OpenCV is an extremely popular open-source computer vision and machine learning software library. Through tools such as cv_bridge, already-existing image processing code utilizing OpenCV can easily be converted to work within the ROS framework.

openni_launch

A package that facilitates using OpenNI-compliant devices with ROS. Specifically, most people use this for Kinects and ASUS Xtion PRO LIVE devices.

openni_tracker

This package uses the NITE skeleton tracking library in conjunction with an OpenNI-compliant device to provide estimates of human poses.

orocos

The Orocos project is broken into 3 main parts: i) the Kinematics and Dynamics Library (KDL) ii) the Bayesian Filtering Libarary (BFL) iii) Orocos Toolchain (OT). All three of these parts are used by various core packages in the ROS world. (KDL = MoveIt!, BFL = robot_pose_ekf, OT = rtt_ros_integration).

pcl

The Point Cloud Library (PCL) is a standalone project for 2D and 3D image and point cloud processing. It is used extensively by ROS users.

pocketsphinx

This is a simple wrapper around CMU's Pocket Sphinx speech recognizer. This makes it easy to add voice control to your robot.

pykdl_utils

This package contains simple tools for parsing URDFs and converting them into datatypes understood by KDL. This package combined with the Python bindings to KDL (PyKDL) allow you to use KDL primitives to perform geometric calculations on mechanisms defined by a URDF. For example, you can compute forward/inverse kinematics and manipulator Jacobians,

Qt

Qt is a cross-platform framework most-commonly used for creating GUIs. Qt is used for creating nearly all GUIs that you will use in the ROS world.

robot_localization

Nonlinear state estimation through sensor fusion and an arbitrary number of sensors.

robot_pose_ekf

This package uses an EKF to estimate the 3D pose of a robot based on pose measurements coming from wheel odometry, IMU sensors, and visual odometry.

roscpp

This is the client library for C++. It allows C++ programmers to easily interface with ROS topics, services, and parameters.

rosh

rosh is a Python scripting and runtime environment. Combined with IPython, this provides a very interface for interacting with topics, services, parameters, and nodes. Once learned, it can be a great debugging tool.

rospy

rospy is a pure Python client library for ROS. We will use it extensively in this course.

rosserial

This metapackage defines a protocol for transmitting standard ROS serialized messages/services over a character device such as a serial port. This is commonly used for transmitting data between a microcontroller and a ROS node.

sensor_msgs

A package containing a collection of message definitions used with sensors.

std_msgs

A package containing a collection of standard ROS messages.

tf

This package allows users to track multiple coordinate frames over time. It is extremely important in nearly all ROS systems. Technically, tf isn't actually used anymore. Most of the tf functionality has been replaced by tf2. However, the developers of tf2 created a backwards-compatible API, and most people still use the old tf API (even though they are calling tf2 functions).

tf2

The second generation transform library; this has replaced tf.

topic_tools

This package provides tools for redirecting, throttling, transforming, and multiplexing topics.

turtlesim

This is a ROS package made for teaching basic ROS concepts.

urdf_parser_py

This is a simple API for parsing URDF files in Python.

usb_cam

A ROS driver for V4L cameras (most webcams).

visualization_msgs

This package contains several message definitions used specifically for visualization. rviz contains plugins that can already display and interact with the messages defined in this package. Using these messages is a very easy way to build 2D/3D user interfaces and displays.