In this section we briefly overview different control architectures for mobile robots or agents in Section 2.3.1. In Section 2.3.2 we present non-logic-based robot programming languages as a counterpoint to Golog which we discussed in detail before. In Section 2.3.3 we will talk about recent applications (as opposed to those discussed in Section 2.3.1 which mirrors the different paradigms from a more historical viewpoint) and ongoing projects about (cognitive) robotics ap- plications.
2.3.1 Control Architectures
As already noted, the first approach to problem solving on a mobile robot was the STRIPS system (Fikes and Nilson 1971) on the robot Shakey (Nilson 1984). The operation of this robot followed the sense-plan-act scheme, where the robot first gathered new information from its sensors, started a planning process to achieve a goal, and finally started to execute the planned sequence of actions. It is the prototype for what was later called the deliberative or hierarchical paradigm. On each of its hierarchical layers sub-goals were to be achieved. The top layer of this architecture, the camera system of Shakey processed information of the world (sense). This information was handed over to the STRIPS planner on the middle layer (plan). Control commands were passed over to the motors on the bottom layer (act).
The drawback of this approach was that due to low computing power a lot of time could pass by between sensing and acting. Thus, the robot could not react appropriately to changes in the environment, as the motor commands were already outdated when they were executed. One proposal to overcome this, was to simply leave out the plan step. In (Brooks 1986; Brooks 1991) Brooks proposed a behavior-based approach. Instead of a vertical hierarchy he proposed a horizontal task composition. This means that several behaviors get the sensor readings as input. The available behaviors like locomotion or collision avoidance had a vertical hierarchy and those
2.3. ROBOT CONTROLLERS 25
behaviors on a higher level subsumed those of a lower level. Therefore, his approach is also called subsumption architecture. For the low-level control of a robot this is a good scheme, but from the different available behaviors, goal-directed intelligent acting will merely emerge. In the following times Brooks’ thesis that symbolic reasoning hinders the successful development of robots was refuted (e.g. (Gat 1998)).
The solution seems to lie in the middle. In the aftermath, the hybrid paradigm, combining both approaches, was successfully applied. One of the first hybrid architectures is the AuRA architecture (Arkin 1986; Arkin 1987). The deliberative components in his architecture were a mission task planner and a Cartographer. The latter encapsulates all map-building issues. The former is divided into a Mission Planner, Navigator, and Pilot. The Mission Planner deals as a human machine interface, the Navigator plans together with the Cartographer, paths the robot should follow, and the Pilot selects the first sub-task and provides the reactive low-level control (motor modules) with appropriate commands. The planning performed here is an HTN planning approach. Another prominent example is the 3T architecture (Bonasso et al. 1997). It is a three- layered architecture and merges aspects of the ATLANTIS architecture (Gat 1992) and the RAP system (Firby et al. 1995). Three layers are distinguished, a reactive Skill Manager on the bottom level, a deliberative task planner on the top layer, and a sequencer on the middle layer. The top level layer consists of a mission planner which sets the goals to be achieved. These are passed to the sequencer which decomposes the goals making use of HTN techniques. The sequencer calls the low-level behaviors on the bottom layer. This design was deployed successfully for planetary rovers or underwater vehicles at NASA. Simmons et al. proposed the Task Control Architecture (TCA) (Simmons et al. 1997). It is a hybrid approach coming with a task scheduler using PRODIGY (Veloso et al. 1995), a decision-theoretic path planner, and a navigation module deploying POMDP techniques. Interestingly, these are seen as the deliberative layer in (Murphy 2000). The reactive layer consists of an obstacle avoidance scheme based on the curvature-velocity method (Simmons 1996). The robot XAVIER (Simmons et al. 1997) used this architecture in a successful office delivery application.
2.3.2 Non-Logic-Based Robot Programming Languages
PRS-Lite. PRS-Lite (Myers 1996) is a task-level controller for a mobile robot based on the procedural knowledge description of actions by Georgeff and Lansky (1986). The objective was to retain a mixture of goal-directed and reactive behavior in an computational efficient way. PRS- Lite is used as the high-level controller for the robot Flakey from SRI, which uses the Saphira control architecture (Konolige et al. 1997). The control architecture distinguishes between three different control layers, an effector level, a behavior level, and a task level. While the former two deal with controlling sensors and actuators and provide basic behaviors like wall following, the latter deals with the coordination of the control modules present and is implemented using PRS-Lite. A task can be accomplished when all goals of a goal-set are satisfied. They distinguish between two different goal modalities, action and sequencing. For action goals operators exist like tests, execute, and wait-for, which waits for a condition to become true. Further, they can switch on or off intentions and behaviors with intended/unintended statements which enables or disables the hierarchical decomposition of goals. For sequencing they introduced operators for conditionals, parallel goal execution, and branching. The task procedures are compiled into finite state machines yielding activity schemes. These are launched by instantiating their parameters.
Colbert. Later, PRS-Lite was exchanged by Colbert (Konolige 1997) in the Saphira architecture (Konolige et al. 1997). Colbert is a subset of ANSI C and the semantics of programs is given by finite state automatons (FSA), though the mapping between the FSA and the C program is not formally defined. An input program in Colbert is translated to an FSA which is able to control the robot. Colbert is very similar to PRS-Lite w.r.t. expressiveness. Colbert also makes use of conditionals, wait-for, or goto statements, and allows for hierarchical procedures. Also, concurrent execution of goals is supported.
RAP. The idea behind reactive action packages (RAPs, (Firby 1987; Firby 1994)) is to define hierarchical task nets and expand the nets until only primitive actions remain. Partially specified plans are stored in a plan library. For plan execution those plan skeletons have to be instantiated and details are filled in. The reactive plan interpreter takes a set of tasks or goals and refines each goal hierarchically until primitive actions are reached. This hierarchical refinement is achieved by using RAPs from the plan library. The RAP system is able to handle concurrency and synchro- nization (wait-for).
Reactive Plan Language, XFRM, and Structured Reactive Controllers. McDermott (1991, McDermott (1992) proposed the Reactive Plan Language (RPL). It follows the line of reactive planning and elaborates many ideas of other approaches of reactive planning like RAP described before. RPL is a robot control language coming with rich expressiveness. The language is imple- mented in LISP, and the semantics of its statement is that of the LISP execution system. Plans are understood as programs. RPL features standard imperative constructs like procedures (tasks and sub-tasks), sequences, loops and conditionals, and non-standard constructs like condition- and time-bounded statements like wait-for or wait-time.1These non-standard constructs are based
on a notion of fluents, which are time-varying variables which refer to sensor data. Fluents are automatically updated when new sensor data arrive. wait-for and wait-time take a fluent as and argument. RPL offers an account to true concurrency, that is, tasks are executed in parallel (as opposed to interleaved concurrency as for example ConGolog makes use of). This parallelism can be controlled by the programmer by assigned valves to a process. Valves are semaphores, and processes competing for valves will not be executed in parallel. This model is also very useful for controlling blocked processes making use of the wait-for statement, for example. These pro- cesses are suspended until the fluent value becomes true which means that the respective process waits until the associated valve becomes available. With this model of concurrency pure reactive behavior can be modeled. For example, one can assign a process to a fluent with a with-policy statement. An example is the behavior policy “whenever the gripper becomes empty, regrasp the object” while other tasks are performed in parallel. Further, RPL introduced a notion for events, where the beginning and the ending of a task can be queried.
It is important to note that the execution system of RPL supports two modes, a real mode, where the control programs are executed in reality, and a projection mode, where given a sim- ulated time line, programs can be projected into the future. The projections are based on the planning system XFRM (McDermott 1992; Beetz and McDermott 1994). A projected execution is represented by a task network and a time line, where the task network is a tree of the tasks and
1Grosskreutz (2002) integrated several features from RPL in his Golog dialect giving them a formal Golog seman-
tics. As we found parts of our Golog language proposal on the work of (Grosskreutz 2002) we will explain some of these statements in Chapter 4 again.
2.3. ROBOT CONTROLLERS 27
its sub-tasks, and the time line marks start and end points of robot actions. Possible execution scenarios are probabilistically projected, resulting in success and failure cases (see (McDermott 1994) for details on the planning algorithm and the semantics of plans). XFRM offers failure diagnosis for plans. A taxonomy for possible failures exists which might occur during planning. Possible failure cases considered, are for example “object-disappears-after-goal-is-achieved” or “never-achieved-subgoal”. For each failure case a plan revision method is stored which then re- vises the plan. This methods makes the execution of plans more robust as appropriate behaviors for contingencies are foreseen.
With (Beetz 1999; Beetz 2000; Beetz 2001), Beetz proposes Structured Reactive Controllers (SRC), a control framework for robots which is based on RPL. The idea is to realize robust con- trollers by concurrent percept-driven plans. The system consists of behavior modules, fluents, reactive plans, and the RPL run-time system. Making use of RPL control constructs, like with- policy, a controller scheme is defined which allows for plan execution, plan monitoring, and plan revision. Beetz (2001) shows the flexibility of the approach with an application of an office deliv- ery task. The latest extension to RPL is RPLLEARN (Beetz et al. 2004). Following the lines of SRC to formulate an explicit controller framework, Beetz et al. integrate support for learning tasks into the language RPL, that is, the definition of a learning task, how to collect the data needed, which external learning framework should be used, and how to abstract the experiences made dur- ing data collection. In an example of a robot navigation tasks they show the usefulness of their approach.
2.3.3 Recent (Cognitive) Robotics and Agent Applications
Cognitive Systems for Cognitive Assistants. (CoSy) is an ongoing integrated EU project of a research consortium consisting of the Royal Institute of Technology (KTH), Sweden, University of Birmingham, the German Research Center for Artificial Intelligence (DFKI), the University of Ljubljana, the University of Freiburg, the University of Paris, and the Technical University Darmstadt. The vision of this project is ”to construct physically instantiated [...] systems that can perceive, understand [...] and interact with their environment, and evolve in order to achieve human-like performance in activities requiring context-(situation and task) specific knowledge” (CoSy 2007). The project comprises of work on architectures, environment representation, object recognition, human-machine interaction and natural language understanding, planning, or action representations (see e.g. (Burgard et al. 2005; Roth et al. 2005; Meier et al. 2006; Kelleher and Kruijff 2006; Kelleher et al. 2006; Kruijff et al. 2006)). One of the key ideas of this project is to integrate work on the different fields of AI and robotics research as well as the cognitive sciences. We refer to the project homepage for more information about the effort and the publication list (CoSy 2007).
The WITAS Project. A prominent example for an application in cognitive robotics is the WITAS project (Doherty et al. 2000). The project’s objective is to control an unmanned aerial vehicle (UVA). The UVA is a modified Yamaha RMAX helicopter which has a power of 16 kW and a maximum take-off weight of 95 kg. It is equipped with three PC104 embedded comput- ers and a CCD camera on a pan/tilt unit. Applications for this UVA are surveillance tasks or to support rescue efforts from the air. An interesting feature in such intelligent UVA applications is that the role of reactive control is predominant. A failing reactive behavior like motion control for a wheeled robot leads to the robot driving on a wrong trajectory or colliding with objects, for
an aerial vehicle such a failing control instance has hazardous effects as the helicopter can easily crash. Therefore, Doherty et al. propose a reactive/deliberative architecture where r eactive control is of paramount importance. In (Doherty et al. 2004) they introduce a reactive three-layered con- centric modular task architecture. The important aspect in this application is to use “deliberative services in a reactive or contingent manner” on the one hand, and “traditional control services in a reactive or contingent manner” on the other hand. The control modes of the UVA are take- off, landing via visual navigation, hovering, dynamic path following, as well as reactive flight modes for tracking and interception. From these control modes, it becomes clear that reactive as well as deliberative tasks have to be interwoven. Doherty (2005) describes DyKnow, a knowl- edge processing middle-ware for the helicopter. For tasks like dynamic path following they state that the autonomous system must be able to create qualitative knowledge and objects structures to fulfill such tasks. These representations are a prerequisite for applying planning which “[...] is an essential functionality in any intelligent agent system” (Doherty 2005). For planning they make use of the task-based planner TAL (Kvarnstr¨om et al. 2000) and a motion planner. TAL is a forward-chaining logical planner where a plan is viewed as a narrative and goals are temporal for- mulas. Control knowledge can be incorporated by temporal logical formulas which constrain the search. Many publications emanated from this project. We therefore refer to the project’s website at (WITAS 2007) for an overview.
The Cognitive Controller. Qureshi et al. (2004) report on a space robotics application. The task is to capture a satellite, transport it to a service bay, perform the service operations, and re lease the satellite back into orbit. They propose a hybrid system architecture consisting of reactive and deliberative control. The deliberative control guides the reactive one. The authors state that if the satellite is docked, the remaining steps can be performed applying more primitive scripted controllers. The reactive module is implemented as a behavior-based controller and has highest priority to care for safety aspects during operation. There are six different basic behaviors: search, monitor, approach, align, contact, and avoid. Their action selection behavior chooses one of the basic actions that is relevant to achieve the current goal, but it heeds the advice of the deliberative controller. The other low-level components are the perception center, which cares for vision processing, and a memory center which acts as a world model. For deliberation they make use of a GOLOGplanner which plans a sequence of actions from the current state to a predefined goal state. The authors conducted a series of experiments in simulated environments.
Robotic Soccer Applications. One of our application domains for the Golog dialect READY- LOGwhich we propose in Chapter 4 is the robotic soccer domain. A concise discussion of the RoboCup initiative can be found in Chapter 5.2. Here, we want to give some examples for the state of the art in the soccer domain w.r.t. high-level decision making. This overview is not exhaustive, but shall give an impression on how other approaches advance the action selection problem in this domain. One description language which is used by several RoboCup teams is the language XABSL (L¨otzsch et al. 2004). XABSL is a XML-based description of hierarchical tasks. The underlying semantics is that of a finite state automaton. Basically, a decision tree is encoded which implements reactive behavior. Murray et al. (2001) make use of so-called statecharts, which are UML-based state automata. The statecharts are implemented in Prolog. Murray et al. (2001) as well as Stolzenburg and Arai (2003) point out that this reactive approach supports the behavior specification in a multi-agent context. A hybrid approach is proposed in (Jensen and Veloso 1998).