-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

The description below will give you some general information
about RCCL/RCI. If you want the RCCL programming manual, then
you can either send us your physical address and we will mail
you a copy, or you can pick up the compressed PostScript file
from anonymous ftp at larry.mcrcim.mcgill.edu:rccl/rcclguide.ps.Z.
Uncompress this and send it to your favorite PostScript printer.
It's about 200 pages long. Other manuals are provided with the
distribution. 

Introduction to RCCL
------------ -- ----

RCCL is a robot programming language embedded in C that runs on several
workstations (Sun4, Iris, MicroVAX). The language is geared toward serial 
manipulators with closed form solutions, several of which may be controlled 
at once from the same program. The system uses real-time workstation
capabilities (which are specially added in the case of MicroVAXen and Sun4s)
to allow direct on-line control of any robot for which a suitable interface to
the workstation can be arranged. 

Robots which are currently supported include the PUMA, the Stanford arm,
and the "elbow" manipulator. Adding other robots is basically a matter
of adding the appropriate kinematic routines. Using RCCL to control
robots with more than 6 DOF would be possible but would require some
modification to the trajectory generator, which currently exploits the
ability to perform closed form inverse kinematics.

The system also contains a 3D graphical robot simulator that can be used
in place of a real robot. The simulator is used for "dry running" programs
and for programming robots which are otherwise not available, or for which 
a suitable real-time control interface does not exist. Several
robots may be "simulated" at once, and other workspace objects may be
defined and graphically depicted as well. Currently, the simulator does 
_not_ do dynamic modeling or collision detection, although adding modules to
do these computations would be straightforward. 

The RCCL Programming Language
--- ---- ----------- --------

RCCL implements many of the programming ideas expressed in Chapter 10 of
Richard Paul's book ("Robot Manipulators: Mathematics, Programming, and
Control", MIT Press, 1981). It contains primitives and data structures
for describing and manipulating various data types related to robot
programming, including 4X4 transforms, position equations, vectors, 
and quaternions. Robots to be controlled are "opened" and then
referenced using a descriptor. Robot motions are specified by providing
"target" positions in either joint or Cartesian coordinates, as well as
various constraints on motion time, velocity, acceleration, and 
interpolation.

When executing, an RCCL program consists of two tasks: (1) a foreground
"planning" task (the main UNIX program), from which robot motions are 
specified, and (2) a real-time trajectory task, running in the background
at a constant rate (usually 50 to 100 Hz.), which does the interpolation
and smoothing necessary to implement the desired motion requests.
The trajectory task and the planning task communicate through shared memory. 

The trajectory generator produces a stream of setpoints (in either joint or
Cartesian coordinates) which must then be fed into a suitable tracking
controller (which usually runs at a faster rate, such as 1 Khz.). RCCL does
not provide software for the tracking controller, although it can generate
feed forward information for such a controller. Anyone implementing their own
low level controller should be able to place the RCCL trajectory generator on
top of it rather easily.

An important feature of RCCL is the ability to execute real-time application
functions inside the trajectory generator task. These provide an ability to
control motion scheduling, generate unusual trajectory contours, or modify
motion targets in response to real-time sensor inputs. Specific applications
of this have included impedance and force control, telerobotics, and
visual servoing.

Another, newer, feature of RCCL is the ability to control multiple robots
from the same program. Primitives are available to provide the necessary
synchronization. Alternatively, one robot may be "slaved" to another by
designating the T6 transform of the "master" to be contained in the target
position equation for the "slave". It is also possible to create "virtual"
manipulators, which are simple frames in space with no manipulator
attached, that can be "moved" using same the motion primitives available
to regular manipulators. The "T6" transform of a virtual manipulator can
be incorporated into the target position equations for two or more regular
manipulators to achieve multiple arm manipulation of a common object.

The Graphics Simulator
--- -------- ---------

The simulator is a separate program which provides graphic emulation
of one or more of the robots supported by the RCCL/RCI system. An RCCL 
program can be directed to connect to the simulator instead of to real
robots.

A 3D graphic display of each robot is produced, along with other "objects"
which can be defined in a configuration file. The graphic window contains
a small control menu for adjusting the view frame. A simple graphic
"teach pendant" interface is also available.

The graphics is implemented using a generic graphic package called
"grf4" (written by myself), and can run under X11, SGI's GL, or SunView.
Grf4 permits the definition of lines, polygons, or convex objects, which are
rendered using either full shaded graphics (under GL), or as wireframes with 
backface removal (X11 and SunView). The wireframe can also do full hidden
line removal, but this is slow and does _not_ work (yet) for intersecting
objects.

RCCL programs connect to the simulator using internet domain sockets. It is
therefore possible to run the simulator and the RCCL program on separate
machines.

As indicated above, the simulator does not currently support collision
detection or dynamic modeling. There are places in the simulator program
where such modules could be added.

History and Status of RCCL
------- --- ------ -- ----

The system is currently supported here at McGill University (Montreal). It was
developed originally by Vincent Hayward (formerly of Purdue University but now
also at McGill), and then worked on extensively by myself. Probably the most
significant extension over the original version is the ability to control
multiple robots.

The software is not in the public domain, but it is free for non-commercial
applications. For commercial applications, we reserve the right to license it.
I understand that there is a very old public domain version that has migrated
to a bulletin board somewhere; I imagine this predates the multi-robot 
version.

There is a fair amount of documentation (about 800 pages), describing
how to use the system, install it, and hook up the hardware. This is
written using TeX/LaTeX, and contains various figures implemented in
PostScript. The documentation can be printed on a PostScript printer.

Ordering Information
-------- -----------

RCCL is not available on ftp at the moment, although this is being considered.
The usual procedure now is that we ship the software for a fee to cover
materials and shipping. The current fee schedule is:

				Inside North America 	Outside North America

    tape only:				$100.00			$125.00
    tape + doc set: (2 binders;		$200.00			$250.00
	about 800 pages)

Again, if you have a PostScript printer, you should be able to print the
documentation.

Source code is provided.

The distribution fee should be made payable to the "McGill Research Center for
Intelligent Machines", and sent to  

	John Lloyd
	Research Center for Intelligent Machines
	(McGill University)
	3480 University Street
	Montreal, Quebec, CANADA
	H3A-2A7

If you want to arrange some other means of distribution, please let us know.

I send out regular bug fixes to any sites which have an E-mail link. The
fixes are distributed as source code patches using Larry Wall's "patch"
utility.  

What is RCI?
---- -- ---

RCI is the real time control interface used by RCCL.

Implementing RCCL requires that one be able to (1) create a real-time
task to run the trajectory generator, (2) allocate shared memory regions
to communicate with this task, and (3) make simple services (such as
a malloc and a 'printf') available to the real-time task. The package of
routines that provides these capabilities is called RCI (Robot Control 
Interface, or, alternatively, Real-time Control Interface), and its
implementation varies a lot depending on what sort of system RCCL is
implemented on. RCI also defines an abstract robot model and provides
standard interfaces for communicating with the robot controller.

Which Robots are supported:
----- ------ --- ---------

All the PUMA robots (260, 560, and 760) are fully supported by the system,
along with the Mark I, II, and III Unimate controllers. The UNIVAL controller
is not supported because we do not presently know how to "get inside it".
RCCL itself can quite easily support other robots, and presently contains
internal support for the Stanford arm and the "elbow" manipulator. However,
connecting the system to a physical robot requires that a suitable low
level control interface is available (as it is for the PUMA), and most
robot controllers do not provide such an interface. Nor do the manufacturers
like to give out the information required to implement such an interface.
There have, however, been some exceptions to this: an old version of RCCL was
interfaced to a Microbot Ecureuil (a small cylindrical robot manufactured by
the Swiss), the current version of RCCL has been interfaced to a Manutec R3
manipulator with a Siemens robot controller, and I understand the University
of Waterloo did the work necessary to connect RCCL to an Adept-I.
Alternatively, if one has their own controller (or is willing to build one),
then an RCCL interface is easy to arrange. This approach was used for the
RCCL installation at the Jet Propulsion Laboratory. Yet another option
is to connect a different robot to the Unimation controller: the original
version of RCCL at Purdue operated a Stanford arm which was connected to a
Unimation controller. 

What Host System is Required:
---- ---- ------ -- --------

The main constraint on the host computer system is that you need
to run a real-time task under UNIX. We have been able to graft this
ability onto MicroVAXen running 4.1 BSD and Sun Sparc systems running
SunOS 4.0 and up. The real-time patches are primitive but effective.
For MicroVAX systems, we also have the ability to make use of 
extra "real-time" CPUs added to the MicroVAX back plane.
If you use a Sparc system, then you need to have a VME bus connection,
because the hardware necessary to interface with the robot
controller is not available for the S-bus. You can use either a
Sparc system that has a built-in VME bus, such as the Sun 330, or
you can buy an S-bus to VME adaptor. The adaptor plus a small VME chassis
costs roughly $5,000. The RCCL distribution does not specifically support the
adaptor option, but a user at the University of Pennsylvania implemented this
with relatively little difficulty. If you buy the S-bus VME adapter
manufactured by Performance Technologies, they can provide a software
interface that makes the VME transparently available to the Sparc station,
and no modification to the RCCL system code is required.

RCCL on VxWorks
---- -- -------

RCCL has been implemented on VxWorks, the real-time system distributed
by Wind River Systems. The implementation is a bit rough, since some
RCCL applications take advantage of services available under UNIX that
are not provided by VxWorks.

VxWorks versions 4.0 and 5.0 are currently supported.

RCCL on SGI machines:
---- -- --- --------

RCCL has been ported to Silicon Graphics workstations.

Irix, the operating system for Silicon Graphics machines, contains
enough intrinsic real-time support to allow RCI to be implemented 
without having to resort to kernel patches, providing that the
machine is kept unloaded and the control task does not have to
run at rates faster than 100 Hz.

On SGI machines with multiple CPUs (such as the power series), it should 
be possible to achieve better real-time response by running the 
control task on a dedicated CPU, although the software does not 
currently take advantage of this.

Silicon Graphics machines usually have at least one VME bus slot that
can be used to interface to a robot controller.

RCCL on IBM RS-6000:
---- -- --- -- ----

Plans to port RCCL to an IBM RS-6000 are currently on hold because
of lack of demand. The AIX kernel on the RS-6000 does, however,
provide enough real-time support to implement RCI, and interface devices 
are available to connect the RS-6000 directly to a Unimate controller.

Connecting to a Unimate Controller:
---------- -- - ------- ----------

This describes some of the specific equipment needed for connecting
a RCCL host workstation to a Unimate controller.

Once you have the robot, controller, and host computer, you need about
another $2-3K worth of interface boards (parallel ports, ribbon cable,
perhaps a real-time clock board for the Sun system if you want to
run at rates greater than 50 Hz.). Also, if your robot controller
is a Mark I, you should probably upgrade its CPU from an LSI-11/02
to an LSI-11/73, which costs about $1,500. Most Mark II and Mark III
controllers seem to already have this CPU, so this is usually not a problem.

More detailed information on arranging the various hardware configurations
is provided in the RCCL/RCI documentation set.



