for Task Description Lanugage

Robotic language from SRI, extension of C++, uses task description trees

Related languages
ESL => TDL   Influence
RPL => TDL   Influence

  • R. Simmons and D. Apfelbaum "A Task Description Language for Robot Control" Proceedings Conference on Intelligent Robotics and Systems, October, 1998. view details Abstract: Robot systems must achieve high level goals while
    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
    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
    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.