Task Control Architecture

The Task Control Architecture (TCA) simplifies building task-level control systems for mobile robots. By "task-level", we mean the integration and coordination of perception, planning and real-time control to achieve a given set of goals (tasks). TCA provides a general control framework, and it is intended to be used to control a wide variety of robots. TCA provides a high-level, machine independent method for passing messages between distributed machines (including between Lisp and C processes). Although TCA has no built-in control functions for particular robots (such as path planning algorithms), it provides control functions, such as task decomposition, monitoring, and resource management, that are common to many mobile robot applications.

TCA can be thought of as a robot operating system --- providing a shell for building specific robot control systems. Like any good operating system, the architecture provides communication with other tasks and the outside world, facilities for constructing new behaviors from more primitive ones, and means to control and schedule tasks and to handle the allocation of resources. At the same time, it imposes relatively few constraints on the overall control flow and data flow in any particular system. This enables TCA to be used for a wide variety of robots, tasks, and environments. It also allows researchers to experiment easily with different instantiations of robot control schemes. To date, we know of about a dozen robot systems that have employed TCA, including both indoor and outdoor, autonomous and teleoperated robots. Within NASA, TCA has been used on the Ambler, Ratler and Nomad rovers, on the Tessalator tile inspection robot, in the VEVI teleoperator interface, and for autonomous spacecraft simulation. In addition, descendants of the TCA communication mechanisms (TCX and IPC) have been used in the Dante robot, and the Aercam project.

Inter-Process Communication

TCA allows you to construct a distributed system without having to build your own remote procedure call mechanism. At its core, TCA provides a flexible mechanism for passing coarse-grained messages between processes (which we call modules). The communication mechanisms automatically marshall and unmarshall data, invoke user-defined handlers when a message is received, and include both publish/subscribe and client/server type messages, and both blocking and non-blocking types of messages. TCA also provides orderly access to robot resources so that you don't have to build your own queuing mechanisms.

TCA is available for both C and Allegro Common Lisp implementations. It currently runs on the following architectures and operating systems: Sparc (running SunOS, Solaris and Mach), Intel x86 and 486 processors (running Linux, Mach, DOS, Windows 3.1, Windows NT, Windows 95), 680xx processors (running VxWorks), SGI, HP, NeXT. It is easily ported to any machine that supports Unix-style sockets.

Task Management

TCA provides a variety of control constructs that are commonly needed in mobile robot applications, and other autonomous systems.

Planning and Execution

The fundamental capability of a robot is to achieve its goals. TCA enables developers to easily specify hierarchical task-decomposition strategies, such as how to navigate to a particular location or how to collect a desired sample. This can include temporal constraints between sub-goals, leading to a variety of sequential or concurrent behaviors. TCA schedules the execution of planned behaviors, based on those temporal constraints.

Execution Monitoring and Error Recovery

TCA provides constructs that enable the robot system to monitor selected sensors and inform the system when the monitored conditions are triggered. To recover from errors in plans, TCA utilities enable robot systems to reason about plans, terminate or suspend portions of plans, add patches, and retry plans. TCA provides a hierarchical exception-handling mechanism for specifying context-dependent error procedures.

Human/Robot Interaction

No robot will be fully autonomous; interaction with humans is a necessity. TCA provides users with the ability to interact with the robot at any level of the task hierarchy. Users may also view the current task decomposition that the robot is executing, and modify it on the fly, if need be. We are currently developing tools to facilitate the task of designing and debugging complex concurrent, distributed systems.

Note that TCA may not be an appropriate framework for real-time control systems. We are, however, currently integrating TCA with ControlShell, in order to provide both task-level and real-time control within a single architectural framework.

The current version of TCA runs on the following machines types:

  • SPARC running: SunOs 4.1.3, Solaris, Mach 2.6, VX works
  • Motorola 680xx running VxWorks
  • x86 running: DOS (with FTP Software's socket implementation), Windows 3.1, Windows NT, Windows 96 (using the Winsock interface), Linux, and Mach
  • Dec 3100 (pmax) running: Mach 2.6
  • Dec Alpha running: osf 1.3
  • SGI Iris
  • NeXT
  • Soon to be released: Machintosh running: System 7.
  • The system should run on any machine that supports sockets and has a ANSI c compiler (gcc). It also runs on Allegro Common Lisp on Sun machines, running either SunOS or Solaris. For information on porting TCA to a new architecture, contact Reid Simmons

    Send mail to reids@cs.cmu.edu to be added to the tca mailing list, tca-users@cs.cmu.edu.

    Support Tools

    We have developed a number of support tools and packages for building distributed, concurrent software systems. All of these tools and packages are available through the ftp source (see below).
  • comview: A tool for graphically displaying the message traffic between TCA modules. Works by parsing a TCA log file.
  • tview: A tool for graphically displaying the hierarchical task composition of a TCA system. Works by parsing a TCA log file.
  • devUtils: A package for connecting and maintaining connections (e.g., TCA, X, tty-input, RS232).
  • nanny/runConsole: Tools for automatically starting up, killing, restarting, and interacting with processes on multiple machines (currently runs on SunOS and Linux).
  • Source

  • TCA ftp Directory
  • Documentation

  • TCA Manual, version 8.5
  • Comview Manual, version 1.0
  • Release Notes

  • Version 7.4
  • Version 7.5
  • Version 7.6
  • Version 7.7
  • Version 7.8
  • Version 7.9
  • Version 8.0
  • Version 8.1
  • Version 8.2
  • Version 8.3
  • Version 8.4
  • Version 8.5
  • Last Updated: May 7, 1997 reids+@cs.cmu.edu