COMMENT ⊗   VALID 00018 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00003 00002
C00007 00003	\F1\CMONITOR COMMANDS:  PROGRAM CONTROL
C00017 00004	\F1\CMONITOR COMMANDS:  COMPUTER STATUS AND CONTROL
C00021 00005	\F1\CPROGRAM INSTRUCTION SET
C00028 00006	\!command(REST)
C00033 00007	\F1\CUSER PROGRAM INSTRUCTIONS:  ARM CONFIGURATION CONTROL STATEMENTS
C00036 00008	\F1\CUSER PROGRAM INSTRUCTIONS:  INTEGER VARIABLE AND ASSIGNMENT INSTRUCTIONS
C00039 00009	\!command((SHIFT <trans> BY [<dx>],[<dy>],[<dz>]))
C00040 00010	\F1\CUSER PROGRAM INSTRUCTIONS:  CONTROL STRUCTURES
C00051 00011	\F1\CUSER PROGRAM INSTRUCTIONS:  SPECIAL SWITCH STATEMENTS
C00054 00012	\!command(SPEED <value> [ALWAYS])
C00056 00013	\F1\CUSER PROGRAM INSTRUCTIONS:  MISC. STATEMENTS
C00057 00014	\F1\CEXAMPLE PROGRAM
C00060 00015	\,\F1\CERROR CODES
C00061 00016	\, UN-INCORPORATED NOTES
C00063 00017	\F1\CSUMMARY OF INSTRUCTION SET
C00068 00018	\,	      APPENDIX 1: LOADING INSTRUCTIONS
C00070 ENDMK
C⊗;

\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
files. Files are referred to by six character names, which must begin with a 
letter (A-Z) followed by any combination of letters and numbers.
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(DELETE <file>);
\j[ . *]After requesting confirmation, the specified file is deleted from the disk.\.

\!command(ERASE);
\j[ . *] This routine completely erases the contents of the floppy diskette
and initializes the diskette's file directory information.\.

\!command(FORMAT);
\j[ . *] This command must always  be executed first before a new  diskette
can be  used  for storing  programs  or  data.  It  initializes  the  file
directory and has the effect of  erasing the entire diskette by writing  over
any information that it may contain.\.

\!command(LISTF);
\j[ . *] Types the file directory of the diskette currently loaded in the
mini-floppy disk and prints the amount of space still available for storage.\.

\!command(LOADP <file>);
\j[ . *] Loads the program's contained in <file> into the computer's memory.
If a program already exists which has the same
name as a program contained in the disk file,it will be deleted and replaced by the
program contained on the disk.\.

\!command(LOADT <file>);
\j[ . *] Loads all of the position variables which are contained in the
specified disk file into the computer's memory.  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 <file> = [<program1>],...,[<program7>]));
\j[ . *] Stores up to seven specified programs in <file>. If no program names are
given, all existing programs are saved in the specified file.\.

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

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

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

\!command(DO <program instruction>);
\j[.] The single specified  program instruction is  executed as though  it
were te next step in the  previously executed program.  Thus, this command
can be used for moving the arm (eg.  DO MOVE T1) or altering the  sequence
of program  step  execution (eg.  DO  GOTO  100).  If  no  instruction  is
specified, the previously specified instruction is performed once again.\.

\!command((EXECUTE [<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.  Negative values of <nloop> put the program into a continuous
loop.  If <nloop> is omitted or  zero, the program will be
executed one time.  If <program> is omitted, execution of the last user
program EXECUTE'd 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((NEXT [<program>],[<nloop>],[<step>]));
\j[ . ] Program single step mode.  If any of the three optional  arguments
are specified,  the program  execution is  initiated in  exactly the  same
manner as an EXEC command.  However,
unlike an EXEC command, program execution is halted immediately after  the
first program  instruction  is  completed.  If  all  three  arguments  are
omitted, the next program instruction is executed and then the program  is
again halted.  As with the PROCEED and RETRY commands, NEXT with no arguments can
only be executed after a PAUSE instruction, a non-fatal run-time error, or
after single step execution of the previous program instruction.\.

\!command(PROCEED);
\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 PPOCEED has the effect of skipping over the
WAIT instruction.  If a program is executing but is not in a WAIT loop,
this instruction has no effect.\.

\!command(RETRY);
\j[ . ] As with the PROCEED instruction, this command can be used for
restarting program execution after a  runtime error.
In this case, execution resumes at the previous executed instruction
step.  This allows the user to RETRY a step that may have been
aborted.\.

\!command(SPEED <value>);
\j[ .  *] Alters  the speed  at which  all subsequent  program  controlled
manipulator motions are executed.  The speed at which a particular  motion
will execute is approximately related to the product of the speed set  by
this monitor command  and the speed  set by a  program speed  instruction.
The <value> of the  speed can range  from .01 (very  slow) to 327.67  (very
fast) where 100.00 is normal speed.  As an example, if the monitor  speed
command is 50.00 and the program instruction speed is 60.00, the arm  will
move at approximately 30% of its normal speed.\.

\J\N
When a program terminates execution due to a PAUSE or STOP statement or
from any one of a number of runtime 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 AND CONTROL

\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(CALIB);
\j[ . ] This command is used in the Unimate 500 robot system to  calibrate
the joint position sensors.  The arm must be  calibrated whenever the  arm
controller power is  switched on.  Although the  system can  be run  under
manual or program control while  uncalibrated, it is recommended that  the
CALIB instruction be executed as soon after power-up as possible.\.

\!command(DONE);
\j[ . ] MONITOR program stops, computer exits to ODT. The program can be
started by starting execution at location 100000 by typing 100000G. \.

\!command(ENABLE <switch> or DISABLE <switch>);
\j[ . *] These  commands are used  for turning on  and off special  system
hardware features.  At present,  the only switch  defined is "HHT".   This
switch is used for  enabling and disabling the  output of special  control
characters which are  necessary for  the operation of  the Unimation  Hand
Held Terminal.  For terminals other than the HHT, these control characters
will normally not affect the output display.\.

\!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 and subroutine step
currently being executed, the speed set by the monitor SPEED command,
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(ZERO);
\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.\.
\,
\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 seconds, 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>],[<speed>]));
\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. The specified speed supersedes
any previously executed SPEED program instruction.\.

\!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.\.

\,
\!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>);
\jFor 2-state hands  these instructions  are used  without the  <distance>
argument to either OPEN or CLOSE the hand during the execution of the next
motion instruction.  For proportional  hands, these instructions  change
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>);
\jFor 2-state  hands  these  instructions without  a  <distance>  argument
either open or close the hand immediately. For proportional hands OPENI or
CLOSEI perform the same change in hand opening as an OPEN or CLOSE but the
operation is performed immediately instead of waiting for the next  motion
instruction.\.

\!command((GRASP <distance>,[<label>]));
\jFor proportional hands only, this instruction closes 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 seconds.\.

\!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, MOVE, or APPRO 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 variables 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 is 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 <point1> = <point2>);
\jThe value of point 1 is set equal to the value of
point 2.  If the position and orientation of point 2 
are 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. In what follows, <channel> is used to designate one  of
the external signal  input or  output lines.   <channel> can  be either  an
integer number or an integer variable.  The absolute value of <channel> is
used to specify a particular signal line.  The magnitude of <channel> must
be between 1 and N, where N is the number of hardware interlocks  provided
with the system.  For certain instructions, the sign of <channel> is  used
to specify high  and low signal  values.  In these  instances, a  positive
<channel> value indicates a high signal  and a negative value indicates  a
low signal.\.


\!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 [<skip count>]);
\jTerminates execution of the current  user program and resumes  execution
of the last suspended  program. The suspended  program resumes running  at
<skip count>+1 number of steps  following the executed GOSUB  instruction.
Hence, if  the  skip count  is  omitted or  a  count of  0  is  specified,
execution resumes at the instruction following the executed GOSUB.  If the
subroutine started execution due to the triggering of a REACTI  statement,
a skip count  of 1  can be  used to  resume execution  of the  interrupted
routine without re-executing  the interrupted program  step.  Executing  a
RETURN in the main  program produces the same  effect 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((IFSIG <channel>[,<channel>][,<channel>][,<channel>] THEN <label>));
\jIf the states of the external signals exactly match the specified signal
states, the  program  branches to  the  program instruction  specified  by
<label>.  Otherwise,  if any  mismatch is  detected, the  next  sequential
program step is executed.  The  <channel>s are specified as signed  values
to indicate if each  test is to  be made for a  high or low  signal.  Omitted
channel numbers or channel numbers with a value of zero always satisfy the
matching test.\.

\!command(IGNORE <channel>  [ALWAYS]);
\jDisables the  triggering of  the REACT  or REACTI  instruction which  is
associated with  the  specified external  signal  channel.  If  ALWAYS  is
specified, the reaction  is permanently disabled  until completion of  the
next motion statement.  The value of <channel> must always be greater than
zero.\.

\!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.
Only positive values of <channel> are permitted.\.

\!command((REACT <channel>,[<program>] [ALWAYS]));
\jThis instruction  initiates the  continuous monitoring  of the  external
signal specified by <channel>.  If a high value  is detected, the  program
reacts by altering the sequence in  which the following program steps  are
executed. The reaction is equivalent to performing a "GOSUB <program>"  at
the completion of  the program step  folllowing the first  occurance of  a
high signal value.
If ALWAYS is specified, the  signal monitoring is active until  either
an IGNORE statement  is executed or  the reaction is  triggered (in  which
case the  equivalent  of an  "IGNORE  <channel> ALWAYS"  is  automatically
performed).  If ALWAYS is omitted, the  signal will only be checked  until
the completiion  of  the next  arm  motion instruction.   If  <program> is
omitted, the program step  following the first occurance  of a high  value
will be  skipped and  execution will  continue at  the following  program
step.  Only one REACT or REACTI command can be associated with any channel
at any given time.\.

\!command((REACTI <channel>,[<program>] [ALWAYS]));
\jLike REACT, this instruction initiates the continuous monitoring of  the
external signal specified  by <channel>.   However, in this  case, when  a
high value is detected, the  current instruction is immediately aborted
and the equivalent of a "GOSUB <program>" is executed. The subroutine call
to <program> is performed such that if a 
"RETURN 0" is used  to exit from <program>,  the
interrupted program step will be executed once again.  In order to  return
control to the interrupted  program and to skip  the furthur execution  of
the interrupted step, a  "RETURN 1" must be  used to exit from  <program>.
If <program> is omitted, when a high signal on <channel> is detected,  the
current program step is immediately  aborted and the next sequential  step
is executed.  The optional argument ALWAYS and the IGNORE instruction have
exactly the same effect  on REACTI as they  do on the REACT  instruction.
Only one REACT or REACTI command can be be associated with any channel  at
any given time.\.

\!command(SIGOFF <channel>);
\jTurns off the signal to the device attached to the specified output channel.
Only positive values of <channel> are permitted.\.

\!command(WAIT <channel>);
\jThe program  is put  into a  wait loop  until the  proper sense  of  the
external signal  specified by  <channel>  is detected.   Positive  channel
numbers indicate  waiting  until the  external  signal goes  true  (high).
Negative channel numbers indicate waiting until the signal is false (low).
A signal wait loop can be aborted by using the monitor PROCEED command.\.

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

\!command(STOP);
\jSame as PAUSE except that the program cannot be continued unless
more program loops were specified at the time that program execution was
initiated (see EXECUTE command).\.

\,
\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, some 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 [ALWAYS]);
\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 [ALWAYS]);
\jForces the hardware to integrate the position error throughout the next
motion.\.

\,
\!command(SPEED <value> [ALWAYS]);
\jRequests that the next arm motion be performed at a speed other than
normal (=100).  The speed can range from .01 (extremely slow) to
327.67 (extremely fast).\.

\!command((TOOL <tool#> = [<dX>],[<dY>],[<dZ>],[<rZ>]));
\jChanges the  current arm  tool  to <tool#>  and optionally  changes  the
dimensions of <tool#>.  See monitor instruction "TOOL" for a description of the
effect of this instruction.\.


\,

\F1\CUSER PROGRAM INSTRUCTIONS:  MISC. STATEMENTS


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

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

\F1\CEXAMPLE PROGRAM


\F3\J\N
Writing an example program named DEMO1 to pick up an item at point PICK and place it at
point PLACE.\.


.EDIT DEMO1			User types this in to start editing program DEMO1.
EDITING DEMO1			VAL response

1.	OPEN				Open hand during next motion.
2.	APPRO PICK, 50		Approach to 50 mm away from point PICK.
3.	SPEED 30			Slow down to 30% speed for next move only.
4.	MOVE PICK!			Move to point PICK.  Current arm position is point PICK.
5.	CLOSEI			Close hand now, before next motion.
6.	DEPART 70			Move 70 mm away along hand vector.
7.	APPROS PLACE,75		Move in straight line to 75 mm from point PLACE
8.	SPEED 20			Slow down to 20% speed for next motion only.
9.	MOVES PLACE		Move in straight line to point PLACE.
10.	OPENI 			Open hand before next motion.
11.	DEPART 50			Retract 50 mm. away from point PLACE.
12.	E				Exit from editor, program is completely written.


\F3\J\N
One way of entering the point PLACE.\.

.HERE PLACE			Typing this tells VAL to make the current position of the arm point PLACE.

	
X		Y		Z		O		A		T

300.25	-56.82	105.00	58.44		125.30 	90.00


CHANGES?				VAL asks if operator wishes to make any typed in changes. 
.					A carriage return signifies no changes desired.


Running program DEMO1.	First at 50% speed to see everything is right.

.Speed 50
.EXEC DEMO1,3			Executes DEMO1 3 times at 50% speed.

STATUS				Using background mode to check status while arm is running.
   .	
   .
   .
   .

PROGRAM COMPLETED		VAL says its done ...back to monitor mode.
.SPEED 100				Now run at 100 % speed.
.EXEC ,50				50 times through DEMO1 at 100% speed.



\,\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.\.
\, 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.
\F1\CSUMMARY OF INSTRUCTION SET

Monitor Instructions\F5

\!col1;Base [<dX>],[<dY>],[<Z rotation>]\N
\!col2;DIRectory
\!col1;EDit [<program>],[<nstep>]\N
\!col2;DPoint [<position1>],...[<position8>]
\!col1;LISTP <program>,[<step1>],[<step2>]\N
\!col2;Here <position>
\!col1;POint <position1> [=<position2>]\N
\!col2;LISTT [<position1>],...,[<position8>]
\!col1;Tool <tool#> = [<dX>],[<dY>],[<dZ>],[<rZ>]\N
\!col2;Where

\!col1;DElete <file>\N
\!col2;ERase
\!col1;FOrmat\N
\!col2;LISTF
\!col1;LOADP <file>\N
\!col2;LOADT <file>
\!col1;STOREP <file>= [<program1>],...,[<program7>]\N
\!col2;STORET <file>

\!col1;Abort\N
\!col2;CAlib
\!col1;DISable <switch>\N
\!col2;DO <program instruction>
\!col1;DONe\N
\!col2;ENable <switch>
\!col1;EXec [<program>],[<nloop>],[<step>]\N
\!col2;FRee
\!col1;Next [<program>],[<nloop>],[<step>]\N
\!col2;PRoceed
\!col1;Retry\N
\!col2;SPeed <value>
\!col1;STAtus\N
\!col2;Zero

\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; \N
\!col2;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>],[<speed>]
\!col1;MOVES <position> [!]\N
\!col2;OPEN <dist>
\!col1;OPENI <dist>\N
\!col2;REAdy

\!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;IGnore <chan> [ALways]\N
\!col2;IFSig <chan>[,<chan>][,<chan>][,<chan>] THEN <label>
\!col1;PAuse <string>\N
\!col2;REACT <chan> [,<prog>] [ALWAYS]
\!col1;REACTI <chan> [,<prog>] [ALWAYS]\N
\!col2;RETurn <skip count>
\!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 [ALWAYS]\N
\!col2;INTON [ALWAYS]
\!col1;NONull [ALWAYS]\N
 !col2;NUll [ALWAYS]
\!col1;SPeed <value> [ALWAYS]\N
\!col2;TOol <tool#> = [<dX>],[<dY>],[<dZ>],[<rZ>]

\!col1;REMark <string>\N
\!col2;TYPE <string>
\,	      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