Emergent Architectures: A Case Study for Outdoor Mobile Robots

Abstract

Software reuse is a key issue in any long term software engineering endeavor, such as the ongoing development of robotics systems. Existing approaches to software reuse involve fixing part of the software landscape as a constant foundation to build upon. Some approaches fix the software archi tecture, i.e., how data flows through the system, and then allow the user to swap components in and out. Other approaches define a suite of stable components and interfaces which can be mixed, matched, and extended. All of these approaches assume that the key to software reuse is pervasive and long lasting standards. Unfortunately, in a young domain such as mobile robotics both software components and software architectures are items of research, and thus are in constant flux. This dissertation proposes the replacement of global, system-wide, permanent standards with local, transient standards in the form of reconfigurable interfaces. These interfaces are not simply librar ies of system calls, but contain mediators and adapters which stand between a software module and the system architecture, providing a module with a locally stable view of the system in which it resides, translating the module's requests and notifications into the protocols and data flow of that particular architecture. This system of mediation facilitates the emergence of a system architecture from the current needs and requirements of the tasks, rather than forcing the a priori adoption of any single architecture. To demonstrate the feasibility of this approach, two very different robotic tasks were examined: first the implementation of a dedicated, high-speed road following system under Carnegie Mellon's NavLab project, and second the implementation of a multi-modal military reconnaissance vehicle for the Unmanned Ground Vehicle program. Radically different architectures and components emerge from the requirements of these two tasks and the current capabilities of the component modules, but it is demonstrated that reconfigurable interfaces allow the moving of critical code between the two without even recompilation. The mediating abilities of reconfigurable interfaces are provided without requiring any pervasive, long-lasting communications standards while only requiring the execution overhead of a few pointer dereferences.