perm filename UNI2.X[V,VDS] blob sn#411687
filedate 1979-01-18 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00018 PAGES
C REC PAGE DESCRIPTION
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
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.\.
\j[ . *]After requesting confirmation, the specified file is deleted from the disk.\.
\j[ . *] This routine completely erases the contents of the floppy diskette
and initializes the diskette's file directory information.\.
\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.\.
\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.\.
\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.\.
\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.\.
\j[ . *] Stores the names and values of all defined position variables
in the specified floppy disk file.\.
\F1\CMONITOR COMMANDS: PROGRAM CONTROL
The following commands are used for executing and stepping through
\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.\.
\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.\.
\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.\.
\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.\.
\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
\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.\.
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
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.\.
\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.\.
\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.\.
\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
\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
\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
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
\!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 [!].\.
\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
\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.\.
\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
\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.\.
\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
\!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
\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.\.
\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
\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
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,
\!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)
\F1\CUSER PROGRAM INSTRUCTIONS: INTEGER VARIABLE AND ASSIGNMENT INSTRUCTIONS
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
\jTypes the value of the integer variable <i.var>.\.
\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
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
\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
\!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
\!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
\!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
\jPerforms an unconditional branch to the program step specified by
\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.\.
\jTurns off the signal to the device attached to the specified output channel.
Only positive values of <channel> are permitted.\.
\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.\.
\jTerminates execution of a user program and types the message <string>. Execution
can be continued from this point by typing PROCEED.\.
\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.\.
\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.\.
\jOpposite of the COARSE instruction. This is the default state of the
\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.\.
\jOpposite of the NONULL instruction. This is the default state of the
software control system.\.
\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.\.
\jForces the hardware to integrate the position error throughout the next
\!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
\jComment line, a no-operation at run-time.\.
\jTypes the message <string> on the console terminal.\.
Writing an example program named DEMO1 to pick up an item at point PICK and place it at
.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.
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.
.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.
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.
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
;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
\!col1;Base [<dX>],[<dY>],[<Z rotation>]\N
\!col1;POint <position1> [=<position2>]\N
\!col1;Tool <tool#> = [<dX>],[<dY>],[<dZ>],[<rZ>]\N
\!col1;STOREP <file>= [<program1>],...,[<program7>]\N
\!col2;DO <program instruction>
\!col1;<any program instruction>\N
\!col1;R [<arg#>],[<new value>]\N
\F1User Program Instructions\F5
\!col1;APPRO <position>[!], <dist>\N
\!col2;APPROS <position>[!], <dist>
\!col1;GO <position> [!]\N
\!col1;MOVE <position> [!]\N
\!col1;MOVES <position> [!]\N
\!col2;IF <i.var1> <relationship> <i.var2> THEN <label>
\!col1;IGnore <chan> [ALways]\N
\!col2;IFSig <chan>[,<chan>][,<chan>][,<chan>] THEN <label>
\!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
\!col1;SPeed <value> [ALWAYS]\N
\!col2;TOol <tool#> = [<dX>],[<dY>],[<dZ>],[<rZ>]
\, 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.
100 102 CLOCK TRAP
102 2 RTI
R6 1000 STACK POINTER
57744 16701 MOV 57776,R1
57750 12702 MOV #352,R2
57754 5211 INC (R1)
57756 5711 TST (R1)
57760 100376 BPL .-2
57762 116162 MOVB 4(R1),57400(R2)
57770 5267 INC 57752
57774 765 BR 57750
57776 167770 HSR STATUS WORD
After entering the above instructions, the Bootstrap Loader can be
executed by typing:
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