The most extensive and powerful robot control system on the planet
ROBOFORTH II is a 4GL robot control language designed to cover every eventuality in programming your robot, whether it be coating, assembly, laboratory handling, testing, or whatever. There are various means of acquiring spatial data and using it such as matrices, continuous path, object tracking, collision avoidance, plus numerous input-output features making it easy to interface with and control peripheral equipment at the same time as control the robot arm. Above all ROBOFORTH is a real language i.e. has an extensive vocabulary of words, which, like a natural language, help you express your ideas to the system. As a language ROBOFORTH is a means of communication between the human user and the robot arm: for the user to tell the robot what to do and how to do it; for the robot to tell the user what it is doing and what it knows.
FORTH and ROBOFORTH are organized as a linked list of words known as the dictionary. Together with each word in the dictionary is its definition, which is usually in terms of words lower down in the dictionary except for 'primitives' at the bottom, which are coded in machine language. There are 300 - 400 words in ROBOFORTH available to the user. Programming in FORTH and ROBOFORTH consists of entering new words into the dictionary whose definitions are in terms of words already defined. New words may include data e.g. positional information about the robot. Data (or arguments) are passed between words on a stack. Machine code may be included; these also have dictionary entries. For those familiar with FORTH the dictionary structure is designed on the original indirect address pattern. Programming is with text files not block files. more information
Any given position of the arm may be specified as coordinates relative to a central position for the arm known as the HOME position. In ROBOFORTH II these coordinates are in terms of the movement required by the motors of the arm to reach that position i.e. number of motor 'bits' counted from the HOME position. Alternatively they may be expressed in millimetres in Cartesian X,Y,Z coordinates. To teach the robot you first move the arm to the required position using any of the means provided and secondly record the coordinates of that position. When replayed the arm moves from one position to the next in turn (point-to-point programming). Each position is a list of values plus flags to indicate what kind of data it is e.g. Cartesian coordinates, absolute or relative coordinates, name of any object in that position etc. The robot can also learn positions itself, for example by searching or by computing a target position or by modifying a taught path to suit a new requirement.
In ROBOFORTH II there are various means of moving the robot and various ways of teaching the robot. These are distinctly separate. In practice the procedure is to first move the robot to the desired position then learn it. Positions or lists of positions have names, which are provided by you, the user and the names or 'words' form headers. Finally the words are used in procedures, which determine, which positions the robot goes to and when/why. There are three files resulting: the positional data, the headers and the procedure (program) file.
The gripper must also be operated and learned as two separate operations. Similarly any activity may be tested in immediate mode or 'compiled' into the definition of a new word. Error conditions can be re-programmed so, for example you can determine what the robot does and what happens to the associated equipment in the event of the stop button being pressed or in the event of a stall because of jammed product. These and other features make ROBOFORTH II the most powerful robot control system in existence.
While ROBOFORTH runs in the robot controller its counterpart, ROBWIN runs in the computer. ROBWIN is only used for programming and may be dropped once the robot is programmed.
ROBWIN provides a communications window through to the controller but also allows the user to quickly access many of the features of ROBOFORTH by clicking buttons and by completing 'dialog boxes' and maintains disk files.
Moving the robot and teaching the robot are two separate operations.
Moving the robot
may be achieved with any or a combination of four methods:
1. Using a TEACH PAD:
After clicking the teach button on screen simply select a joint or axis on the teachpad then press the + key to move in one direction or - in reverse; movement continues as long as the key is pressed. Low speeds are appropriate for accurate positioning and speed may be changed up or down on screen or from the teachpad.
2. Commanding each joint:
Commands such as TELL SHOULDER 1000 MOVE which moves the shoulder axis 1000 counts. Other commands are: MOVETO (an absolute command), GRIP, UNGRIP, HOME, CARTESIAN, JOINT, ALIGN/NONALIGN and so on. There are about 250 commands and settings in ROBOFORTH and a total vocabulary of around 800 words.
3. Positioning in Cartesian coordinates: (reverse kinematics)
Dialog boxes permit positioning in absolute or relative coordinates. Alternatively MOVE or MOVETO commands may be entered or included in a program. Wrist/hand angles may be specified or controlled. Tool transformations depend on robot model and number of axes.
4. Jog.
The teach pad may be used in 'Jog' mode in which the keys represent X, Y, Z, pitch and roll axes. Each press of the + or - key causes the robot to move a set increment in the selected direction. The increment may be reduced on screen or from the teachpad as the robot nears the target position.
5. 'Lead-by-the-nose'
As with most robots it is possible to de-energize the robot, position it by hand and learn that position. However the skill required to position a robot to better than a millimeter is beyond most people so we don't recommend it.
Teaching the robot
may be achieved by choosing one of two 'entities':
1. A Route:
This is a list of spatial coordinates each of which is a row of numbers representing motors counts away from the zero (HOME) position or absolute cartesian coordinates. The route is created by the user with his/her given name e.g. ROUTE I66. ROBWIN makes this simple with a dialog box that creates the entry in the controller as well as on disk. Coordinates are then added to the list by clicking 'insert position' or using the tick key on the teachpad. The robot moves from point to point with the command RUN - either stopping at each point or moving through them. Associated commands provide editing and the ability to run parts of a route, or to retrace. A route is also used as a reference for discrete positions, for palletizing for example. Editing is achieved using dialog windows or with ROBOFORTH commands such as REPLACE which also permit self learning features, for example the robot can modify its own positions according to the programmed procedure. Functions such as gripper operation, delays, speed changes, spray/glue on/off etc. can be embedded in the route to take effect in the required sequence.
A Matrix is also a list, organized in 2 dimensions and a row is one-dimensional. The number of rows and columns are specified in dialog boxes, the corners of the matrix learned and the system computes the rest of the positions and downloads them to the controller.
2. A Place:
This is a single named coordinate. It is self learning and self executing. It is created by the user with his/her given name using a dialog box or with a native command e.g. PLACE JIG.
To return the robot to this position later simply use the word JIG.
Finally all these learned and named entities are used in the procedure file to create new definitions or 'words' which determine how the positions are used, i.e. in what order, in what circumstances etc. For example a word might be defined using a PLACE named JIG and a matrix route named TRAY:
: GETPART
TRAY INTO
GRIP
UP
JIG
UNGRIP
WITHDRAW
;
Because FORTH and ROBOFORTH are stack oriented the position within the TRAY is given on the stack just before the command, for example
5 GETPART will get a part from position 5 of the TRAY and put into the JIG
This may be typed as a command into the communications window, or sent from a supervisor, which computes the position number, or further compiled into an even higher level definition.
Extensive input-output is also provided, which is easily programmed and integrated with robot motion, for example suppose a pump were connected to parallel port PA on bit 5. You could add a definition thus:
: PUMP PA 5 ;
You can then control the pump with simple PUMP ON and PUMP OFF. This could then be included in your higher level definition:
: GETPART
TRAY INTO
GRIP
UP
JIG
UNGRIP
WITHDRAW
PUMP ON
5000 MSECS
PUMP OFF
;
Object database
Objects may be defined and used to ensure the robot has gripped successfully, keeping track of where it has put things and eliminating the danger of placing an object in a position already occupied. The above definition could be enhanced thus:
OBJECT PART
PART TRAY FILLUP
: GETPART
TRAY INTO
GET
UP
JIG PUT
PUMP ON
5000 MSECS
PUMP OFF
;
Advanced features
Include the ability to re-program errors such as what happens when you press the stop button. The robot always stops with controlled deceleration when the 'soft' stop is pressed, and normally the system aborts. However it is possible to program alternative action using 'vectored execution', for example turn on a light and wait for the green button to be pressed, then perform some recovery procedure and continue with the main task. The result is rather like an interrupt, which is also programmable as are positional errors. For example if there is a jam in the machine with which the robot is working the robot may crash into it, causing a positional error, which normally aborts the system. This could be reprogrammed to pull back, flash a light then wait for an operator to clear the condition and press the continue button. Suppose the robot is carrying a rotary cutter. When the stop button is pressed the cutter must stop also. When the continue button is pressed the robot can continue; the cutter is turned back on but only if it was on when the stop was pressed.
New I/O service routines can be programmed in machine code, which have dictionary entries and can be included in other definitions. Real processor interrupts can also be programmed if required without any effect on robot motion. Other features include the ability to take analog measurements while the robot is moving, for example to build a force/displacement profile and upload it to the PC.
The robot can be programmed to learn it's own coordinates (self teaching), for example to modify a path you taught it so that it changes as a target position changes.
Because ROBOFORTH is based on a real computer language your robot program can include calculations, branching, recursion and so on.
This has been just a glimpse of the immense power of this little known open architecture system, containing several hundred commands and unique extensions. It's a building block approach, which encourages programming interactively with the robot system, a true man-machine interface.
ROBWIN
ROBWIN is a visual project management system for most versions of Windows.
ROBWIN brings everything together in one screen - the robot controller and your files, the positional information and the procedures, which use that information. Once programmed ROBWIN can be terminated and the new commands sent by other software or equipment or the controller can be set to auto-run with no computer. One window, which appears provides the user with direct communication with the robot controller, for entering commands, trying out small robot procedures before using them as building blocks for bigger ones.
ROBWIN generates ROBOFORTH commands, which it sends down to the controller and they appear in the communications window along with your own. As locations are learned and edited the data is built up both in the computer and in the controller. ROBWIN maintains the data files and the header files invisibly and provides a text editing window for the procedure file. Matrix generation is made easy and learned locations can be renamed, edited and so on all on-screen. In addition it can communicate and upload/download data. A typical screen is shown below.
Typical ROBWIN screen:
Functions available
Pull-down menus from left to right:
File: open ed2 text file, download text file to controller, upload/download binary, print.
Edit: usual cut and paste etc. for the text files.
Settings: Load/save a settings file with speeds and joint names, change speed and acceleration, configure system.
Comm: Change baud rates also change fonts.
Robot: display or change position of robot in joint or Cartesian coordinates, relative or absolute moves. Choose modes, for example smooth mode, continuous path mode.
Project: open/save project files.
Macro: you can write/edit macro commands, which are strings sent to the controller. Seven wide buttons are available for this. In the example above you can see three buttons programmed with 19200 baud, 56000 baud and CONTINUOUS mode. Just by pressing the 56000 button for example the controller will be sent a string, which changes its baud rate to 56000.
View: changes which tool bars show.
Window: usual Windows feature.
Help: Forehelp system. ROBWIN is supported but not the whole of ROBOFORTH. A manual for ROBOFORTH is in html with dynamic links between inter-related subjects.
Buttons, left to right
Open file, save file, cut, copy, paste, START, CALIBRATE, HOME, TEACH mode - invokes the teach pad, JOG mode - invokes the teach pad in Cartesian mode, GRIP/UNGRIP (toggles), SMOOTH mode, JOINT mode, CARTESIAN mode, upload data from controller, download text to controller, help, help specific.
A typical open route dialog box
showing creation of a new matrix TRAY1 in Cartesian mode, 10 columns by 5 rows.
A typical route editing
Here a Cartesian matrix, "route" 3SHELF is being edited using add-to-all, which can shift the entire matrix in any direction. This matrix has 10 positions (could just as easily be several hundred) comprising a 4 by 2 matrix plus two extra positions plus a relative position (marked R). The system adds the relative position to the other 10 to provide another 10 displaced from the first (in this case by 30mm in the Z direction), for example as approach or via positions. This economizes on memory space. Only three corners of a matrix need be taught (marked with asterisks) then the interpolate button is pressed and all the in-between positions are computed. Robwin and ROBOFORTH are designed to permit creation and editing of very large matrices with ease and can manage a great number of them to suit the most complex workspace.
Programming techniques:
Routes and places may be created using the visual project management system, ROBWIN. These are put into the dictionary in the controller and the positional data goes into a data area, which holds all the coordinates. The data area is maintained simultaneously in the computer. The system creates a text file for route and place names (header file) and the procedure continues in a second text file. The procedure file is edited in its own window and downloaded to the controller after each edit.
Normally there are many refinements which are developed to suit any particular application. For example it might be a bad time to invoke the error, which prevents collisions if the robot is inside some machine. So checking for the presence of an object in the way may be done before the robot enters the machine.
Supervisors
A supervisor is software, which controls other equipment besides the robot, supervising the entire process. Once ROBWIN has been used to create spatial data, define procedures, device handling strategies etc. these procedures, known as words, may be sent to the controller via serial link, for example using PRINT commands in BASIC or via RobX ST's ActiveX interface. proprietary supervisors may be used for example 'A-S Automate' from Aitken Scientific and Overlord from Process Analysis Automation (PAA). Both these supervisors have been used successfully to manage and schedule large systems comprising diverse instruments serviced by ST robots. Using RobX you can also write your own supervisor in VB or C and it works successfully with Labview.
ActiveX
If you are writing your own supervisor you can set up your own RS232 handler (or USB/RS232 converter) or can use ST's ActiveX interface. Commands or 'methods' are of the form:
short OpenComm(short Port, long BaudRate);
Opens the communications port. The return value is 1 if successful, 0 for failure. Use the method GetCommErrorString() to get a description of the problem.
short SendString(LPCTSTR String);
Sends the string to the controller. The string should end with a "Carriage Return" character (ASCII 0D hex). Typical strings will be definitions you have programmed into the controller using ROBOFORTH for example GETPLATE. 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:
-1: Communication error
0: Waiting
1: Ready, but not OK (some robot error)
2: Ready received OK
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 2 the response string indicates what went wrong, for example you told the robot to go to a position it could not reach, or to put an object in a place already occupied.
Other methods include about box, closing the comms port, getting error codes etc.
Manuals
Software manuals are provided on disk only; hard copy is no longer used. You can see new and archived manuals at 
