Keeping it SIMPL
Since May 2013, I have been slowly developing a tiny interpreted language that can be used to initialise and exercise hardware when developing with a new processor.
SIMPL is primarily intended to be a very low overhead language, requiring only a serial uart (or bit banged serial) for communication to a PC hosted terminal program.
Commands are in plain, human readable ascii text - with an emphasis on being easy to remember.
SIMPL is based on Ward Cunningham's Txtzyme interpreter - originally for Arduino - but ported onto several other microcontrollers - as it is written mainly in C.
The kernel or SIMPL interpreter needs only a few resources:
2K bytes of program memory (Flash)
35 bytes of RAM
UART getchar and putchar functions
On the Arduino these delays are provided by the delay() and delayMicroseconds() functions but can be provided with simple delay loops.
Once you have this 2K of code on-board, you can then start to add it more functionality - that is tailored to your particular application.
Slimming Down the Interpreter Kernel.
As originally written, Ward Cunningham's Txtzyme compiles to 5032bytes of flash and 209 bytes of RAM. (The exact number of compiled bytes may vary on what version of the Arduino IDE you are using).
As it made use of several of the high level functions available in Arduino - such as Serial.print, digitalWrite etc, - it was certainly not optimised for codesize.
I rewrote and enhanced the interpreter - so that now it fits into just short of 2048 bytes, and is written in more generic standard C for easier porting to other processors.
I have also added more functions including arithmetic, bitwise logic and memory operations.
I am sure that if the routines were handcoded in AVR assembly language, that further reductions in codesize could be achieved. However, I wanted a useful kernel that would fit in 2K and was easy to understand.
I have placed the SIMPL kernel here as a Github Gist.
Growing the Kernel
It has long been my intention to make SIMPL an extensible language, and so for this approach I have chosen to use some of the ideas used in Forth.
The kernel can easily be extended from some 30 basic functions to about 85, just by extending the switch/case statement that forms the basic subroutine calling mechanism at the heart of the kernel.
I keeping with Charles Moore's philosopy of "Problem Oriented Languages" the kernel of SIMPL may be extended in whatever way needed for solving the problem, and should as such be considered to be a minimum common starting point - for any cpu.
Once the 2K core of the kernel was established, it was time to add in the extra functionality that allows users to add their own functions. This is done in the spirit of Forth - but with certain limitations to keep the code size down. However, with the added functionality - the code grew from 2Kbytes to 3982 bytes. The main difference is in the amount of RAM that is used - the extra code allocates a User RAM array of 1248 bytes.
If you would like to look at the code and try it out on an Arduino - I have created a Github Gist here.
If you are using a standard Arduino with the LED on Pin 13 change line 64 to:
int d = 13; // d is used to denote the digital port pin for LED operation
As this is a work in progress - more details will emerge in a later post.