This directory contains executable programs for the RCCL/RCI system.

These include non-robot programs, sych as:

rcc --	   a simple C compiler front end used for compiling RCI programs.
	   The reason we use a seperate command is to (1) provide us
	   with a way to designate code in the program that will be used at
	   the control level, and (2) to provide all the RCI libraries by 
	   default. See man page. rcc makes use of local mods to the
	   C compiler front end (cc) and the loader (ld).

cc -- 	   local copy of the C compiler (NOT INSTALLED on non-VAX systems).

	   The local copy of the C compiler
	   is exactly like the usual C compiler, except that it also 
	   supports a '-b' option. What is the -b option? It specifies
	   that unitialized data, which is normally targeted by the
	   compiler for the bss segment, be put into the data segement
	   instead. The motivation for this is that structures in the
	   data segment are arranged by the loader in strict consectutive 
	   order on a file by file basis, whereas structures in the bss
	   segment may be scattered all over the bss segment, regardless of
	   which file they were declared in. This creates a problem for the
	   rcc command, which wants to locate all the code and data in an
	   RCI program which is associated with the RCI task level into
	   contiguous memory areas so that those areas can be treated
	   specially (locked into memory, if control tasks are running on
	   the arbiter, or loaded into the auxiliary CPUs, if auxiliary CPUs 
	   are available). So rcc uses the '-b' option.

ld -- 	   local copy of the loader (NOT INSTALLED on non-VAX systems).

	   This is exactly like the usual C loader,
	   except that it supports a couple of extra options, which are
	   also motiivated by the rcc command (see the description for cc,
	   above). When the rcc is loading and RCI program, it wants to put
	   all the code/data associated with the control level into contiguous
	   memory areas. It is also desirable to arrange for these data areas
	   to be page aligned. Page alignment can be done by using the 
	   -aa, -at, or -ad options on the loader.

		-at tells the loader to page align the text loaded from the
		    next file.

		-ad tells the loader to page align the data loaded from the
		    next file.

		-aa tells the loader to page align both text and data loaded
	            from the next file.

down --    a program to download pdp11 executable code into a Unimation
	   PUMA controller. See man page.

termlink -- a program that puts your terminal into virtual communication
	   with another terminal line. It is usually used around here to
	   communicate with the console line of another system (such as
	   the PUMA robot controller or an auxiliary CPU console line).
	   See man page.

arc --	   A robotics oriented desk calculator. See man page.

eqenv --   Program that checks to see if an environment variable is
	   defined, or defined to be a particular value. Written for
	   use by Makefiles, but not currently used.

less --	   A public domain program for viewing files.

xargs --   A program used by the Makefiles that accepts file names
	   from 'stdin' and then expands executes a command on them
	   when a large number of them have accumulated.

tcmp --	   A program used by the Makefiles that compares the modify
	   times of two different files.

makejls -- Program that creates a binary robot joint specification file
	   from an ascii file. See the man page.

imake --   A utility program brought over from X11 which is used to
	   automatically build "Makefile"s from template "Imakefile" files.
	   The usefulness of this is that Imakefile can be made fairly
	   independent of the system version. See the man page for 'imake'.

rmkmf --   An interface script to "imake". 

Robot utility programs:

pumacal	--  Program to calibrate PUMA robots. The robots can be calibrated
	    from either the park position, from any location using the
	    pots (if the robot has pots), or from the nest position (if
	    the robot is a 260). See man page.

free --	    Program to free up the joints of a robot. See man page.

park --	    Program to move the robot to its park position. See man page.

move --	    Program to move the robot to a specified joint position, where
	    the position can be specified as an absolute set of joint
	    angles, a set of joint angle offsets from the current position, or
	    an absolute location defined in a file. See man page.

primecal -- A program to do primary calibration on a robot. Primary 
	    calibration consists of finding the numbers to put into
	    the 'encCalvec' field of the robot's JLS data structure.
	    It is generally done once every few months or so. See man page.

potcal --   A program to calibrate the pots for a particular robot so that
	    it can use pots to calibrate itself. Calibrating the pots consists
	    of finding the aproximately linear relationship between pot values
	    and encoder values for a robot; i.e., the 'potSlope' and 
	    'potIntercept' fields of the JLS data structure. See man page.

teachdemo -- A program that calls the RCCL routine rcclTeach(). This
	    lets you move the robot around with commands from the teach
	    pendant or the keyboard. See man page.

robotsim -- The robot simulator program that pretends it is a PUMA robot
	    controller (`moper' program) for running RCCL/RCI in simulation
	    mode. See the man page.

zerograv -- A program that puts the robot in a weightless mode where its
	    gravity loadings are compensated fro and you can move it
	    around freely with a minimum of effort. See man page.

power --    Program for turning robot arm power on or off. See man page.

