WHYP A Programming Language for the FC16 Forth Core

WHYP

A Programming Language for the

FC16 Forth Core

WHYP

Pronounced “whip”

“Words to Help You Program”

Subroutine-threaded Forth for Embedded Systems

68HC11 (16-bit)

68332 (32-bit)

68HC12 (16-bit)

WHYP is developed from scratch in the new book:

Design of Embedded Systems Using 68HC12/11 MicrocontrollersbyRichard E. HaskellPrentice Hall, 2000

FORTH is a programming language that ---was invented by Charles Moore in the early 70’s

is extensible

keeps all definitions in a dictionary

is extremely compact

is recursive

can be programmed in RAM, PROM, or ROM

is structured

uses a stack and postfix notation

Chuck Moorereading Haskell’sWHYP book

is extremely modularis interactiveis easy to debugallow easy machine accessis fastis transportablecan be understood in its entiretyis unlike any other language

FORTH is a programming languages that ---

Everything in WHYP is a word

WHYP words must be separated by a space

WHYP words are stored in a dictionary

WHYP words may be either interpreted or compiled

When in the interpret mode, a WHYP word is executed

When in the compile mode, a WHYP word is stored in the dictionary

Introducing WHYP (Forth)

If you type a WHYP word and press <enter>, the word will be executed (interpret mode)If you type a number (e.g. 6) and press <enter>, the number will be pushed on the data stack.WHYP uses the stack to pass parameters from one word to the next.You can define new words in WHYP by stringing together previously defined words.

Introducing WHYP (Forth)

The Structure of WHYP

Serial Line

send address

PC Target 68HC12

Kernel: LOOP BSR INWDY JSR 0,Y BRA LOOP

F82C

F82C ----- ----- ----- ----- ----- RTS

Dictionary: --- --- --- --- --- --- --- --- display F82C --- --- --- ---

C++ Program

ScreenC:\>whyp ok display

WHYP Arithmetic Operators

7 9 + .8 5 - .4 7 * .8 3 / .8 3 /MOD . .

WHYP Colon Definitions

: squared ( n -- n**2)DUP * ;

: cubed ( n -- n**3)DUP \ n n squared \ n n**2* ; \ n**3

WHYP Stack Manipulation WordsDUP ( n -- n n )SWAP ( a b -- b a )DROP ( a -- )OVER ( a b -- a b a )TUCK ( a b -- b a b )ROT ( a b c -- b c a )-ROT ( a b c -- c a b )NIP ( a b -- b )2DUP ( a b -- a b a b )2SWAP ( a b c d -- c d a b )2DROP ( a b -- )2OVER ( a b c d -- a b c d a b )

WHYP on the FC16

Stack Manipulation WordsFC16 Primitives

: DUP ( w -- w w ) DUP (0001);

: DROP ( w -- )DROP (0003) ;

: SWAP ( a b -- b a)SWAP (0002)

: NIP ( a b -- b ) NIP (0007);

Stack Manipulation WordsFC16 Primitives

: ROT ( a b c -- b c a)ROT (0005) ;

: -ROT ( a b c -- c a b)MROT (0006) ;

: OVER ( a b -- a b a)OVER (0004) ;

: TUCK ( a b -- b a b)TUCK (0008)

Stack Manipulation Words

Colon Definitions

: 2DUP ( a b -- a b a b )OVER (0004) \ a b aOVER (0004) ; \ a b a b

Memory Access Words

Fetch\ Fetch word at address T in RAM and \ load it into T

: @ ( a -- w ) fetch (0034) ;

Store\ Store the word in N at the address T. \ Pop both T and N.

: ! ( w a -- ) store (010E) ;

RAM Module

FC16

clk clrT

N

E1

SB

P

M

we

oe

cclk

E2

mclk bn

ProgramROM

P

M RAM

clk

clrwe

T

digload

clr

N

Return Stack WordsTo-R

: >R ( w -- ) \ pop T & push to R TOR (0030) ;

R-From: R> ( -- w ) \ pop R & push to T RFROM (0031) ;

R-Fetch: R@ ( -- w ) \ copy R & push to T RFETCH (0032) ;

R-From-Drop: R>DROP ( -- ) \ pop R & drop it RFROMDROP (0033) ;

Arithmetic Words

Plus w3 = w1 + w2: + ( w1 w2 -- w3 ) PLUS (0010) ;

minus w3 = w1 - w2: - ( w1 w2 -- w3 ) MINUS (0011) ;

Arithmetic Words

One-plus w2 = w1 + 1: 1+ ( w1 – w2 ) PLUS1 (0012) ;

One-minus w2 = w1 - 1: 1- ( w1 – w2 ) MINUS1 (0013) ;

Logical Words

Bitwise AND: AND ( w1 w2 -- w3 ) ANDD (0015) ;

Bitwise OR: OR ( w1 w2 -- w3 ) ORR (0016) ;

Bitwise XOR: XOR ( w1 w2 -- w3 ) XORR (0017) ;

One’s complement: INVERT ( w1 -- w2 ) INVERT (0014) ;

TRUE = X“FFFF”: TRUE (-- w ) ONES (0020) ;

Logical Words

FALSE = X“0000”: FALSE (-- w ) ZEROS (0021) ;

Branching and Looping in WHYP

IF…ELSE…THEN

FOR…NEXT

BEGIN…AGAIN

BEGIN…UNTIL

BEGIN…WHILE…REPEAT

IF…ELSE…THEN

<cond> IF <true statements>

ELSE<false statements>

THEN

<cond> is either TRUE (-1) or FALSE (0)

WHYP Conditional Words

< ( n1 n2 -- f ) (“less-than”)> ( n1 n2 -- f ) (“greater-than”)= ( n1 n2 -- f ) (“equals”)<> ( n1 n2 -- f ) (“not-equals”)<= ( n1 n2 -- f ) (“less-than or equal”)>= ( n1 n2 -- f ) (“greater-than or equal”)0< ( n -- f) (“zero-less”)0> ( n -- f) (“zero-greater”)0= ( n -- f) (“zero-equal”)U< ( u1 u2 -- f ) (“U-less-than”)U> ( u1 u2 -- f ) (“U-greater-than”)U<= ( u1 u2 -- f ) (“U-less-than or equal”)U>= ( u1 u2 -- f ) (“U-greater-than or equal”)

\ Convert hex to ASCIIHEX

: hex2asc ( n -- asc ) 0F AND \ mask upper nibble DUP 9 > \ if n > 9 IF 37 + \ add $37 ELSE 30 + \ else add $30 THEN ;

>R

Decrement top of return stack and branch back to <WHYP statements> if not equal to zero.Therefore, <WHYP statements> are executedn times.

FOR…NEXT Loop

n FOR <WHYP statements> NEXT

drjne <WHYP statements>

BEGIN…AGAIN

BEGIN <WHYP statements> AGAIN

BEGIN…UNTIL

BEGIN <WHYP statements> <flag> UNTIL

<flag> is either TRUE or FALSEusually from some WHYP conditional word

BEGIN…WHILE…REPEAT

BEGIN <words> <flag>

WHILE <words>

REPEAT

\ Example of BEGIN...WHILE...REPEAT

: factorial ( n -- n! ) 1 2 ROT \ x i n BEGIN \ x i n 2DUP <= \ x i n f WHILE \ x i n -ROT TUCK \ n i x i * SWAP \ n x' i 1+ ROT \ x' i' n REPEAT \ x i n 2DROP ; \ x

x = 1; i = 2;WHILE (i <= n) { x = x * i i = i + 1 }factorial = x

Zero-equals -- true if T = 0 (NOT): 0= ( n -- f )

zeroequal (0022) ;

FC16 Relational Operator Words

Zero-less-than -- true if T < 0: 0< ( n -- f )

zeroless (0023) ;

Zero-greater-than -- true if T > 0: 0> ( n -- f )

DUP 0= \ n f1SWAP 0< \ f1 f2

OR NOT ;

U-less-than -- true if u1 < u2: U< ( n1 n2 -- f )

ult (0025);

Relational Operator Words

equal-to -- true if n1 = n2: = ( n1 n2 -- f )

eq (0026) ;

if N > T then ones;else zeros;endif;

when ugt

Implement theseinstructions directlyIn Funit

U-greater-than -- true if u1 > u2: U> ( u1 u2 -- f )

ugt (0024);

U-greater-than-or equal -- true if u1 >= u2: U>= ( u1 u2 -- f )

ugte (0027) ;

Relational Operator Words

not-equal-to -- true if n1 /= n2: <> ( n1 n2 -- f )

neq (0029) ;

U-less-than-or equal -- true if u1 <= u2: U<= ( u1 u2 -- f )

ulte (0028) ;

greater-than -- true if n1 > n2: > ( n1 n2 -- f )

gt (002A) ;

Relational Operator Words

less-than -- true if n1 < n2: < ( n1 n2 -- f )

lt (002B) ;

use IEEE.std_logic_arith.all;

variable avs, bvs: signed (width-1 downto 0);

In Funit16

use IEEE.std_logic_arith.all;

variable avs, bvs: signed (width-1 downto 0);

for i in 0 to width-1 looptrue(i) := '1';false(i) := '0';av(i) := a(i);bv(i) := b(i);avs(i) := a(i);bvs(i) := b(i);

end loop;

variable y_tmp: STD_LOGIC_VECTOR (width-1 downto 0);

when “101010" => if (avs > bvs) then y <= true;

else y <= false; end if;

  when “101011" =>

if (avs < bvs) then y <= true;

else y <= false; end if;

In Funit16

greater-than-or-equal -- true if n1 >= n2: >= ( n1 n2 -- f )

gte (002C) ;

Relational Operator Words

less-than-or-equal -- true if n1 <= n2: <= ( n1 n2 -- f )

lte (002D) ;

if ( f -- ) JZ (0102)----

else JMP (0101)------

then

Branching Words

begin----

while ( f -- ) JZ (0102)------

repeat JMP (0101)

Branching Words

begin------------

until ( f -- ) JZ (0102)

Branching Words

begin------------

again JMP (0101)

Branching Words

for (cnt -- ) >R------------

next DRJNE

---

Looping Words