COMMENT ⊗   VALID 00025 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00004 00002	\|\\M1BDR30\M2SIGN57\M3NGR25\M4NGR20\M5NGB25\M6SGN114\N
C00006 00003
C00007 00004	\F3
C00011 00005	\F8\CVAL - THE UNIMATION ROBOT CONTROL SYSTEM
C00018 00006	\N
C00020 00007	\F1\CMONITOR COMMANDS:  PROGRAM EDITING
C00024 00008	\N
C00028 00009	\F1\CMONITOR COMMANDS:  POSITION VARIABLE AND PROGRAM LISTING
C00030 00010	\F1\CMONITOR COMMANDS:  PROGRAM AND POSITION DATA STORAGE
C00034 00011	\F1\CMONITOR COMMANDS:  PROGRAM CONTROL
C00037 00012	\N
C00040 00013	\F1\CMONITOR COMMANDS:  COMPUTER STATUS
C00043 00014	\F1\CPROGRAM INSTRUCTION SET
C00044 00015	\F1\CUSER PROGRAM INSTRUCTIONS:  MOTION STATEMENTS
C00049 00016	\N	
C00053 00017	\F1\CUSER PROGRAM INSTRUCTIONS:  ARM CONFIGURATION CONTROL STATEMENTS
C00056 00018	\F1\CUSER PROGRAM INSTRUCTIONS:  INTEGER VARIABLE AND ASSIGNMENT INSTRUCTIONS
C00060 00019	\F1\CUSER PROGRAM INSTRUCTIONS:  CONTROL STRUCTURES
C00064 00020	\F1\CUSER PROGRAM INSTRUCTIONS:  SPECIAL SWITCH STATEMENTS
C00068 00021	\F1\CUSER PROGRAM INSTRUCTIONS:  MISC. STATEMENTS
C00069 00022	\,\F1\CERROR CODES
C00070 00023	\F1\CSUMMARY OF INSTRUCTION SET
C00074 00024	\, UN-INCORPORATED NOTES
C00076 00025	\,	      APPENDIX 1: LOADING INSTRUCTIONS
C00078 ENDMK
C⊗;
\|\\M1BDR30;\M2SIGN57;\M3NGR25;\M4NGR20;\M5NGB25;\M6SGN114;\N
\M7NGB40;\M8BDR40;\N
\⊂'210555;\Nturn on flags outovl option, nest⊃quote, multiarg macros, lf sim,
\←=30;\→S\ε\N Interbase spacing in register S:  single spacing
\N
\N	page numbers and binder indentation
\N\←L\+=100;\→L\;  moving the left margin in to give the binder room
\N\←R\-=100;\→R\;  moving the right margin in to give the binder room
\←L\+=40;\→l\←R\→r \N set up secondary margin
\N
\←=1;\→N\;  This is the starting page number
\∞EVERYPAGE[\N
\oHEAD{1[\DN]}\N This has no section number included
\N\oHEAD{1[V.\DN]}\N This has the section number included.
\←R\→D\1HEAD;\¬D\→D\2HEAD;\¬D\-=1;\→D\N  This is for right numbering
\N\←L\→D\N This is for left numbering
\WHEAD,D=150;\N
\←N\+=1;\→N]\;
\N
\∞figure[\←N\+=1;\→N]
\N
\8command(a)[\#\F5⊗a⊗\G]\N
\∞col1[\←L\+=50;\→.]\N
\∞col2[\←L\+=600;\→.]\N
\,







\F2\CUSER'S GUIDE TO 


\F6\CV A L\.

\F7
\CA Robot Programming and Control System










\F8\CUnimation, Inc.
\CShelter Rock Lane
\CDanbury, Conn.  06810


\F1\C2\∩nd\⊗ Printing - February 22, 1978

\Cc
\F3







\F8\CINTRODUCTION




\F3\JVAL is a system  for programming  all computer controlled  robots
and manipulators.  The VAL system and  language has been developed over  a
period of several years  and is based  on more than  15 years of  computer
controlled manipulator research and development efforts.

VAL is universal.  All instructions and programming  concepts
can be  applied  to  any  manipulator system  capable  of  being  computer
controlled.

VAL is easily learned.  All instructions are clear, concise, and generally
self explanatory.  All commands and communications with the robots or
manipulators are in the English language, and use easily understood word
and number sequences.  Program writing may be done on the same computer
that controls the robot, or on any other computer or computer terminal
capable of storing the instructions in the proper format.

VAL is  easily upgraded.  New  commands and capabilities  are
continually being added to the VAL language.  The system has been designed
to be  easily modified  to suit  specific applications  and to  work  with
manipulators or  robots  of different  configurations  and size.  The  VAL
system can be used with  process controllers and other peripheral  devices
on assembly lines or in manufacturing operations.

VAL programs are universal.   A VAL program written  for one robot may  be
used to operate many different types of robots.

VAL features the ability to  generate libraries of manipulation  routines,
so that  complex  operations  may  be easily  and  quickly  programmed  by
combining pre-defined sub tasks.

VAL operates in real-time.  Continuous, real-time computation permits
complex motions to be quickly executed with efficient use of computer
memory and reduction in overall system complexity.  The VAL system
continuously generates robot control commands, and simultaneously
interacts with a human operator or other interactive controller.  This
permits on-line program generation and modifications.

VAL is self  contained.   The entire  VAL  language,  program
development, and manipulator control system is contained within a  single,
compact, low cost computer/controller unit.

VAL is  easily used.  This  guide  contains most  of  the
information required to  be able to  create robot control  programs and  to
operate a computer controlled robot.\.
\F8\CVAL - THE UNIMATION ROBOT CONTROL SYSTEM


\F3\J\N
Preceding the monitor instructions described below are two symbols which
indicate when each command can be executed.  A period (.) signifies that
the command can be performed when VAL is in its top level monitor mode
and no user program is being executed.  An asterisk (*) indicates that
the command can be performed at the same time that VAL is executing a
user program.  If both symbols are present, then the command can be
always be performed.

For both monitor and program instructions, items enclosed in brackets ([...])
are optional.  Angle brackets (<...>) are used to indicate that the enclosed
item is the name of the actual argument to appear.\.



\F1\CMONITOR COMMANDS:  DEFINING POSITIONS

\F3\J\N
The position and orientation of a manipulator can be stored within the
computer using either a transformation or a precision point.

A transformation is a cartesian description of the position and
orientation of the manipulator's hand.  The hand's X, Y, Z location is
stored as a vector and its orientation is stored as a 3 by 3 matrix.  This
representation is advantageous where relative translations and rotations
are to be performed.  Furthermore, because transformations only refer to
the position and orientation of the hand, they are independent of the
geometry of the manipulator.

Due to the complexity of the computations necessary to convert between
joint angles and cartesian coordinates, using transformations to store the
position and orientation of the manipulator can, at times, be somewhat
inaccurate.  If high precision is required, the manipulator's position and
orientation can be stored as a precision point.  Precision points save the
joint angles of the manipulator and are therefore capable of achieving
full precision playback.  For most instructions requiring a manipulator
position, precision points and transformations can be used
interchangeably.

The names of both precision points and transformations consist of a string
of six characters starting with a letter and followed by any sequence of
letters and numbers.  Precision points and transformations are
distinguished by the fact that precision point names must always be
preceded by the symbol "#".  The number of precision points and
transformations that can be stored in the computer is only limited by the
size of the computer memory.

There are several commands that can be used for defining positions and
determining the current location of the arm:\.


\!command(POINT <position>);
\j[ . *] The current value of the <position> is printed and any of its
coordinates may be modified by typing a new value after the query
CHANGES?.  Coordinate values must be separated by commas and values that
are not to be changed can be omitted.  Changes are continuously asked for
until no change in the transform is made.  If the position variable is a
precision point, its 6 joint angles are printed.  Otherwise the position
variable is a transformation and its value is typed as (X,Y,Z,O,A,T).  The
X,Y,Z specify the position of a point centrally located between the finger
tips in table coordinates.  O,A,T specify the orientation of the hand (Euler angles).
With all three angles (in degrees) zero, the hand points in the negative Y
direction with the fingers in a horizontal plane.  The orientation vector
which points from one finger tip to the other is aligned along the X axis.
O specifies a rotation of the orientation vector about a vertical
direction.  Thus at O=90deg, the hand, still horizontal, would point along
the positive X direction.  A is a rotation about the orientation vector.
With A=90deg, the hand always points straight down.  T is a final
rotation about the axis of the wrist and corresponds to a rotation of the
final (#6) joint.\.  
\N
\!command(HERE <position>); 
\j[ . *] Defines the value of the <position> variable to be equal to
the current arm position.  As with POINT, post modification of the
position coordinates is permitted.\.

\!command(WHERE);
\j[ . *] Prints out the current location of the arm in Euler and joint
angles along with the current hand opening.\.

\!command((BASE [<dX>],[<dY>],[<Z rotation>]));
\j[ . ] Offsets and rotates the location of the base of the manipulator.
Normally when the VAL system is initialized, the base of the arm is
assumed to be located at position {0,0,0} and its orientation such
that in the READY position, the links of the arm are roughly pointed
along the positive Y axis.  If the base is actually located at some other
position {dX,dY,0} and is rotated about the Z axis by an angle
of <Z rotation>, the BASE command can be used to modify the computations
necessary to convert between joint angles and cartesian coordinates to
account for these alterations.\.




\,
\F1\CMONITOR COMMANDS:  PROGRAM EDITING

\F3\J\N
Distinct sequences of instructions to be executed are stored as user
programs within the computer.  The number of programs that can be saved
is limited only by the amount of computer memory available.  Programs are
referred to by six character names which, like position variables, must begin
with a letter and can be followed by any sequence of letters and numbers.

Each instruction within a program is referred to by a unique step number.
Step numbers are numbered consecutively and are automatically adjusted
whenever instructions are inserted or deleted.  In addition, program steps
can contain step labels.  Step labels are used for program controlled
branching and looping.  Step labels are integer numbers ranging
from 0 to 32767.

Programs can be developed off-line in any computer capable of generating
ASCII text strings or they can be developed using the program
editing routines which are a standard feature of this language.  These
editing routines can be used for both modifying existing programs and
creating new programs.  The editing instructions are explained below.\.


\!command((EDIT [<program>],[<step>]));
\j[ . *] Permits the user to create or modify the <program> starting at step
<step>.  If no step number is specified, editing proceeds from the step
were the last editing session was terminated -1.  If no program is
specified, the last program edited is re-opened.\.


\JOnce having entered the EDIT mode, the following edit functions may
be invoked.\.


\!command(<any program instruction>);
\j[ . *] Replaces the program instruction stored at the current step with the
instruction typed in.  The next step is then displayed for editing.\.

\!command(<carriage return>);
\j[ . *] Typing an empty line (carriage return) leaves the current step
unaltered and displays the next instruction for editing.\.

\!command((C <program>,[<step>]));
\j[ . *] Changes EDITing from the current program to the new user
<program> starting at step <step>.  As always, <step> can be
omitted and editing will begin with the first program instruction.\.
\N
\!command(D [<nstep>]);
\j[ . *] Deletes the specified number of instructions starting with the
current instruction step.  If <nstep> is not specified, only the current
step is deleted.\.

\!command(E);
\j[ . *] Exits the EDIT mode and returns to MONITOR mode.\.

\!command(I);
\j[ . *] Moves instructions starting at the current step down one and
inserts in its place any motion instruction that is typed in.  The process
is repeated until an empty line is typed.\.

\!command(L);
\j[ . *] Leaves the current step unaltered and displays the
previous step for editing.\.

\!command(P [<nstep>]);
\j[ . *] Prints the next <nstep> number of program steps and sets the
current line number equal to the last line printed.\.

\!command((R [<arg#>],[<value>]));
\j[ . *] Replaces argument number <arg#> of the current program instruction
with the new value specified by <value>.  If <arg#> is negative, zero, or
omitted, the first argument is replaced.  If <arg#> is greater than the
number of possible arguments, the last argument is changed.  "SETI" instructions
and instructions requiring string arguments cannot be altered using
this EDIT function.\.

\!command(S [<step>]);
\j[ . *] Leaves the current step unaltered and displays the instruction
which is at step <step> in the user program.  If <step> is omitted, the
first instruction of the program is displayed for editing.\.

\!command(T);
\j[ . *] Initiates program teach mode.  In this mode, each time that the
RECORD button on the manual control box is pressed, a MOVEI instruction is
generated which contains as its arguments, the current arm position (in
joint angles) and the hand opening.  By successively manually positioning
the arm and pressing the RECORD button, a complete motion task can be
taught.  This mode is terminated by typing a carriage return on the
console keyboard.\.



\,
\F1\CMONITOR COMMANDS:  POSITION VARIABLE AND PROGRAM LISTING


\F3\J\N
The following commands are used to get hard copies of programs and
position variables.  The execution of these commands can be aborted by
typing a carriage-return (CR) character on the console keyboard.\.


\!command((LISTT [<position1>],...,[<position8>]));
\j[ . *] Types out the values of up to eight selected position variables.
If no position variable names are specified, the values of all existing
position variables will be printed.\.

\!command((LISTP <program>,[<step1>],[<step2>]));
\j[ . *] Types out the user <program> from <step1> to <step2>.
If the step numbers are omitted the entire program will be printed.\.

\!command(PROGS);
\j[ . *] Prints out the names of all user programs that have at least one
program step defined.\.
\F1\CMONITOR COMMANDS:  PROGRAM AND POSITION DATA STORAGE


\F3\J\N
The following commands are used to store and retrieve user programs and
position data on the mini-floppy disk.  The disk is logically divided into
10 files which are each capable of holding over 100 position variables or
program steps.  The files are numbered from 1 to 10.  In all cases where
an operation may result in destructively writing over valid data which
is contained on the disk, verification is first required before the
operation is performed.  The execution of these commands can be aborted by
typing  carriage-return at any time.\.


\!command(ERASE);
\j[ . *] This routine completely erases the contents of the floppy diskette
and initializes the diskette's file directory information.  This operation
must always be performed before a new diskette is used for data storage.\.

\!command(LISTF);
\j[ . *] Types the file directory of the diskette currently loaded in the
mini-floppy system.\.

\!command(STORET <file>);
\j[ . *] Stores the names and values of all defined position variables
in the specified floppy disk file.\.

\!command(LOADT <file>);
\j[ . *] Loads all of the position variables which are contained in the
specified disk file into the computer memory.  Note that if a position
variable is already defined and a variable with the same name is contained
in the disk file, the position's value will be replaced by the value
read from the disk.\.

\!command((STOREP <program>,<file>));
\j[ . *] Stores the user <program> into the disk <file>.  Only
one program can be stored per file.\.

\!command((LOADP <file>,[<program>]));
\j[ . *] Loads the program contained in <file> into the computer memory.
If the optional  second argument is specified, the loaded program will be
assigned the name <program> instead of the program name contained in the
file directory.  If a program already exists which has the same
name as the assigned name, it will be deleted and replaced by the
program contained on the disk.\.



\,
\F1\CMONITOR COMMANDS:  PROGRAM CONTROL

\F3\J\N
The following commands are used for executing and stepping through
user programs.\.


\!command((EXEC [<program>],[<nloop>],[<step>]));
\j[ . ] Executes the user <program>, <nloop> number of times.  A loop is
terminated when either a STOP instruction or the last defined step of the
program is encountered.  The value of <nloop> can be between 32767 and
-32768.  All negative values of <nloop> put the program into a continuous
loop.  If <nloop> is omitted or assigned a zero value, the program will be
executed one time.  If <program> is omitted, execution of the last user
program EXEC'ed will be re-initiated.  If <step> is specified, the motion
program begins execution at motion program step <step> for the first pass,
otherwise, the program starts execution at step #1.  All successive passes
begin at the start of the program.\.

\!command(P);
\j[ . *] Proceeds user program at the step following the step where
execution was halted due to a PAUSE instruction or runtime error.  If a
program is currently running but is in a WAIT loop, waiting for an
external signal to be given, typing P has the affect of skipping over the
WAIT instruction.  If a program is executing but is not in a WAIT loop,
this instruction has no affect.\.
\N
\!command(R);
\j[ . ] As with the "P" instruction, this command can be used for
restarting program execution after a PAUSE or runtime error.
However, in this case, execution resumes at the previous instruction
step.  This allows the user to "retry" a step that may have been
aborted due to an error condition.  Note that execution is resumed at the
previous program step, not the previously executed program
step.  Hence it is not possible to use this instruction to back up to
a instruction which generated a program branch or subroutine call.\.

\!command(S);
\j[ . ] Program single step mode.  Executes the next instruction in the
user program and then halts.  "S" can only be typed after a PAUSE
instruction has been executed, after a non-fatal run-time error has
occurred, or after single step execution of the preceding instruction.\.

\!command(ABORT);
\j[*] Program execution is terminated at the completion of the step
currently being executed.\.


\J\N
When a program terminates execution due to a PAUSE or STOP statement or
from any one of a number of run-time errors, an appropriate message will
be typed out followed by one of the
following three phrases: 1) "HALTED AT STEP xxx", 2) "HALTED AT ppp-xxx", or
3) "USER PROGRAM TERMINATED".  The first message is printed when the main
program terminates execution due to an error or a PAUSE statement.  In
this case, "xxx" is the number of the program step following the instruction
that generated the halt.  If a similiar termination takes place but the
halt occurs during the execution of a program subroutine, the subroutine
name is printed (ppp) followed by the subroutine step number.  Finally, if
a STOP instruction is executed or the last defined step of a
program has completed execution, the third phrase is printed.\.



\,
\F1\CMONITOR COMMANDS:  COMPUTER STATUS

\F3\J\N
There are a number of commands which can be used to determine the current
state of the manipulator computer and to initialize and terminate
execution.  These commands are briefly summarized below.\.


\!command(CLEAR);
\j[ . *] Re-initializes the VAL system and deletes all defined positions
and user programs.  This is a totally destructive operation.  This
function first asks "ARE YOU SURE (Y,N)?" to verify that the operation is
to be performed.\.

\!command(FREE);
\j[ . *] Types the percentage of available memory that is not currently in use.  As
the available memory is being added up, a simple check of the
whole area is made to ensure that the bookkeeping tags are
consistent.\.

\!command(STATUS);
\j[ . *] Prints the status information of the user program being executed.
This includes data on the program or subroutine step at which the
program halt occurred and the number of program EXEC loops completed and
still remaining.  Note that if the program is in an infinite EXEC loop,
i.e.  nloop < 0, the print out of the number of loops completed can be off
by 32767*n counts (n=1,2,..,∞), since the loop counter is permitted to
overflow.\.

\!command(DONE);
\j[ . ] MONITOR program stops, computer exits to ODT. The program can be
restarted by starting execution at location '20000.\.
\F1\CPROGRAM INSTRUCTION SET

\F3\J\N
The following sections describe the available program instructions.
Because of the great flexibility of the basic structure of the VAL language,
new instructions and data types which are deemed necessary can be easily added.\.


\,
\F1\CUSER PROGRAM INSTRUCTIONS:  MOTION STATEMENTS

\F3\JIn the following motion instructions all distances are in inches, time
is in clock ticks (100 ticks per second), and strings can be up to one line
long.\.


\!command(GO   <position> [!]);
\jMoves the arm to the position and orientation specified by the <position>
variable.  There is no path computed for this motion, the hardware position
servo operates in slew mode.  Any changes in configuration requested by
the user are executed during the motion.  If the position name is followed
by an exclamation mark (!), <position> will be set equal to the manipulator's
location at the time the GO instruction is typed.\.

\!command(MOVE <position> [!]);
\jMoves the arm to the position and orientation specified by the <position>
varible.  Intermediate set points between the initial and final arm
position are computed by interpolating the initial and final joint angles.
Any changes in configuration requested by the user are performed during
the motion.  See GO for an explanation of [!].\.

\!command((MOVEI [<jt1>],[<jt2>],[<jt3>],[<jt4>],[<jt5>],[<jt6>],[<hand>]));
\jPerforms the same type of motion as a MOVE instruction, except that the
final arm position is explicitly stated in terms of its six joint angles
and its hand opening instead of a position variable.\.

\!command(MOVES <position> [!]);
\jMoves the arm to the position and orientation specified by the <position>
variable.  The hand is moved along a straight line path and the hand
orientation is smoothly rotated to its final position.  No changes in
configuration are permitted during this motion.  See GO for an explanation
of [!].\.

\!command((DRAW [<dX>],[<dY>],[<dZ>]));
\jMoves the arm along a straight line a distance of dX in the X direction,
dY in the Y direction and dZ in the Z direction.  Any distances omitted
are assumed to be zero.  The arm configuration and orientation are
maintained during this motion.\.

\!command(DEPART <distance>);
\jMoves the hand a distance <distance> along the current axis of
rotation of the last joint.  Negative distances move the hand forward,
positive distances move the hand back.\.

\!command((APPRO <position>[!], <distance>));
\jMoves the hand to the position and orientation specified by
<position>, offset by a distance <distance> along the axis of rotation of the
last joint.  Positive distances move the hand back from the specified
position, negative distances move the hand beyond the position.  See GO
for an explanation of [!].\.

\!command((APPROS <position>[!], <distance>));
\jSame as APPRO, but the hand is moved along a straight line path and the
hand orientation is smoothly rotated to its final position.  No changes in
configuration are permitted during this motion.  See GO for an explanation
of [!].\.

\!command(READY);
\jMoves the arm to the READY position above the work space.  This forces
the arm into a standard configuration.  No matter where the manipulator
is originally positioned, this instruction will always succeed.\.
\N	
\!command(REST);
\jMoves the arm to the REST position.  This leaves the arm in a safe
position in case power is turned off.  If no special speed has been set
via the SPEED command, the arm will move to rest at half the normal
speed.\.

\!command(OPEN <distance>   or   CLOSE <distance>);
\jChanges the hand opening to <distance> inches during the execution of
the next motion instruction.  If <distance> is negative, the hand is
closed as far as possible, and if <distance> is very large, the hand is
opened as far as possible, otherwise the hand opening is set equal to
<distance>.  Both the OPEN and the CLOSE instructions produce exactly the same
effect.\.

\!command(OPENI <distance>   or   CLOSEI <distance>);
\jPerforms the same change in hand opening as an OPEN but the operation is
performed immediately instead of waiting for the next motion instruction.
Both the OPENI and the CLOSEI instructions produce exactly the same
effect.\.

\!command((GRASP <distance>,[<label>]));
\jCloses the hand and checks to see if the final hand opening was less
than the specified distance.  If so, the program branches to the step
indicated by the program label or an error message is generated if the
optional program label is not specified.  This instruction provides a
simple one step method for grasping an object and testing to ensure that
proper contact was achieved.\.

\!command((DRIVE <jt>,<angle>,<time>));
\jOperates the single joint specified by the parameter <jt> (1-7).  The
current joint angle is changed by an amount <angle>.  The change in joint
angle must be specified in degrees.  The duration <time> must be specified
in clock ticks.\.

\!command(DELAY <duration>);
\jPuts the program in a wait loop for the specified amount of time.  The
duration can be given as any value between .01 and 327.67 seconds.  This
instruction operates just like a "move to nowhere" motion instruction.
In particular if there is a pending hand operation, the hand motion will
take place during the execution of the DELAY instruction and if any
temporary special switches have been specified, they will be cleared after
the conclusion of the DELAY (see section on special switches).\.



\,
\F1\CUSER PROGRAM INSTRUCTIONS:  ARM CONFIGURATION CONTROL STATEMENTS

\F3\J\N
For an anthropomorphic, six-joint
manipulator, most points in the work space of the
arm can be reached by assuming one of eight possible spatial
configurations.  Normally, the arm will remain in whatever configuration
it starts in when the user program begins execution or continues from a
PAUSE statement or runtime error.  The only exceptions to this rule are:
1) when the arm is forced to change from FLIP to NOFLIP or vice versa
in order to keep joints 4 or 6 within stop limits or 2) when a READY or REST
instruction is executed or 3) when a specific change in configuration is
requested by the user program through the execution of any of the
following program instructions.  When the user specifies a change in arm
configuration, the requested change with be accomplished during the
execution of the next GO or MOVE motion instruction.\.


\!command(RIGHTY or LEFTY);
\jRequests a change in the arm configuration so that the manipulator's
first three joints resemble a human's right or left shouldered arm,
respectively.\.

\!command(ABOVE or BELOW);
\jRequests a change in arm configuration so that the elbow of the arm is
either pointed up or down.\.

\!command(FLIP or NOFLIP);
\jChanges the range of operation of joint 5 to plus (NOFLIP) or minus (FLIP)
angles.\.
\F1\CUSER PROGRAM INSTRUCTIONS:  INTEGER VARIABLE AND ASSIGNMENT INSTRUCTIONS

\F3\J\N
In most cases where an integer variable is required as an argument for a
user program instruction, either the symbolic name of a variable can be
given or an integer value can be specified.  Integer variable names conform
to the syntax given for position variable and program names and their
values must be between 32767 and -32768.  The only time that an integer
value cannot be used in place of a integer variable is when the specified
operation would result in an attempt to alter the value of the constant.
In this case an error message in generated.\.


\!command(SETI <i.var1> = <i.var2> [<operation> <i.var3>]);
\jThe value of <i.var1> is set equal to the result of evaluating
the expression on the right side of the equal sign.  The permitted
<operation>'s are:  addition (+), subtraction (-), multiplication (*),
integer division (/), and modulus determination (%).  If both the operation
and the third variable are missing, the instruction is a direct assignment
statement.\.

\!command(TYPEI <i.var>);
\jTypes the value of the integer variable <i.var>.\.

\!command(HERE <position>);
\jSets the value of the specified position variable equal to the current
manipulator position and orientation.\.

\!command(SET <trans1> = <trans2>);
\jThe value of transformation 1 is set equal to the value of
transformation 2.  If the position and orientation of transformation 2 
is not yet defined an error message will be generated.\.

\!command((SHIFT <trans> BY [<dx>],[<dy>],[<dz>]));
\jThe X, Y, and Z positions of the transformation <trans> are
modified by adding the changes in distances <dx>, <dy>, and <dz>,
respectively.  If the value of the transformation has not yet been defined
or if its new X, Y, Z position is too large to represent, an error message
will be generated.\.



\,
\F1\CUSER PROGRAM INSTRUCTIONS:  CONTROL STRUCTURES

\F3\J\N
The following instructions are used to alter the sequence in which
user program instructions are executed and for interlocking the
arm computer with other devices.\.


\!command(GOSUB <prog>);
\jExecution of the current program is temporarily suspended and program
execution continues starting with the first step of the user program
<prog>.  The address of the next step in the current program is
automatically saved and up to 10 programs can be superseded at any given
time.\.

\!command(RETURN);
\jTerminates execution of the current user program and resumes
execution of the last suspended program at the step following the executed
GOSUB instruction.  Executing a RETURN in the main program produces
the same affect as executing a STOP instruction.\.

\!command(IF <i.var1> <relationship> <i.var2> THEN <label>);
\jThe value of <i.var1> is compared to the value of <i.var2> and if
the stated <relationship> is true, the program branches execution to the
program step specified by <label>.  Otherwise, the next sequential step of the
program is executed as usual.  The possible relationships that can be
tested for are: equal (EQ), not equal (NE), greater than (GT), greater
than or equal (GE), less than (LT), and less than or equal (LE).\.

\!command(GOTO <label>);
\jPerforms an unconditional branch to the program step specified by
<label>.\.

\!command(SIGON <channel>);
\jTurns on the signal to the device attached to the specified output channel.\.

\!command(SIGOFF <channel>);
\jTurns off the signal to the device attached to the specified output channel.\.

\!command(WAIT <channel>);
\jThe program is put into a wait loop until a signal is received on the
indicated input channel.  This instruction can be skipped by typing the "P"
monitor command.\.

\!command(PAUSE <string>);
\jTerminates execution of a user program and types the message <string>.  Execution
can be continued from this point by typing "P".\.

\!command(STOP);
\jSame as PAUSE except that the program cannot be continued.\.



\,
\F1\CUSER PROGRAM INSTRUCTIONS:  SPECIAL SWITCH STATEMENTS

\F3\JThe following instructions are used for enabling and disabling special
features of the hardware position servo and the software trajectory
generator.  As indicated below, a few of these instructions can be
followed by the word ALWAYS if it is desired that the requested option be
turned off or on during all successive motions.  Whenever a switch is not
followed by ALWAYS, it is assumed that the switch setting is only to
affect the next motion.\.


\!command(COARSE [ALWAYS]);
\jThe low tolerance feature is enabled in the hardware servo so that
larger errors in the final position of the arm joints will be permitted at
the end of the next motion.  This will result in much faster motion
execution times if high accuracy is not required.\.

\!command(FINE [ALWAYS]);
\jOpposite of the COARSE instruction.  This is the default state of the
hardware servo.\.

\!command(NONULL [ALWAYS]);
\jThe next executed motion is terminated without waiting for the electronics
to signal that all moving joints have reached their specified positions.
Like the COARSE command, this mode results in faster motion times if final
position accuracy is not required.  However, since no position error
checking whatsoever is done, motion execution times will be fixed and
final position errors can be quite large.\.

\!command(NULL [ALWAYS]);
\jOpposite of the NONULL instruction.  This is the default state of the
software control system.\.

\!command(INTOFF);
\jTurns off the hardware position error integration feature during the
next motion.  However, the hardware integration is always enabled during
the final position error nulling period.\.

\!command(INTON);
\jForces the hardware to integrate the position error throughout the next
motion.\.

\!command(PULSE);
\jEnables the electronic hand pulse mode during the next arm motion for
approximately 100 msec.  This mode is useful for freeing the hand after it
has jammed open or closed.\.

\!command(SPEED <i.var> [ALWAYS]);
\jRequests that the next arm motion be performed at a speed other than
normal (=100).  The speed can range from 1 (extremely slow) to
32767 (the largest possible integer variable number which in this case
produces a hardware slewing mode).\.



\,
\F1\CUSER PROGRAM INSTRUCTIONS:  MISC. STATEMENTS


\F3\!command(COMMNT <string>);
\jComment line, a no-operation at run-time.\.

\!command(TYPE <string>);
\jTypes the message <string> on the console terminal.\.

























\F1
\CWelcome to VAL.  Good luck, and may the robots obey all your commands!
\,\F1\CERROR CODES

\F1\L     Code\cMeaning

\F3\N
1,2,3,4,5,6,7		\jNumber of arm joint out of tolerance or preventing
                        required arm solution.\.

8                       \jDesired position too close.\.

9                       \jDesired position too far out.\.
\F1\CSUMMARY OF INSTRUCTION SET


Monitor Instructions\F5

\!col1;BASE [<dX>],[<dY>],[<Z rotation>]\N
\!col2;EDIT [<program>],[<nstep>]
\!col1;HERE <position>\N
\!col2;LISTP <program>,[<step1>],[<step2>]
\!col1;LISTT [<position1>],...,[<position8>]\N
\!col2;POINT <position>
\!col1;PROGS\N
\!col2;WHERE

\!col1;ERASE\N
\!col2;LISTF
\!col1;LOADP <file>,[<program>]\N
\!col2;LOADT <file>
\!col1;STOREP <program>,<file>\N
\!col2;STORET <file>

\!col1;ABORT\N
\!col2;CLEAR
\!col1;DONE\N
\!col2;EXEC [<program>],[<nloop>],[<step>]
\!col1;FREE\N
\!col2;P
\!col1;R\N
\!col2;S
\!col1;STATUS

\F1Edit Instructions\F5

\!col1;<any program instruction>\N
\!col2;<carriage return>
\!col1;C <program>,[<nstep>]\N
\!col2;D [<nstep>]
\!col1;E\N
\!col2;I
\!col1;L\N
\!col2;P [<nstep>]
\!col1;R [<arg#>],[<new value>]\N
\!col2;S <step>
\!col1;T

\F1User Program Instructions\F5

\!col1;APPRO <position>[!], <dist>\N
\!col2;APPROS <position>[!], <dist>
\!col1;CLOSE <dist>\N
\!col2;CLOSEI <dist>
\!col1;DELAY <duration>\N
\!col2;DEPART <distance>
\!col1;DRAW [<dX>],[<dY>],[<dZ>]\N
\!col2;DRIVE <jt>,<angle>,<time>
\!col1;GO   <position> [!]\N
\!col2;GRASP <distance>,[<label>]
\!col1;MOVE <position> [!]\N
\!col2;MOVEI [<jt1>],[<jt2>],[<jt3>],[<jt4>],[<jt5>],[<jt6>],[<hand>]
\!col1;MOVES <position> [!]\N
\!col2;OPEN <dist>
\!col1;OPENI <dist>\N
\!col2;READY
\!col1;REST

\!col1;ABOVE\N
\!col2;BELOW
\!col1;FLIP\N
\!col2;LEFTY
\!col1;NOFLIP\N
\!col2;RIGHTY

\!col1;GOSUB <prog>\N
\!col2;GOTO <label>
\!col1;HERE <position>\N
\!col2;IF <i.var1> <relationship> <i.var2> THEN <label>
\!col1;PAUSE <string>\N
\!col2;RETURN
\!col1;SET <trans1> = <trans2>\N
\!col2;SETI <i.var1> = <i.var2> [<operation> <i.var3>]
\!col1;SHIFT <trans> BY [<dx>],[<dy>],[<dz>]\N
\!col2;SIGON <channel>
\!col1;SIGOFF <channel>\N
\!col2;STOP
\!col1;TYPEI <i.var>\N
\!col2;WAIT <channel>

\!col1;COARSE [ALWAYS]\N
\!col2;FINE [ALWAYS]
\!col1;INTOFF\N
\!col2;INTON
\!col1;NONULL [ALWAYS]\N
\!col2;NULL [ALWAYS]
\!col1;PULSE\N
\!col2;SPEED <i.var> [ALWAYS]

\!col1;COMMNT <string>\N
\!col2;TYPE <string>
\, UN-INCORPORATED NOTES

DPOINT 8 POSITIONS
DONT RECOVER EVERYTHING

LABELS RANGE FROM 0 TO 32767.  JUMPS TO UNDEFINED LABELS DONT GENERATE
ERROR MESSAGES UNTIL RUN-TIME WHEN THE BRANCH IS ATTEMPTED.

USING FREE STORAGE RTNS DURING TOUCH UP MODE MAY AT TIMES CAUSE
SLIGHT TIME DELAYS IN THE EXECUTION OF A PROGRAM THAT IS COMPETING
FOR USE OF THE F.S. RTNS.

PROM CHECKSUM

LISTT DOES PRINT UNDEFINED POSITION VARIABLES.

TOOL # = X,Y,Z,Z ROT
;THIS ROUTINES SETS TOOLX, TOOLY, TOOLZ AND TOOLRT FOR USE BY THE A
;SOLUTION ROUTINES.  IF THE DIMENSIONS OF A TOOL ARE SPECIFIED THE NEW
;TOOL DIMENSIONS ARE SAVED AND THE CURRENT TOOL IS SET EQUAL TO THE
;SPECIFIED DIMENSION.  IF DIMENSIONS OF ZERO ARE SPECIFIED FOR THE TOOL
;OR IF NO DIMENSIONS ARE GIVEN, THE CURRENT TOOL IS SWITCHED TO THE
;DIMENSIONS OF THE TOOL WHICH WHERE PREVIOUSLY SPECIFIED.  THE TOOL
;DIMENSIONS ARE AUTOMATICALLY RESET TO THE DEFAULT VALUES ON POWER UP
;AND BY THE "CLEAR" INSTRUCTION.  THE TOOL INSTRUCTION CANNOT BE GIVEN
;WHICH THE ARM IS BEING DRIVEN UNDER MANUAL CONTROL IN EITHER TOOL OR
;WORLD COORDINATES.
;IF TOOL #0 IS SPECIFIED, THE DIMENSION ARGUMENTS AR IGNORED AND
;THE CURRENT TOOL IS SET EQUAL TO THE DIMENSIONS OF THE DEFAULT TOOL.
\,	      APPENDIX 1: LOADING INSTRUCTIONS

The Absolute Loader can be read in using the high speed reader by
manually entering the following Bootstrap Loader in the LSI via ODT
and starting execution at loc = 57744.

LOCATION 	CONTENTS	
  100		   102		CLOCK TRAP
  102		     2		RTI

   R6		  1000		STACK POINTER

57744		 16701		MOV	57776,R1
57746		    26
57750		 12702		MOV	#352,R2
57752		   352
57754		  5211		INC	(R1)
57756		  5711		TST	(R1)
57760		100376		BPL	.-2
57762		116162		MOVB	4(R1),57400(R2)
57764		     4
57766		 57400
57770		  5267		INC	57752
57772		177756
57774		   765		BR	57750
57776		167770		HSR STATUS WORD


After entering the above instructions, the Bootstrap Loader can be
executed by typing:
			57744G

After the paper tape has been read, the compute will halt at
location 57500 indicating that the Absolute Loader has been
properly entered into memory.  The ARM CONTROL PROGRAM can now
be loaded by typing:
			57500G   OR  P

Once loader, the ARM CONTROL PROGRAM can always be restarted by
typing:
			1000G