IEEE Robotics & Automation Magazine - December 2014 - 14

ros Topics

ROS Topics: Capabilities
By William Woodall, Marcus Liebhardt, Daniel Stonier, and Jonathan Binney

ne of the challenges of robot
software systems is that they
typically have a large number
of components that interact
with each other. A single robot may
have processes that are doing path planning, obstacle avoidance, manipulation,
sensor processing, and so on. Starting,
stopping, and monitoring these processes to make sure that the right set is
running to accomplish the robot's current task is a challenge. The robot operating system (ROS) "capabilities"
package provides a systematic way of
doing this. This article describes how
capabilities work and how they can be
used in typical robot applications.
ROS provides operating-system-like
features that allow robot developers to
build complex and intelligent robots more
efficiently. ROS provides communications,
development tools,
community infraROS provides
structure, and imoperating-system-like plementations of
common robot
features that allow
functionality. ROS
typically manifests
robot developers to
as a group of loosebuild complex and
ly coupled programs that, when
intelligent robots
run and configmore efficiently.
ured together,
make an entire
robot software system. To help robot developers manage these often complex
groups of programs and configurations,
ROS provides a tool called roslaunch. DeDigital Object Identifier 10.1109/MRA.2014.2360622
Date of publication: 19 December 2014

IEEE ROBOTICS & AUTOMATION MAGAZINE

velopers use roslaunch by defining XML
documents that describe what programs
to run and how those programs should be
connected through configuration.
Historically, one of the issues with
roslaunch files is that they are monolithic. Although roslaunch files can be
written to include other roslaunch files
to compose a larger system, developers
usually end up with several launch files
that they must run to get the robot running. One common solution to this is to
have a single master launch file that just
aggregates all of the robot's functionality, but the issue with this is that the single master launch file is not dynamic
enough for many use cases.
To understand this better, imagine a
robot that has many sensors, some of
which are needed for each specific application. This is analogous to the idea of
applications on a smartphone. Smartphones have many capabilities, but most
applications only use a few at a time.
Similarly, applications for robots may
only require a few of the available capabilities of the robot to function. Also, like
smartphones, there is usually a benefit in
terms of battery life to only running parts
of the robot software system when they
are needed. For example, running the robot's navigation system may not be required while idle or being remotely
controlled. To do this, you need to capture what constitutes the navigation system in the robot's stack of software and
what applications need the navigation
system. This kind of information is what
the new capabilities system (see http://
wiki.ros.org/capabilities) in ROS is designed to capture.

December 2014

How Capabilities Work
Capabilities are defined in terms of interfaces and interface providers.
The interface, which describes a capability, is defined in terms of ROS
primitives such as topics, services, and
parameters. The capability's interface is
the common ground to which both the
robot application developers and robot
developers adhere. The robot application developers will build on these interfaces to create more sophisticated
robot applications.
The robot developers, people who
set up a robot to implement capability
interfaces, will create interface providers for each capability their robot implements. An interface provider
consists of details about the implementation of a particular capability for a
particular robot. These details include a
launch file that implements that capability interface for that robot. This way
a capability is defined by an interface
but requires an implementation that is
defined in an interface provider to be
executed. This allows users who are
trying to build dynamically configured
robots to define the pieces of the robot
software stack separately and compose
them in different ways, depending on
the application.
To orchestrate this, the new capabilities system in ROS comes with a
capability server that is always running on the robot and allows applications to use capabilities when they are
started. When a capability is in use,
the capability server will automatically
execute that capability's associated
launch file. This effectively replaces

http://http:// http://wiki.ros.org/capabilities

Table of Contents for the Digital Edition of IEEE Robotics & Automation Magazine - December 2014