<< back to topics

Robotics

A selection of papers from Bernhard Rumpe and the Software Engineering Group

We consider modern robotics as a special field of Cyber-Physical Systems (CPS) which is defined by an inherent heterogeneity of involved domains, relevant platforms, and real world challenges. The engineering of robotics applications requires composition and interaction of many software modules. This usually leads to complex monolithic software solutions hardly reusable, maintainable, and comprehensible, which hampers broad propagation of robotics applications.

Our research in model-driven software engineering for robotics on one hand focuses on software architectures to structure reusable units of behavior. On the other hand, we concentrate on modeling languages (DSLs) for robotic product assembly tasks in industrial contexts as well as planned and unplanned logistic tasks. We apply this to indoor robots interacting with humans as well as to industrial robots as well as to autonomously driving cars.


Modeling Robotic Application Architectures and Behavior

Describing a robot's software architecture and its behavior in integrated models, yields many advantages to cope with this complexity: the models are platform independent, can be decomposed to be developed independently by experts of the respective fields, are highly reusable and may be subjected to formal analysis.

In [RRW12] we have introduced the architecture and behavior modeling language and framework MontiArcAutomaton which provides an integrated, platform independent structure and behavior modeling language family with an extensible code generation framework. MontiArcAutomaton’s central concept is encapsulation and decomposition known from Component & Connector Architecture Description Languages (ADLs). This concept applied to the modeling language, the code generation process and the target runtime to bridge the gap of platform specific and independent implementations along well designed interfaces. This facilitates the reuse of robot applications and makes their development more efficient.

MontiArcAutomaton extends the ADL MontiArc and integrates various component behavior modeling languages implemented using MontiCore. The integration of automata and tables to model component behavior are described in [RRW13c]. The integration capabilities of MontiArc have been extended and generalized in [RRRW15b]. If interested, the MontiArcAutomaton website provides further information on the MontiArcAutomaton framework.

In several projects, we modeled logistics services with Festo Robotino Robots, ROS, and Python.


LightRocks: Modeling Robotic Assembly Tasks

The importance of flexible automatized manufacturing grows continuously as products become increasingly individualized. Flexible assembly processes with compliant robot arms are still hard to be developed due to many uncertainties caused - among others - by object tolerances, position uncertainties and tolerances from external and internal sensors. Thus, only domain experts are able to program such compliant robot arms. The reusability of these programs depends on each individual expert and tools allowing to reuse and the compose models at different levels of detail are missing.

In cooperation with the DLR Institute on Robotics and Mechatronics we have introduced the LightRocks (Light Weight Robot Coding for Skills) framework in [THR+13] which allows robotics experts and laymen to model robotic assembly tasks on different levels of abstraction, namely: assembly tasks, skills, and elemental actions. Robotics experts provide a domain model of the assembly environment and elemental actions which reference this model. Factory floor workers combine these to skills and task to implement assembly processes provided by experts. This allows a separation of concerns, increases reuse and enables flexible production.

The framework is implemented based on MontiCore language profiles for UML/P Statecharts and UML/P class diagrams, which allows to reuse much of the UML/P framework for modeling, model validation, code generation, and editor generation.


Autonomous Driving

Many of the concepts we learnt in engineering autonomic robotics come from automotive software engineering and especially our successful participation in the DARPA Urban Challenge. In [BBR07] we describe the well-engineered model-driven toolchain, which is heavily based on automatic simulation of a cars context (actually streets, obstacles, other cars of an entire city) and automatic testing for correct a driving behavior. We discussed in [BR12b] that this a main enabler for intensive regression testing and thus agile development and has now become the primary technique for virtually driving millions of miles for safety validation in the car domain.



Summary:

  1. Development of robotics applications is highly complex and requires abstraction, e.g using appropriate abstract modeling techniques.
  2. Domain specific modeling languages (DSLs) apply perfect to model tasks of robots, the surrounding world, test scenarios etc.
  3. Abstraction through DSLs leads to better standardization and allows improve quick development of robotic application as well a agile adaptation of robot tasks by users.
  4. Autonomously driving cars exhibit lots of robotic characteristics and many techniques used there for function validation can be carried over.

Further Topics:


Selected(!) Publications:


<< list of all topics list of all publications >>