A Teleo-Reactive Architecture for Fast, Reactive and Robust Control of Mobile Robots

Transcription

1 A Teleo-Reactive Architecture for Fast, Reactive and Robust Control of Mobile Robots Gerhard Gubisch, Gerald Steinbauer, Martin Weiglhofer, and Franz Wotawa Institute for Software Technology, Graz University of Technology Inffeldgasse 16b/II, A-8010 Graz, Austria Abstract. One of the elementary tasks of an autonomous mobile robot is the execution of different behavior patterns in order to fulfill a given task. The complexity of this problem is especially high if the robot operates in a dynamic, unpredictable environment and requires the parallel control of multiple actuators. In this paper we present a novel architecture for robust and fast mobile robot control. The architecture is based on Teleo-Reactive Programs. We discuss the benefits and drawbacks of such programs, extend the basic definition for the parallel control of multiple actuators, and propose a new language and a compiler for extended Teleo-Reactive Programs. These tools simplify the creation of new behavior patterns and increase the runtime performance. Finally, we discuss implementation issues of the architecture when applying it to RoboCup Middle-Size soccer robots. Key words: autonomous agents, control architecture, teleo-reactive programs, parallel actions, teleo-reactive program compilation 1 Introduction The execution of different behavior patterns in order to achieve a given task is one of the fundamental prerequisites of an autonomous mobile robot. Once a robot has derived a plan to achieve its task, some mechanism is needed to execute the plan. Such a mechanism has to be flexible in order to allow the execution of different plans, sub-plans or behavior patterns. This requires an appropriate description or programming language. In addition, the mechanism has to be robust against failure. Even in situations which are new to the robot, the execution of behavior patterns should not fail. There is a great number of proposed mechanisms to organize, structure and describe the task execution of autonomous robots. On the highest level these mechanisms can be divided into three major groups: (1) the reactive paradigm, (2) the deliberative paradigm and (3) the hybrid paradigm. Mechanisms of the first group commonly use sets of simple reactive behavior and setup more complex behavior patterns by blending these simple ones. The advantage of these Authors are listed in alphabetical order.

2 mechanisms is their quick response to changes in the sensory input. The second group uses planning and reasoning capabilities in order to derive sequential plans. Mechanisms of this group are able to handle very complex tasks but suffer from performance issues when deriving appropriate plans. The last group merges the advantages of the first two. It provides fast reaction on sensory input and the capability to plan in domains of greater complexity. In this paper we present a framework to organize and execute behavior patterns in a flexible and robust way using the hybrid paradigm. The organization of the reactive part is based on Teleo-Reactive (TR) Programs proposed by Nilsson [1]. TR-Programs are ordered lists of condition-action pairs, which ensure robustness in dynamic environments. Because basic TR-Programs are not able to deal with parallel actions, we introduce extended TR-Programs. Such TR-Programs serve as actions for a higher-level planning module. In order to improve the runtime performance and ease the use of extended TR-Programs we define a description language for the TR-Programs. Furthermore we show how a compiler can convert an extended TR-Program into native C++ code. This paper continues as follows: In the next section we discuss TR-Programs and introduce extended TR-Programs. In Section 3 we present the design of the proposed framework, our language for extended TR-Programs and a compiler for converting extended TR-Programs to C++. Section 4 discusses an implementation of the framework for our RoboCup Middle-Size soccer robots. Section 5 shows an overview of related research. Finally, we draw our conclusions in Section 6. 2 Teleo-Reactive Programs Teleo-Reactive Programs are a formalism to control mobile robots in dynamic environments. They address the problem of plan execution in a real world environment. In such dynamic environments the effect of an executed action may be changed or canceled by exogenous events. Thus, the execution of a plan will fail if the control software of the robot relies on the successful execution of an action. Teleo-Reactive Programs provide a solution to this problem. According to [1] a Teleo-Reactive Sequence is an ordered set of production rules, where K i denotes a first order logic condition and a i denotes an executable action: K 1 a 1,...,K i a i,...,k m a m. Formally a Teleo-Reactive Program can be defined as follows: Definition 1 (Teleo-Reactive Sequence) A Teleo-Reactive Sequence τ is a finite ordered list of m condition-action pairs (K i,a i ) with i {1,...,m} and a i A where A = A disc A dura T S is the union of the disjoint sets of discrete actions A disc, durative actions A dura and all Teleo-Reactive Sequences T S: τ = (K 1,a 1 ),...,(K i,a i ),...,(K m,a m )

3 Definition 2 (Teleo-Reactive Program) A Teleo-Reactive Program is a Teleo- Reactive Sequence with variables. When the sequence is called, the variables are bound to either constant values or to entities that are computed continuously. The execution of such a sequence is simple. The interpreter scans the production rules from left to right. It chooses an action for execution if the according condition is the first one which is satisfied. TR-Sequences can be organized hierarchically, i.e. the actions a i of a TR-Sequence can be Teleo-Reactive Sequences themselves. The primitive actions of a TR-Sequence can be either discrete or durative. A durative action a i is executed continuously as long as K i remains the first true condition in the list. In contrast to that, a discrete action is called once, as soon as the first true condition in the list is the action s condition. Assume, that S holds the initial truth values of the predicates which are used to formulate the conditions. effect(a i ) returns the effect in terms of predicate truth values when executing action a i. A B = B {l l A l / B} represents a state update operator and Φ(K i,s) = ( j<i K j S) K i S represents the condition check. obs() denotes a function which returns the currently observed state. Then the formal semantics of a Teleo-Reactive Sequence τ = (K 1,a 1 ),...,(K i,a i ),...,(K m,a m ) is given as follows (where denotes the interpretation function): τ (S) = (K 1,a 1 ),...,(K m,a m ) ( (K i,a i ) (S)) if Φ(K i,s) a i (S) if a i T S (K i,a i ) (S) = a i disc (S) if a i A disc (K i,a i ) dura (S) if a i A dura { S if effect(a i ) S Φ(K i,s) (K i,a i ) dura (S) = (K i,a i ) dura ( a i dura ) otherwise a i disc (S) = S effect(a i ) a i dura (S) = S obs() The robustness of the execution of TR-Programs comes from two properties. The regression property ensures that the conditions in the list are regressive. That means, that each action a i should activate a condition K j with j < i. The regression property ensures that the agent proceeds towards the goal. A TR- Program is complete if the disjunction of all condition forms a tautology, which ensures, that there is always one action that can be executed. A TR-Program which has both properties is called a universal TR-Program. Beside the advantages of TR-Programs there is one major drawback that comes with the original formalism, which is the lack of support for simultaneous action execution. Assume the two scenarios illustrated in Figure 1. The appliance of TR-Programs will fail if an agent has to start action a i at time t while the currently active action a j should not be stopped before t with t > t. For example action a 2 runs simultaneously with action a 1 between t 1 and t 2 in Figure 1. One practical example of such a setting is a robot equipped with a gripper operating

4 Fig. 1. Example of the simultaneous action problem. in a ware-house environment. The task of the robot is to pick up packages from a moving conveyor belt. While the robot waits for the package it pre-positions its gripper (action a 1 ). If the package appears on the conveyor belt the robot starts moving parallel to the package (action a 2 ) and simultaneously grabbing the object of interest. When the packages has been taken, the gripper can be frozen (time t 2 ) while the robot drives towards it final position (action a 2 ). Another problematic setting is, if action a j should be started at time t 1 and stopped at t 2 while action a i is active all the time (e.g. a 3 and a 4 in Figure 1). That is, for example if a soccer robot should dribble (action a 3 ) and kick (action a 4 ). If the robot stops dribbling in order to prepare kicking, the ball will roll away from the robot. Thus, the robot has to kick while it concurrently dribbles. 2.1 Extended Teleo-Reactive Programs To address the problem of simultaneous action execution we extend the basic definition of a TR-Programs. Therefore, we introduce an additional operator that can be used within the action parts of a TR-Sequence. Definition 3 (Parallel Composition Operator) Given two actions a i and a j with i j, then the composition with the -operator a i a j is again a valid action denoting the parallel execution of the two actions. The parallel execution of actions a i and a j still has to satisfy the regression property. In the following we will write A i to denote either a single action a i or a parallel composition of n actions a i1 a i2... a in. We use lower case letters a i for single actions. A denotes the set of all actions. Definition 4 (Extended Teleo-Reactive Sequence) An extended Teleo-Reactive Sequence τ e is a finite ordered list of m condition-action pairs (K i,a i ) where A i = a i a i A or A i = a i1... a in with j=1...n a ij A. The semantics of an extended Teleo-Reactive Sequence is given by e. Definition 5 An extended Teleo-Reactive Program is an extended Teleo-Reactive Sequence with variables. When the sequence is called, the variables are bound to either constant values or to entities that are computed continuously.

5 The use of the -operator extends the semantics for a Teleo-Reactive Sequence τ e to the semantics e as follows: τ e e (S) = (K 1,A 1 ),...,(K m,a m ) e ( (K i,a i ) e (S)) if Φ(K i,s) (K i,a i ) e (S) = a i A i (K i,a i ) (S) Note, that any basic Teleo-Reactive Program can be interpreted by e. Thus, the set of all basic Teleo-Reactive Programs T RP is a subset of all extended Teleo-Reactive Programs T RP ext, i.e., T RP T RP ext. An extended Teleo-Reactive Program encoding the action sequence of Figure 1 looks like following: K e a 3, K d a 3 a 4, K c a 3, K b a 2, K a a 1 a 2, true a 1 Extended TR-Programs are appropriate for the description of the behavior of a robot for a wide range of tasks. But there are two issues that have to be solved when applying TR-Programs for mobile robot control. First, for complex high level tasks some deliberative component is needed in order to enable the robot to fulfil the task. TR-Programs are valuable for the execution of the behavior but the gap to the deliberative component has to be filled. Second, the execution of Teleo-Reactive Programs must be fast such that reactions to changes in the environment are taken into account immediately. We will now introduce a framework for mobile robot control, which addresses these two issues. 3 Organization and Specification of Behaviors Fig. 2. Schematic overview of the proposed framework. Figure 2 shows an overview of our architecture for robust control of mobile robots. The central elements within this architecture are extended Teleo-Reactive Programs that are translated to native C++ code. During the runtime a high

6 level planning module selects the currently best Teleo-Reactive Program for a given situation from a list of predefined TR-Programs. Thus, the Teleo-Reactive Programs are actions for a high level planning module. The Teleo-Reactive compiler uses predicates, actions and algorithms, and translates a given extended Teleo-Reactive Program into C++. This code is compiled by a standard C++-Compiler into executable object code and linked into the robot control software. The translation of extended TR-Programs from a native language to object code has two major advantages. First, it simplifies the process of writing a extended Teleo-Reactive Program where the programmer does not have to care about complex features of modern programming languages. Second, we have experienced a significant improvement in the run-time performance when executing compiled Teleo-Reactive Programs instead of interpreting Teleo-Reactive Programs. The reasoning within the TR-Program happens over values from the configuration, over data from the world model and over parameters retrieved from the planning module. Every durative action is implemented in a separate flow of control, i.e., a separate thread. The action-interfaces used by the TR compiler communicate with that thread by sending start commands and stop commands with parameters. Beside the advantage of having several actions executed simultaneously, this separation of actions has an additional benefit: Because there is only one instance of every action, the action can remember previous parameter values and can benefit from the history of parameters. 3.1 Teleo-Reactive Program/C++ Transformation Algorithm 3 translates any non-hierarchical extended Teleo-Reactive Program into a C++ program. An example is illustrated in Figure 4. As Figure 4 shows, function transform( (K 1, A 1),..., (K m, A m) ) A := S i=1,...,m Ai; writeln "void main() { while(true) evaluate(); }" writeln "void evaluate() {" for i = 1 to m do writeln "if (K i) {" for all a j A \ A i do writeln "a j.stop();" done for all a k A i do writeln "a k.start();" done writeln "return; }" done writeln "}" Fig. 3. Algorithm for the translation of extended Teleo-Reactive Programs into C++. the resulting C++ code consists of two functions. The main loop calls the evaluate function continuously. The evaluate function contains a list of if-then statements. Each condition-action pair corresponds to one if-then-statement.

7 The condition of a (K i,a i )-tuple forms the condition in the if-clause. The thenbranch is built by starting and stopping the actions of A i (functions start() and stop()). These functions start and stop durative actions in a separate thread. Note, that the functions are called multiple times, where the parameters to those functions may be changed. Thus, start functions should start the thread only if it is not running yet. If the thread is already running, the functions should only exchange the old parameters with the new ones. For discrete actions, the start function runs the action once and refuses execution if called multiple times until the stop function has been invoked. The resulting C++ program does not interrupt durative actions and start them immediately again, which would break a continuous execution. Thus the C++ program starts an action a i for a conditionaction pair (K i,a i ) if a i A i. An action a j is stopped in the then-branch of a condition-action pair (K k,a k ) iff a j A k.from the semantical point of view, Scored nil, InRange(Goal) DribbleTo(Goal) Kick(), true DribbleTo(Goal) void main() { while(true) evaluate(); } void evaluate() { if(scored.eval()){dribbleto.stop();kick.stop();return;} if(inrange.eval(goal)){dribbleto.start(goal);kick.start();return;} if(true){dribbleto.start(goal);kick.stop();return;} } Fig. 4. Translation of an extended Teleo-Reactive Program for a scoring behavior (top) into C++ code (bottom). the two versions of TR-Programs in Figure 4 are equivalent. Both versions of the TR-Program will execute A i if ( j<i K j ) K i. If the Teleo-Reactive Program is complete, i.e., K 1 K 2 K i K m is a tautology, there will be always one action that is selected for execution in both versions of the TR-Program. If the Teleo-Reactive Program satisfies the regression property, the C++ version will satisfy this property as well, because we do not change the order of the condition-action pairs. 3.2 Teleo-Reactive Language In this section we propose a programming language for TR-Programs, which is related to the imperative programming paradigm. According to the grammar of Figure 5, a TR-Program comprises two sections. One section contains the global variables, i.e., variables that are used as parameters in conditions or in more than one action block. The other section comprises the list of conditionaction pairs that forms the body of the TR-Program. Conditions are built by combining the predicates of the control framework with the boolean operators and, or and not. In contrast to the Teleo-Reactive Language defined in [2], this grammar provides a more flexible form of writing actions. Instead of having a single object which is called for execution, an action is built by a code block. This code block can either be the name of one of the basic actions, or it can be a

8 program ::= TR-PROGRAM : globals section tr stmt section globals section ::= GLOBAL : ( var decl+ ǫ ) var decl ::= type id = param expr ; param expr ::= float integer string param funcall var param ::= object(id) param(id) config(id(.id)*) random(paramlist) tr stmt section ::= TELEO-REACTIVE : tr stmt+ tr stmt ::= task name : condition : action* ; condition ::= predicate ((and or) predicate)* predicate ::= true false (! ǫ) funcall (! ǫ) ( condition ) action ::= var decl function call; funcall ::= id ( paramlist ǫ ) paramlist ::= param expr (, param expr )* Fig. 5. Grammar of the Teleo-Reactive language. code block that uses algorithms, local variables and action objects. An algorithm does not execute any action but calculates parameters needed by some action. This is, why we propose to split up actions and algorithms. Each action and each algorithm should provide an atomic piece of operation. In that way new behavior can be composed without adding new functionality to the framework. In addition, the modular action block allows to use more than one basic action within such a block. The given basic actions are executed in parallel using the semantics of extended Teleo-Reactive Programs. 4 Applying the Framework to Mobile Soccer Robots This section discusses an implementation of the proposed architecture for our RoboCup Middle-Size soccer robots. The planning module of Figure 2 is realized as a hierarchical state machine, which uses extended TR-Programs as actions. One extended TR-Program is mapped to one C++ class. The list of if-then statements is encoded in an execute method. The main loop which calls this execute method is located in a controller class. This controller is responsible for switching between TR-Programs selected by the hierarchical state machine. Our compiler 1 is implemented in C++ using of the Boost Spirit Library 2 for parsing, and implements simple type checking. For our mobile soccer robots, the framework is currently equipped with two predicates (IsAtPosition(pos) and IsAtScoringPosition()), two actions (GotoPosition(pos) and KickTheBall), and the four algorithms (Scanline: calculate a heading of the robot, where there is a maximum distance along the soccer field width between two obstacles, CalcKickerParams: determine currently optimal kick strength, CalcStrategicPosition: calculate a global position and a heading, which is strategically advantageous based on the work of [3], CalcGrabBallPosition: calculate position and heading for graping the ball such that the robot does not push the ball out of the field, CalcGoalBlockingPosition: calculates an intercept position for the goalkeeper if the ball rolls towards the goal)

9 Currently we use 15 different teleo-reactive programs for our RoboCup Middle- Size soccer robots. The average number of used condition-action pairs is 2.13 per TR-program. At maximum we use 4 condition-action pairs per TR-program. The smallest TR-program, which prevents the robot from doing anything (i.e. the idle TR-program) comprises only one condition-action pair. In four cases we make use of parallel actions. These TR-programs are basically all programs where some ball handling actions are involved. 5 Related Research Brooks proposed in [4] to blend simple behaviors, which provide a fast coupling of sensors and actuators, in order to get more complex behaviors. The basic behaviors are always active, receive their sensory input and immediately calculate their desired output for the actuators. An arbiter takes care about which output or which mixture of outputs are feed to the actuators. In difference to that, extended Teleo-Reactive programs only execute actions concurrently if required. Furthermore, the outcome of the actions are not merged by the use of an arbiter. The Miro robot software framework provides a so called BAP framework in order to organize and execute behaviors [5]. The framework allows to arrange continuous and event-driven behaviors into behavior patterns and to blend the individual behaviors trough the use of different arbiters. The authors of [6] presented an approach for robust plan execution in dynamic environments. The approach is based on a hybrid architecture and uses classical STRIPS planning. The behavioral level is organized using the framework of Miro. The robustness of the plan execution derives from the use of plan invariants, which are conditions that have to be true throughout the execution of the entire plan. Such condition can be used to monitor plan execution in order to detect infeasible or faulty plans. In [7] Beetz presented a control architecture for mobile robots, which comprises a plan-based high-level control. The controller monitors the execution of plans by the use of prediction models of the behavior of actions. In the case of a problem the controller can react by modifying plans on the fly. Furthermore, the controller is able to execute concurrent plans and may postpone the execution of plans until some conditions are satisfied again. In [8] Nilsson proposed the triple-tower architecture for the control of autonomous robots. The architecture is guided by the hybrid paradigm and comprises three towers for sensing, reasoning and acting. The acting tower is responsible for the execution of behaviors and comprises one or more TR-Programs. The higher level decision process is implemented by the reasoning tower which performs logical reasoning about the state of the world and the agents task. The Task Description Language (TDL) proposed by Simmons [9] is a tasklevel programming language for robots. It is a extension to the C++ language and supports task decomposition, synchronization and exception handling. The authors provide a compiler to convert the TDL program into a native C++ code.

10 6 Conclusion In this paper we have presented a novel architecture for fast, reactive and robust control of mobile robots. The architecture is based on an extension of TR- Programs. Beside the benefits of basic TR-Programs, extended TR-Programs allow the robust execution of concurrent actions. Furthermore, we introduced a description language for extended TR-Programs and showed how to transform extended TR-Programs to native C++ code. We have implemented the proposed architecture for our autonomous mobile soccer robots which led to promising results. By the use of this architecture our robots are able to react fast to changes in the environment. The main advantages of our architecture based on compiled extended TR-Programs can be summarized as: Fast and robust execution: Because of the indirect compilation to object code the time consumed by program management during the execution of TR-Programs is negligibly small. The execution is robust in highly dynamic environments, where exogenous events may cancel effects of actions. Simultaneous actions: Our approach is able to control multiple actuators in parallel by executing actions simultaneously. Simple behavior pattern creation By providing the user an intuitive language it is easy to create new behavior patterns. Further Research Currently, we require that parallel actions do not contradict with each other. We need to investigate in some technique that allows to detect such contradicting actions. References 1. Nilsson, N.J.: Teleo-reactive programs for agent control. JAIR 1 (1994) Nilsson, N.J.: Toward agent programs with circuit semantics. Technical Report STAN-CS , Standford University (1992) 3. Tews, A., Wyeth, G.: Thinking as one: Coordination of multiple mobile robots by shared representations. In: IROS. (2000) Brooks, R.A.: A robust layered control system for a mobile robot. IEEE Jornal of Robotics and Automation RA-2 (1986) Utz, H.: Advanced Software Concepts and Technologies for Autonomous Mobile Robotics. PhD thesis, University of Ulm, Neuroinformatics (2005) 6. Fraser, G., Steinbauer, G., Wotawa, F.: Plan execution in dynamic environments. In: 18th International Conference on Industrial and Engineering Applications of Artificial Intelligence and Expert Systems., Bari, Italy, Springer (2005) Beetz, M.: Plan-Based Control of Robotics Agents, Improving the Capabilities of Autonomous Robots. Volume 2554 of LNAI. Springer (2002) 8. Nilsson, N.J.: Teleo-reactive programs and the triple-tower architecture. Electronic Transactions on Artificial Intelligence 5 (2001) Simmons, R., Apfelbaum, D.: A task description language for robot control. In: Conference on Intelligent Robotics and Systems. (1998)