code sine       ( array arraysize binangle -- )
    mov PTRA,b
    shl PTRA,#3
    add PTRA,c
    sub PTRA,#8                         ' ptra points to last sample in the array
    rdlong xx,ptra++
    rdlong yy,ptra                      ' xx,yy loaded with last sample in the array
    mov zz,a                               ' zz loaded with the intersample binangle
    mov PTRA,c                          ' PTRA points to start of array
    rep #3,#preload                  ' repeat preloading a number of x,y points into the cordic queue
    setq yy                                       ' yy = y value of sample
    qrotate xx,zz                             ' rotate xx,yy by zz binangle
    add zz,a                                     ' zz = zz + binangle
    ' rep #7,#therest                 ' repeat reading rotated x,y + writing more points to cordic
    ' getqx r2
    ' wrlong r2,ptra++                     ' store rotated x in array
    ' getqy r2                                    ' store rotated y in array
    ' wrlong r2,ptra++
    ' setq yy                                      ' y value
    ' qrotate xx,zz                            ' rotate x,y, by zz angle
    ' add zz,a                                     ' zz = zz + binangle
    rep #4,#preload                   ' repeat reading the remaining points from the cordic queue
    getqx r2                                       ' store rotated x in array
    wrlong r2,ptra++
    getqy r2                                       ' store rotated y in array
    wrlong r2,ptra++
    3DROP;                                   ' tidy up the data stack
end

If I uncomment the middle section, 'sine' crashes. I suspect my timing is off and cordic results are being lost. Has anyone successfully done an 'overlapped' cordic on a large buffer in hub ram. Some sample code would be appreciated if you have. I'm tempted to learn some more Spin and rewrite in Pnut, but (I presume) you can't single step this code, it would still leave me guessing at what's wrong. (The cordic engine doesn't slow down during single step and results would be lost)

Cheers, Bob

even if this FORTH forum is quite dead, a small peace of code for extreme simple temperature measurement. For about 40 years there is the SMT 172 (former SMT 160) temperature sensor around.
Its output is not analog nor I2C but a PWM modulated signal. The sensor accuracy is better then ±0.06°C (range +10°C to +40°C) and the power consumption about 60 µA.
The total temperature range is -45°C to +130°C.
The data sheet you may find at:
https://sensorsandpower.angst-pfister.com/fileadmin/products/datasheets/276/SMT172_1650-21914-0013-E-0224.pdf

You need only one pin aside the power supply (3.3V and GND) and you can easily connect 16 of the sensors to the Propeller 2 w/o any add. hardware or interfaces. it gives the temperature between -45°C and + 130°C With our (loved and hated) TAQOZ 2.8 the software is incredible simple.
Here an example, the sensor is connected to pin 30. The integration time is 0.1 s. It prints the temperature with 7 decimal places. For faster measurements juts reduce the number in the word SMT.
Still missing the output in Fahrenheit, Kelvin or whatever ... should be not sooo difficult.
Disadvantage: the price of the sensor is about 6 ... 8 €/$

P.S. I am in no relation to the manufacturer, just a user.

( 30  := SMTPIN \ f. SMT 172  3.3 V green, GND = bn, signal = white )

pub SMTINIT ( -- )
    SMTPIN PIN
    ;


\ there are 2 methods to claculate the temperature from the PWM 
\ the linear calculation SMTLIN (linear calculation) and the slightly more accurate 
\ SMTQUAD with a second order equation
\ the measurment length in us gives a kind of integration time. 
\ as longer the time, as more stable the temperature signal. 



pub SMTLIN  ( meas_length_us -- temp 10_7 )
    RAWFREQ? ( clocks states periods )
    DROP
    \ duty = states * 100_000 / clocks
    SWAP 100_000 SWAP
    */ DUP
    \ CRLF ." Duty = " 2 .DP ." %" CRLF  ( clocks periods )
    \ T = 212,77 * DC - 68,085
    21277 *
    \ Erg : 919_166_400 = 91,91
    680_850_000 -
    \ 68,085 -
    ." Temp = " 2 .DP ." C" CRLF
    ;


pub SMTQUAD ( meas_length_us -- temp 10_7 )
    RAWFREQ? ( clocks states periods )
    DROP
    \ duty = states * 100_000 / clocks
    SWAP 100_000 SWAP
    \ CRLF ." SWAP 100_000 SWAP " CRLF
    */ DUP
    \ CRLF ." Duty = " 2 .DP ." %" CRLF  ( clocks periods )
    \ T = 212,77 * DC - 68,085
    DUP DUP *
    100000 /
    -143 *
    SWAP
    21456 * +
    \ Erg : 919_166_400 = 91,91
    686_000_000 -
    \ 68,6 -
     ." SMT:TEMP:+ " 2 .DP ." ;" CRLF
    ;



\ measure the temperature with the second order equation. 
\ the printout is the temperature in Clesius with 2.7 digits  

pub SMT (  --  )
    !SP
    SMTINIT
    100000 SMTQUAD
    ;

I'd like to simplify the program using Smartpins in asynch serial mode. The transmit side is working thanks to Peter and Bob's examples in 'The Bit Bashers Guide to the Parallax P2', where there are examples of transmitting serial data, but I am struggling to work out how to receive serial data using Smartpins.

Does anyone have any experience of receiving and handling serial data with Smartpins using TAQOZ ROM FORTH?

Thanks, Pete

Motivations
1. It would be nice, if we could use drivers, others have written and placed in OBEX, so an integration into FlexProp together with SPIN or C files would be nice. Forth as a script language inside FlexProp.
2. Because Taqoz holds both stacks in LUT, it is not really suitable to do classical PAUSE multitasking. You have to swap loads of longs in and out of LUT and COG ram.
3. It would be nice to have an ANSI Forth. Because of portability and documentation.
4. I wonder, if the reason that Peter did not use certain elements of P2, was because they came late in P2's development? For example it seems natural to use PUSHA and POPA to implement the data stack.

So one direction, I am thinking is porting a Forth, that is written in C. Unfortunately my first goal the great ESP32Forth by Brad Nelson was a dead end, because it uses elements from C++ and is not documented enough for my needs to find work-arounds.
Out of pForth, Atlast, YAFFA, lbForth, ceForth and cForth the last one, cForth by Mitch Bradley seems attractive because it is very complete. Up to now I have not yet understood how I could bring the many source files into a structure, that can be compiled with FlexProp.

An idea is to make a Forth compiler for the FlexProp nucode-machine. As this uses only one stack this is not straight forward and would mean a lot of overhead for each subroutine level. I am not sure, if you can mix nucode with native code.

A totally different thing would be a new direct threaded Forth implementation:
1. Use direct threaded or subroutine threaded code, that can inline small core words like Forth09 https://colorcomputerarchive.com/repo/Documents/Manuals/Programming/Forth09 (D.P. Johnson).pdf . Inlining is limited by a size limit per word. IP is the program counter. Code is machine code. The idea would be, that this enables the micro cache of P2 to chime in. Downside is low code density.
2. Use PTRA for data stack (POPA, PUSHA), only TOS and NOS (2nd) in cog ram. Use PTRB for return stack (CALLB, RETB). So the stacks are in HUB Ram and can be switched easily.
3. As this machine would not be capable of calling high level code of other languages (at least I don't know how) perhaps a ServerCog could be used.

Comments? Ideas?

Cheers, Christof

Taqoz runs normally after selecting "Compile and Load RAM"
Taqoz starts up (outputs start message) but does not respond to the serial terminal after selecting "Compile and Load RAM and Debug"

Anyone tried this? - it'd be nice sometimes to use the very useful P/NUT debugger when PASM coding.

Attached is my Taqoz source fle, which needed a few minor typos fixing before it would compile. ( CON moved to column zero etc)

The driver is coded in Forth, no assembler, and capable of 18_000 clocks per step = 200_000_000/18_000 = 11_000 steps per second for each of the 4 motors in parallel. Linear movement of 4 axis in parallel is done like this:

• The axis with the maximum of steps in that movement is found as the leading axis. It gets assigned the fixed step-time.
• For each of the other axis, which have lower distance to travel, their time per step is precalculated in a way, that they will arrive at the same time.
• To achieve acceleration and deceleration nearby the start and the destination, a factor for the step time is calculated and applied for each axis.

Acceleration/deceleration is defined by 2 constants
accel# is (not exactly) the number of steps until full speed is reached.
minDist# defines the speed at start.

In my setup right now a minimum of 12_000 clocks per step would be possible, before some resonance is starting at one axis. So this driver leaves some sort of safety factor for the speed....

Have fun!
Christof

`
\ -- Mode: Forth --
\ https://gist.github.com/nfunato/5018107

\ Conway's Game of Life
\ originally from http://rosettacode.org/wiki/Conway's.Game.of.Life#Forth
\ see also http://en.wikipedia.org/wiki/Conway's.Game.of.Life

\ -------------------------------------------------------------------

IFDEF LIFE
oldorg org
FORGET LIFE }

pub LIFE PRINT" GameOfLifeB.fth" ;
0 bytes oldorg

\ The fast wrapping requires dimensions that are powers of 2.
\ CWE: switched for slower wrapping ==> any width allowed
\ (for playing just size, you may set terminal size to 64x17)
alias := constant

80 constant .width.

30 constant .height.

nrows .width. * 2* ;
1 nrows constant .row.
.height. nrows constant .size.
.size. .width. - 1- := wrapper

\ create$ world .size. allot

.size. bytes world

world value old

old .width. + value new

clear-world world .size. erase ;

flip-world new old to new to old ;

foreach-row ( xt -- ) .size. 0 do i over execute .row. +loop drop ;

row+ .row. + ;

row- .row. - ;

col+ 1+ ;
\ : col- 1- dup .width. and + ; \ avoid borrow into row

col- 1- dup .width. // 0= if .width. + then ; \ for any width
\ : wrap ( i -- i ) [ .size. .width. - 1- ] literal and ;
\ : wrap wrapper and ;
\ : wrap ;

wow@ ( i -- 0/1 ) ( wrap ) old + c@ ;

wow! ( 0/1 i -- ) ( wrap ) old + c! ;

ow@ ( i -- 0/1 ) old + c@ ;

nw! ( 0/1 i -- ) new + c! ;

sum-neighbors ( i -- i n )
dup col- row- wow@ over row- wow@ + over col+ row- wow@ +
over col- wow@ + over col+ wow@ +
over col- row+ wow@ + over row+ wow@ + over col+ row+ wow@ + ;

long gen \ generation

clear clear-world 0 gen ! ;

age flip-world 1 gen +! ;

\ the core Game of Life rules: just 3=>born, 2or3=>still alive, else=>die

gencell ( i -- ) sum-neighbors over ow@ or 3 = 1 and swap nw! ;

genrow ( i -- ) .width. over + swap do i gencell loop ;
\ : gen ( -- ) ['] genrow foreach-row age ;

gen ( -- ) ' genrow foreach-row age ;
32 := bl

emit-pos ( 0/1-- ) if '*' else bl then emit ;

showrow ( i -- ) crlf old + .width. over + swap do i c@ emit-pos loop ;

show ( -- ) ' showrow foreach-row crlf ." Generation " gen @ . ;

\ alias %XY at-xy

\ : home 0 0 at-xy ;

life ( -- ) key drop begin gen %home show key until ;

\ -------------------------------------------------------------------
\ patterns
\

\ char | constant '|'

pat' ( i addr len -- )
rot dup 2swap over + swap do
i c@ '|' = if drop row+ dup else
i c@ bl = 1+ over wow! col+ then
loop 2drop ;

count dup len$ ;

pat ( i c-addr -- ) count pat' ;

\ sample usage: "pentomino test-pat"

\ (also you may try "' pentomino test-pat" for random image)

ini' ( qp x y -- ) .width. * + swap clear pat page %home show ;

ini ( qp -- ) .width. 2/ .height. 2 - ini' ;

nex ( -- ) gen %home show ;

{

test-pat' ( qp -- )
begin
key case
[char] x of 1 endof
[char] n of nex 0 endof
( do nothing ) 0
endcase
until ;

test-pat ini test-pat' ;
}

\ still lifes

block. " |" ;

beehive " **|* *| **" ;

loaf " **|* *| * *| *" ;

boat " **|* *| *" ;

\ oscillators

blinker " ***" ; \ period 2

toad " ***| ***" ; \ period 2

beacon " || **| **" ; \ period 2

clock " *| || *" ; \ period 2

pulsar " *****|* *" ; \ period 3 after prelude

decathlon " **********" ; \ period 15 after prelude

pulsar3 " " ; \ not yet implemented

\ spaceships

glider " *| *|***" ;

lwss " ****|* | *| *" ; \ light weight space ship

ship " ****|* *| *| *" ; \ another lwss

\ breeder (if wide screen)

1d-breeder " ******** ***** *** ******* *****" ;
\ : test-1db 1d-breeder .width. 2/ 2/ .height. 2 - ini' test-pat' ;

\ long life

pentomino " **| **| *" ; \ finally still

pi. " | **|" ; \ finally oscillator

diehard " *|**| * ***" ; \ die off after 130-gen

acorn " *| *|** ***" ; \ spawn 13 gliders in 5206-gen (if wide)

\ -------------------------------------------------------------------
\ some usage demos
\

\ clear 0 glider ini life

{
clear 0 glider ini life
*
*

Generation 0 ok

gen show
* *
**
*
Generation 1 ok

clear 500 pulsar show

life

}

tst
\ clear
0 blinker
ini
10 for
lap gen lap
%home show \ lap
.lap
next
;
\ 128 * 32
\ Generation 10 35,466,424 cycles= 177,332,120ns @200MHz ok
\ 80 * 30 mit display: 24,029,273 cycles= 120,146,365ns @200MHz ok
\ 80 * 30 ohne display: 17,574,728 cycles= 87,873,640ns @200MHz ok
`

The idea is to be able to call a Forth Word from inside a code word. Of course you must be careful, that your register variables might get overwritten by the Forth code. While it is easy to call the Forth word, some effort must be done to enable correct return to the calling routine. - If anyone has a more elegant way to do it, feel free to post it...

484 := wPointer \ store for the Instruction word Pointer
$31 := doNext

: prtHello \ do something
   crlf
   ."    Hello"
   ."  from Forth"
   crlf

   \ return to assembler
   SUB:
      mov PTRA,wPointer ' \ return from Forth restore IP
      pop r1            ' \ discard one return level
      ret
   FORTH:
   ."  never reached "
;

' prtHello := aPrtHello  \ get start address


code cTest ( x -- x+6 ) ' \ calls a Forth word
   add a,#1
   mov wPointer,PTRA      ' \ save IP
   mov PTRA,##aPrtHello
   call #doNext
   add a,#5
   ret
end


: cT
   1 cTest . \ use the code word
;

Have Fun! Christof

Functions DoPush and DoPop shown below work with the initialized cog's hardware stack.
The opcodes can be found by hand assembly if no assembler is available.

The FORTH words in this block set up a cog to do this.

long Cmd long Xhub long Yhub 27 longs TestCode
$FD800007 TestCode   0 + ! ---          JMP     #\ClearCmd  '
Cmd       TestCode   4 + ! --- Cmd_ptr  LONG    0           ' Pointers
Xhub      TestCode   8 + ! --- X_ptr    LONG    0           '  to hub     (for Xhub)
Yhub      TestCode  12 + ! --- Y_ptr    LONG    0           '  variables. (for Yhub)
$00000000 TestCode  16 + ! --- Cmd      LONG    0           ' Local command to exec.
$00000000 TestCode  20 + ! --- Xcog     LONG    0           ' Local input variable.
$00000000 TestCode  24 + ! --- Ycog     LONG    0           ' Local return variable.
                           --- '----------------------------------------------------
$F6040800 TestCode  28 + ! --- ClearCmd MOV     Cmd,#0      ' Clear command.
$FC600801 TestCode  32 + ! ---          WRLONG  Cmd,Cmd_ptr ' Store in hub.
$FB000801 TestCode  36 + ! --- DoInstr  RDLONG  Cmd,Cmd_ptr ' Get command from hub.
$F21C0800 TestCode  40 + ! ---          CMP     Cmd,#0  WCZ '
$AD800009 TestCode  44 + ! ---   IF_Z   JMP     #\DoInstr   ' If (Cmd==0) Wait.
$ED800007 TestCode  48 + ! ---   IF_LE  JMP     #\ClearCmd  ' If (Cmd<=0) Clear Cmd.
$F21C0802 TestCode  52 + ! ---          CMP     Cmd,#2  WCZ '
$1D800007 TestCode  56 + ! ---   IF_A   JMP     #\ClearCmd  ' If (Cmd>2) Clear Cmd.
                           --- '----------------------------------------------------
$FD600830 TestCode  60 + ! ---          JMPREL  Cmd         ' Jump table.
$FD800009 TestCode  64 + ! ---          JMP     #\DoInstr   ' 0=Do nothing.
$FD800013 TestCode  68 + ! ---          JMP     #\DoPush    ' 1=Do first function.
$FD800017 TestCode  72 + ! ---          JMP     #\DoPop     ' 2=Do second function.
                           --- '----------------------------------------------------
$FD640C5F TestCode  76 + ! --- DoPush   DRVNOT  #6
$FB000A02 TestCode  80 + ! ---          RDLONG  Xcog,X_ptr  ' Xcog=Xhub;
$FD600A2A TestCode  84 + ! ---          PUSH    Xcog        '
$FD800007 TestCode  88 + ! ---          JMP     #\ClearCmd  '
                           --- '----------------------------------------------------
$FD640C5F TestCode  92 + ! --- DoPop    DRVNOT  #6
$FD600C2B TestCode  96 + ! ---          POP     Ycog        '
$FC600C03 TestCode 100 + ! ---          WRLONG  Ycog,Y_ptr  ' Store Ycog to Yhub.
$FD800007 TestCode 104 + ! ---          JMP     #\ClearCmd  '
TestCode 1 COGINIT ---  ok

Then the cog's (in this case) two functions can be used like this.
3 Xhub ! --- Stores 3 in the shared memory variable Xhub to be pushed to the stack.
1 Cmd ! --- Stores 1 into Cmd. This causes the DoPush function to push Xhub to the stack.

2 Cmd ! --- Stores 2 into Cmd. This causes the the DoPop function to pop Yhub from the stack.
Yhub @ . --- Prints the resulting Yhub.

This block shows 10 numbers being pushed to the hardware stack.

# 10 Xhub ! 1 Cmd ! ---  ok
#  9 Xhub ! 1 Cmd ! ---  ok
#  8 Xhub ! 1 Cmd ! ---  ok
#  7 Xhub ! 1 Cmd ! ---  ok
#  6 Xhub ! 1 Cmd ! ---  ok
#  5 Xhub ! 1 Cmd ! ---  ok
#  4 Xhub ! 1 Cmd ! ---  ok
#  3 Xhub ! 1 Cmd ! ---  ok
#  2 Xhub ! 1 Cmd ! ---  ok
#  1 Xhub ! 1 Cmd ! ---  ok

And this shows trying to read them back.

# 2 Cmd ! Yhub @ . --- 1 ok
# 2 Cmd ! Yhub @ . --- 2 ok
# 2 Cmd ! Yhub @ . --- 3 ok
# 2 Cmd ! Yhub @ . --- 4 ok
# 2 Cmd ! Yhub @ . --- 5 ok
# 2 Cmd ! Yhub @ . --- 6 ok
# 2 Cmd ! Yhub @ . --- 7 ok
# 2 Cmd ! Yhub @ . --- 8 ok
# 2 Cmd ! Yhub @ . --- 8 ok (The cog's hardware stack is indeed 8 levels deep.)

Many things could be investigated using this idea.
1. The CNT counter.
2. Bit operations.
3. Conditional execution.
4. JMP CALL RET branching.
5. Smart pins.
6. Math instructions details. Like how the Carry and Zero flags work.
7. CORDIC functions.
8. Repeating instructions.
9. FIFO/Streamer.
10. Locks.
11. Event handling.
12. Etc...

Here is some added information about the idea.
As before, a cog can be started with code stored in a longs array.

25 longs AnArray
{ Long   Address ByteOffset Add Store }
$00000000 AnArray     0      +     !
$00000001 AnArray     4      +     !
...

Then a new cog can be started like this.

AnArray 1 COGINIT

Executing the word AnArray returns the address where the code longs are located.

A cog can also be started with longs loaded in a published word. It requires less typing.

pub SomeWord
$00000000 , $ 00000000 , etc ...
;

Trying to execute the word SomeWord would probably crash because it is not FORTH code.
A new cog that runs these assembly code longs can be started like this.

COGINIT uses two stack parameters (HubAddress CogNum -- )
The tick mark ( ' ) retrieves the address of SomeWord and puts it into the stack,
ready for COGINIT to use. So ( ' ) needs to be included.

Assembly code to count low to high transitions of a smart pin.
It arbitrarily uses pin 5.

         '=======================================================================
         ' Put total number of lo/hi transitions on pin in hub Count variable.
         '-----------------------------------------------------------------------
                   ORG
         '-----------------------------------------------------------------------
$FD800006 Top       JMP     #\Init     ' Jump over variables.
$00000000 pCount    LONG    0          ' Pointer to hub Count.
$00000005 pin       LONG    5          ' Local pin number.
$00000000 tmp       LONG    0          ' Used to transfer count.
         '                    AAAA_BBBB_FFF_MMMMMMMMMMMMM_TT_SSSSS_0 
$0000001C incUp     LONG    %0000_0000_000_0000000000000_00_01110_0 ' Inc A up.
$0098967E halfsec   LONG    9_999_998  ' 20,000,000 MHz / 2 - 2 clock.
         '-----------------------------------------------------------------------
$FD600440 Init      DIRL    pin        ' Hold pin in reset.
$FC000802           WRPIN   incUp,pin  ' Mode = increment on A-rise.
$FC180002           WXPIN   #0,pin     ' Measurement is continuous not periodic.
$FC280002           WYPIN   #0,pin     ' Ignore adjacent B pin.
$FD600441           DIRH    pin        ' Start smart pin.
$FA880602 L1        RDPIN   tmp,pin    ' Get count. Ack pin.
$FC600601           WRLONG  tmp,pCount ' HUB["count"]= (A-rise) count;
$FD64025F           DRVNOT  #1         ' Blink LED 1.
$FD600A1F           WAITX   halfsec    ' Wait for 1/2 second.
$FD80000B           JMP     #\L1       ' Keep reading and writing count.
         '-----------------------------------------------------------------------

Here is how to run this using internal FORTH.

The cog first initializes pin 5 as a smart pin to count total Low to High transitions.
Then it goes into a loop that keeps writing the total count of transitions and a 1/2 second delay.
Here is what it looks like to query the variable Count while the cog is running.

Because buttons are usually noisy, often the count will skip ahead more than one.
The smart pin does not know about the 1/2 second delay.
For some unknown reason, this button is very quiet. But it skips sometimes.

This cog code can be used as a digital logic counter.

The newest Kernel Source code seems to be in TAQOZ.zip 2024-02-19 2.4 MB in https://sourceforge.net/projects/tachyon-forth/files/TAQOZ/binaries/
After minor tweaks I am able to compile this kernel.
The fth-files in this zip are not up to date and do not compile.

The fth-files here: https://sourceforge.net/projects/tachyon-forth/files/TAQOZ/Forth/
do compile but the VGA output seems to be broken.
Edit: VGA does work but there now is a difference between C! and c!

Has someone got a complete set of working files?
Thanks a lot!
Christof

Edit2:
Ok, there are a lot of other "deep" changes with 2.14, like assembler registers r3 and r4 are no longer available, but consistency seems to be given. The bug in CASE is fixed in the kernel using a register in cog ram. ALIAS is fixed too in Extend. My !MOUNTA has found its way into FLAT32, but only as a comment and so my "bad" cards are still not working without the patch. (So, Peter, you seem to read our posts, hi there!)
There are LOCALS ( >a type ) now. But they have no stack?

Why?
Taqoz V2.8 comes with a versatile VGA Bitmap Driver, which can do nice graphics. When I made my local Forth Editor it became clear, that color is quite desirable for syntax highlight and of course you want to see a lot of text at the same time. Unfortunately you also want to hold long texts in RAM.
Something like a dream would be to have multitasking with several screens. A keystroke brings you to another task, like OS9 on the coco3.

With the original Bitmap Driver, you need HW(Color=4) = 10 * 6 * 4=240 bits per Character, which is for 96 Lines and 128 columns 96 * 128 * 240 / 8=368.640 bytes.

Inspirations
There was a time, when microcomputers had limited RAM, so it was interresting to look at formats of old computers. A nice format is found for C128 for it's 80 columns screen. They used only one color for background for the entire screen.
Another inspiration comes from ZX80 and Amstrad CPC: To have a character set with 2*2 sub-tiles, which you can use to plot figures with 4 fold resolution.

Implementation "Tile12":
So the idea was to bring in a compact Tile Driver for VGA, which needs 12bits per Character. 8 Bits for the Char and 3 bits for 8 colors plus 1 bit for inverse. So we need 96 * 128 * 12 / 8=18.432 bytes per screen.
The driver is a variation and simplification of Eric Smiths Tile Driver, which comes with Flex. Of course Taqoz is by Peter Jakacky. Many thanks for both!

Tile12 has the screen buffer format:
EvenChar, ColorByte, OddChar; EvenChar, ColorByte, OddChar;….
ColorByte has the format: %ICCCiccc
The capitals stand for the bits for the odd char, the othes for the even char.

The Color Palette is dynamically reloaded, so you can manipulate the colors while the Driver is Running.
$80808000 tileColors 16 cells + ! - Will change the background color.
Also you can set a new screen buffer base address, which can give you several screens.

I did consider to implement the tile driver with own Taqoz's P2asm, but while this tool is very nice for small code words, it is not well suited for longer routines with lots of labels, which often point forward.
Also I did have a look at Taqoz V2.14, but I found myself not willing to rewrite my own code because of incompatibilities and I found no striking advantages.

So the driver is put into the end of the kernel in tTaqozC.SPIN2 (There is no Spin in it.) And only two new Forth words could be squeezed in:
TILEENTRY@ ( -- startaddress ) gives the address in hub ram of the driver
COGINITP ( to_ptra startaddr cognr -- ) can start assembler code using setq to pass a parameter in ptra to the cog.
tTaqoz.SPIN2 is compiled with FlexProp 6.9.1.
Be aware, that I put
_xinfreq = 25_000_000
for the Kiss board.

While the driver is part of the kernel, timing parameters, color palette, character set and handling routines are loaded with TileDrvC.fth. Order of Modules is:
Kernel - Extend-A.fth - File-A.fth - AutoT-A.fth - TileDrvC.fth

The base pin for the VGA output is set to 8 and the timings are for 1024x768 with 65MHz pixel frequency.
At the moment the character set (8x8) is the Parallax set but to have the graphics, the last 16 chars are patched. It would be nice to use the Amstrad CPC set, but I could not yet find a hex dump of it.

A nice feature of Forth and of Taqoz is the ability to redirect output. The word TILE redirects to the Tile driver, CON back to serial, CONTILE activates both.
tSetScrn ( 0-3 -- ) selects the active screen out 4.
^p will cycle through the screens

Have Fun
Christof!

About Forth basics:
http://www.murphywong.net/hello/simple.htm#L00

About TAQOZ Forth for Propeller P2:
This Version of TAQOZ is well described and has a complete listing:
https://sourceforge.net/projects/tachyon-forth/files/TAQOZ/binaries/OLD/TAQOZ.zip/download

This Version is described in Bobs Great Glossary:
https://github.com/bob-g4bby/Bob-Edwards--Forth-Stuff/blob/main/Parallax Propeller 2/TAQOZ RELOADED GLOSSARY.pdf
Which is discussed here: https://forums.parallax.com/discussion/173302/taqoz-reloaded-v2-8-word-glossary/p1

For the Taqoz inline assembler:
https://github.com/bob-g4bby/Bob-Edwards--Forth-Stuff/blob/main/Parallax Propeller 2/Taqoz v2.8 - Writing inline assembly language version 16.pdf

Propeller P2 assembler instructions:
https://docs.google.com/spreadsheets/d/1_vJk-Ad569UMwgXTKTdfJkHYHpc1rZwxB-DcIiAZNdk/edit#gid=0
And: https://p2docs.github.io/p2_optable.html

Incomplete Assembler Manual:
https://docs.google.com/document/d/1rQ_2FPLebT9GL6cZxgwHFbqxO9Kh9SfO6yn9gGTT6EE/edit

P2 Docu:
https://docs.google.com/document/d/1gn6oaT5Ib7CytvlZHacmrSbVBJsD9t_-kmvjd7nUR6o/edit

https://p2docs.github.io/

P2 datasheet:
https://www.parallax.com/package/propeller-2-p2x8c4m64p-datasheet/

P2 Boot process:
https://forums.parallax.com/discussion/170637/p2-sd-boot-code-rev-2-silicon/p1

P2 SPIN Language (contains constants)
https://docs.google.com/document/d/16qVkmA6Co5fUNKJHF6pBfGfDupuRwDtf-wyieh_fbqw/edit?usp=sharing

Kiss board hardware:
https://forums.parallax.com/discussion/172225/kiss-eval-board-general-discussion/p1

Other useful stuff:

ASCII Table:
https://www.torsten-horn.de/techdocs/ascii.htm

VT100 escape sequences:
https://espterm.github.io/docs/VT100 escape codes.html

My contributions:

Named local variables:
https://forums.parallax.com/discussion/174970/p2-taqoz-v2-8-lutlongs-value-type-variables-locals-now-faster#latest

Editor for forth source code:
https://forums.parallax.com/discussion/175634/fed-a-local-forth-source-code-editor-for-p2-taqoz#latest

Perhaps we can have this "sticky"?
Have fun!
Christof

I am new to Forth and currently going through the online version of Starting Forth and was using the terminal to execute the words on the P2 using TAQOZ, but I feel there are some differences and that may not be the best possible route? I have started going through the links that I found in some previous posts for the Wiki and github repos. Am I missing that TAQOZ is not fully compliant or there are just minor differences between Forth implementations? For example:

TAQOZ# : ?FULL 12 = IF . " It's full " THEN ; --- ok
TAQOZ# 11 ?FULL --- ok
TAQOZ# 12 ?FULL --- 50096 ok

but in ForthWin

?FULL 12 = IF ." It's full " THEN ;
Ok
11 ?FULL
Ok
12 ?FULL
It's full Ok

Is there a best resource for me to learn how to properly learn how to do everything in TAQOZ? or have I been doing something wrong?

Thank you!

EDIT: It was noted to me of the space before the quote in the IF statement.

I am trying to read a binary file from SD card. After some hours fiddling around i found the following solution working for me:

pub FILEDUMP ( -- ) 
FOPEN test.bin
FSIZE@
0
." ----- " CRLF
DO
 I  16  //   \ CRLF each 16 bytes
 0=
  IF
    CRLF
    I .ADDR ." " 
  THEN
 I SDC@
 .BYTE ."  | "
LOOP
FCLOSE
;

for the first call it works perfectly
BUT
at a second call I got different data.
For me it seems that TAQOZ was reading another sector after the first call of the word.
A 3rd and 4th call of FILEDUMP is showing the same wrong data.
Any ideas, or is there a better solution? The max. file size is about 32 kByte.
I want to output the data 4 byte by 4 byte to some device and forget the data afterwards.

Markus

Markus

This got me wondering how forth uses external programs. Lets say we have a program that is saved as .fth

I know that you can create functions and make them part of the running forth which would be lost at the next power cycle but lets say I want a bunch of applications/functions or words that arnt saved into the tachoz system on flash but instead are files on some media.

How do you go about loading a file and running it. Like one that sends "hello world" to the terminal or one that does a bunch of tasks to be more than one line of code.

Also, is it possible to store such applications on the Flash to be called up by Tachoz

While I am writing, I am thinking about the concept to not tinker with the running Tachoz itself but create external forth scripts that are loaded and ran by the Tachoz, in the usual file system way like we would with Basic

Last one, of course if all the files are stored on lets say SD, and the P2 was power cycled, what would run the first application, basically it needs some user intervention to get rolling, does Tachoz look for some specific file/word on the lines of Autoexec.bat

This subject is likely very useful for others also looking at forth and Tachoz.

Anyone can enlighten this a little bit.

My task: I want to realize a USB <-> 16 bit parallel bus (similar to ISA or UNIBUS) R/W interface with the Prop 2 using TAQOZ.
Some words like
SENDBUS address data
or
READBUS addres data

should write a word of 16 bit to PIN 0..15 and set also R/W PIN16 to high and also handle Address/Data line at PIN17. etc..
I know that I can easy handle each PIN with Forth, but all the documentation of TAQOZ and Assembler is for a beginner overwhelming.
So I am just looking for some hints, how to handle such a task in the most professional / elegant way.
Is bit banging of each pin the right way? Or is there some command to set 16 bit input / output as a single command?
Many thanks in advance for each reply
Markus

The parent-file contains
include

The child must end with
endInclude
to go back to the parent.

(Tested with version _BOOT_P2.BIX in Taqoz.zip in https://sourceforge.net/projects/tachyon-
forth/files/TAQOZ/binaries/ . )
Have Fun! Christof

long incDepth   incDepth ~

pre include \ <filename>
   incDepth ++
   filesect @ >L
   _fread @ >L
   [C] FOPEN
   @FILE OPEN-SECTOR
;

: endInclude \ resume to the including file
   incDepth @ 0exit
   incDepth --
   L> _fread !
   L> filesect !
   get$ drop \ drop the file name
;

include test2.fth

." Welcome back from test1.fth"

{
\ test2.fth
." Hello from test2!"

endInclude

}

The original version is very elegant, fast and compact. So the suggested patch is not so fast and does not fit into the same space and will be sitting in HUB RAM.
As the original word is used by other words, the suggestion is to patch a jump to the new version into the original code in cog memory.

code newLEN$ ( str$ -- length ) ' \ original fails when interrupted
   mov r0,a
   mov a,#0
   .l1 rdbyte r1,r0 wz
      if_z ret
      add r0,#1
      add a,#1
   jmp #l1
   jmp #\0 ' \ dummy to get the code for patch
end
\ 0BC22 FD80_0000     jmp #\0 ' \ dummy to get the code for patch
' newLEN$ 2+ $FD80_0000 or $7b cog! \ patch jmp to newLEN$ into original cog routine

(Mandatory for this is the use of the version _BOOT_P2.BIX in Taqoz.zip in https://sourceforge.net/projects/tachyon-forth/files/TAQOZ/binaries/ . )

@bob_g4bby , perhaps it would be a good idea to place a warning in your Glossary?

Have fun, Christof

These are the 5 words and 1 variable that I used

byte pin_# \ variable for the pin connected to the pressed button

rst 0 pin_# ! ; \ word to initialize the variable to zero

set_pd pin 2304 wrpin L ; \ set a pin to 1k5 pull down

read_buttons 32 28 do I pin@ -1 = if I pin_# ! then loop ; \ monitor the buttons and store the value in pin_#

case_test switch 28 case 25 pin H break 29 case 24 pin H break 30 case 26 pin H break 31 case 27 pin H break ; \ switch case pin_# and set led high

all_low 28 24 do I pin L loop ; \ take all led pins low

usage
Make sure pins 28 to 31 are set to pull down before running the following loop

begin rst read_buttons pin_# @ case_test 100 ms all_low key until

TAQOZ# 36 PIN R SETPIN PULLDOWN

I can see where it sets the pin low when I check "lsio" but it is not reading the input from the control button when I press it, the leds are working fine.

Video

TAQOZ# : ml ---
   " 1 .  " ---
   dup ---
   dup len$ 1- + $000D swap ! ---
   mload ---
   2 . ---
; ---  ok
TAQOZ#  ---  ok

TAQOZ# ml --- 2  ok
TAQOZ# 1 .  --- 1  ok

So I'm wondering if there is a place where a noob like me can get help to get started, a page perhaps with examples such as "blink.forth" or just generally controlling gpio.

Also is the zip I downloaded the best file to have or use, the zip has files that I put on an SD card and that worked nicely. It reports that I have v2.7 of Taqoz Reloaded sIDE is this the version I need.

The report seemed to suggest that I have 17 modules on the SD card is there a link on how to use a module or add other modules.

I started exploring Forth for the first time yesterday. I can now add the two values on the top of the stack, I think that's the correct way to phrase it. So I'm sure a lot of the questions I have will be answered as I learn Forth but a jump start will be appreciated.

I have attached a video if I'm heading in the wrong direction please tell me so that I can change course.

T.I.A.

Video:

As always:
(Mandatory for this is the use of the version _BOOT_P2.BIX in Taqoz.zip in https://sourceforge.net/projects/tachyon-forth/files/TAQOZ/binaries/ . )

Have fun!
Christof

When I write programs with Taqoz, I have P2 connected to a Windows PC and use the nice editor Notepad++. I then copy the program into the Tera Term. When the program gets longer, this procedure gets increasingly cumbersome and slower. Due to the limited serial buffer of Taqoz, problems start to arise and you have to load into a file on the SD card and then compile from SD card.

So, if there was an Editor in Taqoz, which had a certain "sufficient" level of comfort, perhaps you could really use this? The idea is still to have the PC with Teraterm, because web and pdf documents have to be accessible.

I have now begun to write this Editor. It is no longer a Block Editor but still has fixed length lines. And it does not spill over from line to line. When the file is saved then the fixed length of each line is converted to a line ending with CRLF. Taqoz has a file system with names and the FAT is compatible with Windows.
For my monitors a height of 48 of 54 lines and a width of 100 columns is much better than the old 16*64 screens. ( In my opinion, those old crammed screens have contributed a lot, that many people know Forth as write only language... )

The picture shows syntax highlighting and there is the feature to jump to the beginnings of definitions. In the upper part of the screen there is a list of the definitions as a table of contents, which can be used to jump very quickly. If a word is defined with PUB it will be printed in red in this table, which gives the possibility to structure.
The dictionary is used for the color too: If a word is not existent in the vocabulary, then it will be printed in yellow. So here we can have an advantage, that we are on the target machine. This feature is quite nice, because words with typos will be yellow too. In the picture, the inline assembler is yellow, because its vocabulary is not activated.

This is work in progress. I think, some sort of block copy will be needed and I am thinking about a feature which shows the first line of the definition of the word under the cursor. Jump to this definition and back again.
Also it seems feasible to display a relevant line from Bobs Forth Glossary.

Other thoughts, ideas?
Have fun, Christof

I'm looking for help to fix this as my knowledge of Taqoz source code and assembly language is limited. Here's what I've tried - assembling using flexprop 5.9.9 using this source code.

I add a new long 'cswitch' to COG memory:-

txpin       long    tx_pin

pinreg      long    0       ' PIN  - access via PIN operation'
cswitch     long    0       ' storage for the SWITCH selection

u
ACC     long    0       ' accumulator register cleared to zero before instruction'
xx
x       long    0

I substitute for words _SWITCH and SWFETCH:-

' ************** CASE STATEMENTS *********************8
{
' SWITCH ( val -- )
_SWITCH word    rg+uswitch,STOREX+ex


' SWITCH@ ( -- val )
SWFETCH word    rg+uswitch,FETCHX+ex      ' Peter's original words
}

_SWITCH word cswitch,STOREX+ex

SWFETCH word cswitch,FETCHX+ex               ' New words cause Taqoz boot to fail or other hiccups

I've tried a number of different phrases but haven't hit on the right one over several days. the problem could do with a fresh pair of eyes!