Programming modular robots with locally distributed predicates (original) (raw)

Declarative Programming for Modular Robots

Because of the timing, complexity, and asynchronicity challenges common in modular robot software we have recently begun to explore new programming models for modular robot ensembles. In this paper we apply two of those models to a metamodule-based shape planning algorithm and comment on the differences between the two approaches. Our results suggest that declarative programming can provide several advantages over more traditional imperative approaches, and that the differences between declarative programming styles can themselves contribute leverage to different parts of the problem domain.

Towards a Robust Spatial Computing Language for Modular Robots (Position Paper)

2012

Self-reconfigurable, modular robots are distributed mechatronic devices that can autonomously change their physical shape. Self-reconfiguration from one shape to another is typically achieved through a specific sequence of actuation operations distributed across the modules of the robot. More generally, control of self-reconfigurable robots requires individual modules to act in specific ways in response to sensor input, and these actions need to be coordinated across the modules of the robot. Robust sequential control and role-based control of individual modules has been experimentally demonstrated using the DynaRole language. DynaRole however only allows simple sequences of distributed operations to be executed, which is suitable for self-reconfiguration sequences but lacks the generality needed to implement more complex behaviors. In this position paper we present initial ideas on generalizing the DynaRole language to support a wider range of modular robot control scenarios, while...

CoolBOT: A Component-Oriented Programming Framework for Robotics

Lecture Notes in Computer Science, 2002

This paper introduces at the specification level CoolBOT, a component-oriented programming framework for robotics designed to assist robotic system developers in obtaining more structured and reusable systems without imposing any specific architecture. Within this framework components are conceived as Port Automata (PA)[8] that interact through their ports and that can be composed to build up new components from existing ones. Components, no matter if they are atomic or compound, are internally modeled as Discrete Event Systems and controlled using the same state control graph. CoolBOT hides the programmer any aspects related to communications and provides standard mechanisms for different modes of data exchange between components, exception handling and support for distributed computing environments.

Distributed Control Diffusion: Towards a Flexible Programming Paradigm for Modular Robots

The Proceedings of First International Conference on Robot Communication and Coordination, 2007

A self-reconfigurable robot is a robotic device that can change its own shape. Self-reconfigurable robots are commonly built from multiple identical modules that can manipulate each other to change the shape of the robot. The robot can also perform tasks such as locomotion without changing shape. Programming a modular, self-reconfigurable robot is however a complicated task: the robot is essentially a real-time, distributed embedded system, where control and communication paths often are tightly coupled to the current physical configuration of the robot. To facilitate the task of programming modular, selfreconfigurable robots, we present the concept of distributed control diffusion: distributed queries are used to identify modules that play a specific role in the robot, and behaviors that implement specific control strategies are diffused throughout the robot based on these role assignments. This approach allows the programmer to dynamically distribute behaviors throughout a robot and moreover provides a partial abstraction over the concrete physical shape of the robot. We have implemented a prototype of a distributed control diffusion system for the ATRON modular, self-reconfigurable robot. The prototype relies on a simple virtual machine with a dedicated instruction set, allowing mobile programs to migrate between the modules that constitute a robot. Through a number of simulated experiments, we should how a single rule-based controller program implemented using distributed control diffusion can perform simple obstacle avoidance in a wide range of different car-like robots constructed using ATRON modules.

Accomplishing high-level tasks with modular robots

Autonomous Robots, 2018

The advantage of modular self-reconfigurable robot systems is their flexibility, but this advantage can only be realized if appropriate configurations (shapes) and behaviors (controlling programs) can be selected for a given task. In this paper, we present an integrated system for addressing high-level tasks with modular robots, and demonstrate that it is capable of accomplishing challenging, multi-part tasks in hardware experiments. The system consists of four tightly integrated components: (1) A high-level mission planner, (2) A large design library spanning a wide set of functionality, (3) A design and simulation tool for populating the library with new configurations and behaviors, and (4) modular robot hardware. This paper build on earlier work by the authors [10], extending the original system to include environmentally adaptive parametric behaviors, which integrate motion planners and feedback controllers with the system.

Programming with Components in Robotics

This paper describes a component-oriented programming framework for robotics, CoolBOT, which is actually under development at the University of Las Palmas de Gran Canaria (ULPGC). The framework has been designed to assist robotic system developers in building more structured and reusable systems. Components are the basic building blocks used in this framework, modeled as Port Automata, PA , that interact through their ports and that can be composed to build up new components from existing ones. Components, whether atomic or compound, are internally modeled as Discrete Event Systems and controlled using the same state control graph. CoolBOT hides any aspects related to communications and provides standard mechanisms for different modes of data exchange between components, exception handling and support for distributed computing environments.

Another Component Based Programming Framework for Robotics

Developing software for controlling robotic systems is costly due to the complexity in- herent in these systems. There is a need for tools that permit a reduction in the program- ming effort, 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 (1). This document presents CoolBOT, a component oriented framework for programming robotic systems, based on a port automata model (2) that fosters controllability and observability of software components. CoolBOT (3) (4) is a C++ component-oriented framework for programming robotic systems that allows designing systems in terms of composition and integration of soft- ware components. Each software component (5) is an independent execution unit which provides a given functionality, hidden behind an external interface specifying clearly which data it needs and which data i...

Reactivity in a Logic-Based Robot Programming Framework (Extended Version)

Artificial Intelligence, 1999

A robot must often react to events in its environment and exceptional conditions by suspending or abandoning its current plan and selecting a new plan that is an appropriate response to the event. This paper describes how high-level controllers for robots that are reactive in this sense can conveniently be implemented in ConGolog, a new logic-based robot/agent programming language. Reactivity is achieved by exploiting ConGolog's prioritized concurrent processes and interrupts facilities. The language also provides nondeterministic constructs that support a form of planning. Program execution relies on a declarative domain theory to model the state of the robot and its environment. The approach is illustrated with a mail delivery application.

A tale of two planners: Modular robotic planning with LDP

2009 IEEE/RSJ International Conference on Intelligent Robots and Systems, 2009

LDP (Locally Distributed Predicates) is a distributed, high-level language for programming modular reconfigurable robot systems (MRRs). In this paper we present the implementation of two motion-planning algorithms in LDP, and analyze both their performance and ease of implementation. We present multiple variations of one planner, including a novel resource allocation algorithm. We then draw conclusions about both the utility of the motion-planning algorithms and the suitability of LDP to the problem space. Our experiments suggest that metamodule-based planning approaches have a cost in time and/or energy terms, but that the cost can be worth paying in exchange for the additional generality and separationof-concerns offered by these techniques. The particular tradeoff for a given system will depend upon its goals and the details of the underlying modules.

Generalizing metamodules to simplify planning in modular robotic systems

2008

In this paper we develop a theory of metamodules and an associated distributed asynchronous planner which generalizes previous work on metamodules for lattice-based modular robotic systems. All extant modular robotic systems have some form of non-holonomic motion constraints. This has prompted many researchers to look to metamodules, i.e., groups of modules that act as a unit, as a way to reduce motion constraints and the complexity of planning. However, previous metamodule designs have been specific to a particular modular robot.