ROS Glossary

ROS Concepts

A service that can be interrupted prior to completion.

A file that contains recorded topic data. See rosbag

callback

A function that is called whenever an event occurs. Events in ROS occur when a subscriber receives a message/ over a topic, a timer expires, or a service returns.

catkin

This build system for ROS, used to generate code from message definitions, compile C++ code into binary form, define package installation instructions, and run unit tests.

client libraries

Programming language specific libraries that enable code to interact with ROS through concepts such as nodes, parameters, publishers, subscribers, etc. The two primary client libraries are rospy (for python) and roscpp (for C++).

computation graph

A network containing all ROS processes and their interconnections. Consists of nodes, the master the parameter server, messages, services, topics, and bags.

CMakeLists.txt

Part of the CMake build system which describes how a package should be built and installed. Much of catkin is implemented using CMake and every ROS package has a CMakeLists.txt which is used to control the build process.

environment variables

Variables stored by the shell. ROS uses several of these to determine where to find packages. They are typically set in setup.bash (for bash) and /setup.zsh) for zsh.

launching

A launch file along with the command line tool roslaunch allow you to perform 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 feature 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. Logs are created from messages published to the rosout topic, using ROS logging statements 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. Use rosclean to clear old log files.

manifest

Alternative name for package.xml. The original build system in ROS was called rosbuild and it used manifest.xml files to identify packages. When the build system switched to catkin the file changed names as well.

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.

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. Packages containing .msg files must add commands in their CMakeLists.txt that cause the .msg files to be converted to language-specific implementations which can then included in your ROS nodes (using import in python and #include in C++).

metapackage: A package used for grouping other packages by declaring them as dependencies. Formerly and colloquially 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 process that, when run, registers itself with the ROS master and serves as the basic unit of computation in ROS. Nodes communicate with each other via topics, services, and parameters.
package: A collection of source code, configuration files, and other resources that implements functionality in ROS. By dividing related functionality into packages, it can be shared with others and reused across projects. All packages must have a package.xml file defining its manifest.
package.xml: A file that must be included in the root directory of any ROS package. The file declares the package name, dependencies, version number, author, and other meta information.

parameters

Globally accessible variables (all nodes can see them) typically containing configuration information or calibration data. They are set and retrieved via the parameter server run by roscore.

publisher

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

remapping

Many ROS names such as topics, services, and parameters can be changed at runtime, allowing multiple nodes of the same type to communicate over different topic names and nodes to be reused in different projects

rosbuild

An old build-system for ROS that was replaced by catkin in ROS Groovy (back in 2012)

service

Request-reply communication between nodes, defined by .srv files.

stack

A stack is an older term for what are now called metapackages

subscriber

Nodes use subscribers to listen to data being published on topics. A callback is issued whenever a new message arrives.

tf

A compatibility layer built on top of tf2 for tracking coordinate systems in ROS.

tf2

The package used to track coordinate systems and transformations in ROS.

time

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

timer

Timers are used to run callbacks at a specified frequency.

topic

A topic is a named channel over which nodes communicate messages. Topics facilitate a one-to-many or many-to-many communication. One or more publishers send messages to a topic and one or more subscribers receive these messages and call a callback function.

URDF

The "Universal Robot Description Format" (of course it is not universal as it cannot describe closed chain robots). This is an XML schema that defines a standard for describing robot models, sensors, environments, etc.

workspace

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

xacro

Most real-world URDFs are built using xacro, an XML macro language. xacro files enables you to use variables, math, and other constructs to generate an XML file.

YAML

YAML is a "markup language" for defining dictionary-like data (e.g., key-value pairs) ROS uses YAML files for defining many parameters and configurations. YAML syntax is also used in command-line options for several ROS tools.

ROS Utilities

This is a list of tools I commonly use.

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_make

Builds targets contained in a workspace. Must be executed from the root of the workspace. This is the simplest and fastest ROS build tool but it builds all packages as a single CMake project which often leads to difficulties.

catkin_make_isolated

Builds each package in your workspace as a separate CMake project. This also allows including non-catkin CMake project in the workspace.

catkin_tools

The ROS build tool that is still in "beta", but works quiet well. It has the nicest interface of all the catkin build tools.

catkin_lint

A tool for finding issues with catkin package.xml and CMakeLists.txt files.

vcstool

This command/package is used for updating and installing multiple source-code-based packages into a workspace.

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 which can then be read by vcstool to enable compiling a workspace and its dependencies from source.

rosmsg

Display information about messages including message definitions, packages using a message, and the messages defined in a package.

rossrv

Display information about services including service definitions, packages using a service, and the services defined in a package.

rosdep

Used for installing system dependencies for ROS packages. Can be used across many different Linux distributions

roslaunch

When called with a .launch file, starts many nodes at once, sets parameters, automatically respawns crashed nodes, and automatically start master.

roscd

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

rosnode

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, and raw values.

rosparam

List, get, and set parameters

roscore

Start the master and the parameter server.

roscp

Copy files from ROS packages

rosed

Used to automatically open ROS files from a given ROS package in a text editor

rosls

View contents of a package/metapackage or location

rosrun

Start a nodes.

roswtf

Diagnosing common issues with a ROS system.

rqt

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 but you can also create ;your own GUI tools

rviz

The primary 3D visualization tool used in ROS.

ROS Packages

This is a brief list of packages and non-ros libraries that you may encounter.

armadillo: This is a C++ matrix library that works as a front-end to standardized linear algebra code.
bullet: Bullet is a non-ROS physics library that is a system dependency of ROS that is used in many of the geometric calculations done in tf. It's python version pybullet is a popular simulation engine in the machine learning community and is the way that most people interact with bullet currently.
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 conversions between ROS image formats and OpenCV image formats.
dynamic_reconfigure: Provides a mechanism for changing a variety of node configurations without having to restart the node.
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. It is probably the most popular C++ matrix library; however, I find armadillo to have a cleaner syntax and more versatile since it directly uses BLAS and LAPACK instead of being a complete re-implementation.
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: 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. Capabilities include rectifying distorted images, generating disparity maps, and converting color images to grayscale. The idea is to chain the topics of these nodes together so the final output image that you receive has already gone through basic processing steps.
image_transport: 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.
MoveIt!: MoveIt! is the primary package for path planning and manipulation in ROS.
navigation: This is a metapackage that enables safe 2D navigation of mobile robots. It includes tools for estimation, localization, and planning.
nodelet: Allows multiple nodes to share memory with a zero copy transport between them by running them in the same process. Nodelets are extremely useful when working with message types that have a significant memory footprint such as sensor_msgs/Image and sensor_msgs/PointCloud2, but they are only accessible through C++.
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.
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.
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 many packages 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). It appears to be the most recently updated of the several ROS camera packages.
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.