Darmstadt Dribbling Dackels Darmstadt Dribblers


RoboFrame - a software framework tailored for heterogeneous teams of autonomous mobile robots

Different mechanisms for message exchange

Specific Characteristics
Developing and programming autonomous robots is a complex, time consuming and error-prone task. A large variety of hardware and software components has to be developed to achieve a well performing system. Additionally, these parts have to be integrated into an overall system and tested for correctness and robustness thoroughly. The task of system integration becomes increasingly essential in the future, when more and more high level functionality and various different algorithms have to be integrated into more complex autonomous robots. Especially for resource constraint mobile robots the efficiency of the system integration is crucial. A middleware eases the interfacing of these various components and provides fundamental properties well known from software engineering, e.g., decoupling of software blocks, distributed processing, flexibility, and therefore makes the process of software development more efficient. But this layer of indirection naturally introduces an additional overhead.

Efficient Communication
RoboFrame is a message-oriented middleware developed in C++ and with modern object-oriented design techniques. It is designed as a framework from bottom-up following the concept of inversion-of-control. The platform specific implementation is wrapped in a thin abstraction layer and currently the operating systems Linux (x86 and MIPS architecture), BSD Unix, Windows 2000/XP/7/CE are supported. RoboFrame provides publish/subscribe and shared memory communication mechanisms with two specific features addressing the particular demands of mobile robots:

  • Even if the latency of local message exchange is quite low for common middleware (around 0.05-0.5 ms for small messages) it becomes a significant overhead when a large quantity of messages (several hundreds per second) or large messages (several hundred Kilobytes) are exchanged which is common for complex control software. Therefore RoboFrame enables exchanging messages between components running in the same thread using references without any overhead commonly present (like (de-)marshaling and memory copy).
  • The subscription to a message bus must not be a simple binary condition but permits additional filter parameters to reduce the number of messages directly at the publisher which can be dynamically adjusted. This enables remote monitoring especially tailored to the bandwidth available between the robot and the remote computer.

Sophisticated Analysis Tools
In contrast to other middleware RoboFrame provides an integrated graphical user interface (GUI) with sophisticated usability features known from IDEs. It is extensible with custom visualizations and is used for debugging, monitoring and analyzing single robots as well as teams of cooperating robots.

Graphical user interface

Any message exchanged in the control software can be introspected and visualized in the GUI. For each particular component at least one specific view has been developed to debug and monitor the internals of the implementation.

Any message exchanged between the components can be recorded either on the robot or in the GUI and replayed for offline review and analysis. For multiple robots the distributed recorded data are automatically synchronized for playback. Furthermore extrinsic videos can be replayed synchronously to provide additional information of the situation for offline analysis.

Since the amount of data recorded for offline analysis is tremendous it becomes a challenging task to inspect all information in a reasonable time. The manual review process is time consuming and error-prone and since it is not very efficient it is often neglected. Therefore RoboFrame provides a convenient way to automate the analysis and search for well known issues. Currently implemented algorithms cover the detecting of discontinuity of the self localization as well as state oscillation in hierarchies of finite state machines. Furthermore competitive algorithms or differently parametrized instances of the same implementation can be compared automatically which results in efficiently computable objective results.