ESL(ID:4960/esl001)for Executive Support Language Language for Supporting Robust Plan Execution in Embedded Autonomous Agents Eran Gat JPL Caltech 1991 Built as an extensio to LISP Related languages
References: ESL (Execution Support Language) is a language for encoding execution knowledge in embedded autonomous agents. It is designed to be the implementation substratefor the sequencing component of a three-layer architecture such as 3T or ATLANTIS. The sequencer in such an architecture coordinates the actions of a reactivec ontroller, which controls the agent's actions, and a deliberative component, which generates plans and performs other high-level computations. The sequencer must be able to respond quickly to events while bringing potentially large quantities of information - both knowledge and run-time data - to bear on its decisions. An implementation substrate for such a system should also be able to deal with a variety of different strategies for assigning responsibilities to the various layers, from mostly reactive strategies, to ones where the planner is the prime mover. pdf in Proceedings of the IEEE Aerospace Conference, 1997 view details in Proceedings of the IEEE Aerospace Conference, 1997 view details in Proceedings of the IEEE Aerospace Conference, 1997 view details in AAAI Spring Symposium on Planning with Incomplete Information. view details in AAAI Spring Symposium on Planning with Incomplete Information. view details Introduction Robot systems, such as autonomous mobile robots, need to achieve high level goals while remaining reactive to contingencies and new opportunities. They need to recover gracefully from exceptions and effectively manage their resources (such as actuators, sensors, and computation). These capabilities are referred to as task-level control [15], and they form the basis of the executive layer of modern three-tiered robot control architectures [1, 3, 4, 10]. In such architectures (Figure 1), the behavior (real-time control) layer interacts with the physical world, controlling actuators and collecting sensor data. The planning layer specifies, at an abstract level, how to achieve goals and how to deal with goal interactions. The executive layer mediates between the symbolic level of the planner and the continuous level of the behaviors. It expands abstract goals into low-level commands, executes the commands, monitors their execution, and handles exceptions. Unfortunately, task-level control programs are often difficult to develop and debug. One problem is that effective task-level control often requires that the robot do things concurrently, such as moving and sensing, planning and executing, manipulating and monitoring, etc. These concurrent activities often need to be scheduled and synchronized, either to avoid interactions or to coordinate activities. Another difficulty is that exception handling often involves non-local flow of control. For example, if a robot encounters an unexpected obstacle, it might first try the move again (the obstacle may have moved). If that fails, it might replan its path, switch to another goal, etc. Using conventional programming languages to implement such task-level control functions would result in highly non-linear code that is often difficult to understand, debug, and maintain. To address this, we have designed TDL (Task Definition Language), an extension of C++ that simplifies the development of robot control programs by including explicit syntactic support for task-level control capabilities. TDL directly supports task decomposition, fine-grained synchronization of subtasks, execution monitoring, and exception handling (support for resource management [11] is planned). We have developed a compiler that transforms TDL code into efficient, platform-independent C++ code that invokes a Task Control Management (TCM) library to manage task-control aspects of the robot system. The following section presents related research in languages for task-level control. We then describe task trees, the semantic construct underlying TDL and TCM. Task trees encode the hierarchical decomposition of tasks into subtasks, as well as synchronization constraints between tasks. We then describe the language itself, and illustrate it with a simplified example of its use in an autonomous delivery robot [16]. Finally, we present overviews of the TDL and TCM implementations, as well as tools that we are developing to further support the design and debugging of task-level control programs. Extract: ESL ESL (Executive Support Language) is the language most closely related to TDL, and TDL is influenced by many of the ESL design concepts [5]. Like TDL, ESL is an extension of an existing language (in this case, Lisp). ESL is implemented as a set of macros that expand into Common Lisp and invoke Lisp?s multi-tasking library. In addition to the usual task-level control constructs, ESL provides for resource management and supports a Prologbased data base. ESL is currently being used in the NASA New Millennium Remote Agent [10]. Extract: PRS PRS (Procedural Reasoning System) is based around the concept of a procedural reasoning expert [6]. PRS facilitates deciding what actions an agent should be doing at any given time. Both Lisp-based and C-based interpreters for PRS have been implemented. PRS, like RAP, is tightly integrated with a ?world model? knowledge base that is used to identify opportunities, exceptions, and when to transition between tasks. TDL does not make this ontological commitment: A separate knowledge base could be integrated, but is not mandated. We feel that this gives developers more flexibility in deciding how to design their systems, without precluding such architectural decisions. in AAAI Spring Symposium on Planning with Incomplete Information. view details |