Reusable robotics software collection

1998

Autonomous Robots, 1999

Robotics researchers have been unable to capitalize easily on existing software components to speed up their development e orts and maximize their system's capabilities. A component-based approach for building the software for robotics systems can provide reuse and sharing abilities to the research community. The software engineering community has been studying reuse techniques for three decades. We present several results from those e orts that are applicable to the robotics software integration problem. We describe how to specify a software component s o that a potential user may understand its capabilities and facilitate its application to his or her system. At the National Institute of Standards and Technology, w e h a v e developed a three-stage, component-speci cation approach. We illustrate this approach for a component that is relevant to robotics.

Robotics and Computer-Integrated Manufacturing, 1999

In this paper a framework for constructing #exible, robust and e$cient software applications for robots is described. The basic concepts needed to integrate complex, multidisciplinary robot software architectures are identi"ed, and the methods to achieve them are taken from di!erent areas of research (programming languages, network communication systems, real-time systems, etc.). The result is an open software system called NEXUS which includes the basic characteristics needed for the integration of very di!erent software modules, minimizing the e!ort of integration and maximizing the reusability, e$ciency and robustness of the resulting software applications. This software has proven to be a basis for more sophisticated tools that help in reducing the cost of modi"cations to and the complexity of multidisciplinary projects, allowing highly structured and reusable designs to be implemented. Although it has been currently implemented for mobile robots, it is a su$ciently generic framework suitable for use in other control systems.

SPIE Proceedings, 2003

In this article, we will present an overview of the Coupled Layered Architecture for Robotic Autonomy. CLARAty develops a framework for generic and reusable robotic components that can be adapted to a number of heterogeneous robot platforms. It also provides a hmework that will simplify the integration of new technologies and enable the comparison of various elements. CLARAty consists of two distinct layers: a FUIIC~~OM~ Layer and a Decision Layer. The Functional Layer defines the various abstractions of the system and adapts the abstract components to real or simulated devices. It provides a-work and the algorithms for low-and mid-level autonomy. The Decision Layer provides the system's high-level autonomy, which reasons about global resources and mission constraints. The Decision Layer accesses information from the Functional Layer at multiple levels of granularity. In this article, we will also present some of the challenges in developing interoperable software for various rover platforms. Examples will include challenges from the locomotion and manipulation domains

Proceedings of the 10th Performance Metrics for Intelligent Systems Workshop on - PerMIS '10, 2010

In recent years increased research activity in robotics has led to advancements in both hardware and software technologies. More complex hardware required increasingly sophisticated software infrastructures to operate it, and led to the development of several different robotics software frameworks. The driving forces behind the development of such frameworks is to cope with the heterogeneous and distributed nature of robotics software applications and to exploit more advanced software technologies in the robotics domain. So far, though, there has been not much effort to foster cooperation among these frameworks, neither on conceptual nor on implementation levels. Our research aims to analyse existing robotics software frameworks in order to identify possible levels of interoperability among them. The problem is tackled by determining a set of software concepts, in our case centering around component-based software development, which are used to determine a set of common architectural elements in an analysis of existing robotics software frameworks. The result is that these common elements can be used as interoperability points among software frameworks. Exploiting such interoperability gives developers new architectural design choices and fosters reuse of functionality already developed, albeit in another framework. It is also highly relevant for the development of new robotics software frameworks, as it opens smoother migration paths for developers to switch from one framework to another.

MELECON 2006 - 2006 IEEE Mediterranean Electrotechnical Conference, 2006

Software development for large robotic projects involves many different researchers with different programming needs, levels of mastery, and areas of research. Integrating such heterogeneous software while maintaining requirements like realtime, dependability, intensive access to hardware, etc., is a challenge in any long-term effort of this kind. A step forward along that way is the BABEL development system that supports heterogeneous programming languages (C, C++, JAVA), communication middleware (CORBA, TCP/IP connections), and platforms (RT-operating systems, MS-Windows). This paper focuses on the core of BABEL: the Aracne specification that covers the design phase of the robotic application lifecycle.

2011 IEEE International Conference on Robotics and Automation, 2011

As robotic software systems become larger and more complex, it is increasingly important to reuse existing software components to control development costs. For a broad class of relatively simple components, ranging from sensor and actuation interfaces to many simple perception and navigation algorithms, this can be a reasonably straightforward process, and many excellent frameworks have been developed in recent years that support reuse of such components in novel systems. However, there is also a class of more advanced software components, such as for modeling and interacting with complex environments, for which reuse can be a much more challenging problem. In particular, many advanced robotic algorithms can be highly sensitive to the perception and actuation capabilities of the specific robots they are deployed on, in turn requiring significant and invasive modifications to accommodate the specific capabilities of a different robotic system. This work examines the nature of this sensitivity and proposes a novel design methodology for isolating a stable, reusable "core" algorithm from any platform-specific enhancements, or "supplemental" effects. Modern software engineering techniques are used to encapsulate these supplemental effects separately from the core algorithm, allowing platform-specific details to be accommodated by modular substitution instead of direct modification of the "core" component. This methodology is experimentally evaluated on existing software for autonomous driving behaviors, yielding useful insights into the creation of highly adaptable robotic software components.

2014 IEEE/RSJ International Conference on Intelligent Robots and Systems, 2014

Systematically developing high-quality reusable software components is a difficult task and requires careful design to find a proper balance between potential reuse, functionalities and ease of implementation. Extendibility is an important property for software which helps to reduce cost of development and significantly boosts its reusability. This work introduces an approach to enhance components reusability by extending their functionalities using plug-ins at the level of the connection points (ports). Application-dependent functionalities such as data monitoring and arbitration can be implemented using a conventional scripting language and plugged into the ports of components. The main advantage of our approach is that it avoids to introduce application-dependent modifications to existing components, thus reducing development time and fostering the development of simpler and therefore more reusable components. Another advantage of our approach is that it reduces communication and deployment overheads as extra functionalities can be added without introducing additional modules. The details of the plug-in system is described in the paper and its advantages for the development of robotics applications are demonstrated by developing a step-by-step example on the iCub humanoid robot.

2010

Abstract 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.

Lecture Notes in Computer Science, 2010

The idea of component-based software engineering was proposed more that 40 years ago, yet only few robotics software frameworks follow these ideas. The main problem with robotics software usually is that it runs on a particular platform and transferring source code to another platform is crucial. In this paper, we present our software framework Fawkes which follows the component-based software design paradigm by featuring a clear component concept with well-defined communication interfaces. We deployed Fawkes on several different robot platforms ranging from service robots to biped soccer robots. Following the component concept with clearly defined communication interfaces shows great benefit when porting robot software from one robot to the other. Fawkes comes with a number of useful plugins for tasks like timing, logging, data visualization, software configuration, and even high-level decision making. These make it particularly easy to create and to debug productive code, shortening the typical development cycle for robot software.

2015

Effective system integration requires strict adherence to strong software engineering standards, a practice not much favoured in many collaborative research projects. We argue that component-based software engineering (CBSE) provides a way to overcome this problem because it provides flexibility for developers while requiring the adoption of only a modest number of software engineering practices. This focus on integration complements software re-use, the more usual motivation for adopting CBSE. We illustrate our argument by showing how a large-scale system architecture for an application in the domain of robot-enhanced therapy for children with autism spectrum disorder (ASD) has been implemented. We highlight the manner in which the integration process is facilitated by the architecture implementation of a set of placeholder components that comprise stubs for all functional primitives, as well as the complete implementation of all inter-component communications. We focus on the component-port-connector meta-model and show that the YARP robot platform is a well-matched middleware framework for the implementation of this model. To facilitate the validation of port-connector communication, we configure the initial placeholder implementation of the system architecture as a discrete event simulation and control the invocation of each component's stub primitives probabilistically. This allows the system integrator to adjust the rate of inter-component communication while respecting its asynchronous and concurrent character. Also, individual ports and connectors can be periodically selected as the simulator cycles through each primitive in each subsystem component. This ability to control the rate of connector communication considerably eases the task of validating component-port-connector behaviour in a large system. Ultimately, over and above its well-accepted benefits for software re-use in robotics, CBSE strikes a good balance between software engineering best practice and the socio-technical problem of managing effective integration in collaborative robotics research projects.

2012

Developing reliable robotics applications is a difficult and resource-consuming task. The scientific community is undertaking several initiatives to devise standard design techniques, and the deployment of reusable and interoperable components. At this point in time, a variety of approaches for robotic software development have been proposed, due to the wide range of domains where robots are used, the many forms and functions that a robot can have, and the diversity of people involved in robotics. Specifically, we focus on modularity and rapid development of distributed robotic systems. First, we survey the main issues in developing software frameworks for robotics, and we briefly discuss existent approaches, highlighting their goals, advantages and weaknesses. Then, we address the most significant design choices that arise in the implementation of robotic software and motivate the specific approach taken in OpenRDK, a software framework developed in our laboratory. Finally, we describe h...