Rob Perrin Ron Hathaway

Forth History Forth started in the 50's as Charles Moore person work tool in response to his frustration with existing software tools, which he viewed as a sort of "tower of Babel." By 1971, Charles Moore began calling the interpreter Fourth. This was due to the fact that they were working on machines that were considered third-generation. He felt his interpreter was so advanced, that it was a fourth-generation language. He had intended to call it Fourth, however, the system he was working on at the time only had space for five character identifiers. Therefore, the "u", was dropped and thus FORTH was born.

Elements of Forth: Dictionary with words Push down stacks Interpreter Assembler Postfix computation Interactive Absolutely no data typing "If I want to add 1 to the letter A, it's none of the compiler's business to tell me I can't."

What do this have to do with pbForth? Forth in it's popularity and commercialization has spawned dozens of Forth variants. pbForth is a version designed by Ralph Hempel to work specifically with the LEGO Mindstorms RCX brick as volatile firmware sitting between non-volatile firmware and end user programs. After pbForth (14KB) is loaded 14KB is left in RAM for pbForth programs to run compared with 6KB in the case of the standard firmware.

Forth Words and the Dictionary: The Dictionary in pbForth is a maintained list of all the currently defined Words. Words can either be made of a collection of other Words or a set of direct assembly instructions to the hardware. Other versions of Forth may implement multiple Dictionaries.

Forth Words Continued: The definition of a new Word starts with a : and ends with a ; The first white space delineated string after the colon is the new Word. All subsequent strings are Words defining the action of the new Word. : double (n1 -- n2) 2 * ; (n2 is 2 times n1

Forth Words Continued: To see the construct behind a Forth Word you would use the SEE command. SEE double : double (n1 -- n2) 2 * ; (n2 is 2 times n1 ok

Forth Interpreter Model:

Data Stack: The Data Stack holds the arguments being passed between Words. This stack replaces the parameter lists used by conventional languages (pushes the successive numbers on the stack... (pop successive values off the stack To take a look at the stack use the.s command.s ok

Return Stack: The Return Stack is used to hold return addresses for nested definitions, although other kinds of system data are occasionally held there temporarily. The user could access this stack but it is not recommended.

Lexical Input Format: Forth code is just a bunch of Words with spaces between them. There are only minimal rules for how Words are to be used in context or for formulation of expressions.

Line Orientation & Comments: It is not line oriented, with the exception of some forms of comments. ( comment only within parentheses ) ( comment till end of line \ again comment till end of line

White Space: White Space is ignored : double (n1 -- n2) 2 * ; (n2 is 2 times n1 : double (n1 -- n2) (treated the same as above 2 * ; A notable exception is that with the command SEE the Word definition will be returned in the format it was entered.

Data Types: Scalar integer 16 bit, 32 bit, signed, unsigned flag Non-zero is true, zero is false Forth flags are cell-size bit patterns like Forth integers and Forth integers can be used as Forth flags. Memory the cell value stored at the address !(Stores the value x into the cell at the address

Data Types: Aggregates 2.4e float Stored as two integers consecutively in memory To represent floating point numbers they must have an e at the end. “Forth”string.”(prints the up to, not including next double quote Arrays CREATE forthArray 32 CELLS ALLOT and ! to manipulate the array Forth has no support for data typing either at compile time or at runtime.

Scope: General Forth has locals and globals \ Exchange values of two variables \ Without locals : vswap1 ( addr1 addr2 -- ) 2DUP R> ! R> ! ; \ And With locals : vswap2 ( addr1 addr2 -- ) LOCALS| v1 v2 | v1 ! v2 ! ;

Lifetime: Words maintain their meaning even when sub-words are changed. : HELLO." Hello World" ; HELLO Hello World ok : SAY-HI HELLO ; SAY-HI Hello World ok : HELLO." Greetings" ; HELLO Greetings ok SAY-HI (Will keep its original value, despite the change of HELLO Hello World ok

Stack Manipulation: DUP(n1 -- n1 n1) 2 DUP.s 2 2 ok ?DUP (same as above, but only if n1 is not 0 OVER(n1 n2 -- n1 n2 n1) 1 2 OVER.s ok

Stack Manipulation: SWAP (n1 n2 -- n2 n1) 1 2 SWAP.s 2 1 ok DROP (n1 -- ) 1 2 DROP.s 1 ok

Stack Manipulation: NIP(n1 n2 -- n2) 1 2 NIP.s 2 ok TUCK(n1 n2 n3 -- n1 n3 n2 n3) TUCK.s ok

Stack Manipulation: ROT(n1 n2 n3 n4 -- n2 n3 n4 n1) ROT.s ok -ROT(n1 n2 n3 n4 -- n4 n1 n2 n3) ROT.s ok

Stack Manipulation: By putting a two, 2, in front on these Words the action will affect two members of the stack. 2DUP (n1 n2 -- n1 n2 n1 n2) 1 2 2DUP.s ok Notable, no documentation of being able to use larger numbers to manipulate more elements.

Display Options: There are several ways to format output, if no option is given the value will be returned as a signed integer. DECIMAL(print as decimal HEX(print as hex CR (force carriage return u (as unsigned integer c (as ASCII character d (as signed double-cell integer f (as floating-point

Math, Postfix Evaluation: + (n1 n2 -- n3) -(n1 n2 -- n3) *(n1 n2 -- n3) /(n1 n2 -- n3)(stores only the quotient */(n1 n2 n3 -- n4)(equivalent to [n1*n2]/n3 MOD(n1 n2 -- n3 n4) (remainder & quotient */MOD(n1 n2 n3 -- n4 n5) * (equivalent to [2+3]*4

Conditionals: =(n1 n2 -- f) <(n1 n2 -- f) >(n1 n2 -- f) 0=(n1 -- f) 0<(n1 -- f) AND(n1 n2 -- n3) (bitwise AND on n1 & n2 OR(n1 n2 -- n3) (bitwise OR on n1 & n2 XOR(n1 n2 -- n3) (bitwise XOR on n1 & n2 INVERT(n1 -- n2) (bitwise inverse of n1

Loops:.. IF.. ELSE.. THEN : ifLoop ( n1 -- n2 ) 0 = IF 4 ELSE ( ELSE is optional 6 THEN ; ( may also use ENDIF

Loops:.. DO.. LOOP : doLoop ( n1 n2 -- ) (for loop equivalent DO (sets loop index i to n2 i.s LOOP(increment i up by 1, if i > n1 exit, else repeat ; Notable, i is a keyword as are j and k for further nested loops

Loops: BEGIN.. UNTIL : finiteLoop ( n1 -- ) BEGIN DUP. 1 - DUP 0 <(loop till this condition is met UNTIL DROP ;(then go on

Loops: BEGIN.. AGAIN : infiniteLoop ( n1 -- n1 ) BEGIN DUP. AGAIN ; (loop back to the BEGIN

Loops: BEGIN.. WHILE.. REPEAT : multiLevelLoop BEGIN DUP DUP. 0 = if WHILE(if flag true, do lower block,.(else start over at BEGIN REPEAT;

Direct Memory Access: CREATE, ALLOT CELLS CELL+ VARIABLE CONSTANT VALUE TO

Multi-Tasking: Older version of pbForth where multi-tasking, but current version is not

The RCX: The software engineers at LEGO provided the RCX with a bunch of helper routines. The pbForth system uses the obvious ones to control the motors, read sensors, and drive the LCD. There are also math routines for multiply and divide built into the RCX, and this version of pbForth makes extensive use of them. The result is blazingly fast fixed-point math.

The RCX: RCX and Power Controls RCX_INIT (Before any other command can be (issued the RCX must be initialized. RCX_SHUTDOWN RCX_POWER(return value of POWER_GET POWER_OFF(shutdown POWER_GET(what is the voltage and is it on

The RCX: Motor Control MOTOR_SET ( power mode idx -- ) power has a range of 0 to 7 idx indicates which output 0 = A, 1 = B, 2 = C mode 1Forward 2Backward 3Stop 4Float MOTOR_SET (Have motor C run forward at full power

The RCX: Button Controls BUTTON_INIT (Button system must be initialized (before any buttons can be used. RCX_BUTTON (return the value of BUTTON_GET BUTTON_GET 1RUN button pressed 2PRGM button pressed 3VIEW button pressed

The RCX: Sensor Controls SENSOR_INIT (Sensor system must be initialized (before any buttons can be used. SENSOR_TYPE(type idx -- ) Type 1Touch(must be set to active 2Temperature(must be set to passive 3Light(must be set to passive 4Rotation(must be set to active idx 0 Sensor 1 1Sensor 2 2Sensor 3

The RCX: Sensor Controls SENSOR_ACTIVE ( idx -- ) SENSOR_PASSIVE (idx -- ) SENSOR_MODE (mode idx -- ) mode 0Raw mode 32Boolean mode 64Edge detection - every transition counts 96Pulse detection - only negative transitions count 128Percent of scale 160Degrees Celsius 192Degrees Fahrenheit 224Angle detection

The RCX: Sensor Controls SENSOR_READ ( idx -- ) (get data from this sensor SENSOR_RAW ( idx -- raw ) SENSOR_VALUE ( idx -- val ) SENSOR_BOOL ( idx -- bool ) SENSOR_CLEAR ( idx -- )(clears stored value, leaves (mode and type intact

The RCX: Timer Controls High Resolution There are ten, with 10ms declinating counters that stop at zero. timer_SET( idx value -- ) timer_GET( idx -- value ) Low Resolution There are four, with 100ms incrementing counters that roll over at TIMER_SET( idx value -- ) TIMER_GET( idx -- value )

The RCX: Sample Code :square ( -- ) BEGIN MOTER_SET (both motors forward MOTER_SET timer_SET ( 0 4 ) timer_GET = 0 IF UNTIL BEGIN MOTER_SET (set motor to reverse timer_SET ( 0 4 ) timer_GET = 0 IF UNTIL AGAIN ;

Sources: Dan Lovette & Fuyuko Takegawa Josh King & Joe Spears Forth, Inc explaination of Forth Forth: An underview American National Standard for Information Systems, Programming Languages, Forth The Rochester Forth Conference, Held at UofR Hempel Design Group, LEGO? Models and Robotics ForthFreak Crash Course In Forth Lost at C? Forth May Be the Answer