Wellys Dev

2022-05-29

Flashforth: Using the Three Values of Forth

Where I demonstrate the three values of Forth; speed, extensibility and interactive, to develop a better understanding of the ATmega328P.

Sources

Flashforth Example on Github

Introduction

In describing Forth to others, I typically use what I call the “Three Values of Forth”. They are speed, both in execution and development, extensibility, the capability to easily add to the language and interactive, the ability to easily interact with Forth using the serial terminal. It is these three values which make Forth, a great language to use for programming microcontroller boards.

2022-05-06

Mecrisp-Stellaris Forth: Dictionary 0

Where I keep my dictionary 0 with all of the basic Forth definitions.

Introduction

It helps to have the complete dictionary for Mecrisp-Stellaris Forth, this is dictionary 0 which has my most basic definitions. I load this before I start doing any work in Forth on the RP2040.

\ main dictionary for words which have been debugged
compiletoflash
: words4 ( -- ) cr  \ A columnar Word list printer. Width = 20 characters, handles overlength Words neatly 
   0				    \ column counter
   dictionarystart
      begin
	 dup 6 + dup
	 ctype			    \ dup before 6 is for dictionarynext input
	 count nip		    \ get number of characters in the word and drop the address of the word
	     20 swap - dup 0 > if   \ if Word is less than 20 chars
		   spaces swap	    \ pad with spaces to equal 20 chars
		   else drop cr	    \ issue immediate carriage return and drop negative number
		   nip -1	    \ and reset to column -1
		   then		       
		      dup 3 = if 3 - cr \ if at 4th column, zero column counter			   
		      else 1 +
		      then
	 swap		       
	 dictionarynext		    \ 	( a-addr - - a-addr flag )
      until
   2drop
;

: freememory ( -- )
	compiletoflash unused ." FLASH: " .
	compiletoram unused ." RAM: " .
;

\ xterm colors 256!
\ https://github.com/sindresorhus/xterm-colors
: esc 27 emit ;
: black      ( -- cursor colour )  esc ." [38;5;0m" ;
: red        ( -- cursor colour )  esc ." [38;5;9m" ;
: green      ( -- cursor colour )  esc ." [38;5;2m" ;
: purple     ( -- cursor colour )  esc ." [38;5;93m" ;
: blue       ( -- cursor colour )  esc ." [38;5;12m" ;
: magenta    ( -- cursor colour )  esc ." [38;5;127m" ;
: cyan       ( -- cursor colour )  esc ." [38;5;51m" ;
: white      ( -- cursor colour )  esc ." [38;5;15m" ;
: grey       ( -- cursor colour )  esc ." [38;5;8m" ;
: fuchsia    ( -- cursor colour )  esc ." [38;5;13m" ;
: green3     ( -- cursor colour )  esc ." [38;5;34m" ;
: lime       ( -- cursor colour )  esc ." [38;5;10m" ;
: navy       ( -- cursor colour )  esc ." [38;5;4m" ;
: darkorange ( -- cursor colour )  esc ." [38;5;208m" ;
: grey62     ( -- cursor colour )  esc ." [38;5;247m" ;
: grey82     ( -- cursor colour )  esc ." [38;5;252m" ;

: test_black      black      ." BLACK black " black ;
: test_red        red        ." RED red " black ;
: test_green      green      ." GREEN green " black ;
: test_purple     purple     ." PURPLE purple " black ;
: test_blue       blue       ." BLUE blue " black ;
: test_magenta    magenta    ." MAGENTA magenta " black ;
: test_cyan       cyan       ." CYAN cyan" black ;
: test_white      white      ." WHITE white " black ;
: test_grey       grey       ." GREY grey " black ;
: test_fuchsia    fuchsia    ." FUCHSIA fuchsia " black ;
: test_green3     green3     ." GREEN3 green3 " black ;
: test_lime       lime       ." LIME lime " black ;
: test_navy       navy       ." NAVY navy " black ;
: test_darkorange darkorange ." DARKORANGE darkorange " black ;
: test_grey62     grey62     ." GREY62 grey62 " black ;
: test_grey82     grey82     ." GREY82 grey82 " black ;

: colors 
        cr test_black cr test_grey cr test_grey62 cr test_grey82 
        cr test_white cr test_red cr test_darkorange cr test_lime
        cr test_green3 cr test_green cr test_cyan cr test_blue
        cr test_navy cr test_magenta cr test_fuchsia cr test_purple
        cr
;

: bp blue cr . .s cr black ;

$40014000 			constant IO_BANK0_GPIO0_STATUS \ GPIO status
$40014004 			constant IO_BANK0_GPIO0_CTRL \ GPIO control including function select and overrides.
$d0000000 			constant SIO_BASE

#5 			    constant SIO 				\ SIO (F5) DS_p258
SIO_BASE $004 + constant GPIO_IN       \ Input value for GPIO
SIO_BASE $010 + constant GPIO_OUT      \ GPIO output value
SIO_BASE $014 + constant GPIO_OUT_SET  \ GPIO output value set
SIO_BASE $018 + constant GPIO_OUT_CLR  \ GPIO output value clear
SIO_BASE $01c + constant GPIO_OUT_XOR  \ GPIO output value XOR
SIO_BASE $020 + constant GPIO_OE       \ GPIO output enable
SIO_BASE $024 + constant GPIO_OE_SET   \ GPIO output enable set
SIO_BASE $028 + constant GPIO_OE_CLR   \ GPIO output enable clear
SIO_BASE $02c + constant GPIO_OE_XOR   \ GPIO output enable XOR

\ Feather RP2040 localization
#13					constant GP13
GP13      			constant LED
#2						constant minGPIO
#29					constant maxGPIO
#0						constant minTest
#3						constant maxTest
#8						constant padsize

: GPIO_ctrl ( GPIO -- ) \ get the address for the specific GPIO ctrl register
	#8 * IO_BANK0_GPIO0_CTRL +
;

\ print values of the GPIO_CTRL registers of all GPIO pins
: .CTRL ( -- ) \ print CTRL values of all GPIO pins
	30 0 CR DO 
	I GPIO_ctrl @
	I . . CR
	LOOP 
;

: one_sec ( -- ) 		\ one sec ( -- )ond delay
	1000 ms
;

: half_sec ( -- )		\ half sec ( -- )ond delay
	500 ms
;

: qtr_sec ( -- )		\ quarter sec ( -- )ond delay
	250 ms
;

: tenth_sec ( -- )		\ tenth sec ( -- )ond delay
	100 ms
;

: GPIO_F5 ( GPIO -- )		\ ensure GPIO is in F5
	dup GPIO_ctrl 
	@ %11111 and
	5 = if drop else ." Not F5! " 5 swap GPIO_ctrl ! then
;

: GPIO_OUT ( GPIO -- )	\ set GPIO to output, uses atomic set
	1 swap lshift GPIO_OE_SET !
;

: tog_GPIO ( GPIO -- )	
	1 swap lshift GPIO_OUT_XOR !
;

: high_GPIO ( GPIO -- )	
	1 swap lshift GPIO_OUT_SET !
;

: low_GPIO ( GPIO -- )	
	1 swap lshift GPIO_OUT_CLR !
;

: blink_GPIO ( GPIO -- ) 
	dup GPIO_F5
	dup GPIO_OUT 
	  begin
	    dup tog_GPIO
	    tenth_sec ( -- )
	  key? until drop
; 

: ms_blink_GPIO ( n GPIO -- ) \ blink GPIO every n milliseconds, until key
	dup GPIO_F5
	dup GPIO_OUT 
	  begin
	    dup tog_GPIO
	    swap dup ms swap
	  key? until drop drop
; 

: us_blink_GPIO ( n GPIO -- ) \ blink GPIO every n microseconds, infinite
	dup GPIO_F5
	dup GPIO_OUT 
	  begin
	    dup tog_GPIO
	    swap dup us swap
	  again drop drop
; 

padsize buffer: pad
: .pad 
	padsize 0 do 
   pad I + c@ hex .
   loop
;

: erase_pad 
	padsize 0 do 
   0 pad I + c! 
   loop 
;

: endofDict0 ;
0 save#
compiletoram

2022-04-19

Comparing Board and Language Speeds

Where I compare the execution speeds of different combinations of boards and languages. I will continue to update this post with other languages and processor combinations.

Table for the impatient

ucontroller/Speed(MHz)	Method*	frequency	Language
ATSAMD21/48Mhz	Integral	.6kHz	CircuitPython
ATSAMD21/48Mhz	Integral function	.7kHz	CircuitPython
ATSAMD21/48Mhz	Library	.7kHz	CircuitPython
RP2040/133Mhz	Integral function	1.0kHz	CircuitPython
RP2040/133Mhz	Library	1.44kHz	CircuitPython
ATmega328/16MHz	struct/function pointer	6.1kHz	Arduino C++
ATmega328/16MHz	words in an infinite loop	27KHz	FlashForth
ATmega328/16MHz	struct/function pointer	55kHz	C
ATmega328/16MHz	struct/function pointer	56kHz	Arduino C++ w/ native toggle
ATmega328/16MHz	Assembly language toggle	108kHz	FlashForth
ATmega328/16MHz	Assembly language toggle inlined	444kHz	FlashForth
RP2040/133Mhz	struct/function pointer	578.7kHz	C
RP2040/133Mhz	words in an infinite loop	2.841 MHz	Mecrisp Forth
*See text for an explanation of method.

Introduction

While writing about CircuitPython and the FIDI board, I was curious as to the execution speed of CircuitPython on a extremely powerful (relative to the AVR ATmega328) ARM M0+ microcontroller. The M0+ is a modern RISC 32-bit processor with a considerable amount of memory, while the ATmega is 20 year old RISC 8-bit processor with a limited amount of memory. That said, one can’t run CircuitPython on ATmega processors, one must use C or Forth.

2021-07-09

Mecrisp-Stellaris Forth: Creating a New UF2

Where I describe how to edit, assemble, link, and UF2 Mecrisp-Stellaris for the RP2040 and specifically, the Adafruit Feather RP2040 and Pico/Pico W.

Sources

Updated

Now that I have gone through over 20 assemble/link/UF2 cycles, I have a better understanding of what needs to be done, specific to macOS Big Sur.

Follow the comments as to “The process…” particularly as it regards getting macOS to run the ARM toolchain. This has to happen first.
Reduce the complexity of Mecrisp-Stellaris. Matthias has performed a remarkable job in getting so many processors to run this version of Forth. This achievement needs to be applauded and appreciated. That said, unless you are running a significant number of versions, delete those that you aren’t using. In my case, I used the 128k/128K version to determine what was required for the RP2040. This is my base moving forward. Note In reviewing version 2.6.5, the new model is 128K/128K from Matthias.
Terry’s directions below (Understatement), however, its even easier. If you have performed point 2, then the solution is simply:

cd mecrisp-stellaris-x.x.x
./release
# put board in USB mode, drag/drop UF2 file and go to work

Really important things to do: (Instructions below)

Implement Terry’s improvement on Stair-Stepping by adding a CR to the OK prompt.
Implement Piotr’s improvement on uploading

Understatement

(With apologies to Terry Porter) Terry’s page above as Mecrisp Patching was extremely helpful and contained this nugget. Which is true, however, it takes a little bit of additional work to get there with the RP2040.

2021-07-05

Mecrisp-Stellaris Forth: RP2040 and Pin Testing

Where I work with the Adafruit Feather RP2040 (Feather), Mecrisp-Stellaris Forth (MSForth) and create Forth versions of ManPinTest and PinTest.

Sources

Background

This entry will be very similar to the one using the RP2040 and MicroPython, the difference will is I will use MSForth instead.

Getting Started

I’m going to assume that the serial connection, Forth installation and the ability to write/edit/run Forth programs on the RP2040 already exists. If not see this entry.

2021-06-27

Mecrisp-Stellaris Forth: Notes

Where I compile interesting notes as to how Mecrisp-Stellaris Forth is implemented on the RP2040 microcontroller.

ALWAYS WRITE SHORT DEFINITIONS!!

I was working on this entry and was attempting to hand-write the definition of PIN_BLINK by keeping the stack in my head. As my definition approached over 10 albeit short lines, it continued to not work. This is when I remembered, Forth is designed to be easy to read and interactive, work with Forth, not against it!

2021-06-23

Mecrisp-Stellaris Forth: On the RP2040

Where I implement Forth on the Feather RP2040 using Mecrisp-Stellaris Forth.

Sources

Products

How to Begin

(Follow directions based on your board)

2021-05-31

ESPForth 7.0

Where I find a much, more evolved version of ESPForth. While investigating a bug I found in ESPForth (now called ESPForth6), I ran across a new version of ESPForth 7.0, which I’ll refer to as ESPForth7.

Sources

Comments

Each time I used ESPForth6, I would experience a bug with the word “constant”.

So I began to investigate ESPForth. Arduino-Forth who had been using FlashForth has now begin to investigate it. Which led me to the sites above. The good news is that I downloaded the ino file for ESPForth 7.05 and it compiled and loaded the first time.

2021-05-28

PinTest

Where I write an Arduino program to test pins on a specific board in order to confirm a Forth HAL for the same board.

Pin Testing

When writing software which will control a circuit, it is best to confirm the behavior of circuit using known or familar test software before attempting to write with a new language. For example, I am developing a HAL/Primitive/User layer for the ESP32 using ESPForth. As the board, the Adafruit HUZZAH32 has an Arduino framework already developed for it, it is a good idea to test the board using the Arduino C++ code before testing it with the ESPForth words.

2021-05-23

Which Forth?

Where I discuss several versions of Forth and the attributes of each.

Forth Versions

There are many versions of Forth. This is due to a variety of reasons:

Forth as a language is over 60 years old, hence there has been a significant amount of time for it to evolve.
Forth tends to be processor-focused. Some people might argue this point, however, due to Forth’s ability to work well at a low-level, implementations tend to be aimed at a particular processor than other high-level languages.
Forth is a relatively easy language to write and it is extensible, which means its not unusual for someone to “roll their own version”.

To date, I have focused on two specific versions: