insert a line
add to all - this will add the same value to all the lines at once, useful for shifting an entire route up or down.
Typical editing dialog: 
Typing the name of the route makes it the currently active route.
All commands thereafter such as LISTROUTE, RUN, LINE, GOTO, LEARN, REPLACE, DELETE, RETRACE etc.
will apply to the currently active route and no other route.
To see which route is currently active enter:-
WHICH TEST1 ABSOLUTE OK
The routes window lists all the routes created so far or in the command window enter:-
ROUTES
nnnn 6 TEST2 nnnn 9 TEST1
2 words
OK
The "nnnn n" in the above are the RAM address and lengths of each
word in the dictionary. See VLIST under INFORMATION.
Editing in the comms window alone
The route window provides all necessary editing buttons. However if you use any of the following commands they will change data in the controller but not in RobWin. To update RobWin click on 
LEARN adds one line to the route with the current position of the robot.
RLEARN adds one line to the route with the last relative move of the robot.
(n) DELETE deletes the line number (n) and moves all the following lines down one.
(n) INSERT moves all lines from (n) up one and inserts a new line (n) with the current co-ordinates of the robot.
INSERT may produce a FULL error even when no recent entities have
been added, in which case reserve more space with (n) RESERVE.
(n) REPLACE
replaces the co-ordinates of line n with the current co-ordinates of the robot. This command can also be used in user's software (new definitions).
You would not normally use any of the above commands while using RobWin as RobWin sends these commands when you click the various buttons.
However (n) REPLACE is often used within a program to self-learn a particular position, for example by computation or to synchronize the end of one route with the start of another. See below and example in section 12.
ERASE erases the entire list.
UNLEARN deletes the last line learned.
STARTOVER restores the NEXT
pointer to the start of the memory block. This would be disastrous for any
entities which had been created. If no entities have been created
then it is OK to use STARTOVER. Normally STARTOVER and ROBOFORTH
are used together. ROBOFORTH clears out all the user's words from
the dictionary requiring a fresh load from the text file.
RTYPE changes the type of route (e.g. JOINT or CARTESIAN) to the current mode (e.g. CARTESIAN or JOINT).
A list of co-ordinates is not necessarily to be RUN in sequence. It can also be used as an array or matrix of positions for example a grid of test tubes. See Matrices. To access the data in individual lines:
(n) LINE returns the memory address of the data in line (n).
This address is suitable for words like GOTO and ASSUME. e.g.
(n) LINE GOTO
GOTO requires the address of some positional data. If you leave
out LINE then GOTO assumes the argument is a line number and finds the data e.g.
(n) GOTO
Click 'goto' on the route window.
For ASSUME the syntax is (n) LINE ASSUME
For VIEW the syntax is VIEW LINE (n)
To run the route type RUN
Segmented mode only: To introduce a delay into the program highlight the line before which you wish to insert the delay and click 'insert func'. In the dialog box enter the word MSECS and in the lower space enter the number of milliseconds to pause. Click the space after the last line to 'insert' the delay onto the end of the route.
To abort the route while it is running press ctrl-C - the robot will stop
after executing the current line. The stop button stops the robot
immediately. The line at which the route aborted is contained in
the variable LINE#. Inspect with LINE# ?
FIRST# and LAST# are variables containing the first and last
lines to be RUN (set by SEQUENCE).
MOVES is a pseudo-variable i.e. a routine which behaves like a variable and contains
the total number of lines in the list or route. e.g.:
MOVES E@ .
The address left by MOVES is in high memory so must be accessed with E@ and E!
Example use to self learn the last position in a route:
MOVES E@ REPLACE
or just LASTLINE REPLACE
See example in section 12.
To have the gripper operate during progress of the program first enter GRIP or UNGRIP as appropriate to immediately operate the gripper then 'insert func' GRIP or UNGRIP. Leave the value at 0.
In Cartesian mode LEARN learns the Cartesian co-ordinates instead
of the joint co-ordinates. The same applies to REPLACE and INSERT.
However, you can force the system to learn the joint co-ordinates
instead with:
JL
Likewise a line containing any kind of data may be replaced with joint co-ordinates with
JR
Then upload the data to the computer with
7.3.2 PUTTING FORTH WORDS INTO ROUTES
( "TICK" COMMANDS )
It is possible during the progress of a route to have the controller execute a FORTH program or "word" for example GRIP and UNGRIP, MSECS, changes in SPEED or other variables, or user defined words.
Use insert func
For example, to insert a 5 second delay:
or a speed change
You can also insert words you have defined.
Example Forth word to make the robot wait until an object is
present to be picked up, indicated by bit 7 of port PB going to a
logical '1':-
: PRESENT BEGIN PB 7 BIT? UNTIL ;
Then click insert func and enter PRESENT
In the comms window or hyperterminal you can type 'LEARN PRESENT
However it is not a good idea to 'INSERT (insert func) or 'LEARN (append function) words which you have created because your word is looked up in the dictionary and it's code field address (CFA) is compiled into the route. This is then executed when that line is reached (using the word EXECUTE). In Forth this is known as "vectored execution ". This address could change if you edit the text file rendering the address in the route invalid and the system will crash (and probably the robot as well). You would have to edit all occurrences of your word using edit line. Therefore stick to words in ROBOFORTH. Any ROBOFORTH words can be inserted as functions, leaving the argument (value) at zero. Words which can have values are: MSECS GRIPPER SPEED SETPA
If you must use new definitions and subsequently re-compile a number of words from the editor so that the address of the word changes then a better practice is to put the line 'REPLACE (word) in your text file to re-install the correct CFA each time the text file is reloaded. Don't forget to precede it with the name of your route or it will be put in the wrong route e.g. if the route is called PATH1 and you have your function in line 2 then enter
PATH1 2 'REPLACE PRESENT
If you wish to update the listing in RobWin then click the red up-arrow
WARNING: If you remove or FORGET a word which you have 'LEARNed or 'insert func' into a route then you must also DELETE the line in the route which holds it. Otherwise you will leave an invalid address in the route to be executed and the system will crash.
Note that most words can not be inserted into a route that is intended to run in CONTINUOUS (or SMOOTH) mode. For example you can't use MSECS because a continous path route is meant to be continuous and not held up part way through. So you can only insert words (functions) that take no time and are recognized by the DSP for example GRIPPER or SETPA.
AGAIN
In the comms window or hyperterminal you can type 'LEARN AGAIN
or click insert func and enter AGAIN
To repeat a route in CONTINUOUS mode use REPEATS.
This simply repeats the route from the beginning again. It only works in SEGMENTED mode. It never ends until you stop it with control-C
The default value of REPEATS is 0.
1 REPEATS ! gives you 1 repeat or two complete runs. n REPEATS ! gives you n+1 complete runs.
There are restrictions in using this feature, see 7.3.5
ROW
Click new in routes window; in route create box click row. Then enter the number of points in the row in the columns box. Make sure the number of lines reserved is at least 1 greater than the number in the columns box. Move robot to first position, click the first line in the route window and click set-to-here. Then move robot to last position in the row, click the last line in the route window and click set-to-here. Finally press interpolate.
The number of positions in the row is held in the variable POSNS
GRID
This sets up a 2-dimensional array.
1. Click new in routes window; in route create box click grid. Select whether the numbers should be JOINT or Cartesian co-ordinates. Almost certainly joint mode will be meaningless unless you are using a Cartesian robot so select Cartesian mode. Then enter the number of rows and columns. Make sure the number of lines reserved is at least 1 greater than rows times columns. There's plenty of space so just reserve plenty. It is possible to increase this later if necessary.
2. Guide robot to the first position in the matrix, that will be row 1 column 1. Highlight line 1 (which has an asterisk next to it) and press set-to-here
3. Guide robot to the end of the last column, row 1 i.e. the next corner of the matrix. Highlight the next line with an asterisk and click set-to-here
4. Guide robot to the last position i.e. last row last column. Highlight the last line (which has an asterisk) and click set-to-here
5. Click interpolate.
Image: dialog box showing creation of a new matrix TRAY in Cartesian mode, 3 columns by 9 rows.
Using the 4-point feature: in some cases the 4th corner (and related points distant from the 3 corners) may be slightly out due to errors in the tray or the robot. Guide the robot to the 4th corner, position carefully and click the line marked i4 and set-to-here. Then click interp. 4pt.
The number of positions in each row of the GRID is held in the variable POSNS. The number of rows is in ROWS.
A number of words are provided to work with ROWs and GRIDs. They all require an extra line added to the list which contains a relative (type R) co-ordinate which is added to any line to make an approach position for every line. This line is always the last line and the address of the data is data is MOVES E@ LINE
You can create this approach position as follows:
1. Guide the robot to one of the target positions (one of the lines). The robot might already be there after learning the third corner.
3. Command the robot to an approach position using a Cartesian MOVE or use JOG. For example a vertical movement on Z alone might suffice for a position over a test tube rack.
4. Press set aproach
Once the relative position, line n+1 has been learned a number of other words may be used:
(n) NEAR
This sends the robot to the approach position for line (n) obtained by ADDing the co-ordinates in the last (type R) line to the co-ordinates of line (n).
(n) NEARAD
This looks up the memory address of the near position and leaves it on the stack. It does nothing otherwise. NOTE in v10.0 and below this command actually sent the robot to the near position. The new form of this command:
TRAY (n) NEARAD AXES
extracts the coordinates of the near position to WHERE
It may be useful for tail-ending other routes. For example suppose you have a matrix route TRAY with an approach position and another route PATH to get you to the general area of the tray from somewhere else. You can amend the last line of PATH so the robot finishes up at the required near position of the tray. The command string would be:
TRAY (n) NEARAD AXES PATH LASTLINE REPLACE or
where TRAY is the name of the matrix route, (n) is the position within that matrix you want to go to. NEARAD produces the address of the approach position of line (n) and AXES extracts the Cartesian co-ordinates of that approach position into the variables X Y Z W etc. Next PATH invokes the route which gets the robot there. LASTLINE leaves the line number of the last line of that route on the stack and REPLACE replaces that (last) line with the co-ordinates in the variables X Y Z W etc. extracted from the NEAR position of TRAY. So to get smoothly from the starting position of PATH to, say position 5 of TRAY you could use this sequence of commands.
TRAY 5 NEARAD AXES
PATH LASTLINE REPLACE RUN
TRAY 5 GOTO
or a generic word to take the line number off the stack:
: GOTRAY
DUP ( needed by NEARAD and GOTO
TRAY NEARAD AXES
PATH LASTLINE REPLACE
RUN
TRAY GOTO
;
usage
(n) GOTRAY
NOTE in version 13.65 up the command CARTASSUME may be used in place of AXES as it is semantically similar to ASSUME
(n) INTO
This sends the robot to line (n) of the row or grid via the approach position.
DOWN
Moves the robot from the approach position to the target position - use only after (n) NEAR.
UP
Moves the robot up from the target position to the approach position. (Actually moves the robot up from any position!)
Before using any of the above words the route to which they refer must be selected. If in doubt enter the name of the route again; Remember to use the route name in any definitions.
An example of how to use these commands.
Suppose you were taking parts from a TRAY and putting them on a BELT
: EMPTY-TRAY
TRAY
MOVES E@ 1 DO
I INTO
GRIP
UP
BELT
UNGRIP
LOOP
;
Note the use of MOVES E@ above. In the first place MOVES is one more than we need, being the number of the line with the RELATIVE position. In the second place, due to a Forth idiosyncracy DO LOOPs require one more than the actual number of loops, e.g. 9 1 DO LOOP will do 8 loops not 9. Remember also that MOVES is in high memory so must be read with E@ not just @
A route may be used to generate an almost continuous path. For this the CPU passes all the route data to the DSP line by line and the DSP executes the motion without the CPU being involved (see later, three phases of operation). Learn a route as normal but to RUN it first enter
CONTINUOUS
to put the system into continuous path mode.
SMOOTH is an identical command that includes ADJUST (v11 up) (see 7.3.5)click 
Then when you type RUN
the robot will run through all the points without stopping. The CPU waits for the DSP to finish driving the robot before control comes back to the user or the software moves to the next word.
To run the route backwards enter
RETRACE
To cancel CONTINUOUS mode enter
SEGMENTED
which returns motion to line by line mode.
The speed in continuous path mode is determined by the variable SPEED. A value of 1000 is a low speed, 10,000 is a high speed. Highest possible is 65535 but of course the robot may not physically be able to do that. Acceleration is determined by the variable ACCEL 100 is very low acceleration, 5000 would be a high acceleration. Acceleration may not be reached if the value of JERK is too low. For highest throughput increase both ACCEL and JERK.
The route may contain contain joint or Cartesian values.
To change speed within the route go to the route box and highlight the required line before which the speed must change. Click 'insert func' then enter SPEED in the dialog box and the required speed below it.
To turn the gripper on or off within the route go to the route box and highlight the required line at which the gripper should operate. Click 'insert func' then enter GRIPPER in the dialog box and the value 1 below it to turn it on, or 0 to turn it off. You cannot use the word GRIP which only works in segmented mode.
STOP BUTTON:
If the stop button is pressed while a continuous path is running then the entire route is abandoned even if the stop button does not itself cause an abort (i.e. re-programmed with STOPVEC). The task programmed into STOPVEC will be executed but the run will not resume and the next word will be executed.
When a route is run in continuous path mode the DSP computes the
required speed for each motor to get from present count to the
counts in the next line. The path between one line and the next
is called a segment. The speed for a given motor will be
different in one segment from the next. To change speed from one
segment to the next the DSP computes a ramp using the values of
ACCEL and JERK. If the motor cannot reach the required speed before the
next segment comes up then an error message
"Too tight, line (n)" is issued and the system aborts with error 22. This means one
motor cannot get from current speed to the computed speed within
the segment.
This programmed path comprises 2 right-angle turns. The DSP rounds off the corners according to the acceleration programmed. A high value for ACCEL means a tighter turn (smaller radius). In the above the robot is able to change direction by 90 degrees and back again in the space between lines 2 and 3.
In the above lines 2 and 3 are too close together. The DSP obviously cannot round off both corners so the CPU issues the message "too tight, line 3". Only if ACCEL is increased (and JERK if that is the limitation) i.e. reduce the radius of the two curves can the robot make it round both corners. If SPEED is reduced this has the same effect i.e. smaller radius.
For similar mathematical reasons if the distance between lines 1 and 2 is too short then the DSP can not get the robot up to set speed before the first change of direction so would issue the message "too tight line 2". Similarly if lines 3 and 4 are too close the message would be "too tight line 4".
The fix is to reduce the value of SPEED or increase the
acceleration ACCEL. The route is tested first so that the error
does not occur while the robot is in motion and if there is no
such error in the route then the route is run. You can test the
route yourself with the command
DRY RUN
There are 3 modes of RUN. After a DRY RUN, CONTINUOUS is re-asserted. In CONTINUOUS mode RUN automatically does a dry run first to make sure settings are valid. In NOCHECK mode (not R19) a dry run check is not performed. The reason for this is that for a very long route a CONTINUOUS RUN takes a significant time resulting in a delay before the robot moves whereas a NOCHECK RUN moves the robot immediately. Lines in a very long route queue up. It is up to the user to ensure that SPEED, ACCEL and JERK settings are valid before a NOCHECK RUN. If not the results can be catastrophic.
There exists the possibility to reduce the speed of a route automatically and temporarily with the command
ADJUST (then RUN)
or
SMOOTH selects continous mode then does ADJUST e.g.
(route-name) SMOOTH RUN
Note that this command will not work if there is a SPEED command
embedded in the route. The system will hang and you will
have to press the escape key to get the system
back. In this case ERR value will be 23 (See section 11.2).
When ADJUST is used the value of SPEED is reduced until a workable value is found. However the original SPEED is saved. You can restore the original speed with
RESTORE
Note that the DSP only uses joint counts. If the route is a Cartesian route and all the lines are Cartesian the system converts each line to joint counts before sending to the DSP. If the route is very long then this can take some time and there will be a short pause before motion. If ADJUST or SMOOTH are used then the delay can be significant because the entire route must be converted and sent to the DSP several times to get a working speed. This delay can be dramatically reduced by converting the whole route to joint coordinates first with the command
CONVERT
After this command all the lines in the route will be joint coordinates however the display in RobWin will still be in the original Cartesian coordinates and can still be edited as Cartesian coordinates.
CONVERT is part of V16 up. If your system does not have it you can add it to your project ed2 window (section 7) as follows:
: CONVERT
LASTLINE 1+ 1 DO
I LINE EXAD E@ 2 = IF
I LINE AXES
TRANSFORM I LINE 16 MOVUP
THEN
LOOP
;
Looping a route: A route can be made to repeat from the beginning without stopping using the user variable REPEATS. (v17.3 up only)
The default value of REPEATS is 0.
1 REPEATS ! gives you 1 repeat or two complete runs. n REPEATS ! gives you n+1 complete runs.
IMPORTANT As explained above the system doesn't work well if the coordinates in two successive lines are too close together. It doesn't work at all if two successive lines are identical. In the case of REPEAT make sure the last line is not the same as the first line or they are effectively successive and identical and the robot will stop with error 33. It is a good idea to add a line that is identical with the first line, then use SMOOTH or ADJUST to find an ideal speed, then delete the last line again then run with REPEATS using the value for SPEED that was recommended by SMOOTH or ADJUST.
REPEATS can not be used with SEQUENCE or RETRACE.
7.3.6 Controlling outputs in continuous path
Besides the gripper other output bits may also be operated by inserting the function SETPA with other values:
Words that you embed must be complete before the next embedded word or the end of the route. For this reason RoboForth permits quickly passing the embedded value to the output port.
SETPA 3 - turns on PA 0 (gripper) (note you can not control an electric gripper with this.)
SETPA 2 - turns off PA 0
SETPA 5 - turns on PA 1
SETPA 4 - turns off PA 1
SETPA 7 - turns on PA 2
SETPA 6 - turns off PA 2
SETPA 9 - turns on PA 3
SETPA 8 - turns off PA 3
SETPA 11 - turns on PA 4
SETPA 10 - turns off PA 4
SETPA 13 - turns on PA 5
SETPA 12 - turns off PA 5
SETPA 15 - turns on PA 6
SETPA 14 - turns off PA 6
SETPA 17 - turns on PA 7
SETPA 16 - turns off PA 7
Note these functions only work with RUN not with CRUN - see three phase operation below.
To incorporate these functions into a route using RobWin click append function (or insert function), enter SETPA then in the box below enter the number from the above list. Never make the function as line 1; line 1 must always be a position.
Suppose you have a glue gun on PA 0 (the gripper line), a route with 10 lines and wish to turn on the gun at line 2 and off at line 8:
Click line 2 then insert function. Enter 3 as a value. Click line 9 (was line 8 before line 2 was inserted) and insert function, use 2 as a value.
?RUN
This leaves a value on the stack as follows:
0 - DSP is idle
1 - DSP is running a route
2 - DSP has read a line GRIPPER 0 which means turn off gripper
3 - DSP has read a line GRIPPER 1 which means turn on gripper
4 - DSP has read a line SETPA 4 which means turn off PA 1
5 - DSP has read a line SETPA 5 which means turn on PA 1
6 - DSP has read a line SETPA 6 which means turn off PA 2
7 - DSP has read a line SETPA 7 which means turn on PA 2
8 - DSP has read a line SETPA 8 which means turn off PA 3
9 - DSP has read a line SETPA 9 which means turn on PA 3
10 - DSP has read a line SETPA 10 which means turn off PA 4
11 - DSP has read a line SETPA 11 which means turn on PA 4
12 - DSP has read a line SETPA 12 which means turn off PA 5
13 - DSP has read a line SETPA 13 which means turn on PA 5
14 - DSP has read a line SETPA 12 which means turn off PA 6
15 - DSP has read a line SETPA 13 which means turn on PA 6
16 - DSP has read a line SETPA 12 which means turn off PA 7
17 - DSP has read a line SETPA 13 which means turn on PA 7
All values for SETPA and ?RUN from 18 to 255 are available to operate other functions in advanced programming.
For example if you absolutely must operate a word that takes time to operate (for example GRIP for an electric gripper) you can use the higher values. The embedded word is still SETPA but you can write a word to read back the value and operate your time-using word. Put that word in the vector DSPVEC. The executable value in DSPVEC is execute repeatedly during RUN.
For example to do GRIP and UNGRIP on the fly you could use values 18 and 19:
: XGRIP
?RUN 18 = IF
PA 0 BIT? 0= IF GRIP THEN
THEN
?RUN 19 = IF
PA 0 BIT? IF UNGRIP THEN
THEN
;
: START
START
SET DSPVEC XGRIP
;
Since the value from SETPA remains until the next line of the route we need the PA 0 test so we only operate the gripper once.
7.3.7 Advanced commands
CRUN
WARNING If you use this command the robot will not stop when you press the stop button. To stop the robot execute the command STOP.
WARNING If the value of SPEED is invalid the robot will go out of control. Always test the route first with RUN or DRY RUN and reduce speed, increase acceleration or use ADJUST (7.3.5) if necessary.
CRUN passes the route data to the DSP but does not wait for it to finish. If the route is short enough control passes straight back to the CPU i.e. you will get OK or the next word will be executed while the DSP is still running the robot. If the route is a long one then the CPU will be held up for a while. CRUN ought not be used with routes that contain SETPA or GRIPPER commands because the CPU must remain monitoring the DSP to get these commands as they arise. When the robot has stopped WHERE will show the robot to be still where it was before you executed CRUN therefore you must, as soon as robot motion finished, or at worst before you execute the
next command, execute
DSPASSUME - this reads back from the DSP the position the robot got to when it was stopped and changes the counts to the correct values.
To determine if the DSP has finished use EITHER:
1. ?STOP - this traps until the DSP has stopped.
It also checks the stop button and stops the DSP prematurely if pressed. As long as the CPU is in command mode or executing some other command the stop button is ignored.
If the stop button is pressed while executing ?STOP then a flag FSTOP is set to a '1', see below.
OR
2. ?RUN
This leaves a value on the stack as follows: 0 - DSP not running, 1 - DSP running a route, 2 or more - controlling an output; see SETPA, 7.3.6
Three phases of operation
A DSP controlled RUN may proceed in three phases. In the first phase the CPU is downloading positions (route lines) to the DSP. The DSP fills up a buffer with a capacity of about 50 lines. If there are not enough lines to fill the buffer then once all the lines are downloaded then the robot begins to move. If there are more lines than the buffer can hold then when the buffer is full the robot begins to move and while the DSP is moving the robot it gradually empties the buffer. After each line is executed space is freed and the next line is downloaded into the DSP. When there are no more lines to download the second phase ends. Then the CPU enters phase 3, a loop simply monitoring the DSP waiting for it to finish by polling for a motion complete flag. RUN finishes only when all motion is finished. If CRUN is being executed it (CRUN) finishes after phase 2 when there are no lines left to download. At this point there could be up to 50 lines in the DSP buffer so the robot will carry on moving, but the CPU will either be waiting for a command or executing the next word in the definition.
During the first phase (loading buffer) no other activity takes place. During the second and third phases ?GRIP is executed which transfers SETPA or GRIPPER flags to the PA output port. Therefore if you use CRUN, when control is returned to the CPU, no further SETPA commands will be executed. The DSP continues to issue flags but the CPU is not reading them. You must therefore include ?GRIP or ?RUN in the code following CRUN if you want to use SETPA with CRUN. ?GRIP is a self contained word that operates the output register directly. ?RUN polls the DSP and leaves a flag on the stack as listed above.
STOP
This tells the DSP to stop moving the robot.
Example program
This example uses a vertical straight line. The robot moves down the line, all in Z axis.
We want the robot to stop moving when a sensor is reached. So this is in a BEGIN-UNTIL loop. When the sesnor activates the loop ends.
It must also end if the stop button is pressed or if the route finishes without the sensor being reached.
: TASK
R1
SMOOTH ( FIND SAFE SPEED
CRUN ( RUN WITHOUT WAITING
BEGIN
PB 7 BIT? ( SENSOR TRUE
?RUN 0= OR ( DSP FINISHED ALREADY
STOP? OR ( IS STOP BUTTON PRESSED?
UNTIL
STOP ( STOP DSP RUN IF NOT ALREADY STOPPED
?STOP ( WAIT FOR IT TO STOP
DSPASSUME ( GET BACK COUNTS OF WHERE IT GOT TO
COMPUTE ( CONVERT TO CARTESIAN
;
ESTOP?
If the flag FSTOP is set then ESTOP? executes the emergency stop procedure.
The stop button normally executes STOPABORT i.e. aborts with "stop button pressed"
message, (or else whatever word is SET into STOPVEC (See section 6.1).)
For example the above definition could be expanded to test the stop button and emergency stop the robot if pressed:
replace the line
STOP? OR ( IS STOP BUTTON PRESSED?
with
ESTOP?
The OR is not needed because we want to stop unconditionally.
Words of the above type are only necessary if you intend to send
a command to the DSP and do something else while the DSP controls
motion. The definition above could be expanded further to do all
kinds of things, for example take analog measurements, while the
robot is running a route in continuous path mode.
If ?RUN ever returns a true value when it should not be, for example due to a programming error confusing the DSP you can send the command:
CLRDSP
7.3.8 Vectored execution in a DSP controlled route
Using vectored execution (see section 10.1 is a way of making sure that a given word is executed all the time the robot is running regardless of which phase the CPU/DSP communication is in. A variable DSPVEC is provided which if non zero will be executed at every opportunity during 2nd and 3rd phases. Remember that this will be executed repeatedly, maybe thousands of times so you need to write appropriate logic for a single operation of something.
Example: This will 'chase' lamps connected to the PA output port as the robot moves. Each lamp will stay on for 100mS.
USER CYCLES
USER LAMP
: SCAN
LAMP @ 5 > IF 0 LAMP ! THEN
LAMP @ BIT PA OUT
LAMP INC
100 MSECS
;
: TEST
SET DSPVEC SCAN
TR ( NAME OF A ROUTE
10000 SPEED !
SMOOTH
RUN
;
Although stated that you can only include SETPA I/O control when using RUN, it is possible to set up a loop that monitors the DSP responses to SETPA and operates an output depending on what comes back from the DSP.
For example the following definition will call another routine to
turn on or off a device depending on the state of another input:
: CYLINDER PA 5 ;
: TASK
CRUN
BEGIN
?RUN
DUP 15 = PB 7 BIT? 0 > AND IF CYLINDER ON THEN ( SETPA 15 learned
DUP 14 = PB 7 BIT? 0= AND IF CYLINDER OFF THEN ( SETPA 14 learned
0= UNTIL
;
In the example above it is assumed that CRUN has completed as far as the CPU is concerned and the DSP is busy running motors, and issuing flags as programmed. However in the case of a long route the software might be in the second phase of running, and therefore the robot will be moving without TASK being executed.
7.3.9 Straight lines
A straight line in any robot is merely a succession of points in a line. The robot passes from point to point. The robot does not move in a straight line between points so to make the path straighter you need more points. However more points will slow down the robot.
Create a ROUTE e.g. SLINE, click Cartesian and Row. Choose number of Columns depending on how straight you want your line. If this is greater than Reserved then increase Reserved. Remember that 50 segments is 51 lines.
Method 1
Using commands or JOG
1. move the robot to one end of the straight line, highlight line 1 of the route and click 'set to here'.
2. Then move the robot to the other end of the straight line, highlight the last line and click 'set to here'.
3. Then click 'interpolate'.
Method 2
1. Determine the exact co-ordinates of each end of the line.
2. Highlight the first line and click 'edit line'. Enter the co-ordinates.
3. Highlight the last line and click 'edit line'. Enter the co-ordinates.
4. Click 'interpolate'.
Example:
Enter CONTINUOUS RUN
If you get "too tight" message try
ADJUST to reduce the speed, or else increase value of ACCEL
SMOOTH sets continuous mode and calculates maximum speed.
Insert function into a straight line
You can't easily do this because of the limitations of RobWin. Here are two work-arounds:
1. In the communications window do a ROBOFORTH insert, for example to insert GRIP before line 5 enter
5 'INSERT GRIP
2. Type L. to confirm
3. Click the red up-arrow in Robwin to upload the changed data to Robwin. Close and re-open the route to confirm.
You can no longer use interpolate.
or
1. Create a second route with a different name, for example SPATH. Make sure you reserve enough lines for the co-ordinates and the functions.
2. Enter this definition to copy the straight line to the new route: (you can copy and paste this text)
: COPY
SLINE MOVES E@ SPATH MOVES E! ( MAKE #MOVES THE SAME IN EACH
SLINE 1 LINE ( SOURCE ADDR
SPATH 1 LINE ( DEST ADDR
MOVES E@ 16 * ( BYTES TO MOVE IN MEMORY
ECMOVE ( MOVES BYTES IN EXTENDED MEMORY
;
3. Type COPY then Click the red up-arrow to upload the data to the new route. Open SPATH to confirm.
4. Use insert function in the new route SPATH.
You can also use the straight line function in the curve generator commands of RobWin7. See RobWin7.pdf
7.3.10 RELATIVE Cartesian routes
Sometimes it is desirable to program a motion in Cartesian co-ordinates and have it repeated starting from various positions. For example to pull out a shelf might require a move towards the shelf, then down onto the handle then pull out the shelf. Having programmed this for one shelf you can use the same route for the other shelves.
From any position in the workspace you can run the route as if it was starting from that position. Use
START-HERE
This adjusts all the positions in the route relative to where the robot is now. Note that although the data in the controller will change the data on screen in RobWin will not change. The name of the route must be declared before you use START-HERE
Example usage:
P1 GOTO PATH1 START-HERE CONTINUOUS RUN
The robot will go to point P1 then run the route PATH1 starting at the position P1.
Note that P1 is a POINT not a PLACE.
A similar word is
END-THERE
In this case you need to supply the position where the route is to end without the robot being at that position, for example:
P1 PATH1 END-THERE CONTINUOUS RUN
The robot will run PATH1 from whatever position is necessary to finish at P1.
Again note that P1 is a POINT not a PLACE.
You can also use another route for the reference positions, for example:
TRAY 1 LINE PATH1 END-THERE CONTINUOUS RUN
The robot will run PATH1 from whatever position is necessary to finish at line 1 of TRAY.
7.3.11 Timed segments
Version v13.5 up.
Consider a route created as a ROW in which the points are equally spaced. This could be a straight line, or perhaps a circle comprising 36 points as in the following example. There would be 37 lines, line 37 being the same as line 1, so the robot could draw a circle comprising 36 segments of 10 degrees each.
A problem arises because as various axes become dominant in different parts of the circle, or as reach changes, the speed of the arm in real terms changes. This can be corrected by specifiying a time for each segment. This is a completely different mode. To invoke this mode enter
CONTINUOUS TIMED
To cancel this mode and return to the usual mode enter
CONTINUOUS
Having specified the mode you now need to specify the time for each segment - i.e. the time between one line and the next. Enter a value in milliseconds for SEGTIME e.g.
1000 SEGTIME !
Will make each segment 1 second long. This results in the circle being drawn at 10 degrees per second and takes 36 seconds all the way round.
Obviously this can be applied to any path where exact linear speed is critical. The DSP adjusts the speed so that the time between points (lines) is as specified. Clearly if the distance between one pair of points is very large then the DSP will speed up the robot to cross that distance in the specified time.
finally
RUN
The complete line being CONTINUOUS TIMED RUN
Pitfalls
As with normal continuous mode if the move is too long or the time is too short then the DSP can not compute a viable speed and you will get the "too tight" error. ADJUST will not work. The solution is to increase the time, or bring the points closer together, or increase the value of ACCEL. You may also need to increase JERK to achieve that acceleration.
Unlike the normal mode you can never have two points too close together. In fact you can have two lines with identical coordinates (not possible in the normal mode). The robot would simply pause at that position for the specified time before moving on.
Back to contents page
7.4 OBJECTS
There is also a third entity, the OBJECT. This is only a dictionary entry and has no data in the data area; its data is in the USER variable area. Any item to be handled by the robot can be named. For example:
OBJECT PART
creates an object called PART in the dictionary.
Note that although you can type this directly into the communications window OBJECTs are best declared near the start of your text.
The object can be introduced into the system in a number of ways:
After simply closing the grippers on the object enter:
HOLDING PART
This tells the system that the robot is holding PART.
WHERE
WAIST SHOULDER ELBOW HAND WRIST OBJECT
TRACK LIFT EXTEND HAND WRIST OBJECT
1000 0 0 0 0 PART
642 0 0 0
1001 0 0 0
The address of the object being held is stored in a variable OBJECT-HELD.
Alternatively the object may be placed at a known position e.g.
PART ISAT CAMBRIDGE
or
PART ISAT LINE 5
This tells the computer where the object is.
It can be confirmed with:
VIEW CAMBRIDGE or VIEW LINE 5
WAIST SHOULDER ELBOW HAND WRIST OBJECT
WAIST LIFT EXTEND HAND TRACK OBJECT
nnn nnn nnn nnn nnn PART
You can also enter:-
WHEREIS PART CAMBRIDGE OK
To make the robot pick up the object first send the robot to the
position with the place name or with GOTO e.g.
CAMBRIDGE or 5 GOTO
then enter:-
GET
In the case of a single position the arm moves to the position
then the grippers close on the object. In the case of a place
name with an approach position the arm moves via the approach
position to the target position, the grippers close on the object
then the arm moves back to the approach position. Confirm with
WHERE, VIEW (position) and WHEREIS (object)
The object can be put at a known position by first sending the
robot to the position with a place name or with GOTO then
entering PUT e.g.
CAMBRIDGE PUT
When an object is logically transferred to a position with PUT or
ISAT the position is also recorded in the object's data field.
This information is used by WHEREIS and also facilitates GOGET
e.g.
GOGET PART
Drives the robot to the position where the object is, via
the approach position if there is one and GETs the object,
withdrawing to the approach position if there is one.
IMPORTANT: GOGET (object) cannot be compiled into a definition.
Another form which can be compiled is (object) COLLECT e.g.
PART COLLECT
A list of all the objects so far created can be had with:-
OBJECTS
Notes:
(1) An object cannot be at HOME because HOME is in the ROBOFORTH dictionary
(2) The same object can be at two or more positions at once. The
name of the object is recorded in all the positions. However,
only one place can be recorded in each object.
UNGRIP removes the object from the known workspace (sets OBJECT-HELD to zero).
WHEREIS PART NOWHERE
To clear an object from a place or a line use
0 ISAT (place-name) or 0 ISAT LINE n
OBAD is a word which converts a route line address to the memory location address which contains the object. Thus you can manipulate the object field directly with e.g.:
(object-name) (n) LINE OBAD E! note E! because all routes are in upper memory.
This puts the object in at line (n).
To fill a route with the same object use:
MOVES E@ 1+ 1 DO (name) I LINE OBAD E! LOOP
Note DO-LOOPs can only be used inside a definition.
To clear all the objects from a route use:
EMPTY
Remember that if you have more than one route you may need to invoke the name of the route you wish to empty unless you are already working with it, for example:
TRAY EMPTY
If you wanted to preset all the positions with a part so you could remove them one by one the words are:
PART TRAY FILLUP
Back to contents page
7.5 USING THE TEXT WINDOW
Once you have created some routes or places you can now define how they are used, that is when or why the robot goes to which places or routes and in what order.
WARNING: All words are stored in the dictionary as a length plus the first 5 characters of the word.
Therefore ambiguities are possible and should be avoided (such as ROBOT1 and ROBOT2 which are the same
length and have the same 5 starting characters).
In particular avoid creating words similar to Roboforth words for example if you create a word RECEIPT this has the same first 5 characters and the same length as RECEIVE. Since RobWin uses this word communication between RobWin and Roboforth is disabled.
click the (project name).ED2 window and enter your text there.
When you have finished editing the text file you can download it with the 
button. The communications window will show a line of chevrons
>>>>>>>>>>>>>>>>>>>>>>>>
while the file is loaded and compiled by the controller. At any time you can edit the file and press again.
Example. Suppose you have created some PLACES called BELT and LATHE, you might write the definition of a word to use these places in your .ed2 text file:
( TEST.ED2 )
DECIMAL
OBJECT WIDGET
: FEED
WIDGET ISAT BELT
WIDGET COLLECT
LATHE PUT
;
Test the new word FEED. Once tried and tested the word can be used in higher level definitions and so on until the entire task is defined as one word (or a number of high level words to be sent by the computer).
Back to contents page
INPUT-OUTPUT
8.1 OUTPUTS
This will obviously depend on which input/output cards are fitted
to the system, but the following examples apply to the standard unexpanded outputs.
The standard I/O has three ports which are called PA PB PC and PD. Each
of these is based on the communications register principle, and can
be controlled on an individual bit basis and outputs can be read as well
as written. PC and PD are only used by the teach pad. The addresses of these ports have constants in
ROBOFORTH; the constants are: PA PB PC and PD
TO OUTPUT connect to PA as indicated on connector pinout in the controller manual.
The most basic form of output is:
(val) (port) OUT - outputs 8-bit (val) on (port) e.g. 55 PA OUT
Any output port can be read back e.g. PA IN . 55
Individual bits may be manipulated:
(port) (bit) ON turns on a single bit of the output.
(port) (bit) OFF turns off a single bit of the output.
Suppose there were an air solenoid connected to PA 4. You could
turn it on with PA 4 ON and off with PA 4 OFF
A better idea would be to define AIR as follows:-
: AIR PA 4 ;
Now you can type (or include in a higher level definition):-
AIR ON and AIR OFF
Not only is it more readable you can change the connections and bit address without having to go right through your text looking for occurrences of PA 4.
If a second Peripheral Interface Adaptor (PIA) is fitted the other output ports are QA and the upper 4 bits of QC.
In case of accidental un-programming of either PIA enter:
PROGPIA
You may wish to have an output activity synchronized with robot motion. The way to do this is to embed an I/O word into a route using Insert Function. If you will run the route in segmented mode then you can insert any word either already in ROBOFORTH such as GRIP/UNGRIP or any new word you define though the latter is not recommended. You may used the word SETPA with a value in which case an output will turn on or off depending on the value. Remember that the robot will stop and wait for any word which takes time. If you wish to run the route in continuous mode then only certain words may be used, notably GRIPPER and SETPA. SETPA will turn an output on or off depending on the value of the argument. Remember that the robot will not wait for the output activity to complete but will continue moving. A typical use of this function is controlling a spray gun for e.g. overspray.
You will need to know how to insert words into a route, explained in Putting Forth words into Routes, section 7.3.1.
How to use SETPA including a table of SETPA values is explained in DSP hardware, continuous path, section 7.3.6
Back to contents page
8.2 INPUTS
The standard input port allocated is PB. TO INPUT connect to PB as indicated on connector pin-out.
The address of PB is the constant PB
The most basic form of input is:
(port) IN - inputs a value from (port) leaving it on the stack.
Note that this is an 8-bit twos-complement integer.
(port) (bit) BIT? leaves a true if that bit of input is true and false if that bit is a false.
Suppose there were a switch on PB bit 4 which made PB 4 a logic zero when closed, but logic '1' when open (see connector pin-outs) You could define a word:-
: SWITCH PB 4 ;
then
SWITCH BIT? leaves a number on the stack if switch is open, or zero if switch closed.
For the purposes of words like IF and UNTIL zero is FALSE but any value is TRUE. Using the Forth syntax definitions could be built up as follows:-
: HI BEGIN SWITCH BIT? UNTIL ;
: PROC2 SWITCH BIT? IF TRAY2 RUN THEN ;
etc.
BEGIN ... UNTIL is a loop which executes all the words between BEGIN and UNTIL.
A condition (true or false) must be on the stack before UNTIL. If the condition is false (zero) then the program loops back to BEGIN but if it is true (non-zero) it drops through to the next word.
WARNING: because BIT? leaves any value for a true, not
necessarily a '1', you may not be able to use AND, for example
after defining : SW1 PB 5 ; : SW2 PB 6 ;
the following will not work: : RDY SW1 BIT? SW2 BIT? AND IF ....
Instead use the form : RDY SW1 BIT? 0 > SW2 BIT? 0 > AND IF ....
Another word is WAIT which waits for the specified input to change to a specified state. Example:
PB 4 0 WAIT waits for bit 4 of port PB to go to zero, or
SWITCH 1 WAIT waits for bit 4 of port PB to go high.
You can monitor the PB input while setting up hardware (or testing robot sensors) with
PP
You will see a row of 8 1's
11111111
if any input goes to zero the 1 changes to zero, for example
11011111
Note that any PB bit can be used to generate an interrupt. Normally PB 6 is chosen. See hardware manual
If a second PIA is fitted the input ports are QB and the lower 4 bits of QC.
The QB equivalent of PP is>br>
QB WATCH
or SB WATCH QC WATCH etc.
In case of accidental un-programming of the PIA enter:
PROGPIA
Back to contents page
8.3 SEARCHING
One feature of ROBOFORTH is the ability to move the arm until
an event takes place. For example, a light-beam device on the
arm could be interrupted when the arm reaches the object.
Single axis search
You can initiate a slow or fast search, after first selecting the
joint(s) to move using TELL.... etc. These searches are for a single axis only and may only be suitable for R15 and R19.
To set up a slow search you must first determine the criterion
for the search. Define a word which leaves a true when the
search is to end, for example if the light beam device is
connected to, say, bit 5 of port PB, normally a '0' going to '1'
when the beam is interrupted:-
: FOUND PB 5 BIT? ;
You now set the criterion by entering:-
SET CRITERION FOUND
Test the slow search with ?TERMINAL which leaves a true if the
escape key is pressed:-
SET CRITERION ?TERMINAL
TELL WAIST SLOWSEARCH
If the beam is interrupted in the first example or if the escape
key is pressed in the second example while the robot is in motion
then the robot will stop immediately.
WHERE
WAIST SHOULDER ELBOW HAND WRIST OBJECT
WAIST LIFT EXTEND HAND TRACK OBJECT
n - - - -
Where n is the count reached when beam breaks/escape pressed.
The fast search accelerates the selected motors to the full SPEED value. The CPU then checks the criterion and if true sends a STOP command to the DSP and reads back from the DSP where it had got to (DSPASSUME).
The fast search syntax is:-
TELL WAIST (limit) FASTSEARCH
where (limit) is the max movement the axis will make if the criterion is not met.
To search in the opposite direction use the form:-
TELL WAIST REVERSE SLOWSEARCH
or TELL WAIST REVERSE (limit) FASTSEARCH
Straight line search
A straight line search may be achieved by creating a route which is a straight line.
You can make a CARTESIAN ROW and just learn the start and finish then click interpolate. See section 7.3.3
Learn the route such that it is long enough to start in front of the object you are searching for and ends after it.
For example if searching for a surface make sure the route passes through the surface. The route can be moved later using
START-HERE (see section 7.3.10).
Suppose you wish to search vertically (Z axis only) and the route is called ZLINE and your sensor is connected to PB 7.
(see section 8.2).
: ZFIND
ZLINE ( invoke the route )
START-HERE ( move the start of ZLINE to where the robot is now )
SLOW ( predefined to put a low value in SPEED )
CRUN ( tell the DSP to run the robot )
BEGIN ( begin a loop )
?RUN 0= ( checking to see if the DSP has finished )
PB 7 BIT? 0= OR ( or if the object is sensed )
STOP? OR ( or if the stop button is pressed )
UNTIL
STOP ( stop the DSP )
BEGIN ?RUN 0= UNTIL ( wait for the DSP to finish deceleration )
DSPASSUME ( ask the DSP where it got to in counts when it was stopped )
COMPUTE ( change the counts to Cartesian coordinates )
900 PITCH ! 0 W ! ( make sure the hand is still vertical )
;
Run ZFIND until the robot stops. Type WHERE to see where it stopped.
The Z coordinate will be in the variable Z.
Simple delays can be introduced into any word with (n) MSECS or (n) USECS, e.g.
500 USECS (500 microseconds)
or for e.g. a 5 second delay enter
5000 MSECS
There is also an event timer.
RESETMS resets (zeros) the timer.
MSECS? gives the time since the last reset. Use it or print it e.g. MSECS? .
Maximum time is 32767 mS.
8.5 INTERRUPTS
Put a valid word in INTVEC. See vectored execution. The word must have the word RETURN as it's last line before the semi-colon for it to work with interrupts e.g.
: NEWWORD
action
RETURN
;
However RETURN must be bracketed out for testing in immediate mode e.g.
: NEWWORD
action
( RETURN )
;
Then remove the brackets when you are ready to use NEWORD as an interrupt word.
Next put the CFA of the new word in the variable INTVEC e.g.
SET INTVEC NEWWORD
INTVEC is a reserved variable that the interrupt code looks in to see what to execute.
Alternatively make two words, one for testing and one simple definition with the tested word followed by RETURN.
For example if you want the interrupt to just beep the terminal do
: BEEPER BEEP RETURN ;
SET INTVEC BEEPER
Then when the interrupt occurs the terminal will beep and the current word being executed continues.
As soon as the interrupt happens further interrupts are disabled. The word RETURN returns the new word back to the BIOS that initiated the interrupt which re-enables interrupts for the next time. An alternative word XRETURN ends the interrupting word and leaves interrupts disabled.
It can of course be any word, but remember that while this word is executing the current (interrupted) word is delayed. If the current word was a motion word then the DSP controls the motion so the motion may not be affected but motion controlled by the CPU e.g. CALIBRATE may be affected. For long routes the CPU is busy "feeding" the DSP with data because its buffer is full. If this process is delayed it can result in erratic motion.
It is possible, within the definition of a word that has been invoked by an interrupt, to change the contents of INTVEC to a new word so that the next interrupt executes the new word.
There are two kinds of interrupts available:
Interrupt from external signal.
Any PB input can create an interrupt. It requires a link on the CPU card from the chosen input (usually PB 6). See controller manual section 8 for hardware details.
If input interrupts are enabled then if PB 6 goes low the interrupt will occur. This is not edge triggered so as long as PB 6 is low the interrupt will keep occurring. However interrupts are disabled for as long as your interrupting word runs and will stay disabled if XRETURN is used. Therefore you must either (a) make sure the input is a pulse which lasts for less time than your interrupt word (minimum duration 10 microseconds) or (b) make the word wait for the input to go high again with PB 6 1 WAIT. But be careful because as long as the system is stuck in the WAIT because PB 6 has not yet gone high, the top level word that was interrupted will be halted. So a pulse is preferable.
Enable interrupts with ENABLE and disable with DISABLE
Note: the first use of ENABLE after a controller reset executes the interrupt one time.
Here is an example. Scenario: we want to count products going past a light beam.
The light beam connects to a circuit that puts PB 6 to zero each time the product is detected.
DECIMAL
USER COUNTER
: INT ( this is the word that will run each time there is an interrupt )
PB 6 1 WAIT ( wait for the beam to clear. Warning as long as PB 6 is low the top level program can not )
( continue. Of course if the DSP is running the motors that is not held up. )
COUNTER INC ( increment the counter )
RETURN ( return from interrupts - and in the process re-enable interrupts for the next count )
;
SET INTVEC INT ( set the CFA of the word INT into INTVEC.
: Q ( this word will run in the top level to show you what is happening in the interrupts )
-1 COUNTER ! ( set a starting value of -1 )
ENABLE ( enable interrupts and also runs INT once.
CR ( start a new line )
BEGIN ( start a loop )
13 EMIT ( return the cursor to start of line )
COUNTER ? ( print value of COUNTER over the top of the last one )
100 MSECS ( wait 0.1 second then )
?TERMINAL UNTIL ( go round again unless escape is pressed )
( or CTRL-C UNTIL ( or do it until ctrl-c is pressed.
DISABLE
;
To test the above type Q [enter] and the count will continuously display on the screen. You should see the starting value is 0 because ENABLE for some reason gives one interrupt, changing from -1 to 0.
Timer interrupt.
A CPU timer can be set to interrupt every n milliseconds. This value must be put in the variable INT-TIME before you start the timer. The maximum time is 500 msecs. Then use SET-TIME e.g.
250 INT-TIME ! (sets to 250 msecs)
Start the timer with
START-TIMER
Stop the timer with STOP-TIMER
Your interrupting word must end with RETURN
As with the PB 6 interrupt the new word may delay the current word that was interrupted. Also the new word must not take longer to execute than the setting of the timer. For example if you set 100 msecs then in your word you had included 200 MSECS then clearly the word will not complete before the next interrupt.
RETURN returns the word to machine code that ends this interrupt and re-enables the interrupts for next time.
XRETURN ends this interrupt and disables any future interrupts i.e. a one-off event.
Rules
1. Always disable interrupts before reloading a project. As a precaution put DISABLE STOP-TIMER at the head of your ED2 text screen.
2. The interrupting word must not access the DSP while the robot is in motion.
3. In the case of a timer interrupt the interrupting word must not last longer than the timer.
4. The interrupt word must be stack neutral - not leave anything on the stack or take anything off.
5. Because of possible CPU conflicts do not use USECS or MSECS in the interrupt definition.
See section 12 for programming example.
Back to contents page
SAVING ON DISK
9.1 DISK FILES
Note that the flash disk drive in Forth is no longer available. All files are in the PC
Programming the robot results in two distinct segments of information:
(1) The positional data. This is saved as a binary file by uploading from the controller to the disk. These files have the extension .RUN e.g. TEST.RUN
(2) The dictionary. As you create PLACEs, ROUTEs and other
definitions these are compiled directly into the dictionary.
RobWin treats all this as a project. Work is saved to disk by creating or opening a project then saving it back to disk. A project comprises 3 files with the same name and 3 different file types:
.RUN - binary positional data.
.ED1 - a list of headers of all the routes and places created.
.ED2 - your text file defining higher level words and the final program.
9.1.1 Text Files
Suppose you type two definitions into the system thus:
: HI ." HELLO" ;
: BYE ." GOODBYE" ;
When you execute HI you will see the following:
>HI HELLOOK
The HELLO and the OK merge and a better definition of HI would be
: HI ." HELLO" CR ; i.e. add a new line with CR.
If you just type in the new definition of HI you will see two definitions of HI when you type VLIST - the new and the old. The old one can never be accessed because Forth searches the dictionary from the top down, so it is a waste of space. You need to type FORGET HI then re-enter it. Unfortunately FORGET HI also forgets BYE and every other definition added since. Clearly some sort of editing would be useful. The only way of editing the dictionary is to edit text which is then compiled each time you edit:
click the (project name).ED2 window and enter your text there. There is no need to worry about the other files as these are created and maintained by RobWin. When you have finished editing the text file you can download it with the button. The communications window will show a line of chevrons >>>>>>>>> while the file is loaded and compiled by the controller. At any time you can edit the file and press again.
Each time the text is reloaded the words ROBOFORTH and STARTOVER are sent to the controller and the PLACE and ROUTE headers are re-created at the start of the dictionary. RobWin maintains both the ED1 and ED2 files and always downloads the ED1 file first.
WARNING: All words are stored in the dictionary as a length plus the first 5 characters of the word.
Therefore ambiguities are possible and should be avoided (such as ROBOT1 and ROBOT2 which are the same
length and have the same 5 starting characters).
In particular avoid creating words, routes or places with names the same as or similar to Roboforth words for example if you create a word RECEIPT this has the same first 5 characters and the same length as RECEIVE. Since RobWin uses this word communication between RobWin and Roboforth is disrupted.
9.1.2 Saving your work
DISK Periodically save your work back to disk by clicking project, save. When you download the text file with the button the text file is automatically saved to disk (but not the data).
FLASH ROM Although you have saved the work to disk you also need to save it to the flash ROM so that next time the controller is powered up (or the reset button is pressed) your work is restored to RAM. Otherwise if you power down/up or press reset it will be your previous work that is reloaded to RAM. Save to flash ROM with the command:
USAVE (note this takes a few seconds)
You can, if you wish, make this the last line in your text file so that it happens every time you download with the button.
9.1.3 Reloading your work
Click project, open, select the project you wish to reload. A blue progress bar indicates downloading of the data from the .RUN file. After it reloads 3 windows are opened (if not already open) - the routes window, the places window and the text window (ED2 file). The ED1 and ED2 text files are compiled by the controller CPU and you will see a > for each line the controller compiles so the communications window fills up with >>>>>>>>>>>>>>>>>. Then the routes and places windows open. Note that in settings, configuration bank memory must be checked.
Things that can go wrong:
As soon as the blue progress bar appears the system halts. Probably bank memory is not checked. Press reset on the controller, cancel the download then go to settings, configuration and check bank memory.
RUN-LIST NOT DEFINED Your controller has been cold started. Type ROBOFORTH, turn the switch to warm start and try again.
Back to contents page
9.2
CONTROLLER SOFTWARE
SAVING A COPY OF ROBOFORTH ON DISK
1. Do a cold start (press reset button with selector switch in cold start position). This reloads the RAM from flash ROM but leaves the pointer at the top of Forth and the start of ROBOFORTH
2. Enter ROBOFORTH and press enter key.
3. Use 'file', save binary.
4. Enter start 4000 and length 6000
5. Enter a file name other than that supplied with the CD, e.g. myrobot.RAM
SAVING THE CALIBRATION PARAMETERS
A copy of the RAM image saved as above will contain all the calibration parameters for your robot, however you may save the calibration parameters (known as a signature) to a small file of its own, as follows:
1. V13 up: Use file, save binary. Check that bank is 0 and enter start A200 and length 200
The files may not be 100% compatible.
2. Choose a file name with .SIG in it e.g. myrobot.sig
It will be saved as myrobot.sig.RAM
RELOADING ROBOFORTH or LOADING UPDATED ROBOFORTH
When the controller is switched on the RAM is reloaded from flash ROM. Just about the only way of corrupting the flash ROM is to corrupt the RAM then save the corrupted RAM to flash ROM with PSAVE. If you think you have done that proceed as follows:
1. Do a cold start (press reset button with selector switch in cold start position). This reloads the RAM from flash ROM but leaves the pointer at the top of Forth and the start of ROBOFORTH
2. Go to settings, configuration and make sure bank memory is checked.
3. V13 up: Use 'file', load binary. Check that bank is 0 (it is not asked in RobWin 7) and enter start 4000 and length 6000
4. Enter the file name supplied with the CD: ______.RAM (e.g. R17V16.RAM, R12V16.RAM etc)
5. After software has loaded (about 30 secs) enter:
ROBOFORTH
6. Enter PSAVE which re-writes the flash ROM.
RELOADING PARAMETERS
A copy of the RAM image saved as above will contain all the calibration parameters for your robot, however if a new version of ROBOFORTH has been loaded you may need to install your robots signature in the controller by overlaying the calibration parameters for your robot from a disk file. A calibration filename usually takes the form of the robot serial number followed by .SIG e.g. R17A123.SIG. To do this
1. click file, load binary
2. V13 up: use values bank 0, start A200 and length 200
3. load the file Rxxnnn.SIG.RAM
4. Enter USAVE to write the ROBOFORTH with reloaded parameters back to flash ROM.
LOADING A NEW VERSION OF ROBOFORTH
1. Save the calibration parameters (robot signature) as above.
2. Load the new ROBOFORTH as above.
Back to contents page
9.3
DATA TRANSFER PROTOCOL
The host must be connected via its serial port set up for 19200
baud, no parity, 8 bits, and 2 stop bits. (to change this see section 9.6
An extremely simple protocol is employed:
UPLOADING
To initiate uploading from the controller first send the string
(start-address) (number of bytes) TRANSMIT followed by the return 0Dhex character. The start address and number of bytes may be specified in hex or decimal but hex is usually more useful, for example you may have stored some measurements in the memory from F000 to FFFF. In this case you would upload them with HEX F000 1000 TRANSMIT
The controller will then be waiting for an ENQ (5) character from the computer.
The controller then sends an STX (2) to the host followed
immediately by one block of 256 (100hex) bytes of data. Your host computer software which accepts the data and writes it to a disk file should be buffered.
The controller then waits for the host to send another ENQ and
sends another STX(2) and the next block of 256 bytes. This
repeats until all blocks are sent. When all data is transferred
the controller's answer to ENQ is not STX but ETX (3). When the
host receives ETX instead of STX it finishes the routine and
closes the file.
To upload data from memory bank 1 use
BANK C1SET (start-address) (number of bytes) TRANSMIT
DOWNLOADING
To initiate downloading from host to controller the host sends an
ENQ and waits for STX from the controller. The controller must
first have been given the command
(start-address) (number of bytes) RECEIVE
and the host must also be in some routine to read
data from disk and download it.
The host then sends one block (256 bytes) to the controller.
The host then sends another ENQ and waits for another STX then
sends the next block. This repeats until all the blocks have been
downloaded.
The host then sends sends ETX instead of ENQ meaning no more data
and the host then stops.
Be careful where you load the data. The memory below A000 is ROBOFORTH and your own software is above that. Type HERE X. to see where you have reached in memory.
In memory bank 1 you can load from zero if you wish. Learned positions grow up from 0 and the highest memory location used is found with NEXT @ X.
To load into bank 1 use:
BANK C1SET (start-address) (number of bytes) RECEIVE
9.4 SUPERVISORY SOFTWARE
The host computer can control the robot by sending commands
down the RS232 serial link to the controller. The host software should start by
opening the serial channel e.g.
OPEN "COM1:19200,N,8,1,CS,DS,CD" AS #1
The commands can then be PRINTed to the controller e.g.
PRINT#1,"PURGE". The response from the controller will always be
a reflection of each character sent, except the final return
character which is echoed as a space character. After executing
the command the response should always end in 5 characters:
O K cr lf >
This response may come (a) immediately, (b) after some unknown
time, (c) not at all (in the case of some task which never ends).
The host software should look for the >. The preceding string
should therefore be OK, if not then there was some error message.
In case (c) the host can continue some other task without
waiting.
Suggested flowchart:
NOTES: (1) All characters which come back from the controller
must be used up or "buffer overflow" will occur. (2) Always CLOSE
the channel before SHELLing another program then open it again on
return.
Useful words for a supervisor:
GF - (Globals Fetch) controller returns 5 or 6 values of the joint counts.
CF - (Cartesian Fetch) controller returns 5 or 6 Cartesian coordinates.
Send 5 values (or 6 for 6-axis) followed by CM - (Cartesian Move) robot moves to that position. The 5 or 6 values are in reverse order with X on top (sent last)
for example
900 0 1000 2000 3000 CM - sends robot to X=300mm Y=200mm, Z=100mm, pitch 0, roll 90 deg.
or for 6-axis robot
450 0 900 1000 2000 3000 CM - sends robot to X=300mm Y=200mm, Z=100mm, pitch 90deg, yaw 0, roll 45deg.
The following examples are for 5 axis robots: (6 values for 6-axis robots)
0 900 1000 2000 3000 CG - (Cartesian Get) just sets the variables but does not move the robot.
0 900 1000 2000 3000 CL - (Cartesian Learn) sets the variables and learns them into the current active route but does not move the robot.
100 200 300 400 500 JMA - (Joint Move Absolute) moves each joint to the absolute positions listed on the stack. They all start and stop at the same time. Waist is the last value onto the stack (500 in this example)
100 200 300 400 500 JMR - (Joint Move Relative) moves each joint by the amounts on the stack. They all start and stop at the same time. Waist is the last value onto the stack (500 in this example)
0 900 1000 2000 3000 AL - (Add to All) adds the 5 values (or 6) to all the lines in the currently selected route. It works the same for joint or Cartesian routes. For example in joint mode 3000 would be added to all waist positions.
9.5 ACTIVEX CONTROL
ActiveX Control Robx.ocx
Installation
The installation disk contains the control, the dynamic-link libraries it needs and the installer program setup.exe. Run setup to install and register the components. The program xdem can be used to test the control.
Methods
The following methods are provided. C-Style declarations are used here. If you are using another language then the appropriate declarations should be automatically generated when you add the control to your application.
short OpenComm(short Port, long BaudRate);
Opens the communications port.
Port is 1 for COM1 etc.
BaudRate should normally be 19200 (to change this see section 9.6)
The return value is 1 if successful, 0 for failure. Use the method GetCommErrorString() to get a description of the problem.
void CloseComm();
Call this before quitting the application.
short SendString(LPCTSTR String);
Sends the string to the controller. The string should end with a "Carriage Return" character (ASCII 0D hex).
The return value is 1 if the string was successfully sent, 0 if a communication error occurred. Use the method GetCommErrorString() to get a description of the problem.
The controller must be in the "ready" state (as reported by GetStatus) before invoking this method. After sending the string invoke GetStatus() until the "ready" state is received.
short GetStatus();
Gets the controller status as follows:
0: Waiting
2: Ready, received OK
1: Ready but not OK
-1: Communication error
After receiving status 1 or 2, GetResponse gets the last line sent by the controller.
If status is -1, use GetCommErrorString() to get a description of the problem.
CString GetResponse();
This gets the controller response. If status was 1 the response string indicates what went wrong.
CString GetCommErrorString();
Gets a description of communication problems.
void AboutBox();
Displays the AboutBox();
Back to contents page
9.6 SERIAL PORTS
The main serial port is 'channel 0' and the second is 'channel 1'. The second port is optionally connected to a 9w D connector - see controller manual. Otherwise it is only available on the CPU card.
Changing baud rate on port 0
The Baud rate always defaults to 19200 on a cold start. But you can change the baud rate for a warm start. If you mis-enter the baud rate and get lost simply do a cold start.
The Baud rate factor is in a location BAUD. The value of this factor is 2,000,000 divided by the required baud rate. So the default value is 2,000,000 / 19,200 = 104 (round to nearest integer) or 68 hex. So if you type:
BAUD ?
you should see 104
To change the baud rate enter a new value into Baud, USAVE, do a warm start then change RobWin.
For example to change to 56,000 (factor 2000/56):
36 BAUD !
USAVE
Then press reset. You will lose communication with the computer. Click Comm, configuration and select 56,000 in the drop-down menu.
To send a character out of the serial port use EMIT e.g.
HEX 41 EMIT sends a capital A to the screen
To get a character (byte) from the serial port use KEY - when a character arrives KEY leaves its ASCII value on the stack e.g.
KEY . (press a key) - system waits for the key to be pressed then prints its ASCII value on the screen.
You can read the incoming byte without waiting with INKEY
Second serial port (channel 1)
You will first need to initialize the port using a value calculated as above to set the baud rate. Put the value on the stack then jump to location 001F, e.g.
HEX 68 1F JUMP
will initialize the port to 19200 baud.
HEX D0 1F JUMP
will initialize the port to 9600 baud.
To access the second serial port change the value of IOFLAG from 0 to 1 with
IOFLAG C1SET
From this point on you can only communicate with the controller through the second serial port. Therefore make sure you issue all commands to end with
IOFLAG C0SET
e.g.
IOFLAG C1SET SPACE IOFLAG C0SET
will send a space character out of serial port 1 then return control to port 0.
To get a byte from the second serial port use KEY (as described above) but set the IOFLAG to 1 first, then back to 0 to return control to the computer (channel 0). Note that the system will be stuck in KEY until a byte arrives so if none arrives you'll have to press reset. However you can check to see if a character has arrived by reading port D5 bit 0 e.g. within a definition :
[ HEX ] D5 IN 1 AND IF IOFLAG C1SET KEY IOFLAG C0SET THEN
Note that all serial communication words such as . (print), ASK, EXPECT etc will be via the second serial port if IOFLAG is set to 1. Control will simply switch to port 1. You can then send or type commands into port 1 as you did with port 0. To return to port 0 enter IOFLAG C0SET into port 1.
BUG: for EPROMS version 10 (VA) and below the > character still appears on port 0 even though OK is on port 1. To correct this (if you wish) then perform the following patch:
3A 1FE2 C! 06 1FE3 C! A0 1FE4 C! C3 1FE5 C! C7 1FE6 C! 05 1FE6 C!
This should be typed all on one line at one time. Hit enter at the end. Or put the whole line in your project file.
ADVANCED FEATURES
10.1
VECTORED EXECUTION
The code field (CFA) of a word is executable and can be found using FIND (or using ' (tick) minus 2), e.g. FIND GRIP EXECUTE is the same as GRIP. So you can put this value in a variable and have it executed by some other routine which has already been defined. e.g.
VARIABLE GVEC
FIND GRIP GVEC ! ( FINDs the CFA (code field address) of GRIP and stores it in GVEC
GVEC @ EXECUTE ( fetch the value from the variable GVEC and execute that
An easier way to set the CFA into a variable is using the word SET e.g.
SET GVEC GRIP
Possible uses for this are described in sections 6.1, 7.3.1 7.3.8 8.5.
10.2 TURNKEY OPERATION
In many cases it is desirable to have a program run as soon as
power is switched on rather than have to type something every
time. In these cases the program to run is a single word, or you
might have to generate a new word e.g.:-
: DEMO START CALIBRATE HOME RUN ;
Then enter:-
AUTO DEMO
USAVE
and set the front panel switch to auto position (see system manual and robot manual section A). Now the word DEMO will execute immediately on power-up and the computer can be removed.
Before ever DEMO is forgotten, or words below it are re-compiled
the controller must be put back to warm start position until AUTO is
used again.
When you use AUTO (word) you are putting the CFA (code field address) in the (pseudo) variable TURNKEY.
You can also use this feature to restart a word. Because all Forth loops are structured you can not easily get out of a loop and just go back to the beginning. There is no GOTO as in BASIC for example. What you can do is put a word in TURNKEY. For example suppose you want it so that when the stop button is pressed, the robot does not abort, neither can it continue, but must instead start the whole program from the beginning. Consider a main word
: MAIN
BEGIN
STUFF
?TERMINAL UNTIL
;
: TASK
START
CALIBRATE
MAIN
;
Now in the middle of STUFF somewhere, someone presses the stop button. You want the robot to go back to READY, wait for a signal (say a button connected to PB 6) and start again from the beginning. You can use
RESTART
This jumps to the auto-start entry point of the Forth, see section 2, Initialising.
You can now set a temporary value in TURNKEY that will execute when you use RESTART. The original value for AUTO will be restored from flash after a hard reset.
In immediate mode use
FIND YOURWORD TURNKEY ! (where YOURWORD is an example word)
You can't compile FIND. You also can not use SET with TURNKEY because it is an address not a variable.
Within a definition use
['] YOURWORD 2- TURNKEY !
When using a text file define the (word) to be executed on power-up and at the end of the file put AUTO (word) (see section 7.5).
: ESTOP
BEGIN STOP? 0= UNTIL ( WAIT FOR STOP BUTTON RELEASE
READY
PB 6 0 WAIT ( WAIT FOR CONTINUE BUTTON
RESTART
;
There's no need to recalibrate because there was no hardware reset. This is called a software reset. There is no need to turn the key to auto. A software reset leaves all RAM contents, values in variables unchanged. Even the current position of the robot is unchanged so providing there has not been a crash the positional information is valid.
: TASK
SET STOPVEC ESTOP
['] MAIN 2- TURNKEY !
START
CALIBRATE
MAIN
;
What if you have already set TURNKEY to TASK and have the key set to Auto? Use USAVE to save that to flash. Now if you press the reset button TASK will execute, including START and CALIBRATE.
But as soon as TASK executes TURNKEY changes to MAIN but don't USAVE that.
10.3
RE-ENTRANT OUTER INTERPRETER
If a robot program is currently running it is possible to insert a new command (such as WHERE) and upon completion of this command have the robot continue with its original task. In order to do that you need to poll for some specific character from the supervisor, for example a space. For example
: TASK
BEGIN
SAFE
HOME
INKEY ASPACE = IF WHERE KEY DROP THEN
?TERMINAL UNTIL
;
This program will run the robot back and forth between SAFE and HOME until you press escape at which time the loop quits after doing the last HOME. If you press the space bar then after the robot has completed HOME the space is noticed and the system prints the results for WHERE. It then waits for the use to press another key (KEY DROP) and continues with indefinite SAFE HOME.
You can now replace WHERE KEY DROP with OUTER e.g.
: TASK
BEGIN
SAFE
HOME
INKEY ASPACE = IF OUTER THEN
?TERMINAL UNTIL
;
Now when you press the space bar you will see the OK prompt after the robot goes HOME. You can then enter (or the supervisor can send) any command at all as usual. Finally send the command EXIT and the original TASK will continue as before. Or send the required command and EXIT all on one line, for example WHERE EXIT.
Back to contents page
11 INFORMATION
WHERE
In joint mode yields current position of robot motors and
encoders, in Cartesian mode yields Cartesian position of robot.
WHICH
Tells which route is currently active, and what mode the route is
i.e. relative (a sub-route) or absolute.
MODE
Lists out various modes: local or global, joint or Cartesian,
simple or smooth (joint interpolated motion).
VIEW (position)
e.g. VIEW (place-name), VIEW LINE n
You can also VIEW RATIOS VIEW ENCRATIOS VIEW ENCTOLS
Lists out the co-ordinates of a single position. In the case of a
PLACE name lists out target and approach positions. Also shows
any objects present.
WHEREIS (object)
Shows name of place where object is.
LISTROUTE or L.
Lists the co-ordinates contained in the currently active route.
VLIST
Lists all the words in the dictionary in the form xxxx y zzzzz...
where xxxx is the memory address of the entry, y is the length of
the name, zzzzz... is the name. Each word is stored in the
dictionary as a length plus the first 5 letters of the word.
Therefore when listed back the unknown letters beyond number 5
are replaced with dots.
'VLIST (word)
Lists all the words in the dictionary of the same type as the
example following 'VLIST, in same form as VLIST.
ROUTES
Lists all route names in the dictionary in same form as VLIST.
PLACES
Lists all place names in the dictionary in same form as VLIST.
OBJECTS
Lists all object names in the dictionary in same form as VLIST.
POINTS
Lists all Cartesian points in the dictionary in same form as VLIST.
P
Prints the input on the PB port in binary. A '0' shows a sensor
is covered, a '1' shows axis is clear of sensor.
PP
Continually prints the input on the PB port in binary. A '0' shows a sensor
is covered, a '1' shows axis is clear of sensor.
XX WATCH
(e.g. QB WATCH) will display 8 bits from the specified port as 1s and 0s like PP.
HERALD
Shows current version of ROBOFORTH.
WRU
(who are you) reveals the serial number of the robot.
WWW
(what went wrong) brief explanation or error code of what happened to stop the robot.
SETTINGS
Shows settings of speed, acceleration, jerk and also emergency stop deceleration figure and the segment time for timed routes.
Just press escape if you don't want to change them. Press enter for any parameter to retain the existing value.
Back to contents page
PP
Continually displays the current state of the PB input (see P
above). If an input goes to zero (sensor is covered) there is a
beep.
XX WATCH
(e.g. QB WATCH) will display 8 bits from the specified port as 1s and 0s like PP.
ENCTEST
Continually displays the six encoder counts. As the axis is
moved by hand the counts change.
Further tests are available as projects.
Back to contents page
If the robot stops due to an error the error is reported. Each
error has a value which is put into the variable ERR.
If the computer or terminal is not connected when the error occurs then
the error can be found by inspecting the value in the variable ERR
e.g. ERR ? or you can write WWW (what went wrong?)
The errors are:
ERR value Error/Probable cause
1 Bad value
e.g. impractical value entered for SETRAMP or SETTINGS
2 Encoder mismatch
Robot stalled by obstruction or too high speed/acceleration
3 Stop button pressed
4 Interrupted
Interrupt connected and ENABLEd but INTVEC not SET
5 Can't Reach (co-ordinates out of bounds)
Position further than maximum reach of robot (e.g. 550mm for an
R19, 750mm for an R17, 500mm for an R12)
6 Cartesian position not valid
Some move in joint mode was made since the last Cartesian
move so that the Cartesian variables are out of date.
7 Non positional data in ADD
8 Invalid position in ADD, GOTO or LISTROUTE
9 ADDing joint and Cartesian positions together
10 ADDing two absolute positions
11 Invalid line number
12 Incorrect header using OLD (word doesn't match data)
13 Route full
14 RUN aborted
15 Object lost
UNGRIP used while holding object
16 Can't find sensor (sensor target not reached)
Usual reason is the distance to the sensor is too great and
the system has timed out. Alternatively a fault such as
motor or sensor cable disconnected;
perhaps sensor reflector damaged.
17 Can't clear sensor (behaving as if still on the sensor target)
Perhaps faulty sensor, or robot stalled or excess backlash.
18 Stalled in TEACH mode.
19 No room for any more data.
20 Tried to move with brake engaged.
21 Position already occupied (error in PUT).
22 Continuous path algorithm error.
23 ADJUST was hung (See section 7.3.5)
24 Invalid code in continuous path.
25 Didn't type START
or: PC port was reprogrammed or rewritten in such a way
as to disable the soft stop.
26 No object there (error in GET).
27 RELATIVE and SUB ROUTES discontinued.
28 START-HERE and END-THERE only work in Cartesian mode.
29 Invalid command in curve construction.
30 CHECK (CALIBRATE) error exceeds tolerance.
31 CHASE segment too large.
32 Bad angle value for TOOL motion. (non fatal)
33 ADJUST error – route has 2 or more identical adjacent lines resulting in negative speed.
Errors 12, 13, 19 would only occur in command mode, not while
robot is running.
Errors 14, 15, 18, 32 do not abort robot program i.e. only warnings
Errors 2, 3, 4 may be re-programmed.
For example to reprogram what happens when there is an encoder error enter in your text:
SET ENCVEC (word) where (word) is the definition of what happens when there is an encoder-stepper mismatch. For example:
: ALARM BEEP PA 5 ON ENCABORT ;
SET ENCVEC ALARM
Or to reprogram what happens when you press the stop button:
SET STOPVEC (word) (See section 6.1)
You also can arrange your own error traps with
(n) ABORT
which quits to the outer interpreter leaving (n) in ERR.
FORTH errors
The Forth interpreter itself can also issue errors. These do not
have error numbers. They are as follows:
If you use up a stack value when there is none the message is
"STACK UNDERFLOW". This check is not made until your word has
fully executed and command mode is re-entered, so too much stack
underflow in your word can crash the system.
"NUMERIC OVERFLOW" - result of signed multiply exceeding 32767 or
7FFF hex, or unsigned multiply exceeding FFFF hex or the result
of M* exceeding 7FFF FFFF hex.
"DIVIDE BY ZERO" - also fatal error i.e. program cannot continue
through such an error.
"ILLEGAL" means you used a compile-only word e.g. a control word
or semicolon (;) when not in compile mode.
Look out for possible stack errors including stack overflows. For
example you might confuse the syntax of WAIT with BIT?
PA 4 0 WAIT is legal
PA 4 BIT? is legal
PA 4 0 BIT? will not only NOT test PA 4 but will leave a value
(address of PA) on the stack each time it is invoked. Eventually
the system will crash, for example after some hours running the
system will do a cold or warm start for no apparent reason.
FORTH is a wide open system. Like an assembler you can access any
part of memory or input-output in any way you like. That also
makes it vulnerable.
Another crashing error is unequal nesting for example:
: TEST
PA 4 BIT? IF
TELL TRACK 4000 MOVE
THEN
;
If you leave out the word THEN, TEST will seem to work OK as long
as PB 4 BIT? is true. As soon as it is false the system fails.
: TEST2
100 0 DO
?TERMINAL UNTIL
LOOP
;
Disaster - there is no BEGIN.
During compilation (downloading to the controller) the controller uses the stack to calculate nesting loops. So unequal nesting could result in a stack underflow error. If not then try the command .S
This prints the contents of the stack which should be empty. If it is not empty then don't use the program until you have looked for the nesting problem.
Back to contents page
11.3 USING A NEST
A nest is a known location in the work space to which all the
other locations are related.
In theory all the locations are
related to the calibrate position i.e. the counts in the array
LIMITS. However if the robot is serviced (or even replaced with
another robot having a different "signature") or in case of
severe "trauma" (nasty collision) the calibrate position may
alter. Suppose, for example, the waist sensor were moved. All the
learned positions would move also. Therefore it is necessary to
drive the robot to a known location, count back to the calibrate
position and over-write the values in LIMITS to these new counts.
The nest should, ideally, be a separate location to any of the
positions which have been learned. For example make and mount a
dummy fixture that the robot's end effector can fit onto/into
with some accuracy. Type WHERE and note the (motor count)
positions. Suppose this resulted in:
WAIST SHOULDER ELBOW L-HAND WRIST OBJECT (R12/R17)
or WAIST LIFT EXTEND HAND TRACK OBJECT (R19)
or TRACK LIFT EXTEND HAND WRIST OBJECT (R15)
1000 2000 3000 4000 5000
1280 2560 3480 5120 6402
1001 2002 2999 4000 5001
Then enter:
CREATE NEST 1000 , 2000 , 3000 , 4000 , 5000 , 0 , 0 , 0 ,
The values are entered value space comma space value etc. There
should be 8 values in all so make the last three (or more) values zero.
Make sure this line goes into your text window for reloading.
Note: most learned positions are created in bank 1 of memory but a CREATEd position is in bank 0.
The system needs to be reminded which bank the CREATEd position is in, especially after using most motion commands which automatically switch to bank 1. Use the phrase:
BANK C0SET
Later you can correct errors with this procedure:
1. Press reset and enter START
2. Move to the NEST using commands and/or TEACH
3. Adjust the position of the robot to fit exactly using TEACH
4. enter BANK C0SET NEST ASSUME
5. enter ENCOFF to turn off the encoders (because they will try to undo what you have just changed)
6. TEACH robot clear of NEST
7. HOME
8. enter CHECK - this seeks out the sensors in the same way as
CALIBRATE but does not correct errors.
9. enter SETLIMITS
10. Enter USAVE (only when you have final values)
You have now changed LIMITS to new values to which all your
learned positions are related.
11. Save the new calibration figures by saving a copy of memory to disk using file, save binary, and a filename.RAM
Back to contents page
The best way to start is to sketch the workspace and write a "story board" of sequence of events. At some points in the workspace write possible place names for where the robot will stop. Or a route name if the robot needs to move from one place to another in a defined path.
Example 1
Programming a simple pick-and place cycle.
DEFINE ROBOT TASK:
1. If a part has arrived at the pickup point on the belt a signal
on bit 5 of port PB goes low.
2. Robot takes item from feeder belt and takes to the test jig.
3. Providing the test jig is ready the robot puts the item in the
jig. Jig ready is indicated by bit 6 of port PB being low.
4. Robot signals to test jig that a part is loaded by asserting
PA 1 low.
5. Robot waits for jig to complete. There is a signal from the jig
into bit 6 of port PB which goes logic low if the test
is complete. Bit 7 is high if the part is in the jig. So bit
6 must be low and 7 must be high is the jig is ready to be
unloaded.
6. When test is complete the robot picks the part from the jig.
7. Robot signals jig when it has taken the part by changing bit 1
of port PA back to high. Jig then restores bit 7 of port PB
back to logic low.
8. Robot puts the part into bin.
Note that both PB bits 6 and 7 must be low for the robot to put
a part into the jig. Thus if the test rig is switched off or if
either line breaks the jig cannot be loaded (fail-safe).
PROGRAMMING:
First the co-ordinates have to be programmed:
1. With the robot holding the part and using the teach pad put
the part into the gate on the feeder. 'Practice' removing
and replacing the part.
Create a PLACE called BELT
2. Raise above the belt.
Click 'set apprch'
3. With the robot holding the part (put part into gripper and enter
GRIP) seek out the jig with the teach pad.
Create a place called JIG
4. Using teach pad withdraw part from jig.
Click 'set apprch'
5. With the robot holding the part seek out the bin with the teach
pad. Create a place BIN
6. Raise gripper above and clear of bin.
Click 'set apprch'
7. Drive robot to a new position between the bin and the jig
which is higher than both as a safe intermediate position.
Create a new place SAFE
8. Save all the co-ordinates learned so far with project save
9. Add the program flow to the second text file using the ED2 window as follows.
( TASK.ED2 ) ( 4 JULY 1776 )
OBJECT PART
: JIGLOAD
PB 5 0 WAIT ( WAIT FOR PART TO BE PRESENT AT GATE )
PART ISAT BELT
BELT GET
PB 6 0 WAIT ( WAIT FOR JIG TO BE READY FOR PART )
( WE ASSUME THIS LINE IS ONLY ZERO IF THE JIG IS NOT BUSY )
PB 7 0 WAIT ( DOUBLE-CHECK THAT THE JIG IS EMPTY )
JIG PUT
PA 1 ON ( TELL JIG THAT PART IS LOADED )
( JIG THEN PROCEEDS, AND CHANGES PB 6 TO '1' AND PB 7 TO '1'
SAFE
;
: UNLOAD
PB 6 0 WAIT ( SIGNAL FROM JIG THAT TEST IS COMPLETE )
JIG GET
PA 1 OFF ( TELL JIG ROBOT HAS THE PART )
SAFE
BIN PUT
SAFE
;
: TASK
BEGIN ( BEGIN A CONTINUOUS LOOP )
JIGLOAD
UNLOAD
?TERMINAL UNTIL ( STOP AFTER COMPLETE CYCLE IF THE ESC KEY IS PRESSED )
;
( NOTE ROBOT WILL STOP IMMEDIATELY IF THE STOP BUTTON IS PRESSED )
: FULLTASK
START
CALIBRATE
TASK
;
AUTO FULLTASK ( FULLTASK WILL EXECUTE ON POWER UP )
Example 2
Multiple inputs.
Suppose the following:
: PLC PB 6 ; ( this is a signal from a PLC to pick up a part
: BUTTON PB 7 ; ( this is a button the user can press to end the program
: TASK
some action
this next BEGIN UNTIL loop checkes to see if either input goes too zero
BEGIN
PLC BIT? 0=
BUTTON BIT? 0=
OR UNTIL
if either PLC or BUTTON goes to zero the loop ends and continues here
PLC BIT? 0= IF ( yes it was PLC
but we only do the next bit if it was PLC signal
WHEEL GRIP ( going to wheel & grips disk
WAITING ( move up from wheel
OVERTABL ( move to place over table
TABLE UNGRIP ( move down to drop disk
OVERTABL ( move back up over table
WAITING ( move back to place over star wheel
THEN
if it wasnt the PLC but was the button then program jumps to here
;
The problem with the BEGIN - UNTIL loop above is that if neither signal goes to zero then there is no way out.
A good way to check things without actually aborting the loop would be to add
?TERMINAL IF OUTER THEN
Now if you press escape you get OUTER INTERPRETER and a command line. You can check inputs and anything else such as SPEED ? and so on.
: TASK
some action
BEGIN
?TERMINAL IF OUTER THEN
PLC BIT? 0=
BUTTON BIT? 0=
OR UNTIL
PLC BIT? 0= IF ( yes it was PLC
WHEEL GRIP ( going to wheel & grips disk
WAITING ( move up from wheel
OVERTABL ( move to place over table
TABLE UNGRIP ( move down to drop disk
OVERTABL ( move back up over table
WAITING ( move back to place over star wheel
THEN
;
So it's a useful thing to put in any program. As soon as you press esc you get a command line.
Enter EXIT to continue the program.
Example 3
The following is an example of words to search for an event. In this case the search is in the Z axis only.
The search runs by running a route ZLINE using CRUN. Create ZLINE as a Cartesian Row, suggested 101 lines.
Do set-to-here on the first and last lines then edit the last line say 100.0mm more than line 1 in Z.
Of course it can be in any axis or even at an angle.
The word START-HERE shifts the route to the current
robot position.
In this case the event is a change of state on PB 7 from 1 to 0
: SLOW 1000 SPEED ! ;
: FAST 10000 SPEED ! ;
: ZFIND
ZLINE ( invoke the route )
START-HERE ( move the start of ZLINE to where the robot is now )
SLOW ( predefined to put a low value in SPEED )
CRUN ( tell the DSP to run the robot )
BEGIN ( begin a loop )
?RUN 0= ( checking to see if the DSP has finished )
PB 7 BIT? 0= OR ( or your criterion here )
STOP? OR ( or if the stop button is pressed )
UNTIL
STOP ( stop the DSP )
BEGIN ?RUN 0= UNTIL ( wait for the DSP to finish deceleration )
DSPASSUME ( ask the DSP where it got to in counts when it was stopped )
COMPUTE ( change the counts to Cartesian coordinates )
900 PITCH ! 0 W ! ( make sure the hand is still vertical )
FAST
;
Example 4
The following is an example of a complex definition of an action
to be taken by the CPU while the DSP is running a route.
The required features are:
1. Throughout the route the stop button must be checked and if
pressed the CPU must tell the DSP to stop.
2. Part way through the route we wish to operate an air cylinder
defined as PUSH-CYL. So the line SETPA 5 is inserted at the
appropriate line. When the DSP gets to this it sends the value 5
back when polled by ?RUN and the CPU then operates PUSH-CYL.
3. After PUSH-CYL is operated we then wish to look out for a
signal from sensor PUSHED. When this sensor goes low we open the
gripper. But as a safety measure we insert the line GRIPPER 0
somewhere further along the route. When the DSP reads this line it
issues 2 from ?RUN to the CPU which turns the gripper off anyway.
: DSP? ( to follow CRUN - monitors state of DSP
FGRIP C1SET
BEGIN
STOP? IF ( if stop button pressed
STOP ( stop DSP ) FSTOP C1SET ( set flag
DSPRDY ( wait for DSP to finish
THEN
?RUN ( what is DSP doing?
DUP 5 = IF ( use SETPA 5 to turn on PUSH-CYL not gripper
PUSH-CYL OFF
THEN
DUP 2 = IF GRIPPER OFF THEN ( ANYWAY
PUSH-CYL BIT? 0= ( is PUSH-CYL off?
PUSHED BIT? 0 > ( is the sensor confirming?
AND ( both ) IF
GRIPPER OFF ( ungrip immediately
STOP ( stop the DSP
FGRIP C0SET ( set a flag
THEN
0= ( result from ?RUN is zero i.e. DSP has finished
FGRIP C@ 0= ( or the flag was set 3 lines back
OR UNTIL ( if either is true leave the loop
ESTOP? ( if stop flag was set by ?STOP then execute STOPVEC procedure
DSPASSUME ( correct counts to the values read back from DSP
GRIPPER OFF ( ungrip anyway in case the above fails
;
Example 5
Self learning
Suppose you have a matrix TRAY (with approach level), a place WASHER and route between the two, TOTRAY.
A typical definition might be:
: WASHPART
TRAY INTO GRIP UP ( get part
TOTRAY RUN ( go to the washer
WASHER UNGRIP WITHDRAW ( put part in washer
RETRACE ( go back to tray
;
Usage is (n) WASHPART
Notice that INTO has no number in front of it. It needs to know what number to go into and it gets that from stack. In (n) WASHPART, n is placed on the stack but is used by INTO which is part of the definition of WASHPART
You might also notice a small physical gap between the end of TOTRAY and the approach position of WASHER. You could try to make them the same but then every time you adjusted WASHER there would be a small gap again and an annoying jerk. So you can automatically adjust the last line of TOTRAY the first time round so that thereafter there is no jerk:
: WASHPART
TRAY INTO GRIP UP ( get part
TOTRAY RUN ( go to the washer
WASHER UNGRIP WITHDRAW ( put part in washer
MOVES E@ REPLACE
RETRACE ( go back to tray
;
You can go further. After retracing TOTRAY the robot's next move will be to a different position on the TRAY each time. You could make the first line of TOTRAY always the same as the approach position of the TRAY as follows:
: WASHPART
TRAY INTO GRIP UP ( get part
TOTRAY 1 REPLACE
RUN ( go to the washer
WASHER UNGRIP WITHDRAW ( put part in washer
MOVES E@ REPLACE
RETRACE ( go back to tray
;
This next example is more complex. Consider a reverse situation:
: GETPART
WASHER GRIP WITHDRAW
TOTRAY RUN
TRAY INTO
UNGRIP
UP
TOTRAY RETRACE
;
Usage:
n GETPART
where n is the required position on the tray and is taken up by INTO
Example 5 - interrupts
This example shuws how to set up a timer interrupt to control a heater. It is assumed there is a temperature sensor which gives 1 volt per 10 degrees:
The code checks the sensor every 500 mSecs and turns on or off the heater to regulate temperature to 60 deg. +/- 0.5 deg.
DECIMAL
: HEATER PA 6 ;
: TEMP
0 ADC
2048 -
1000 M* 2048 M/
;
: TEMP-CONTROL
TEMP
DUP 605 > IF HEATER OFF THEN
597 < IF HEATER ON THEN
RETURN
;
: HEAT
500 INT-TIME !
SET INTVEC TEMP-CONTROL
START-TIMER
;
Once you type HEAT the control will continue in the background and you can carry on your robot program.
©1989-2018 David N. Sands
button.