An overview on framework design for autonomous robots <s> Component-Based Software Engineering (CBSE) <s> This Chapter describes Orca: an open-source project which applies Component-Based Software Engineering principles to robotics. It provides the means for defining and implementing interfaces such that components developed independently are likely to be inter-operable. In addition it provides a repository of free re-useable components. Orca attempts to be widely applicable by imposing minimal design constraints. This Chapter describes lessons learned while using Orca and steps taken to improve the framework based on those lessons. Improvements revolve around middleware issues and the problems encountered while scaling to larger distributed systems. Results are presented from systems that were implemented. <s> BIB001 </s> An overview on framework design for autonomous robots <s> Component-Based Software Engineering (CBSE) <s> This paper proposes the RT-Middleware for robot system integration. "RT" means "Robot Technology" which is applied not only to industrial field but also to nonindustrial field such as human daily life support systems. We have studied modularization of RT elements and have developed software platform RT-Middleware which promotes application of RT in various field. Robotic system development methodology and our RT-Middleware concepts is discussed. The RT-Component which is a basic madular unit of RT-Middleware based system integration is derived from this discussion. A methodology of system development with RT-Components, and a framework to make component are shown. <s> BIB002 </s> An overview on framework design for autonomous robots <s> Component-Based Software Engineering (CBSE) <s> The topic of reusable software in robotics is now largely addressed. Components based architectures, where components are independent units that can be reused accross applications, have become more popular. As a consequence, a long list of middlewares and integration tools is available in the community, often in the form of open-source projects. However, these projects are generally self contained with little reuse between them. This paper presents a software engineering approach that intends to grant middleware independance to robotic software components so that a clear separation of concerns is achieved between highly reusable algorithmic parts and integration frameworks. Such a decoupling let middle-wares be used interchangeably, while fully benefitting from their specific, individual features. This work has been integrated into a new version of the open-source GenоM component generator tool: GenоM3 <s> BIB003 </s> An overview on framework design for autonomous robots <s> Component-Based Software Engineering (CBSE) <s> Modern and future robotic applications will have to integrate many software components. Inevitably, the components will be provided by different vendors, and will not be designed together, and in many cases also not implemented from the same source code repository. This paper presents a discussion on how to deal with this multi-component, multi-vendor situation. This situation includes the least optimal case when most or all of the components are “legacy”, in the sense that they have to be integrated as binary pieces of code, without the possibility to change the components for the sole purpose of facilitating system-level integration. The presented approach is illustrated by an application that integrates (i) two KUKA Light-Weight Robot FRI control components, (ii) a set of ROS components to control a Willow Garage PR2 robot, (iii) a Blender component for on-line visualization, and (iv) a set of Orocos/RTT components that take care of the data flow communication and some simple coordination between all components. <s> BIB004 </s> An overview on framework design for autonomous robots <s> Component-Based Software Engineering (CBSE) <s> This paper presents the Robotics Service Bus (RSB), a new message-oriented, event-driven middleware based on a logically unified bus with hierarchical structure. Major goals for the development of RSB were openness and scalability in order to integrate diverse components in the context of robotics and intelligent systems. This includes the ability to operate on embedded platforms as well as desktop computers, reduction of framework lock-in, and the integration with other middlewares. We describe the design of the RSB middleware and explain how it meets requirements which lead to a scalable and open middleware concept. These requirements are based on several application scenarios which are used to verify the applicability of RSB. Furthermore, we relate RSB to other middlewares in the robotics domain. <s> BIB005
is often named as primary approach and some authors propose targeting a component market for robotics BIB001  . There are well-defined, formal component models that are independent from the underlying implementation BIB002  (Figure 2a) . A notable example are "Robotic Technology Components" (RTC) which are an OMG standard  . OpenRTM-Aist is an open-source implementation by the original authors BIB002 , while e. g. Gostai RTC² is a commercial implementation by the developers of Urbi  . Most other frameworks have component models that are more or less tied to a specific implementation. However, some are independent of the middleware that is used when instantiating the components (transport-or middleware-independence, see Figure 2b ) -such as Orocos BIB004  or GenoM3 BIB003 . Other solutions do not have an explicit component model at all. As Wienke et al. BIB005 argue, this can have advantages as well. All these approaches can be found in state-of-theart frameworks, and the choice has an impact on, especially, the evolution qualities of implemented systems. Figure 2 illustrates further cases. Examples for (c) are MCA2  or Microsoft Robotics Developer Studio³. Orca 2 BIB001 and ArmarX  are examples for (d). Based on a professional third-party middleware⁴, using this middleware is sufficient to communicate with a robot control using any supported programming language. Unlike other solutions, Finroc (e) includes several component types that can be added via plugins as required -including third-party component models e. g. from mca2. There is experimental support for RT Components. Apart from that, Finroc is transport-independent regarding inter-process communication.