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,
indoor and outdoor, autonomous and teleoperated robots. Within NASA, TCA
has been used on the Ambler, Ratler and
Nomad rovers, on the
tile inspection robot, in the
interface, and for autonomous spacecraft simulation. In addition, descendants
of the TCA communication mechanisms (TCX and IPC) have been used in the
and the Aercam project.
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.
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.
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
The current version of TCA runs on the following machines types:
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
Send mail to
to be added to the tca mailing list, firstname.lastname@example.org.
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).
Last Updated: May 7, 1997