Open Access

To perform a wide range of tasks service robots need to robustly extract knowledge about the world from the data perceived through the robot's sensors even in the presence of varying context-conditions. This makes the design and development of robot perception architectures a challenging exercise. In this paper we propose a robot perception architecture which enables to select and execute at runtime different perception graphs based on monitored context changes. To achieve this the architecture is structured as a feedback loop and contains a repository of different perception graph configurations suitable for various context conditions.

In this paper we present our ongoing work on Robotics Run-time Adaptation (RRA). RRA is a model-driven approach that addresses robotics runtime adaptation by modeling and resolving run-time variability of robotic applications.

The design, simulation and programming of robotics systems is challenging as expertise from multiple domains needs to be integrated conceptually and technically. Domain-specific modeling promises an efficient and flexible concept for developing robotics applications that copes with this challenge. It allows to raise the level of abstraction through the use of specific concepts that are closer to the respective domain concerns and easier to understand and validate. Furthermore, it focuses on increasing the level of automation, e.g. through code generation, to bridge the gap between the modeling and the implementation levels and to improve the efficiency and quality of the software development process. Within this contribution, we survey the literature available on domain-specific (modeling) languages in robotics required to realize a state-of-the-art real-world example from the RoboCup@Work competition. We classify 41 publications in the field as reference for potential DSL users. Furthermore, we analyze these contributions from a DSL-engineering viewpoint and discuss quantitative and qualitative aspects such as the methods and tools used for DSL implementation as well as their documentation status and platform integration. Finally, we conclude with some recommendations for discussion in the robotics programming and simulation community based on the insights gained with this survey.

The design space of a robotic application defines at a meta level what are all of its possible implementations. Those possibilities are called design alternatives and differ on many different aspects, one being preferred to the other depending on how, where, when or what the application should do. Design Space Exploration (DSE) is the process of reviewing those design alternatives, prior to their implementation, with intention to verify that the set of all design alternatives to be implemented covers all the possible scenarios in which the application is to be executed. In this paper we address two challenges related to DSE, namely, (1) the formal definitions of design spaces, a non-trivial task due to the many dimensions to be taken into consideration, and (2) the automatisation of DSE, that is, enabling a domain expert to review design alternatives corresponding to a given design space effortlessly. In this paper, we address those challenges in the context of robot perception software systems by combining two already existing technologies, namely RPSL for the specification of robot perception system's design spaces and Lightning, a language workbench that we use to formalise RPSL and obtain, from RPSL specifications, corresponding design alternatives.

Control systems for autonomous robots are concurrent, distributed, embedded, real-time and data intensive software systems. A real-world robot control system is composed of tens of software components. For each component providing robotic functionality, tens of different implementations may be available. The difficult challenge in robotic system engineering consists in selecting acoherent set of components, which provide the functionality required by theapplication requirements, taking into account their mutual dependencies. This challenge is exacerbated by the fact that robotics system integrators andapplication developers are usually not specifically trained in softwareengineering. Current approaches to variability management in complex software systemsconsists in explicitly modeling variation points and variants in softwarearchitectures in terms of Feature Models. The novel contribution of this paper is the description of the integration oftwo modeling languages and toolkit, namelyHyperFlex for functional variability modeling and the Robot Perception Specification Language (RPSL), a Domain-specific Language (DSL) enabling domain experts to express the architectural variability of robotperception systems.

The successes of teleoperation scenarios for mobile robots depends on a stable and reliable communication link. The environment information collected by the robot — represented by 2D or 3D images — has to be provided with a high resolution and a low delay to ensure a fast and precise system response. But in most realistic applications, the communication parameters fluctuate strongly over time. It is necessary to monitor the communication link continuously to react in case of reduced bandwidth and increased delay. But which environment information and correspondingly which bandwidth is necessary to control a robot safely? Due to a missing reliable rule set we investigated this question for a UAV scenario based on two different environment representations (camera images, gridmaps). We designed a simulator based study and evaluated the capability of the participants to control a robot in case of delayed or coarsely rasterized information. Although our study involved only non-experts, we found some interesting first results. While the performance of our participants depends strongly on the delay, it is nearly independent on the image resolution, which suggests downsampling as a valid response for bandwidth decrease. We also found that participants generally struggle with using grid map for controlling the robot. However, this type of interfaces requires far less bandwidth than images. They also excel in situations with higher delays, which makes them the tool of choice when there are really bad channel conditions.

Software development for robots is a knowledgeintensive exercise. To capture this knowledge explicitly and formally in the form of various domain models, roboticists have recently employed model-driven engineering (MDE) approaches. However, these models are merely seen as a way to support humans during the robot's software design process. We argue that the robots themselves should be first-class consumers of this knowledge to autonomously adapt their software to the various and changing run-time requirements induced, for instance, by the robot's tasks or environment. Motivated by knowledge-enabled approaches, we address this problem by employing a graph-based knowledge representation that allows us not only to persistently store domain models, but also to formulate powerful queries for the sake of run time adaptation. We have evaluated our approach in an integrated, real-world system using the neo4j graph database and we report some lessons learned. Further, we show that the graph database imposes only little overhead on the system's overall performance.

An efficient object perception is a crucial component of a mobile service robot. In this work we present a solution for visual categorization of objects. We developed a prototypic categorization system which classifies unknown objects based on their visual properties to a corresponding category of predefined domestic object categories. The system uses the Bag of Features approach which does not rely on global geometric object information. A major contribution of our work is the enhancement of the categorization accuracy and robustness through a selected combination of a set of supervised machine learners which are trained with visual information from object instances. Experimental results are provided which benchmark the behavior and verify the performance regarding the accuracy and robustness of the proposed system. The system is integrated on a mobile service robot to enhance its perceptual capabilities, hence computational cost and robot dependent properties are considered as essential design criteria.

Robot programming is an interdisciplinary and knowledge-intensive task. All too often, knowledge of the different robotics domains remains implicit. Although, this is slowly changing with the rising interest in explicit knowledge representations through domain-specific languages (DSL), very little is known about the DSL design and development processes themselves. To this end, we present and discuss the reverse-engineered process from the development of our Grasp Domain Definition Language (GDDL), a declarative DSL for the explicit specification of grasping problems. An important finding is that the process comprises similar building blocks as existing software development processes, like the Unified Process.

Mobile manipulators are viewed as an essential component for making the factory of the future become a reality. RoboCup@Work is a competition designed by a group of researchers from the RoboCup community and focuses on the use of mobile manipulators and their integration with automation equipment for performing industrially-relevant tasks. The paper describes the design and implementation of the competition and the experiences made so far.

Service robots become increasingly capable and deliver a broader spectrum of services which all require a wide range of perceptual capabilities. These capabilities must cope with dynamically changing requirements which make the design and implementation of a robot perception architecture a complex and tedious exercise which is prone to error. We suggest to specify the integral parts of robot perception architectures using explicit models, which allows to easily configure, modify, and validate them. The paper presents the domain-specific language RPSL, some examples of its application, the current state of implementation and some validation experiments.

Deploying a complex robot software architecture on real robot systems and getting it to run reliably is a challenging task. We argue that software deployment decisions should be separated as much as possible from the core development of software functionalities. This will make the developed software more independent of a particular hardware architecture (and thus more reusable) and allow it to be deployed more flexibly on a wider variety of robot platforms. This paper presents a domain-specific language (DSL) which supports this idea and demonstrates how the DSL is used in a model-driven engineering-based development process. A practical example of applying the DSL to the development of an application for the KUKA youBot platform is given.