Goran Ž.

Ferenc
Research Assistant
LOLA Institute, Belgrade
Maja M. Lutovac
Research Assistant
LOLA Institute, Belgrade
Jelena Z. Vidaković
Research Assistant
LOLA Institute, Belgrade
Zoran Ž. Dimić
Research Assistant
LOLA Institute, Belgrade
Vladimir M. Kvrgić
Research Associate
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.

Received: January 2008, Accepted: March 2008

Correspondence to: Dr John Smith
Faculty of Mechanical Engineering,
Kraljice Marije 16, 11120 Belgrade 35, Serbia
E-mail: jsmith@mas.bg.ac.rs

© Faculty of Mechanical Engineering, Belgrade. All rights reserved FME Transactions (200x) XX, x-x 1
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
Institute’s robots started on a previous version of Lola
Institute’s robot controller developed on the OS-9 real-
time 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
architecture and is modernized according to the
development of similar control systems in the world,
achieving greater efficiency and speed [1].
2. OROCOS
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 Högskolan (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
Received: January 2008,
configuration tools, 3D Accepted: March
visualization and2008
simulation,
Correspondence to: Dr John Smith
numerical libraries, inter-process communication,
Faculty of Mechanical
documentation writing Engineering,
tools, etc.
Kraljice Marije
 Robotic16,module.
11120 Belgrade 35, Serbia
This module is software that
E-mail: jsmith@mas.bg.ac.rs
© Faculty of Mechanical Engineering, Belgrade. All rights reserved
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
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 real-
time kernel extensions to Linux; or the Linux-
independent eCos.
 Xenomai is a real-time development
framework cooperating with the Linux kernel, in order
to provide a pervasive hard real-time support to user-
space 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)
FME Transactions (200x) XX, x-x 1
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 application’s
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.
FME Transactions
Figure 2. OROCOS Real-Time Toolkit layers
Considering an OROCOS component is built upon
Real-Time Toolkit (RTT) library, it allows designers to
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 Real-
Time 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, Sequential-
Activity 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.
VOL. xx, No x, 200x ▪ 3

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
Figure 4. Block model of the system architecture
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
4 ▪ VOL. xx, No x, 200x
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].
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 Controller’s 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
FME Transactions
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,
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 Institute’s 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
FME Transactions
[1] Milićević, M., Vidaković, J., Dimić, Z., Trgovčević,
S. (2010), Modern open architecture control
systems for machine tools and robots control, 36th
JUPITER conference, 32th symposium NU-Roboti-
FTS, 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
Parallel Kinematic Machine, FME Transactions,
ISSN 1451-2092, Vol. 37, No. 3, pp. 107-115
[6] Milićević, 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] Milićević, M., Kaplarević, V., Dimić, Z.,
Cvijanović, V., Bućan, 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-99938-
39-36-1, pp. 813-818
[8] Kvrgić, V. (1998), Development of intelligent
systems for industrial robots control and
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., Velašević, D. (1994), L-
IRL: High Level Programming Language for
Robots, In Proc of the European Robotics and
Intelligent Systems Conference, Malaga, Spain
VOL. xx, No x, 200x ▪ 5