1 / 42

Rob Perrin Ron Hathaway

Learn about the origins of Forth programming language and its key elements such as the dictionary, stacks, interpreter, and more. Discover how Forth influenced variants like pbForth and its unique stack manipulation capabilities.

rbrink
Download Presentation

Rob Perrin Ron Hathaway

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Rob Perrin Ron Hathaway

  2. 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.

  3. 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."

  4. 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.

  5. 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.

  6. 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

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

  8. Forth Interpreter Model:

  9. Data Stack: • The Data Stack holds the arguments being passed between Words. This stack replaces the parameter lists used by conventional languages. • 1 2 3 (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 • 1 2 3 • ok

  10. 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.

  11. 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.

  12. 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

  13. 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.

  14. Data Types: • Scalar • 1 2 3 integer • 16 bit, 32 bit, signed, unsigned • 0 3 -1 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 Addresses • @ (Retrieves the cell value stored at the address • ! (Stores the value x into the cell at the address

  15. 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 • Use @ and ! to manipulate the array • Forth has no support for data typing either at compile time or at runtime.

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

  17. 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

  18. 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 • 1 2 1 • ok

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

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

  21. Stack Manipulation: • ROT (n1 n2 n3 n4 -- n2 n3 n4 n1) • 1 2 3 4 ROT .s • 2 3 4 1 • ok • -ROT (n1 n2 n3 n4 -- n4 n1 n2 n3) • 1 2 3 4 -ROT .s • 4 1 2 3 • ok

  22. 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 • 1 2 1 2 • ok • Notable, no documentation of being able to use larger numbers to manipulate more elements.

  23. 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

  24. 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) • 2 3 + 4 * (equivalent to [2+3]*4

  25. 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

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

  27. 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

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

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

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

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

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

  33. 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.

  34. 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

  35. 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 • 1 Forward • 2 Backward • 3 Stop • 4 Float • 7 2 0 MOTOR_SET (Have motor C run forward at full power

  36. 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 • 1 RUN button pressed • 2 PRGM button pressed • 3 VIEW button pressed

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

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

  39. 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

  40. 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 65535. • TIMER_SET ( idx value -- ) • TIMER_GET ( idx -- value )

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

  42. Sources: • http://www.cs.rit.edu/~ats/plcr-2002-1/reports/pbforth/ • Dan Lovette & Fuyuko Takegawa • http://www.cs.rit.edu/~ats/plcr-2003-1/reports/pbforth/index.html • Josh King & Joe Spears • http://www.forth.com/resources/evolution/index.html • Forth, Inc explaination of Forth • http://dec.bournemouth.ac.uk/forth/forth.html • Forth: An underview • http://www.taygeta.com/forth/dpans.html • American National Standard for Information Systems, Programming Languages, Forth • http://dec.bournemouth.ac.uk/forth/rfc/index.html • The Rochester Forth Conference, Held at UofR • http://www.hempeldesigngroup.com/lego/ • Hempel Design Group, LEGO? Models and Robotics • http://www.forthfreak.net/wiki/ • ForthFreak • http://hem.passagen.se/tiletech/forth.htm • Crash Course In Forth • http://www.circuitcellar.com/DesignForum/features/9805022/TNtext.htm • Lost at C? Forth May Be the Answer

More Related