Goran .

Ferenc
Research
LOLA Institute, Belgrade

Maja M. Lutovac
Research
LOLA Institute, Belgrade

Jelena Z. Vidakovi
Research
LOLA Institute, Belgrade

Zoran . Dimi
Research
LOLA Institute, Belgrade

Vladimir M. Kvrgi
Research
LOLA Institute, Belgrade

Distributed Robot Control System

Based on the Real-Time Linux Platform
This paper presents a development of a new distributed control system for
robots control. The system is based on the real-time Linux platform on
which OROCOS open architecture software is set designed specifically for
creating applications of this type. The system consists of components of
various structures and with different roles. They can be distributed to
different hardware platforms with the same operating system. Components
can communicate through the CORBA protocol. The system is designed as
a modular solution that allows easy connection and disconnection of
components with various functions depending on the needs of applications
including communicatation with different types of hardware. That way the
structure of the system remains the same.
Keywords: robot control system, distributed control system, real-time
Linux, OROCOS.

1. INTRODUCTION

Industrial robots are included in a wide range of

applications today, so there are many configurations,
physical shapes and drive robot systems. As the demand
for increased performances is constantly growing,
requirements for better and more complex controllers
are on the rise.
There are two solutions to deal with problem. First,
it is possible to retrofit robots, which includes
replacement of some working parts (machine parts,
machine hardware) and the development of all software
features. These changes are significant and expensive
and take a long time. An open architecture appears as a
alternative solution to problem. This way, almost all
features in the design can be changed by everyone as
well as by the original manufacturer. The price of the
development becomes less and development requires
less time. These benefits are achieved by using open
architecture and open source software platforms.
Development of a new control system for Lola
Institutes robots started on a previous version of Lola
Institutes robot controller developed on the OS-9 realtime platform. Unlike the previous version which
required a specific set of hardware the new version of
the system is developed on the real-time Linux
platform, where the Linux kernel is patched with
Xenomai. OROCOS (Open Robot Control Software)
libraries are installed on this platform and designed
specifically for the development of applications for
robot control. In this way, the real-time part of the
control system is completely changed regard to previous
version of the system. New control system is open
Received:
Accepted: March
2008 to the
architectureJanuary
and 2008,
is modernized
according
Correspondence
to:
Dr
John
Smith
development of similar control systems in the world,
Faculty
of greater
Mechanical
Engineering,
achieving
efficiency
and speed [1].
Kraljice
Marije 16, 11120 Belgrade 35, Serbia
2.
OROCOS
E-mail: jsmith@mas.bg.ac.rs
Faculty of Mechanical Engineering, Belgrade. All rights reserved

OROCOS (Open Robot Control Software) is a

European project, started on September 1 st, 2001. Three
laboratories are participating: the Katholieke
Universiteit Leuven (KULeuven, Belgium, project
contractor), the Laboratory for Analysis and
Architecture of Systems (CNRS/LAAS, France) and
Kungl Tekniska Hgskolan (KTH, Sweden). Many
other European laboratories participate in the
discussions and design [2].
The project aims at producing an open source
software framework, by providing a functional basis for
general robots control. The software intended to be
platform independent, but it is also thought
as application independent.
The OROCOS codebase is divided into modules or
libraries. There are generally three types of modules:

Support module. This module is software

without functional robotics content, but it is needed to
build a working environment for robot control system
such as real-time operating system, software component
configuration tools, 3D visualization and simulation,
numerical libraries, inter-process communication,
documentation writing tools, etc.

Robotic module. This module is software that

implements specific robotics algorithms, kinematics and
dynamics of kinematic chains, servo controllers, motion
planners for mobile robots, serial and parallel
manipulators, Bayesian and Neural Network estimators,
etc. The robotic module makes use of one or more
supporting modules.

Components. These are CORBA (Common

Object Request Broker Architecture) objects with their
IDL (Interface Description Language) descriptions.
These components are constructed out of the previous
two types of modules and they are the building blocks
with which users assemble their robot control software
FME Transactions (200x) XX, x-x

environment.
Open standards are very important for efficient
sharing of software and for its cooperative development.
Only an open source project can guarantee the optimal
use of open standards. The most important standards
that the OROCOS project supports are:

The CORBA IDL for object embedding.

Through the IIOP (Internet Inter-Orb Protocol), all
different implementations of CORBA are interoperable.
CORBA also has a real-time extension, which is very
important for robot control.

The structured document language XML for

configuration and data files.

Modelica for modeling of dynamical systems.

DocBook and LATEX for documentation. Both

are platform independent, open source and can be
translated into many other formats and as such they are
the preferred text processing vehicles.
OROCOS does not want to impose a standard
programming language. The philosophy behind this
strategy is that the best tool for the job should be used.
The CORBA middleware is able to work in an
heterogeneous programming language environment.
The OROCOS software system uses support from
other open source software projects. Some of the
projects that OROCOS can be built on are:

Octave is a very rich numerical library that

uses the same foundations as, and in its scripting form is
very compatible with, Matlab.

Real-Time Linux and/or RTAI, which are realtime kernel extensions to Linux; or the Linuxindependent eCos.

Xenomai is a real-time development

framework cooperating with the Linux kernel, in order
to provide a pervasive hard real-time support to userspace applications [3].

Comedi is a library for real-time device

drivers, such as AD/DA cards.

Various packages and open formats for 3D

visualization: VRML, Java3D, OpenGL with
OpenInventor or Coin3D, etc.
The OROCOS project supports four C++ libraries:
the Real-Time Toolkit, the Kinematics and Dynamics
Library, the Bayesian Filtering Library and the
OROCOS Component Library.

The OROCOS Real-Time Toolkit (RTT) is not

an application itself, but it provides the infrastructure
and the real-time functionalities to build robotics
applications in C++.

The OROCOS Component Library (OCL)

provides some ready to use control components.

The OROCOS Kinematics and Dynamics

Library (KDL) is a C++ library which allows
calculating kinematic chains in real-time.

The OROCOS Bayesian Filtering Library

(BFL) provides an application independent framework
for inference in Dynamic Bayesian Networks, recursive
information processing and estimation algorithms based
on Bayes' rule, such as Kalman Filters, Particle Filters
(Sequential Monte methods), etc.
The OROCOS applications are composed of
software components, which form an applications
2 VOL. xx, No x, 200x

specific network. When using OROCOS, engineers can

choose to use predefined components, or build their
own components, using the OROCOS Real-Time
Toolkit. Components work together, cooperatively. For
example, the application template for motion control
contains components for path planning, position control,
hardware access and data reporting. The components are
chosen as such that their interfaces are compatible.
A single component may be well capable of
controlling a whole machine, or is just a small part in a
whole network of components, for example an
interpolator or kinematic component. The components
are built with the Real-Time Toolkit and optionally use
of any other library (like a vision or kinematics toolkit).
Most users will interface components through their
(XML) properties or command/method interface in
order to configure their applications. Besides defining
the above component communication mechanisms,
OROCOS allows the Component or Application Builder
to write hierarchical state machines which use these
primitives. This is OROCOS way of defining
application specific logic.
2.1 OROCOS REAL-TIME TOOLKIT

The Real-Time Toolkit is referred to as middleware

because it lies between the application and the operating
system, as seen in Figure 1. It allows setup, distribution
and the building of real-time components and also takes
care of real-time communication and execution of
software components [4].

Figure 1. OROCOS Real-Time Toolkit as middleware

The Real-Time Toolkit is structured in layers on the

top of operating system and the I/O devices, as shown in
Figure 2.

Figure 2. OROCOS Real-Time Toolkit layers

Considering an OROCOS component is built upon

Real-Time Toolkit (RTT) library, it allows designers to
FME Transactions

build their components which are configurable using

XML files, accessible over a network and listen to a
scripting interface, which allows components to be
controlled using text commands. OROCOS Device
Interface (DI) defines how to interact with analog and
digital I/O and encoders. A component which accesses
I/O devices can use the OROCOS DI. Components can
make use of external libraries as well.
OROCOS components which use only the RealTime Toolkit are portable over different processor
architectures and Operating Systems (OS). OROCOS
has an internal OS abstraction which allows the
components to run on any supported architecture. When
some component uses an external library portability
depends on these libraries..
2.2 OROCOS COMPONENT INTERFACE

The system is designed as a modular solution that

consists of components. Components are basic units
which executes one or more action with a specific
activity. They are created using RTT OROCOS libraries.
In this way, OROCOS provides an interface for
components design. Components can also use the native
libraries of the operating system. There are four policies
for
the
control
of
component
activities:
NonPeriodicActivity, PeriodicActivity, SequentialActivity and SlaveActivity [2].
Each component inherits a public interface from its
base class (TaskContext), which defines primitives for
component interactions: Events, Methods, Commands,
Properties and Data Port, as seen in Figure 3.
In the development of the system presented in this
paper basic components of OROCOS OCL library are
used: TaskBrowser, DeploymentComponent and
ReportingComponent.
The TaskBrowser is a component used to interact
with other components. Each OROCOS component
inherits a standard interface through the TaskContext
base class, which is used by the TaskBrowser to interact.
It works like a text console, receiving command lines

and executing them.

Figure 3. OROCOS component interface

The DeploymentComponent is a component used to

load and configure other components from descriptions
in XML files. The system configuration is performed by
connecting the components with their peers and their
Data Ports. With all connections done, the Properties of
each component, as well as the component activity are
updated from that file.
The ReportingComponent is used to monitor and
capture data exchanged by other components. This is
performed by connecting as a peer of the components to
be monitored and attaching to the specified Data Ports.
3. CONTROL SYSTEM ARCHITECTURE

Components that are designed by the developer make

the basic architecture of the system. This architecture is
based on the components model for different
independent functional blocks of the system. Each
component model can be instantiated in a component by
using the specific parameters of a given robot. The basic
block model of the system is given in Figure 4 [5-12].

Figure 4. Block model of the system architecture

FME Transactions

VOL. xx, No x, 200x 3

The Sampler is the component that generates the

sampling rate of the control loop and synchronizes the
other components. It generates an Event which is
received by the other components, automatically
triggering a control cycle. The Sampler is configured in
the XML file to generate periodic Event on every 1 ms.
The Interpolator component is a trajectory generator.
It calculates the reference position values that have to be
sent to the Controller component. Every 5 ms new
values are written in Data Port DesiredPosition. The
position trajectory generated by the Interpolator is
implemented in such a way that gives trapezoidal
velocity profile. It is one of the most important
component in the system. Many OROCOS control
systems use nAxisGeneratorPos component from the
OCL library as a trajectory generator. The
nAxisGeneratorPos
calculates
references
using
OROCOS kinematics and dynamics libraries.
In the development of our new system OROCOS
KDL library is not used. The Interpolator component
implements the algorithms developed at the Lola
Institute [7]. The interface of this component to the rest
of the system required a change in the original form of
these algorithms, so this component can be included
into system that is designed on OROCOS platform.
The Controller component model abstracts the
system controller. Every 1 ms this component sends
reference velocity values that have to be reached. It
writes velocities into its Data Port OutputVelocity.
When the Sensor component writes position values
from the sensor to SensorPosition Data Port (on every 1
ms) it triggers a call to the Controllers virtual function
which should compute the control signal and write it to
the OutputVelocity Data Port. That means that the
Controller has five changes to drive the Actuator
component to the position sent by the Interpolator.
In this project the nAxesControllerPos component
from the OROCOS OCL library is used. It uses a
position feedback law to calculate the velocity output
from measured and desired positions.
The Sensor component model abstracts the sensors
of the system. It has a Data Port where it writes the
values which are read from the sensors. This Data Port
is represented by a vector which size depends on the
number of joints of the robot.
The Actuator component model abstracts the system
actuator. Similar to the Sensor component model it has a
virtual member function which is called in response to
an Event from the Sampler. It has a read-only port
where the component can read values sent by the
Controller component. Those values should be applied
to the robot.
The above models are the basic components of the
control system. In addition to these system include more
models. One of them is the Joint component model.
This model represents a component that communicates
with the hardware of joint of robot and the number of
components that are derived from this model depends of
the number of joints. Each of them is associated with
components Sensor and Actuator for which Data Ports
sends signals of all robot's axes in the vector form, and
because of that it is necessary to create components for
multiplexing the signals from the N Joints, and similar,
4 VOL. xx, No x, 200x

for demultiplexing the vector output, so the components

can be connected to each other.
4. DISTRIBUTION OF THE COMPONENTS

As the presented system is designed as modular solution

and built from components, they can be distributed to
different hardware platforms with the same operating
system and to communicate with each other over the
network. Components are linked using CORBA
deployer application. Connecting data flow ports of
components is done by defining connections. When
components are distributed using the CORBA
deployment component, it is necessary to declare a
proxy component in one of the XML files and connect
to a port of that proxy. It is necessary to setup a specific
connection in one XML file, the other XML files do not
need to repeat the same information.
5. CONCLUSION

The goal of a new Lola Institutes control system

development is to provide all necessary functionality for
robots, machine tools and similar devices control in a
more efficient way. Also, the idea is to create modular
solution so that the different functionality could be
included or excluded in accordance with the needs of
applications without changing the structure of the
system. This allows faster and easier possible system
upgrades. The system can be distributed to different
hardware platforms. During its development modern
methods and open source packages are used which
make development easier and less expensive.
ACKNOWLEDGMENT

This work was created within the research project

Development of the devices for pilots training and
dynamic flight simulation of modern combat aircraft: 3
DoF centrifuge and 4 DoF spatial disorientation trainer
that is supported by the Ministry of Science and
Technological Development, Republic of Serbia.
REFERENCES

[1] Milievi, M., Vidakovi, J., Dimi, Z., Trgovevi,

S. (2010), Modern open architecture control
systems for machine tools and robots control, 36th
JUPITER conference, 32th symposium NU-RobotiFTS, Proceedings, ISBN 978-86-7083-696-9,
Faculty of Mechanical Engineering University of
Belgrade, pp. 4.41-4.46
[2] OROCOS - Open Robot Control Software web site
- http://www.orocos.org
[3] Xenomai: Real-Time Framework for Linux web
site - http://www.xenomai.org
[4] Katholieke Universiteit Leuven, Department of
Mechanical
Engineering
web
site
http://people.mech.kuleuven.be/~orocos/
[5] ivanovi, S., Glavonji, M., Dimi, Z. (2009),
Methodology for Configuring Desktop 3-axis
FME Transactions

Parallel Kinematic Machine, FME Transactions,

ISSN 1451-2092, Vol. 37, No. 3, pp. 107-115
[6] Milievi, M., Kaplarevi, V., Dimi, Z., Kvrgi,
V., Cvijanovi, V. (2011), Development of new
control system for robots and multi-axis machining
systems, 4th International Conference on
Manufacturing Engineering ICMEN, Proceedings,
ISBN 978-960-98780-4-3, pp. 451-457
[7] Milievi, M., Kaplarevi, V., Dimi, Z.,
Cvijanovi, V., Buan, M. (2011), Development of
distributed control system for robots control based
on real-time Linux platform, 10th Anniversary
International Conference on Accomplishments in
Electrical and Mechanical Engineering an
Information Technology DEMI, ISBN 978-9993839-36-1, pp. 813-818
[8] Kvrgi, V. (1998), Development of intelligent
systems for industrial robots control and

FME Transactions

programming, PhD thesis, Faculty of Mechanical

Engineering University of Belgrade
[9] Pritschow, G., Altintas, Y., Jovane, F., Koren, Y.,
Mitsuishi, M., Takata, S., et al. (2001), Open
Controller Architecture - Past, Present and Future,
Annals of the CIRP, ISSN 0007-8509, Vol. 50, No.
2, pp. 463-470
[10] Brogardh, T. (2007), Present and future robot
control development-An industrial perspective,
Annual Reviews in Control, ISSN 1367-5788, Vol.
31, No. 1, pp. 69-79
[11] Brecher, C., Verl, A., Lechler, A., & Servos, M.
(2010), Open control systems: state of the art,
Production Engineering, ISSN 0944-6524, Vol. 4,
No. 2-3, pp. 247-254
[12] Pavlovi, M., Kvrgi, V., Velaevi, D. (1994), LIRL: High Level Programming Language for
Robots, In Proc of the European Robotics and
Intelligent Systems Conference, Malaga, Spai

VOL. xx, No x, 200x 5