TDL(ID:7781/)for Task Description Lanugage Robotic language from SRI, extension of C++, uses task description trees Related languages
References: remaining reactive to contingencies and new opportunities. This typically requires robot systems to coordinate concurrent activities, monitor the environment, and deal with exceptions. We have developed a new language to support such task-level control. The language, TDL, is an extension of C++ that provides syntactic support for task decomposition, synchronization, execution monitoring, and exception handling. A compiler transforms TDL into pure C++ code that utilizes a platform-independent task management library. This paper introduces TDL, describes the task tree representation that underlies the language, and presents some aspects of its implementation and use in an autonomous mobile robot. External link: Online copy Extract: Introduction 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: 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. Extract: Conclusions Conclusions This paper has presented TDL, a new language for specifying task-level robot control. TDL is an extension of C++ that includes explicit synchronization constructs to support task decomposition, synchronization, execution monitoring and exception handling. We have described in detail the concept of task trees, which underlies all of TDL, including how it supports fine-grained control over task synchronization. We introduced the syntax of TDL, illustrated it with a simplified mobile robot example, and briefly described how TDL code is transformed into pure C++ code that utilizes calls to our task management library. Designing a new language is tricky. A good language should embody enough constraints so as to guide developers along the ?correct? path, without mandating decisions that may be unwarranted. Simple robot behavior should be simple to state in the language, while complex behaviors should still be expressible, in some manner. It is difficult to make these trade-offs correctly a priori. Our extensive experience with TCA, coupled with our familiarity with other task-level control languages, especially ESL and RAP, has provided a good basis for justifying our choices. The real proof, however, is in the use. To this end, we are starting to use TDL in various applications, including the Xavier mobile robot [16]. Through this experience, we expect to refine and extend TDL, the TCM library, and the various support tools. Our aim is to make developing complex robot control programs as easy as conventional software. The payoff is cheaper, more reliable, and more effective robot systems. |