Mirko Bordignon

Seamless integration of robots and tiny embedded devices in a PEIS-Ecology

The fields of autonomous robotics and ambient intelligence are converging toward the vision of smart robotic environments, in which tasks are performed via the cooperation of many networked robotic devices. To enable this vision, we need a common communication and cooperation model that can be shared between robotic devices at different scales, ranging from standard mobile robots to tiny embedded devices. Unfortunately, todays robot middlewares are too heavy to run on tiny devices, and middlewares for embedded devices are too simple to support the cooperation models needed by an autonomous smart environment. In this paper, we propose a middleware model which allows the seamless integration of standard robots and simple off-the-shelf embedded devices. Our middleware is suitable for building truly ubiquitous robotics applications, in which devices of very different scales and capabilities can cooperate in a uniform way. We discuss the principles and implementation of our middleware, and show an experiment in which a mobile robot, a commercial mote, and a custom-built mote cooperate in a home service scenario.

A virtual machine-based approach for fast and flexible reprogramming of modular robots

Modular robot programming spans a number of issues ranging from high-level coordination to controller distribution and update in individual modules. The latter issue has received little attention from the research community though in our experience it is one of the main factors hindering agile development and experimentation with physical robots: reprogramming tens or hundreds of modules can be a major overhead in the development process and cannot be done with traditional approaches without restarting the robot, which impedes updating a running system. We propose a solution based on a virtual machine design shaped around three core concepts: the context of a module and its role in the ensemble, the reactive nature of robot controllers, and control programs decomposable into subparts that can be dynamically and separately redefined. We show that by incorporating those concepts into the design we are able to both achieve program conciseness (thus providing fast and efficient code distribution) and program expressiveness (thus providing versatility to represent diverse control algorithms). The virtual machine is programmed in a high-level role-oriented language that allows the programmer to declaratively specify how programs are deployed in the modular robot. Our approach enables fast and incremental on-line updates, allowing the programmer to interactively experiment with the physical robots. We show how this design lends itself to an efficient implementation targeting typical resource-constrained modular robotic hardware by illustrating our prototype implementation for the ATRON self-reconfigurable robot.

Morphology Independent Learning in Modular Robots

Hand-coding locomotion controllers for modular robots is difficult due to their polymorphic nature. Instead, we propose to use a simple and distributed reinforcement learning strategy. ATRON modules with identical controllers can be assembled in any configuration. To optimize the robot’s locomotion speed its modules independently and in parallel adjust their behavior based on a single global reward signal. In simulation, we study the learning strategy’s performance on different robot configurations. On the physical platform, we perform learning experiments with ATRON robots learning to move as fast as possible. We conclude that the learning strategy is effective and may be a practical approach to design gaits.

Robust and reversible execution of self-reconfiguration sequences???

Modular, self-reconfigurable robots are robotic systems that can change their own shape by autonomously rearranging the physical modules from which they are built. In this work, we are interested in how to distributedly execute a specified self-reconfiguration sequence. The sequence is specified using a simple and centralized scripting language, which either could be the outcome of a planner or be hand-coded. The distributed controller generated from this language allows for parallel self-reconfiguration steps and is highly robust to communication errors and loss of local state due to software failures. Furthermore, the self-reconfiguration sequence can automatically be reversed, if desired. We verify our approach and demonstrate its robustness in experiments using physical and the simulated ATRON modules, as well as simulated M-TRAN modules. Overall, the contribution of this work is the combination of the tractability of a centralized scripting language with the robustness and parallelism of distributed controllers in modular robots.

Model-based kinematics generation for modular mechatronic toolkits

Modular robots are mechatronic devices that enable the construction of highly versatile and flexible robotic systems whose mechanical structure can be dynamically modified. The key feature that enables this dynamic modification is the capability of the individual modules to connect to each other in multiple ways and thus generate a number of different mechanical systems, in contrast with the monolithics fixed structure of conventional robots. The mechatronic flexibility, however, complicates the development of models and programming abstractions for modular robots, since manually describing and enumerating the full set of possible interconnections is tedious and error-prone for real-world robots. In order to allow for a general formulation of spatial abstractions for modular robots and to ensure correct and streamlined generation of code dependent on mechanical properties, we have developed the Modular Mechatronics Modelling Language (M3L). M3L is a domain-specific language, which can model the kinematic structure of individual robot modules and declaratively describe their possible interconnections rather than requiring the user to enumerate them in their entirety. From this description, the M3L compiler generates the code that is needed to simulate the resulting robots within Webots, widely used commercial robot simulator, and the software component needed for spatial structure computations by a virtual machine-based runtime system, which we have developed and used for programming physical modular robots

Exploit Morphology to Simplify Docking of Self-reconfigurable Robots

In this paper we demonstrate how to dock two self-reconfigurable robots and as a result merge them into one large robot. The novel feature of our approach is that the configuration we choose for our robots allows the robots to handle misalignment errors and dock simply by pushing against each other. In 90 experiments with the ATRON self-reconfigurable robot we demonstrate that two three-module robots can dock in 16 seconds without using sensors and are successful in between 93% and 40% of the attempts depending on approach angle and offset. While this is a modest step towards fast and reliable docking, we conclude that choosing appropriate configurations for docking is a significant tool for speeding up docking.

Generalized programming of modular robots through kinematic configurations

The distinctive feature of modular robots consists in their reconfigurable mechanical structure, as they are assembled on-demand from basic mechatronic units. This implies that kinematic models of the robots need to be computed on a case-by-case basis for each specific assembly, which is a manual and hence time-consuming and error-prone procedure. We propose to automate this process by automatically computing such kinematic models starting from simple descriptions of the modules and their assemblies. This automated computation is supported by our toolchain for programming arbitrary modular robots in arbitrary configurations, presented in this paper. We contribute two novel results through this approach. First, a high-level programming language that provides kinematic abstractions for arbitrary modular robots, in contrast to the robot-specific solutions currently available. Second, a programming abstraction to subsume multiple kinematically equivalent robot assemblies into a so-called kinematic configuration, hence eliminating the need to explicitly enumerate and program each of them. These contributions advance current techniques for modular robot programming by demonstrating a tool that a) targets multiple mechanical platforms, offering the first general solution for modular robot programming, and b) raises the abstraction level by allowing users to reason and program in terms of standardized kinematic models that are automatically mapped to physical robot configurations by the toolchain.

Robust and reversible self-reconfiguration

Modular, self-reconfigurable robots are robots that can change their own shape by physically rearranging the modules from which they are built. Self-reconfiguration can be controlled by e.g. an off-line planner, but numerous implementation issues hamper the actual self-reconfiguration process: the continuous evolution of the communication topology increases the risk of communications failure, generating code that correctly controls the self-reconfiguration process is non-trivial, and hand-tuning the self-reconfiguration process is tedious and error-prone. To address these issues, we have developed a distributed scripting language that controls self-reconfiguration of the ATRON robot using a robust communication scheme that relies on local broadcast of shared state. This language can be used as the target of a planner, offers direct support for parallelization of independent operations while maintaining correct sequentiality of dependent operations, and compiles to a robust and efficient implementation. Moreover, a novel feature of this language is its reversibility: once a self-reconfiguration sequence is described the reverse sequence is automatically available to the programmer, significantly reducing the amount of work needed to deploy self-reconfiguration in larger scenarios. We demonstrate our approach with long-running (reversible) self-reconfiguration experiments using the ATRON robot and a reversible self-reconfiguration experiment using simulated MTRAN modules.

Implementing Flexible Parallelism for Modular Self-reconfigurable Robots

Modular self-reconfigurable robots are drawing increasing interest due to their nature as a versatile, resilient and potentially cost-effective tool. Programming modular self-reconfigurable robots is however complicated by the need for closely coordinating the actions of each module with those of its neighbors. In this paper, we investigate the need for a flexible set of concurrency primitives with which to express control algorithms, while respecting the constraints posed by the physical structure. We present two solutions for the ATRON self-reconfigurable robot built over TinyOS and the Java Virtual Machine. Both solutions are based on the principle of split-phase operations, and both address the need for a structured, language-neutral way to express the desired control flow, while retaining the flexibility needed to efficiently cope with the constraints specific to highly physically concurrent robotic systems.

An inexpensive, off-the-shelf platform for networked embedded robotics

Recent years have witnessed the proliferation of a new class of devices, commonly referred to as Networked Embedded Devices. Their increasingly low cost and small size make them suited for large scale sensing applications. Likewise, they could be appealing as a means to embed intelligent actuation capabilities into the environment, turning simple artifacts into networked robotic appliances. The currently existing devices, however, are not suited for this development. In this paper, we present the PEIS-Mote: an open, general, small-size and inexpensive sensor-actuator node especially suited for networked robotics, and built from commonly available off-the-shelf components. This platform can run a popular operating system for sensor networks, TinyOS, which makes it interoperable with most commercially available sensor nodes.