IEEE Robotics & Automation Magazine - June 2015 - 18

ros Topics

Integrating ROS and MATLAB
By Peter Corke

he Robot Operating System
(ROS) has gained wide currency for the creation of working
robotic systems, initially in the
laboratory but now also in industry.
Despite ongoing evolution, the fundamental principles of publishing and
subscribing on topics, application-specific messages, invoking services, and
sharing parameters have remained constant. The primary programming environment for those working with ROS is
C++ and Python, though using Java is
also possible.
MATLAB is a powerful tool for
prototyping and simulating control
systems and robotics [1], [2], but, until
very recently, it has not been easy to integrate with ROS. The need for such
integration is evidenced by many
solutions that have been developed, including the JavaScript Object Notation-based rosbridge (http://wiki.ros.
org/rosbridge_suite), the Java-based
ROS-MATLAB bridge package
(https://code.google.com/p/mplab-rospkg/wiki/java_matlab_bridge), and the
ROSlab-IPC bridge (https://alliance.
seas.upenn.edu/meam620/wiki/index.
php?n=Roslab.IpcBridge), among others. However, none of these have
caught on in a big way, perhaps due to
installation and usability concerns.
With the recent release of MATLAB
2015a, there is a better option available
through the newly introduced Robotics
Systems Toolbox Q (RST). This toolbox

Digital Object Identifier 10.1109/MRA.2015.2418513
Date of publication: 18 June 2015

IEEE ROBOTICS & AUTOMATION MAGAZINE

june 2015

has three main areas of functionality:
ROS integration, support for pose represented as special Euclidean group (3)
homogeneous transformations, and
probabilistic-road-map-based path
planning. The remainder of this article
will introduce the ROS functionality in a
tutorial manner. Note that this functionality is an evolution of Mathworks' own
ROS input/output package introduced
in 2014, and the RST ROS application
program interface has some changes
with respect to this earlier package.
Assuming the presence of a running
ROS system with an ROS master, we
initialize the MATLAB ROS subsystem
with the IP address and port number of
the ROS master, e.g.,
rosinit('192.168.1.10',
11311).

If no arguments are provided, then
MATLAB will create an ROS master
and display its URI so that it can be
used by other nodes.
Next, we want to publish on a topic;
so let us take a simple example from the
ROS tutorial. We first create a message
object of the standard string type
msg = rosmessage('std_
msgs/String');

and then set its value
msg.Data = 'hello world';

The message is an object, and its properties are hierarchical and match the
fields of the message. We can read or
write the properties directly without
having to use setter or getter methods.
All that remains now is to publish it.

rospublisher('/MyTopic',
msg);

Alternatively, we could create a publisher object and optionally specify the
message type
pub = r o s p u b l i s h e r ( ' /
M y T o p i c ', ' s t d _
msgs/String');

and then invoke its send method
pub.send(msg);

Various options can be configured
at construction time for the publisher object.
Receiving a topic is just as easy. We
first create a subscriber object for the
particular topic and optionally specify
the message type
sub = rossubscriber('/
M y T o p i c ', ' s t d _
msgs/String').

The constructor has various options to
control buffer size and whether only the
most recent message should be returned.
We read the next message on the topic by
msg = sub.receive(),

which blocks until a message is received, but we could also specify a timeout interval in seconds
msg = sub.receive(5)

An alternative to polling for messages is to establish a callback
sub = rossubscriber('/
M y T o p i c ', ' s t d _
m s g s / S t r i n g ',
@rxcallback)

http://www.wiki.ros https://code.google.com/p/mplab-ros https://alliance http://seas.upenn.edu/meam620/wiki/index

Table of Contents for the Digital Edition of IEEE Robotics & Automation Magazine - June 2015