A framework for building mobile single and multi-robot applications

The complexity of robot software systems calls for the use of a well-conceived architecture together with programming tools to support it. One common feature of robot architectures is the modular decomposition of systems into simpler and largely independent components. These components implement primitive actions and report events about their state. The robot programming framework proposed here includes a tool (RoboGraph) to program and coordinate the activity (tasks) of these middleware modules. Project developers use the same task programming IDE (RoboGraph) on two different levels. The first is to program tasks that must be executed autonomously by one robot and the second is to program tasks that can include several robots and building elements.Tasks are described using a Signal Interpreted Petri Net (SIPN) editor and stored in an xml file. A dispatcher loads these files and executes the different Petri nets as needed. A monitor that shows the state of all the running nets is very useful for debugging and tracing purposes. The whole system has been used in several applications: A tour-guide robot (GuideBot), a multi-robot surveillance project (WatchBot) and a hospital food and laundry transportation system based on mobile robots.     

IAda: A language for robot programming based on Ada

We present a programming language for robots which we have implemented based on the Ada language. It is an interpreted language which permits dynamic configuration of software. It manipulates Ada tasks and subroutines. One of the Ada tasks is an inference engine of a logic programming language adapted to real-time constraints. We show how the conjunction of Ada tasks, to perform perception and action functions on the robot, to logic programs, for the control of these tasks, both manipulated by the IAda language, gives a powerful environment for robot programming.     

High-Level Computer Architecture

Associated with each programming language is a computer architecture that executes programs in that language. If the language is a low-level instruction set, the associated computer architecture is a low-level von Neumann architecture; if the language is high-level, the associated architecture is high-level. The internal structure of a high-level architecture reflects the constructs of the high-level language. The articles in this special issue deal with high-level computer architecture.     

A knowledge-based task-level programming and execution environment for robots

A knowledge-based framework to support task-level programming and operational control of robots is described. Our bask intention is to enhance the intelligence of a robot control system so that it may carefully coordinate the interactions among discrete, asynchronous and concurrent events under the constraints of action precedence and resource allocation. We do this by integrating both off-line and on-line planning capabilities in a single framework. The off-line phase is equipped with proper languages for describing workbenches, specifying tasks, and soliciting knowledge from the user to support the execution of robot tasks. A static planner is included in the phase to conduct static planning, which develops local plans for various specific tasks. The on-line phase is designed as a dynamic control loop for the robot system. It employs a dynamic planner to tackle any contingent situations during the robot operations. It is responsible for developing proper working paths and motion plans to achieve the task goals within designated temporal and resource constraints. It is implemented in a distributed and cooperative blackboard system, which facilitates the integration of various types of knowledge. Finally, any failures from the on-line phase are fed back to the off-line phase. This forms the interaction between the off-line and on-line phases and introduces an extra closed loop opportunistically to tune the dynamic planner to adapt to the variation of the working environment in a long-term manner.     

Task-oriented programming of large redundant robot motion

Large robots are a new domain of advanced robotics. Examples of their application fields are tasks like operations on large free-form surfaces, especially aircraft cleaning and removing paint from hulls. They are equipped with a programmable robot control comparable to a control system used for industrial robots. However, conventional teach-in methods are not able to manage the complexity of programming large redundant robot operation on free-form geometries. The Fraunhofer IPA has developed an innovative off-line programming system that allows the creation of robot motion programs which satisfy time and energy optimization criteria. This system helps to avoid collisions within the workspace and to fulfill conditions that arise from the robot kinematics and dynamics. This advanced programming system has been successfully used to generate motion programs for the world's largest mobile robot, the aircraft cleaning manipulator SKYWASH. In this context offline programs for eleven different types of aircraft have been developed.     

A novel trigger-based method for hydrothermal vents prospecting using an autonomous underwater robot

In this paper we address the problem of localizing active hydrothermal vents on the seafloor using an Autonomous Underwater Vehicle (AUV). The plumes emitted by hydrothermal vents are the result of thermal and chemical inputs from submarine hot spring systems into the overlying ocean. The Woods Hole Oceanographic Institution’s Autonomous Benthic Explorer (ABE) AUV has successfully localized previously undiscovered hydrothermal vent fields in several recent vent prospecting expeditions. These expeditions utilized the AUV for a three-stage, nested survey strategy approach (German et al. in Deep Sea Res. I 55:203–219, 2008). Each stage consists of a survey flown at successively deeper depths through easier to detect but spatially more constrained vent fluids. Ideally this sequence of surveys culminates in photographic evidence of the vent fields themselves. In this work we introduce a new adaptive strategy for an AUV’s movement during the first, highest-altitude survey: the AUV initially moves along pre-designed tracklines but certain conditions can trigger an adaptive movement that is likely to acquire additional high value data for vent localization. The trigger threshold is changed during the mission, adapting the method to the different survey profiles the robot may find. The proposed algorithm is vetted on data from previous ABE missions and measures of efficiency presented.     

Caesar: an intelligent domestic service robot

In this paper we present Caesar, an intelligent domestic service robot. In domestic settings for service robots complex tasks have to be accomplished. Those tasks benefit from deliberation, from robust action execution and from flexible methods for human?Crobot interaction that account for qualitative notions used in natural language as well as human fallibility. Our robot Caesar deploys AI techniques on several levels of its system architecture. On the low-level side, system modules for localization or navigation make, for instance, use of path-planning methods, heuristic search, and Bayesian filters. For face recognition and human?Cmachine interaction, random trees and well-known methods from natural language processing are deployed. For deliberation, we use the robot programming and plan language Readylog, which was developed for the high-level control of agents and robots; it allows combining programming the behaviour using planning to find a course of action. Readylog is a variant of the robot programming language Golog. We extended Readylog to be able to cope with qualitative notions of space frequently used by humans, such as ??near?? and ??far??. This facilitates human?Crobot interaction by bridging the gap between human natural language and the numerical values needed by the robot. Further, we use Readylog to increase the flexible interpretation of human commands with decision-theoretic planning. We give an overview of the different methods deployed in Caesar and show the applicability of a system equipped with these AI techniques in domestic service robotics.     

Aibo and Webots: Simulation,wireless remote control and controller transfer

This article introduces a new software tool that provides an accurate simulation of Sony Aibo robots and the capability to transfer controller programs from the simulation to the real robot. Five components are described: (1) a simulated physics-based model of the Sony Aibo ERS-210(A) and ERS-7 quadruped robots; (2) a graphical user interface for controlling the simulated and real robots; (3) a wireless communication protocol for controlling the robot from within Webots; (4) software components on the robot that enable remote control; and (5) a method for cross-compiling Webots robot controllers. The complete system has been calibrated and proof tested. It enables simultaneous control of both a simulated and a real Aibo robot and provides the user with a platform for convenient robot programming without any knowledge of the underlying robot firmware.     

Graphical simulation for sensor based robot programming

The programming of robots is slowly evolving from traditional teach pendant methods to graphical Off-Line Programming (OLP) methods. Graphical simulation tools, such as OLP, are very useful for developing and testing robot programs before they are run on real industrial equipment. OLP systems are also used to develop task level programs. Traditional OLP systems, however, suffer from the limitations of using only position control which does not account for inherent robot inaccuracies and dynamic environments. This paper describes our work on improving and supplementing traditional position control programming methods. A baseline OLP system was implemented at NIST's Automated Manufacturing Research Facility (AMRF). Experience gained in implementing this system showed that an effective OLP system must accurately simulate the real world and must support sensor programming to compensate for real-world changes that cannot be simulated. The developed OLP geometric world model is calibrated using robot mounted ultrasound ranging sensors. This measurement capability produces a baseline geometric model of relatively good static accuracy for off-line programming. The graphical environment must also provide representations of sensor features. For this specific application, force is simulated in order to include force based commands in our robot programs. These sensor based programs are able to run reliably and safely in an unpredictable industrial environment. The last portion of this paper extends OLP and describes the functionality of a complete system for programming complex robot tasks.     

A parallel processing architecture for sensor-based control of intelligent mobile robots

Parallel processing plays an important role in sensor-based control of intelligent mobile robots. This paper describes the design and implementation of a parallel processing architecture used for real-time, sensor-based control of mobile robots. This architecture takes the form of a network of sensing and control nodes, based on a novel module that we call Locally Intelligent Control Agent (LICA). It is a hybrid control architecture containing low-level feedback control loops and high-level decision making components. All the sensing, planning, and control tasks for intelligent control of a mobile robot are distributed across such a network, and operate in parallel. It has been used successfully in many experiments to perform planning and navigation tasks in real-time. Such a generic architecture can be readily applied to many diverse applications.     

Incorporating decision-theoretic planning in a robot architecture

The goal of robotics research is to design a robot to fulfill a variety of tasks in the real world. Inherent in the real world is a high degree of uncertainty about the robot’s behavior and about the world. We introduce a robot task architecture, DTRC, that generates plans with actions that incorporate costs and uncertain effects, and states that yield rewards.The use of a decision-theoretic planner in a robot task architecture is demonstrated on the mobile robot domain of miniature golf. The miniature golf domain shows the application of decision-theoretic planning in an inherently uncertain domain, and demonstrates that by using decision-theoretic planning as the reasoning method in a robot task architecture, accommodation for uncertain information plays a direct role in the reasoning process.     

Evaluation of Architectures for Mobile Robotics

In this paper we make a comparative study of some successful software architectures for mobile robot systems. The objective is to gather experience for the future design of a new robot architecture. Three architectures are studied more closely, Saphira, TeamBots and BERRA. Qualities such as portability, ease of use, software characteristics, programming and run-time efficiency are evaluated. In order to get a true hands-on evaluation, all the architectures are implemented on a common hardware robot platform. A simple reference application is made with each of these systems. All the steps necessary to achieve this are discussed and compared. Run-time data are also gathered. Conclusions regarding the results are made, and a sketch for a new architecture is made based on these results.     

ABE: an environment for engineering intelligent systems

The ABE multilevel architecture for developing intelligent systems addresses the key problems of intelligent systems engineering: large-scale applications and the reuse and integration of software components. ABE defines a virtual machine for module-oriented programming and a cooperative operating system that provides access to the capabilities of that virtual machine. On top of the virtual machine, ABE provides a number of system design and development frameworks, which embody such programming metaphors as control flow, blackboards, and dataflow. These frameworks support the construction of capabilities, including knowledge processing tools, which span a range from primitive modules to skeletal systems. Finally, applications can be built on skeletal systems. In addition, ABE supports the importation of existing software, including both conventional and knowledge processing tools     

Interleaving Planning and Robot Execution for Asynchronous User Requests

ROGUE is an architecture built on a real robot which provides algorithms for the integration of high-level planning, low-level robotic execution, and learning. ROGUE addresses successfully several of the challenges of a dynamic office gopher environment. This article presents the techniques for the integration of planning and execution.ROGUE uses and extends a classical planning algorithm to create plans for multiple interacting goals introduced by asynchronous user requests. ROGUE translates the planner';s actions to robot execution actions and monitors real world execution. ROGUE is currently implemented using the PRODIGY4.0 planner and the Xavier robot. This article describes how plans are created for multiple asynchronous goals, and how task priority and compatibility information are used to achieve appropriate efficient execution. We describe how ROGUE communicates with the planner and the robot to interleave planning with execution so that the planner can replan for failed actions, identify the actual outcome of an action with multiple possible outcomes, and take opportunities from changes in the environment.ROGUE represents a successful integration of a classical artificial intelligence planner with a real mobile robot.     

Direct Virtual-hand Interface in Robot Assembly Programming

For a long time, robot assembly programming has been produced in two environments: on-line and off-line. On-line robot programming uses the actual robot for the experiments performing a given task; off-line robot programming develops a robot program in either an autonomous system with a high-level task planner and simulation or a 2D graphical user interface linked to other system components. This paper presents a whole hand interface for more easily performing robotic assembly tasks in the virtual tenvironment. The interface is composed of both static hand shapes (states) and continuous hand motions (modes). Hand shapes are recognized as discrete states that trigger the control signals and commands, and hand motions are mapped to the movements of a selected instance in real-time assembly. Hand postures are also used for specifying the alignment constraints and axis mapping of the hand-part coordinates. The basic virtual-hand functions are constructed through the states and modes developing the robotic assembly program. The assembling motion of the object is guided by the user immersed in the environment to a path such that no collisions will occur. The fine motion in controlling the contact and ending position/orientation is handled automatically by the system using prior knowledge of the parts and assembly reasoning. One assembly programming case using this interface is described in detail in the paper.     

An imperative language for task-level planning: Definition in temporal logic

The problem of the execution of plans of actions by a robot inspired the conception of various representations. Some of them concern the problems of control theory and geometry involved in the execution of each task of a robot. We are interested in the task-level sequencing of such actions, from the point of view of planning in artificial intelligence and languages for the synchronisation of tasks. Planning formalisms are often based on predicate logic and sometimes temporal logic. Robot programming languages, at the task-level, have classical control structures derived from computer programming languages, as well as ones more specifically related to real-time execution. We propose a logical and temporal model of plans of actions augmented by an imperative control structure. We therefore define, on the basis of an interval-based temporal logic, a set of imperative control primitives that define the temporal arrangement of the actions. After that, primitives for the reaction to evolutions in the environment are defined in the same formalism, in order to respond to constraints concerning interaction and adaptation to the external world. The application of the model in a simulation system is described, as well as its use in execution monitoring systems.     

Active learning of inverse models with intrinsically motivated goal exploration in robots

We introduce the Self-Adaptive Goal Generation Robust Intelligent Adaptive Curiosity (SAGG-RIAC) architecture as an intrinsically motivated goal exploration mechanism which allows active learning of inverse models in high-dimensional redundant robots. This allows a robot to efficiently and actively learn distributions of parameterized motor skills/policies that solve a corresponding distribution of parameterized tasks/goals. The architecture makes the robot sample actively novel parameterized tasks in the task space, based on a measure of competence progress, each of which triggers low-level goal-directed learning of the motor policy parameters that allow to solve it. For both learning and generalization, the system leverages regression techniques which allow to infer the motor policy parameters corresponding to a given novel parameterized task, and based on the previously learnt correspondences between policy and task parameters.We present experiments with high-dimensional continuous sensorimotor spaces in three different robotic setups: (1) learning the inverse kinematics in a highly-redundant robotic arm, (2) learning omnidirectional locomotion with motor primitives in a quadruped robot, and (3) an arm learning to control a fishing rod with a flexible wire. We show that (1) exploration in the task space can be a lot faster than exploration in the actuator space for learning inverse models in redundant robots; (2) selecting goals maximizing competence progress creates developmental trajectories driving the robot to progressively focus on tasks of increasing complexity and is statistically significantly more efficient than selecting tasks randomly, as well as more efficient than different standard active motor babbling methods; (3) this architecture allows the robot to actively discover which parts of its task space it can learn to reach and which part it cannot.     

Direct off-line robot programming via a common CAD package

This paper focuses on intuitive and direct off-line robot programming from a CAD drawing running on a common 3-D CAD package. It explores the most suitable way to represent robot motion in a CAD drawing, how to automatically extract such motion data from the drawing, make the mapping of data from the virtual (CAD model) to the real environment and the process of automatic generation of robot paths/programs. In summary, this study aims to present a novel CAD-based robot programming system accessible to anyone with basic knowledge of CAD and robotics. Experiments on different manipulation tasks show the effectiveness and versatility of the proposed approach.