Abstract Robots often need to be reconfigurable—to customize, calibrate, or optimize robots operating in varying environments with different hardware. A particular challenge in robotics is the automated and dynamic reconfiguration to load and unload software components, as well as parameterizing them. Over the last decades, a large variety of software reconfiguration techniques has been presented in the literature, many specifically for robotics systems. Also many robotics frameworks support reconfiguration. Unfortunately, there is a lack of empirical data on the actual use of reconfiguration techniques in real robotics projects and on their realization in robotics frameworks. To advance reconfiguration techniques and support their adoption, we need to improve our empirical understanding of them in practice. We present a study of automated reconfiguration at runtime in the robotics domain. We determine the state-of-the art by reviewing 78 relevant publications on reconfiguration. We determine the state-of-practice by analyzing how four major robotics frameworks support reconfiguration, and how reconfiguration is realized in 48 robotics (sub-)systems. We contribute a detailed analysis of the design space of reconfiguration techniques. We identify trends and research gaps. Our results show a significant discrepancy between the state-of-the-art and the state-of-practice. While the scientific community focuses on complex structural reconfiguration, only parameter reconfiguration is widely used in practice. Our results support practitioners to realize reconfiguration in robotics systems, as well as they support researchers and tool builders to create more effective reconfiguration techniques that are adopted in practice.

Robots artificially replicate human capabilities thanks to their software, the main embodiment of intelligence. However, engineering robotics software has become increasingly challenging. Developers need expertise from different disciplines as well as they are faced with heterogeneous hardware and uncertain operating environments. To this end, the software needs to be variable-to customize robots for different customers, hardware, and operating environments. However, variability adds substantial complexity and needs to be managed-yet, ad hoc practices prevail in the robotics domain, challenging effective software reuse, maintenance, and evolution. To improve the situation, we need to enhance our empirical understanding of variability in robotics. We present a multiple-case study on software variability in the vibrant and challenging domain of service robotics. We investigated drivers, practices, methods, and challenges of variability from industrial companies building service robots. We analyzed the state-of-the-practice and the state-of-the-art-the former via an experience report and eleven interviews with two service robotics companies; the latter via a systematic literature review. We triangulated from these sources, reporting observations with actionable recommendations for researchers, tool providers, and practitioners. We formulated hypotheses trying to explain our observations, and also compared the state-of-the-art from the literature with the-state-of-the-practice we observed in our cases. We learned that the level of abstraction in robotics software needs to be raised for simplifying variability management and software integration, while keeping a sufficient level of customization to boost efficiency and effectiveness in their robots' operation. Planning and realizing variability for specific requirements and implementing robust abstractions permit robotic applications to operate robustly in dynamic environments, which are often only partially known and controllable. With this aim, our companies use a number of mechanisms, some of them based on formalisms used to specify robotic behavior, such as finite-state machines and behavior trees. To foster software reuse, the service robotics domain will greatly benefit from having software components-completely decoupled from hardware-with harmonized and standardized interfaces, and organized in an ecosystem shared among various companies.

Robots that support humans by performing useful tasks (a.k.a., service robots) are booming worldwide. In contrast to industrial robots, the development of service robots comes with severe software engineering challenges, since they require high levels of robustness and autonomy to operate in highly heterogeneous environments. As a domain with critical safety implications, service robotics faces a need for sound software development practices. In this paper, we present the first large-scale empirical study to assess the state of the art and practice of robotics software engineering. We conducted 18 semi-structured interviews with industrial practitioners working in 15 companies from 9 different countries and a survey with 156 respondents from 26 countries from the robotics domain. Our results provide a comprehensive picture of (i) the practices applied by robotics industrial and academic practitioners, including processes, paradigms, languages, tools, frameworks, and reuse practices, (ii) the distinguishing characteristics of robotics software engineering, and (iii) recurrent challenges usually faced, together with adopted solutions. The paper concludes by discussing observations, derived hypotheses, and proposed actions for researchers and practitioners.

This paper presents the structure and the content of a project-based laboratory in software engineering for autonomous robots. Even if the theory and practice of software development for robotic has been the subject of several editions of the Robotics course at the University of Bergamo, the presented laboratory has been offered for the first time during the 2013 academic year. A preliminary evaluation of the laboratory is discussed in the conclusions.

During the last years robotic researchers have been able of developing extremely complex applications. The complexity of these applications is reflected by the variety of functionalities involved, which are provided by a significant number of components. Although the reuse of software components is becoming a best-practice, the reuse of reference architectures, which model sub-systems providing functionalities common to a great number of applications, is still uncommon. This paper provides two contributions to this topic: (a) a development process that defines how reference architectures can be exploited for building robotic applications, (b) the HyperFlex software toolchain, which has been developed for supporting the design and the reuse of reference architectures. The idea presented in this paper is simple yet powerful: instead of building complex applications by reusing single components, even more complex applications can be developed by reusing reference architectures of mature sub-systems.

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.

Most of the current state of the art motion planning software libraries are not easily interchangeable, because core concepts are represented with different data structures, application programming interfaces (API) are not compatible, or algorithms are encapsulated in modules organized in mutually exclusive abstraction hierarchies. These problems limit the possibility to reuse different libraries in the same application interchangeably and to compare their quality attributes (performance, completeness, etc.). An approach to overcome these shortcomings is refactoring, a technique that aims to restructure a set of existing software libraries without affecting their external behavior in order to harmonize their architecture, data structures, and APIs. This paper presents a component-based refactoring approach that has allowed the transition from motion planning libraries, taking the object-oriented framework CoPP as basis, to a component-based system. In particular we describe a four-step application of well-known architecture refactoring patterns that redistributes the responsibilities among the classes, harmonizes the common data structures and reduces the coupling degree. The obtained system represents a composition of reusable components that are easy to customize and offer different algorithms to resolve the same problem. In this way the user could quickly compile a new motion planning application by simply choosing which algorithm to use for each functionality.

A communication system for robotics application should allow fast exchange of real-time data for low level robot control and large amount of data for high level algorithms like intelligent vision or map building. Ethernet seems to be the perfect candidate for the low level communication interface because of its large diffusion, high bandwidth and low cost. This paper describes a real-time communication protocol for interconnecting robotic smart devices. Some comparison with existing standard are also presented.

Abstract Enterprise frameworks are a special class of application frameworks. They are distinguished from other application frameworks in terms of scale and focus. In terms of focus, application frameworks typically cover one particular aspect of an application, either a domain‐dependent aspect (e.g., billing in a web‐based customer‐to‐business ordering system), or a computational infrastructure aspect such as distribution, man‐machine interface, or persistence, etc. Generally, an application framework alone delivers no useful end‐user function. With infrastructure frameworks, we still have to plug in domain functionalities, while with domain frameworks, we need to set‐up the infrastructure. In contrast, enterprise frameworks embody a reference architecture for an entire application, covering both the infrastructure aspects of the application, and much of the domain‐specific functionality. Instantiating an enterprise framework is nothing short of application engineering, where the architecture and many of the components are reusable. While creativity and continual improvement may be the major ingredients for building a good application framework, anything related to enterprise frameworks, be it building, documenting, or instantiating them, is complex and requires careful design and planning. In this paper, we identify the issues involved in building, using, and maintaining enterprise frameworks, both from research and practical perspective. Copyright © 2002 John Wiley & Sons, Ltd.

The pervasive introduction of the Internet into robotics and automation systems pushes forward an evolution that began when the computer was introduced in the enterprise in the middle of the last century, and that continued. with the interconnection of shop-floor workstations in local networks in the 1980s. Today, the Internet represents a challenge both for research and development in the area of distributed robotics and automation. In order to gain a better understanding and evaluation of results in distributed computing the paper classifies the most promising technological approaches, provides examples of how they are applied in robotics and automation, and discusses available standards and commercial solutions.

Designing automation systems, as in most engineering endeavors, is primarily an architectural problem, involving hardware and software components. The objective of this paper is to introduce the concept of software architecture and styles in designing automation systems, and to describe an object framework for the development of global automation systems.

We present an approach to the control of manufacturing systems via agent interactions. Based on a decentralized control strategy the agents can collaborate with each other conveniently. We provide a distributed architecture to model the elementary services (an unreliable machine coupled with a finite buffer) in terms of hybrid automata which are co-operating in a manufacturing system, and we show how the agents can efficiently make their control decisions using their local rules.

We present an architecture for developing applications which need to integrate legacy business enterprise information systems in a large distributed environment. In particular we address the problem of building virtual factories by interconnecting existing physical factories. The proposed architecture consists of several different frameworks each of them addressing a specific design problem: the communication framework, the security framework, the interface framework and the persistence framework. The communication and security frameworks give solutions to the communication problem based on mobile code and Internet technologies. The interface and persistence frameworks address the problem of the integration of the legacy IS which, in the new system, will be wrapped and presented as a standard business object. Each framework has to be customized for each virtual factory to build.