Davide Brugali

Component-Based Robotic Engineering (Part II)

This article discusses the role of software components as architectural units of large, possibly distributed, software-intensive robotic systems. The focus is on technologies to manage the heterogeneity of hardware, computational, and communication resources and on design techniques to assemble components into systems .A component-based system is a composition of components, and the way components interact with other components and with the computational environment greatly affects the flexibility of the entire system and the reusability of individual functionality.

Component-based robotic engineering (Part I) [Tutorial]

This article is the first of a two-part series intended as an introduction to component-based software engineering (CBSE) in robotics. In this tutorial, we regard a component as a piece of software that implements robotic functionality (e.g., path planning). The focus of this article is on design principles and implementation guidelines that enable the development of reusable and maintainable software-building blocks, which can be assembled to build robotic applications.

Robotic Systems Architectures and Programming

Robot software systems tend to be complex. This complexity is due, in large part, to the need to control diverse sensors and actuators in real time, in the face of significant uncertainty and noise. Robot systems must work to achieve tasks while monitoring for, and reacting to, unexpected situations. Doing all this concurrently and asynchronously adds immensely to system complexity.

The framework life span

referred to as “white-box” and “black-box” approaches to reuse, are simultaneously present in one framework [9]. Features likely to be common to most applications can be offered and therefore reused as black boxes with minor changes. On the other hand, the class library accompanying the framework usually provides base classes (or white boxes) that can be specialized by adding subclasses as needed and that are easily integrated with the rest of the framework. An intriguing relationship exists between frameworks and patterns [7], or, more specifically, pattern languages [1]. Patterns and pattern languages are another concept, besides frameworks, proposed in the OO literature for capturing unifying aspects in software development and raising reusability from the basic level of components to the higher level of complete architectures. While each pattern describes a decision point in the development of an application, groups of related patterns can be organized as a tree or graph in which each pattern leads to a series of other patterns. Such a structure is called a pattern language [2] and represents the sequence of decisions leading to the complete design, so a pattern language becomes a method that guides the development process. This method does not conflict with general development methods, such as Booch’s [5]; instead, it complements them by adding domain-specific, concrete advice to their general guidelines. In a pioneering paper, Johnson argued that patterns document frameworks and help ensure the correct use of framework functionality [8]. We take a more radical position: A pattern language—the organized collection of patterns for a particular application domain [2]—generates the framework that thereafter offers the elements for the pattern implementations and accompanies the framework through its life. Any application framework follows an evolution over time we call the framework life span, during which the basic architectural elements (independent from any specific application) are implemented first. With the help of the pattern language, new applications are Davide Brugali, Giuseppe Menga, and Amund Aarsten The Framework Life Span

Distributed computing in robotics and automation

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.

Mediating the Internet

In this paper we propose Software Agents as a mediation support between the Internet and its users. The paper classifies mediation agents in three categories (Interface Agents, Coordination Agents, and Middle Agents) and provides examples of their usage in three application domains: Public Administration, Electronic Commerce, and Factory Automation. We then describe an agent-oriented mediation framework built on the Object Oriented Technology and we exemplify its usage with a case study in the domain of product negotiation on the Internet.

Design abstraction and processes in robotics: from code-driven to model-driven engineering

Advanced software engineering is the key factor in the design of future complex cognitive robots. It will decide about their robustness, (run-time) adaptivity, cost-effectiveness and usability. We present a novel overall vision of a model-driven engineering approach for robotics that fuses strategies for robustness by design and robustness by adaptation. It enables rigid definitions of quality-of-service, re-configurability and physics-based simulation as well as for seamless system level integration of disparate technologies and resource awareness. We report on steps towards implementing this idea driven by a first robotics meta-model with first explications of non-functional properties. A model-driven toolchain provides the model transformation and code generation steps. It also provides design time analysis of resource parameters (e.g. schedulability analysis of realtime tasks) as step towards resource awareness in the development of integrated robotic systems.

Towards agent oriented application frameworks

Building a reusable application framework requires a deep understanding of its application domain in terms of the entities and the relationships that can be captured by reusable components and by the reusable patterns of interactions between the components. When the application domain (e.g. large-scale open distributed applications, integrating heterogeneous systems) has rapidly evolving requirements, exibility in the pattern of interactions between the components of a framework is mandatory if the framework itself is to be reusable. Object Oriented (OO) Application Frameworks [Fayad and Schmidt 1997] have

Frameworks and pattern languages: an intriguing relationship

The goal of this paper is the comparison betw een Application Frameworks and Pattern Languages. Frameworks and pattern languages are concepts proposed in the Object-Oriented literature to capture aspects which unify soft w are dev elopmen t and raise reusabilit y from the basic level of components to the higher level of complete architectures. Our experience in developing applications for a speci c application domain (e.g. Flexible Manufacturing Systems), has revealed that an in triguing relationship exists bet w een these concepts. The principal contribution of this paper is to show that frameworks and pattern languages complement each other in the soft w are dev elopmen t process.

Modeling and reusing robotic software architectures: The HyperFlex toolchain.

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.