TOWARDS OBJECT-ORIENTED SOFTWARE DEVELOPMENT FOR

INDUSTRIAL ROBOTS

∗

Facilitating the Use of Industrial Robots by Modern Software Engineering

Alwin Hoffmann, Andreas Angerer, Andreas Schierl, Michael Vistein and Wolfgang Reif

Institute for Software & Systems Engineering, University of Augsburg, Augsburg, Germany

Keywords:

Industrial robotics, Object-oriented software development, Robot programming, Software engineering.

Abstract:

Industrial robotics is characterized by sophisticated mechanical components and highly-developed control

algorithms. However, the efﬁcient use of robotic systems – with regard to ﬂexibility, reusability and exten-

sibility – is very much limited by existing programming methods. As a consequence, software development

for industrial robots is a complex and time-consuming task which generates considerable costs. This work

performs an analysis of the current software development for robotics systems and identiﬁes shortcomings

from a software engineering point of view. Based on that, it outlines an architectural approach that addresses

the identiﬁed problems and allows efﬁcient software development for industrial robotic systems.

1 INTRODUCTION

According to ISO standard 8373, an industrial robot

is deﬁned as “an automatically controlled, repro-

grammable, multipurpose manipulating machine [...]

for use in industrial automation applications”. Given

an appropriate tool, industrial robots are able to per-

form a large variety of tasks ranging from assembly

over welding to quality assurance. But when look-

ing deeper, the use of robots in companies is mostly

restricted to mass production with rather easy, re-

curring tasks. Although small and medium enter-

prises with their small production batches could bene-

ﬁt from ﬂexible production systems, industrial robots

are rarely found there. One major reason for the lim-

ited use is the way of adapting robots to perform a

task. Today, industrial robots are still programmed

with special robot programming languages which

have robotic-speciﬁc data types, allow the speciﬁca-

tion of motions, and communicate with external de-

vices and systems via ﬁeldbus (e.g. tools, sensors, or

PLCs). Programs written in these languages are ex-

ecuted in special runtime environments by stepwise

interpretation of instructions and submitting them to

the underlying robot controller.

∗

This work presents results of the research project Soft-

Robot funded by the European Union and the Bavarian

government within the High-Tech-Offensive Bayern. The

project is carried out together with KUKA Roboter GmbH

and MRK-Systeme GmbH.

Due to these low-level programming techniques,

developing software for an industrial robot is a com-

plex and tedious task requiring considerable techni-

cal expertise. Already in 1990, (Miller and Lennox,

1990) identiﬁed the fundamental problems of pro-

gramming robots which are still relevant in indus-

trial robotics even two decades later. The problems

mentioned are e.g. high costs for application develop-

ment, low reusability of robot-speciﬁc source code,

and the complexity of extending existing applications

with new tasks or devices. Despite these problems, re-

search in software engineering for robotics is mostly

targeting experimental robotics (Brugali, 2007), be-

cause industrial robotics has been considered an al-

ready solved problem for a long time (H

agele et al.,

2008).

Hence, this paper analyzes the software develop-

ment for robotics systems and explains why the cur-

rent practice has shortcomings from a software en-

gineering point of view (Sect. 2). Subsequently, we

brieﬂy present an object-oriented approach that can

overcome those shortcoming in Sect. 3 and illustrate

the possible beneﬁts in Sect. 4. Finally, conclusions

and future work are presented in Sect. 5.

2 PROBLEM ANALYSIS

Software development for commercially available in-

437

Hoffmann A., Angerer A., Schierl A., Vistein M. and Reif W. (2010).

TOWARDS OBJECT-ORIENTED SOFTWARE DEVELOPMENT FOR INDUSTRIAL ROBOTS - Facilitating the Use of Industrial Robots by Modern

Software Engineering.

In Proceedings of the 7th International Conference on Informatics in Control, Automation and Robotics, pages 437-440

DOI: 10.5220/0003002304370440

 SciTePress

dustrial robots is usually performed using the devel-

opment tools available from the robot manufactur-

ers, where each manufacturer provides its own sys-

tem. These systems are mostly based on propri-

etary, special programming languages which are tai-

lored to the features of the underlying robot con-

troller. Examples are the KUKA Robot Language or

RAPID from ABB. These languages are rather lim-

ited compared to general-purpose programming lan-

guages. For example, there is no built-in support

for the development of graphical user interfaces, and

interaction with tools and external systems is based

on low-level ﬁeldbus communication. On the other

hand, these languages focus on the basic features of

automation systems and these limitations help ensur-

ing safety and real-time capabilities, which are nec-

essary to achieve precision and repeatability. Based

on their basic languages, manufacturers provide pro-

gramming extensions for special application domains

like welding. These extensions contain macros for

common application-speciﬁc tasks and allow to con-

ﬁgure tools.

However, with increasing requirements to the ap-

plications, using robot programming languages alone

is not sufﬁcient any more. Especially user interac-

tion or complex domain-speciﬁc application logic is

often realized using a general-purpose programming

language, while robot languages are only used for

moving the robot and triggering exactly timed tool ac-

tions. The interplay between such an application and

the robot controller depends on the use case. One ap-

proach is to generate robot source code and to trans-

fer it to the robot controller. This approach is often

used in off-line programming systems where a virtual

model of the robotic workcell is used to program and

simulate tasks.

A different approach is to use a pre-deﬁned set

of robot programs which can be remotely parameter-

ized and executed by an application. Today, such a

mixed application structure is typical for many exist-

ing solutions in industrial robotics. For example, (Ge

and Yin, 2007) describe the implementation of a plas-

tic injection molding application using the general-

purpose programming language C# for the domain

logic and the graphical user interface whereas RAPID

was only used for commanding the robot. Another

example is described by (Pires et al., 2009) where

a programming-by-demonstration application is pre-

sented. The main application as well as a speech inter-

face were again realized with C#. Although the force-

controlled guiding system was directly implemented

on the robot controller, it is forwarding its data to the

main application for further processing. After hav-

ing taught a new task by demonstration, robot code

is generated and submitted to the controller. As these

examples show, it is possible to implement complex

domain-speciﬁc applications and customized user in-

terfaces on top of existing robot programming envi-

ronments. However, the result is always an individual

solution, requiring great effort and expertise for devel-

opment and, consequently, causing high costs. Eval-

uating these solutions from a software engineering

point of view shows shortcomings in software quality.

While functionality and usability is often increased

using such approaches, other quality attributes (i.e.

reliability, performance, maintainability, extensibility

or portability) are inﬂuenced negatively. For example,

robot motions that are triggered inside an application

must always be backed with appropriate programs

on the robot controller. Consequently, both applica-

tion parts have to be maintained or extended carefully

with mutual dependencies in mind. Approaches that

rely on automatic generation of robot control code

provide a higher level of extensibility (by modifying

code generators) and increase portability (with multi-

ple code generators). However, maintainability prob-

lems arise when generated code has to be adjusted: In

most cases, these adjustments cannot be transferred

back to the generating model. Further issues concern

performance (especially for code generation) and reli-

ability, as concurrent programs are difﬁcult to predict,

test and debug.

Standard business applications are nowadays de-

veloped on top of modern frameworks like Microsoft

.NET or Java Enterprise Edition. These frameworks

offer solutions for many standard problems like com-

munication in distributed systems, persistency and se-

curity. Our goal is to show that with a novel approach

robotic applications can be developed in the same

way as business applications. By providing a robotic

framework that already incorporates the required in-

frastructure solutions, such an approach can increase

productivity, reduce costs and weaken the trade-off

between functionality and software quality.

3 APPROACH

We have analyzed a broad variety of typical tasks for

industrial robots (e.g. welding or palletizing). This

analysis has shown that robot programs usually con-

sist of a deﬁned set of real-time critical control actions

which are embedded into a high-level work ﬂow. For

example, welding a single seam on a workpiece is one

real-time critical action consisting of operations of

the welding torch during the robot’s movement. The

work ﬂow of a welding application only coordinates

the proper execution of these actions in order to weld

ICINCO 2010 - 7th International Conference on Informatics in Control, Automation and Robotics

438

Realtime Primitive Interface (RPI)

Robot Control Core (RCC)

RT Primitive Specification

Parameter specification

RT Primitive Implementation

Parameters

Basic primitives Extension primitives

RT Primitive Specification

Parameter specification

RT Primitive Implementation

Parameters

Dynamic Realtime Primitive Net Construction

Robotics Base Class Libraries

Robotics API

Robotics Class Libraries

Robotics Extension Class Libraries

Graphical Robot Programming

Framework

Specialized LibrariesApplication Service

Application Service Application …

Figure 1: The components of the proposed multi-tier soft-

ware architecture.

a series of seams. Hence, if it is possible to create

an adequate abstraction layer for encapsulating such

real-time critical actions, robotic applications can be

programmed in any programming language or envi-

ronment regardless of real-time issues.

Based on this observation, we have developed a

multi-tiered software architecture (Hoffmann et al.,

2009) which is shown in Figure 1. Core part of this

architecture are the Robotics Base Class Libraries

(RBCL). They represent an object-oriented frame-

work for robotic applications and provide an abstract

class model for the industrial robotics domain as well

as the aforementioned abstraction layer for specify-

ing real-time critical actions. The domain model pro-

vides objects for common concepts like robots, tools,

frames or instructions (e.g. motions or tool actions).

They can be extended in order to encapsulate task-

speciﬁc functionality (e.g. for arc welding) or to add

new robots, tools and sensors. All functionality ex-

posed by the RBCL and their extensions (Robotics

Extension Class Libraries) forms the Robotics Appli-

cation Programming Interface (Robotics API). This

interface is intended to be a broad platform for devel-

opers of robot programs. At the moment, there exists

an implementations of the RBCL in C# which is able

to control KUKA lightweight robots.

Instructions of the Robotics API can either be ex-

ecuted independently of each other, or be combined

to larger instruction units by certain operators with

deﬁned semantics (e.g. temporal delay, superposi-

tion). When executed independently, no hard guaran-

tees can be given concerning timing relations across

multiple instructions. When executing complex in-

structions that have been pre-combined using one of

the aforementioned operators, real-time determinis-

tic execution is guaranteed. To achieve this, all in-

structions are dynamically translated into commands

for the Realtime Primitives Interface (RPI) and exe-

cuted by a Robot Control Core (RCC). Such an RPI

command consists of a combination of certain, pre-

deﬁned (yet extendable) calculation modules, and a

speciﬁcation of the data ﬂow among them. Imple-

menting only the RCC with real-time aspects in mind

is sufﬁcient to allow the atomic execution of Robotics

API instructions under real-time conditions.

4 BENEFITS

Using this approach, applications for industrial robots

can be mainly developed using standard technologies

and environments. For example, a modern general-

purpose programming language such as C# and a de-

velopment environment such as Microsoft Visual Stu-

dio can be used. Common functionality of industrial

robots is provided through a well-deﬁned and exten-

sible application programming interface (the Robotics

API), and can be easily used by application develop-

ers. In consequence, they are able to focus on solving

domain-speciﬁc problems and, as far as possible, do

not have to deal with issues like communication and

synchronization with the robot control or real-time

programming.

Furthermore, the Robotics API provides a com-

prehensive, abstract model of the robotics domain –

including physical objects, interesting points on those

objects and ways to deﬁne specialized devices (e.g. a

welding robot). This framework can be used to for-

mulate certain tasks that are speciﬁc to the applica-

tions of interest (e.g. welding a line on a workpiece).

Basic functionality can be reused, in particular exist-

ing mechanisms for encapsulating real-time critical

work ﬂows (e.g. moving along a welding line with ex-

actly timed activation of a welding torch). With this

abstraction, existing development processes, meth-

ods and tools of modern software engineering can

be used to construct intuitive domain speciﬁc appli-

cations, regardless of real-time issues. As a conse-

quence, complex application logic and high usabil-

ity can be achieved, whereas maintainability, perfor-

mance and reliability are taken care of by the auto-

matic generation and execution of RPI commands.

Besides basic motion commands, our architecture

also supports the integration of new motion types.

The ﬁne grained structure of RPI allows a ﬂexi-

ble speciﬁcation of motion control algorithms as e.g.

required for sensor integration and compliant mo-

tions. The tight integration of high-level motion spec-

iﬁcation and low-level motion execution, which is

achieved by the automatic generation and execution

TOWARDS OBJECT-ORIENTED SOFTWARE DEVELOPMENT FOR INDUSTRIAL ROBOTS - Facilitating the Use

of Industrial Robots by Modern Software Engineering

439

of RPI commands, leads to good maintainability of

resulting applications, and real-time constraints can

be satisﬁed by an appropriate implementation of an

RPI interpreter, ensuring performance and reliability

for the critical system parts.

Traditionally, the communication with external

devices and systems is performed using a ﬁeldbus that

is connected to a port with analog and digital I/Os.

In our approach, the physical I/Os can be mapped to

logical units, e.g. the necessary I/Os to drive a gripper

can be controlled using a single gripper object. This

object encapsulates the properties, i.e. the conﬁgura-

tion, as well as the behavior of the tool and can be

used for programing. Besides, complex devices can

be controlled with real-time performance by introduc-

ing specialized RPI modules and corresponding ob-

jects for the Robotics API. Furthermore, instructions

usually incorporate a two-stage error handling. If an

error occurs during the execution of the instruction,

basic error handling causes the robot system to reach

a stable and secure state. Subsequently, an exception

is thrown and a high-level recovery strategy can be ex-

ecuted. Thus, it is possible to guarantee reliable error

handling and to provide high-level error mechanisms

that developers can use.

There are some tasks which require the use of

multiple robots, e.g. mobile manipulation scenarios

or lifting large and heavy workpieces. Traditionally,

each robot has its own controller and must be pro-

grammed individually, using ﬁeldbus communication

or special markers to handle synchronization with the

other robots. Using our approach, it is possible to de-

velop a single program that controls multiple robots.

The robots can be synchronized with real-time perfor-

mance using special operators offered by the Robotics

API. It is even possible to deﬁne a logical unit, that

consists of multiple robots, but can be programed as

a single robot (e.g. for load sharing, or for a mobile

manipulator).

5 CONCLUSIONS

This paper presents a new approach for the software

development for industrial robots – an approach that

is rather radical. Its focus does not originate from

mechanical engineering or control theory, but from

software engineering. Furthermore, it is not directly

compatible with current robot controllers and even

requires a new generation of robot control software.

However, it shows a way to overcome the intrinsic

problems and limitations of current programming en-

vironments for industrial robots. The development of

this approach is performed in tight cooperation with

industrial partners: KUKA Roboter GmbH, a special-

ist for robotics internals and Europe’s leading robot

manufacturer, and MRK Systeme GmbH, a system in-

tegrator working with KUKA robot and future user of

our approach. This cooperation and the joint devel-

opment of prototypical systems helped greatly in val-

idating the feasibility and industrial meaningfulness

of our research.

The presented approach promises advantages on

the feature side – as it was designed with extensibility

in mind – but the main beneﬁts can be found coping

with non-functional requirements. Most notably, us-

ability and maintainability beneﬁt from the advances

achieved in the ﬁeld of software engineering during

the last 15 years, which can directly be applied to the

robotics domain using our approach. Although the

beneﬁts and ﬁrst results are promising, the approach

must demonstrate its advantages in practice. There-

fore, future work focuses on creating challenging ap-

plication examples on top of our approach. This in-

cludes the development of a reusable graphical robot

programming framework for SMEs and the introduc-

ing of service-oriented architectures for robot-based

automation processes.

REFERENCES

Brugali, D., editor (2007). Software Engineering for Ex-

perimental Robotics. Springer Tracts in Advanced

Robotics. Springer.

Ge, J. G. and Yin, X. G. (2007). An object oriented

robot programming approach in robot served plas-

tic injection molding application. In Robotic Weld-

ing, Intelligence & Automation, volume 362 of Lect.

Notes in Control & Information Sciences, pages 91–

97. Springer.

agele, M., Nilsson, K., and Pires, J. N. (2008). Indus-

trial robotics. In Siciliano, B. and Khatib, O., editors,

Springer Handbook of Robotics, chapter 42, pages

963–986. Springer, Berlin, Heidelberg.

Hoffmann, A., Angerer, A., Ortmeier, F., Vistein, M., and

Reif, W. (2009). Hiding real-time: A new approach

for the software development of industrial robots. In

Proc. 2009 IEEE/RSJ Intl. Conf. on Intelligent Robots

and Systems, St. Louis, USA.

Miller, D. J. and Lennox, R. C. (1990). An object-oriented

environment for robot system architectures. In Proc.

1990 IEEE Intl. Conf. on Robotics and Automation,

pages 352–361, Cincinnati, Ohio, USA.

Pires, J. N., Veiga, G., and Ara

ujo, R. (2009). Programming

by demonstration in the coworker scenario for SMEs.

Industrial Robot, 36(1):73–83.

ICINCO 2010 - 7th International Conference on Informatics in Control, Automation and Robotics

440