Design Principles of the Component-Based Robot Software Framework Fawkes

Tim Niemüller, Alexander Ferrein, Daniel Beck, Gerhard LakemeyerSIMPAR 2010 · DOI

TL;DR

This paper introduces Fawkes, a component-based robot software framework designed to simplify development and improve portability across different robot platforms. By emphasizing well-defined interfaces and a flexible plugin architecture, Fawkes aims to reduce development time and facilitate code reuse in the complex world of robotics.

What Problem Does This Paper Address?

Developing software for robots is notoriously challenging. Robots often operate on specific, sometimes resource-constrained, hardware, and transferring software between these platforms can be a significant hurdle. Traditional approaches can lead to tightly coupled code that is difficult to maintain, debug, and adapt. The authors highlight that while component-based software engineering (CBSE) has been around for decades, its principles haven't been widely adopted in robotics frameworks. This gap leads to duplicated effort, slow development cycles, and difficulties in integrating new hardware or functionalities. The core problem is the lack of a robust, flexible, and portable framework that embraces component-based design for robotics.

Methods

Fawkes is built around a clear component concept, where each functional entity is a plugin. These plugins can be loaded and unloaded at runtime, enabling a fast development cycle where developers can iterate on individual components without recompiling the entire system. The framework utilizes a hybrid blackboard/messaging infrastructure for communication between components. This blackboard acts as a centralized data storage, allowing plugins to read and write data through well-defined interfaces.

Key to Fawkes' design is the concept of aspects, borrowed from aspect-oriented programming. These aspects represent specific abilities or requirements (e.g., logging, communication, accessing the blackboard) that plugins can inherit. This promotes code reuse and modularity. The framework also supports soft guarantees, which provide a basic exception handling mechanism by ensuring that dependencies between components are met during initialization and finalization. Fawkes leverages POSIX threads to exploit multi-core processing capabilities, allowing for concurrent execution of components.

Datasets

Not discussed in the paper.

Key Insights and Ideas

  • Component-based design is crucial for robotics: The paper strongly advocates for CBSE principles as a solution to the inherent complexity and portability challenges in robot software development.
  • Runtime-loadable plugins accelerate development: The ability to load and unload plugins at runtime significantly speeds up the development, testing, and debugging cycle.
  • Blackboard as a central communication hub: Using a blackboard for inter-component communication simplifies data sharing and management, especially in distributed systems.
  • Aspects for modularity and reuse: Borrowing from aspect-oriented programming, Fawkes uses aspects to encapsulate common functionalities, making components more modular and easier to integrate.
  • Soft guarantees for robustness: The concept of soft guarantees provides a lightweight mechanism for ensuring component dependencies are met, contributing to system stability.
  • Portability is achievable through abstraction: By abstracting hardware-specific functions into plugins, Fawkes can be adapted to various robot platforms with minimal code changes.

Key Results

The paper demonstrates Fawkes' effectiveness through its deployment on several robot platforms, including service robots and humanoid soccer robots (wheeled and bipedal). The authors report that the component-based approach facilitated the integration of legacy software from previous frameworks, showcasing Fawkes' extensibility. They also highlight that the framework exhibits a negligible run-time overhead, making it suitable for real-time domains like robotic soccer and even resource-constrained platforms like the Nao robot. The framework's design allows for scalability across multiple machines.

Limitations and Future Work

The authors acknowledge that while Fawkes provides a robust framework, the correctness of the software is not automatically verified. They have implemented quality assurance applications for certain parts of the software. For integrated external applications (not Fawkes plugins), certain guarantees like synchronization via the main loop and aspect inheritance are not available.

Future work includes gaining more experience with Fawkes on diverse platforms, further optimizing scalability and run-time overhead, and developing more sensor and actuator plugins to broaden its applicability. A significant area of future work is interfacing with ROS (Robot Operating System), given its widespread adoption. Additionally, the team plans to develop plugins for high-level reasoning, specifically focusing on a lightweight implementation of Golog and its integration with Fawkes.

Summary updated

BibTeX
@inproceedings{niemuller2010design,
  author = {Tim Niemüller and Alexander Ferrein and Daniel Beck and Gerhard Lakemeyer},
  title = {{Design Principles of the Component-Based Robot Software Framework Fawkes}},
  booktitle = {SIMPAR},
  year = {2010},
  doi = {10.1007/978-3-642-17319-6\_29},
}
Figure