CLARAty: Challenges and Steps toward Reusable Robotic Software
Antonio Diaz2006, International Journal of Advanced Robotic Systems
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
We present in detail some of the challenges in developing reusable robotic software. We base that on our experience in developing the CLARAty robotics software, which is a generic object-oriented framework used for the integration of new algorithms in the areas of motion control, vision, manipulation, locomotion, navigation, localization, planning and execution. CLARAty was adapted to a number of heterogeneous robots with different mechanisms and hardware control architectures. In this paper, we also describe how we addressed some of these challenges in the development of the CLARAty software.
Related papers
CLARAty: an architecture for reusable robotic software
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
Toward developing reusable software components for robotic applications
2001
We will present an overview of the CLARAty architecture which aims at developing reusable software components for robotic systems. These components are to support autonomy software which plans and schedules robot activities. The CLARAty architecture modifies the conventional threelevel robotic architecture into a new two-layered design: the Functional Layer and the Decision Layer. The Functional Layer provides a representation of the system components and an implementation of their basic functionalities. The Decision Layer is the decision making engine that drives the Functional Layer. It globally reasons about the intended goals, system resources, and state of the system and its environment. The Functional Layer is composed of a set of interrelated object-oriented hierarchies consisting of active and passive objects that represent the different levels of system abstractions. In this paper, we present an overview of the design of the Functional Layer. The Functional Layer is decomposed into a set of reusable core components and a set of extended components that adapt the reusable set to different hardware implementations. The reusable components: (a) provide interface definitions and implementations of basic functionality, (b) provide local executive capabilities, (c) manage local resources, and (d) support state and resource queries by the Decision Layer.
CLARAty and challenges of developing interoperable robotic software
Proceedings 2003 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS 2003) (Cat. No.03CH37453), 2003
framework for while maintajning the ability to easily integrate platform-specific algorithms.
Reusable robotics software collection
Proceedings of Workshop …, 2007
Integrating software on board real robots requires to be able to share, distribute and reuse robotics software components among the robotics community. Many projects and frameworks have contributed to this problem. However, most of the frameworks concentrate on providing a particular architecture. This actually leads to a reduced reusability.
Code reusability tools for programming mobile robots
… and Systems, 2004. …, 2004
This paper describes two initiatives aiming at improving code reusability for programming mobile robots: RobotFlow/FlowDesigner, a data-flow programming environment; MARIE (Mobile and Autonomous Robotics Integration Environment), a programming environment allowing multiple applications, programs and tools, to operate on one or multiple machines/OS and work together on a mobile robot implementation. RobotFlow/FlowDesigner's objective is to provide a modular, graphical programming environment that will help visualize and understand what is really happening in the robot's control loops, sensors, actuators, by using graphical probes. MARIE aims at avoiding making an exclusive choice on particular programming tools, making it possible to reuse code and applications.
Engineering Heterogeneous Robotics Systems: A Software Architecture-Based Approach
Computer, 2000
Published by the IEEE Computer Society 0018-9162/11/$26.00 © 2011 IEEE the rest of the system and reuse it. They are thus forced to develop a new system from scratch. The use of common robotics software libraries, such as Player and CLARAty, only partially alleviates this problem. Although these libraries consist of robotics-specific middleware that provides a low-level robot framework and helps with specific advanced features such as distributed communication and code mobility, the existing solutions provide no guidance or support for faithfully preserving the design-time structure of robotics systems.
Integrating Heterogeneous Robotic Software
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.
Design choices for modular and flexible robotic software development: the OpenRDK viewpoint
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...
OpenRDK: A modular framework for robotic software development
2008 IEEE/RSJ International Conference on Intelligent Robots and Systems, 2008
In this paper we conduct an analysis of existing frameworks for robot software development and we present OpenRDK, a modular framework focused on rapid development of distributed robotic systems. It has been designed following users' advice and has been in use within our group for several years. By now OpenRDK has been successfully applied in diverse applications with heterogeneous robots and as we believe it is fruitfully usable by others we are releasing it as open source.
GenoM3: Building middleware-independent robotic components
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.
Related papers
Re-usable kinematic models and algorithms for manipulators and vehicles
2007 IEEE/RSJ International Conference on Intelligent Robots and Systems, 2007
Robotics Library: An Object-Oriented Approach to Robot Applications
Proceedings of the IEEE/RSJ International Conference on Intelligent Robots and Systems, 2017
We discuss the architecture and software engineering principles of the Robotics Library (RL). Driven by requirements of robot systems, research projects, industrial applications, and education, we identify relevant design requirements and present an approach to manage hardware and real-time, provide a user-friendly, object-oriented interface to powerful kinematics and dynamics calculations, and support various platforms. After over ten years of development that started in 2004 and evaluating many variants of the architecture, we discuss the design choices for the components of the library in its current version.
Object-oriented techniques in robot manipulator control software development
2001
Software development for the control of robotic manipulators is a complex task because it requires expertise in many areas (e.g., robotics, real-time programming, hardware integration, concurrency, etc.). Because of this fact, it is difficult to develop a common software platform supporting the diversity of robotic research areas and robotic hardware. Even though a large number of robotic languages, libraries, and tools have been created, they are seldom reused. That is, many research teams develop their own software platform from scratch because existing platforms are too inflexible with regard to modifications and too complex to understand. The authors of this paper believe that code reuse is fostered by providing a lightweight platform rather than requiring the user to modify a complex system. Along this line of reasoning, this paper describes the QMotor Robotic Toolkit (QMotor RTK). The RTK is a set of C++ libraries and programs that follow object-oriented concepts to ensure code reuse, modularity, scalability, and an intuitive code structure. The RTK is a homogeneous system that consists only of PC software. The RTK includes joint level control programs for the Puma 560 manipulator, the Barren Whole Arm Manipulator (WAM), and the Integrated Motion Inc. (IMI) two-link manipulator as well as a joint level trajectory generator and a graphical user interface (GUI)
Integrating Robotics Software
2004
Developing software for controlling robotic systems is costly due to the complexity inherent in these systems. There is a need for tools that permit a reduction in the programming efforts, aiming at the generation of modular and robust applications, and promoting software reuse. The techniques which are of common use today in other areas are not adequate to deal with the complexity associated with these systems. In this work we present CoolBOT, a component oriented framework for programming robotic systems, based on the Port Automata model that fosters controllability and observability of software components. A simple demonstrator outlines the bene ts of using the proposed approach in the development of a robotic application.
Toward adaptation and reuse of advanced robotic software
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.
On device abstractions for portable, reusable robot code
Proceedings 2003 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS 2003) (Cat. No.03CH37453), 2003
We seek to make robot programming more efficient by developing a standard abstract interface for robot hardware, based on familiar techniques from operating systems and network engineering. This paper describes the application of three well known abstractions, the character device model, the interface/driver model, and the client/server model to this purpose. These abstractions underlie Player/Stage, our Open Source project for rapid development of robot control systems. One product of this project is the Player Abstract Device Interface (PADI) specification, which defines a set of interfaces that capture the functionality of logically similar sensors and actuators. This specification is the central abstraction that enables Player-based controllers to run unchanged on a variety of real and simulated devices. We propose that PADI could be a starting point for development of a standard platform for robot interfacing, independent of Player, to enable code portability and re-use, while still providing access to the unique capabilities of individual devices.
The NEXUS open system for integrating robotic software
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.
Software Reuse across Robotic Platforms: Limiting the Effects of Diversity
2005 Australian Software Engineering Conference, 2005
Robots have diverse capabilities and complex interactions with their environment. Software development for robotic platforms is time consuming due to the complex nature of the tasks to be performed. Such an environment demands sound software engineering practices to produce high quality software. However software engineering in the robotics domain fails to facilitate any significant level of software reuse or portability. This paper identifies the major issues limiting software reuse in the robotics domain. Lack of standardisation, diversity of robotic platforms, and the subtle effects of environmental interaction all contribute to this problem. It is then shown that software components, fuzzy logic, and related techniques can be used together to provide suitable abstractions to address this problem. While complete software reuse is not possible, it is demonstrated that significant levels of software reuse can be obtained.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.