Migrated from GitHub

.gitattributes

@@ -57,3 +57,36 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/docs/BASICs/101_BASIC_Computer_Games_Mar75.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/BASICs/AltairBasic_1275.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/BASICs/Apple2AppleSoftBASICRef1977.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/BASICs/ECMA-55_1st_edition_january_1978.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/BASICs/Kilobaud_1977_June.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/BASICs/TinyBASIC-2.0.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/BASICs/aim65_basic.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/BASICs/apple1_basic_manual.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/ABX00053-datasheet.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/Atmel-8869-SEEPROM-AT24CS32-Datasheet.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/BMP280datasheet.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/BST-BME280_DS001-10.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/DS1307.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/DS3231[[:space:]]Real[[:space:]]Time[[:space:]]Clock[[:space:]]Connection[[:space:]]Diagrams.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/DS3231[[:space:]]Real[[:space:]]Time[[:space:]]Clock[[:space:]]Datenblatt[[:space:]]AZ-Delivery[[:space:]]Vertriebs[[:space:]]GmbH.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/DS3231.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/DS3232.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/Digispark.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/ESP8266-01[[:space:]]USB-Stick[[:space:]]DE.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/KeyboardController.pages filter=lfs diff=lfs merge=lfs -text
+data/docs/components/PS2Keyboard[[:space:]]Library,[[:space:]]Connect[[:space:]]a[[:space:]]keyboard[[:space:]]for[[:space:]]user[[:space:]]input.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/Pinout-NANOevery_latest.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/Programming+the+Wemos+Mega+Wifi+Board.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/RK-10290_410.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/SSD1306.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/SSD1963_v1.6.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/ThermalprinterSpecs.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/doc0336.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/components/vga32_v1.4.pdf filter=lfs diff=lfs merge=lfs -text
+data/docs/img/IMG_7220.mov filter=lfs diff=lfs merge=lfs -text
+data/docs/tutorial/BASIC[[:space:]]on[[:space:]]Arduinos[[:space:]]-[[:space:]]Introduction.epub filter=lfs diff=lfs merge=lfs -text
+data/docs/tutorial/BASIC[[:space:]]on[[:space:]]Arduinos[[:space:]]-[[:space:]]Introduction.pages filter=lfs diff=lfs merge=lfs -text
+data/misc/UTFT.pdf filter=lfs diff=lfs merge=lfs -text

data/Basic1/IotBasic/MANUAL.md

@@ -0,0 +1,1975 @@
+# Stefan's IoT BASIC in a nutshell
+
+## Version information
+
+This manual is for the released version 1.3 of Stefan's IoT BASIC interpreter. 
+
+## BASIC language sets
+
+This BASIC interpreter is structured in language sets. They can be compiled into the code separately. With every language set there are more features and command. This makes it adaptable to the purpose. The manual is structured according to the language sets. 
+
+The intepreter has two data types - numbers and strings. The number type can be set at compile time. It is either an integer or foating point. Depending on the definition of number_t in the code the interpreter can use everything from 16 bit integers to 64 bit floats as basic number type. 
+
+Arrays and string variables are part of the Apple 1 language sets. Strings are static, i.e. they reserve the entire length of the string on the heap. Depending on the definition of the string index type in the code, strings can be either 255 characters or 65535 characters maximum length. 
+
+Array can be maximum two dimensional and string arrays can be one dimensional.
+
+Variable names are maximum two letters or one letter and one digit. 
+
+Keywords ad variable names are not case sensitive. They are printed as uppercase with the LIST command. Strings and string constants are case sensitive. 
+
+There is a set of examples program in examples/00tutorial. They are referred to here as "the tutorial".
+
+As a proof of concept many of the 101 BASIC computer games in David Ahl's original book from 1975 have been ported. Look into examples/14games for some 70s gaming fun.
+
+Most Arduino built-in examples from https://docs.arduino.cc/built-in-examples/ have been ported to BASIC. They are in examples in the folders 01-10.
+
+## Core language set
+
+### Introduction
+
+The core language set is based on the Palo Alto BASIC language. This is the grandfather of all the Tinybasics currently on the market. Commands are PRINT, LET, INPUT, GOTO, GOSUB, RETURN, IF, FOR, TO, STEP, NEXT, STOP, REM, LIST, NEW, RUN, ABS, INT, RND, SIZE.
+
+In the core language set there are 26 static variables A-Z and a special array @() which addresses the free memory. If an EEPROM is present or the EEPROM dummy is compiled to the code, the array @E() addresses the EEPROM. 
+
+### PRINT
+
+PRINT prints a list of expressions and string constants. The separator ';'' causes data to be concatenated while ','' inserts a space. This is different from MS BASIC print where ','' prints into data fields and ';'' inserts spaces is numbers are printed. Formatted printing is supported with the '#' modifier. 
+
+Examples: 
+
+PRINT "Hello World"
+
+PRINT A, B, C
+
+PRINT #6, A, B, C
+
+Tutorial programs: hello.bas and table.bas.
+
+A positive number aligns to the right Palo Alto BASIC style. A negative number aligns to the right side. Setting #0 removes the format.
+
+BASIC I/O is stream based. Streams are numbered. The console I/O on a POSIX system or Serial on an Arduino is stream number 1. Other prefefined stream numbers are 2 for displays, 4 for secondary serial and 16 for files. Please look at the file I/O section and the hardware driver chapter for more information. 
+
+Printing to a display would be done with 
+
+PRINT &2, "Hello World"
+
+while 
+
+PRINT &16, "Hello World"
+
+prints to a file.
+
+PRINT ends a line with LF. No CR is sent at the end of a line.
+
+### LET
+
+LET assigns an expression to a variable. It can be ommited and is only added to the language set to ensure compatibility. Typical LET statement would be 
+
+LET A=10
+
+A=B/2+C
+
+Expression evaluation is done left to right with multiplication and division precedence before addition and subtraction. Comparision have lowest precedence and evalute true to -1 and false to 0. This is not C style boolean logic but closer to the old MS BASIC definition. With this, NOT, AND and OR in the Apple 1 language set can be used as bitwise operators because NOT -1 is 0.
+
+Strings evaluate to the ASCII value of the first character.
+
+A="A" : PRINT A
+
+outputs 65.
+
+The operator % calculates the integer divisions modulus. Example:
+
+B=A%2 
+
+to test divisibility.
+
+### INPUT
+
+INPUT accepts a list of string constants and variable. String constants are output and variable request a user input. A "?" prompt is only displayed if not string constant has been supplied. Example: 
+
+INPUT "Input a number", A
+
+INPUT "First number: ", A, "Second number: ", B
+
+Unlike MS BASIC comma separated lists cannot be used as input values.
+
+INPUT A, B
+
+would prompt for two separate number inputs even if two number like e.g. 17,19 are enters after the first prompt. This saves memory. Please look at IOT extension for a way to split lists.
+
+In version 1.3. INPUT cannot read elements of string arrays. Only not indexed string variables are implemented.
+
+Like PRINT, the & modifier can be used to specify an input stream.
+
+INPUT &2, A
+
+would read data from the keyboard of a Arduino standalone system.
+
+### GOTO
+
+GOTO branches to the line number specified. Expressions are accepted. Examples:
+
+GOTO 100
+
+GOTO 100+I
+
+The later statement can be used to program ON GOTO constructs of Dartmouth BASIC.
+
+BASIC has a line cache and remembers jump targets to speed up the code. 
+
+### GOSUB and RETURN
+
+GOSUB is identical to GOTO and saves the location after the GOSUB statement to a return stack. RETURN ends the execution of the subroutine. 
+
+The GOSUB stack is shallow with a depth of 4 elements on small Arduinos. This can be increased at compile time.
+
+### IF 
+
+IF expects an expression and executes the command after it if the condition is true. 0 is interpreted as false and all non zero values as true. Examples:
+
+IF A=0 GOTO 100
+
+IF B=A PRINT "Equal"
+
+There is not THEN in the core language set. THEN is part of the Apple 1 language set.
+
+### FOR loops
+
+FOR have the form
+
+FOR I=1 TO 10 STEP 2: PRINT I: NEXT I
+
+Specifying the parameter I in NEXT is optional. STEP can be ommited and defaults to STEP 1. 
+
+Unline in other BASIC dialects the loops. 
+
+FOR I=10: PRINT I: NEXT
+
+and 
+
+FOR I: PRINT I: NEXT
+
+are legal. They generate infinite loops that can be interrupted with the BREAK command which 
+is part of the extension language set. 
+
+All parameters in FOR loops are evaluated once when the FOR statement is read. FOR loops use the memory location as jump target in NEXT. They are faster than GOTO loops. 
+
+The statement NEXT I, J to terminate two loops is not supported. Each loop needs to have their own NEXT statement.
+
+### STOP
+
+STOP stops a program. There is no END in the core language set.
+
+### REM
+
+Comment line start with the REM statement. As BASIC tokenizes the entire input, comments should be enclosed in comments. Example:
+
+10 REM "This is a comment"
+
+### LIST
+
+Lists the program lines. Examples: 
+
+LIST 
+
+LIST 10
+
+LIST 10, 100
+
+The first statement lists the entire program, the second only line 10. The last statement lists all line between 10 and 100.
+
+### NEW
+
+Deletes all variables and the program. 
+
+### RUN
+
+Starts to run a program. A line can be specified as first line to be executed. RUN deletes all variables and clears the stacks. GOTO linnumber can be used for a warm start of a program.
+
+### ABS
+
+Calculates the absolute value of a number. Example:
+
+A=ABS(B)
+
+### INT
+
+Calculates the integer value of a number. Example:
+
+A=INT(B)
+
+### RND
+
+Calculates a random number. The builtin random number generator is a 16/32 bit congruence code and is good enough for games and simple applications but repeats itself rather fast. The argument of the function is the upper bound. 
+
+On an integer BASIC 
+
+PRINT RND(8)
+
+would produce numbers from 0 to 7, while 
+
+PRINT RND(-8)
+
+would produce numbers between -8 and -1. 
+
+The random number seed can be changes by using the special variable @R. See the "special variable" section for more information.
+
+### SIZE
+
+Outputs the space between the top of the program and the bottom of the variable heap. It is the free memory the interpreter has. 
+
+### Storing programs with SAVE and LOAD
+
+LOAD and SAVE are part of the core language set if the hardware has a filesystem. On POSIX systems (Mac, Windows, Linux) they take a file name as argument. Default is "file.bas". 
+
+Arduino systems with only EEPROM support save the program to the EEPROM in binary format, overwriting all data on the EEPROM by it. 
+
+If a file system is compiled to the Arduino code. The commands work like on a POSIX system. LOAD "!" and SAVE "!" can be used in these cases to access programs stored in EEPROM.
+
+File names must be strings. To load a program you need to enter
+
+LOAD "myprog.bas"
+
+i.e. with the filename enclosed quotes.
+
+### Special variables and arrays 
+
+The character @ is a valid first character in variable names and addresses special variables. These variables give access to system properties. 
+
+@() is an array of numbers starting from the top of memory down to the program area. It can be used like any other array in BASIC. Indexing starts at 1. 
+
+@ is the upper array boundary of the array @() i.e. the number of elements in the array. 
+
+The program area is protected by BASIC. The maximum index prevents a program to overwrite the program.
+
+@E() is the EEPROM array. It indexes the entire EEPROM area down from the highest address. 
+
+@E is the number of elements in the EEPROM array. Unlike with the memory array @() there is no protection of saved programs in the EEPROM. @E() can overwrite the program space. 
+
+@R is the random number seed. It can be written and read. 
+
+@O is the currently active output stream.
+
+@I is the currently active input stream. 
+
+@C is the next character of the input stream or output stream. 
+
+@A is the number of available character of the current input stream.
+
+@S is the I/O error status. See the file I/O section for more information on it.
+
+@V is the number of characters processed in VAL(). 
+
+@U is the user variable. It can be used to extend BASIC. 
+
+The variables @O, @I, @C, and @A can be used for byte I/O on any stream. 
+
+The array @T() is the real time clock array. @T$ is a string containing date and time. See the hardware drivers section for more information.
+
+The string @A$ is the command line argument on POSIX systems. See the hardware section for more details.
+
+## Apple 1 language set
+
+### Introduction
+
+The Apple 1 language set is based on an early version of the Apple Integer BASIC. I never worked with the language and just took the information from the the manual. The language set adds many useful features like arrays, strings, two letter variables, boolean expressions and a few functions. 
+
+### Variables 
+
+In addition to the static variable A-Z all two letter combinations which are not a keyword are legal variable names. Examples: 
+
+A0, BX, TT 
+
+Variables are placed on a heap that is searched every time a variable is used. Variables which are used often should be initialised early in the code. This makes BASIC programs faster. Static variables A-Z are accessed approximately 30% faster than heap variables. They should be used for loops.
+
+### Strings
+
+String variables can also have two characters followed by the $ symbol. Example: 
+
+ME$="Hello World"
+
+Unlike in the original Apple 1 BASIC, strings can be used without explicitely dimensioning them. They are auto dimensioned to length 32. Strings are static. The entire space is allocated on the heap and stays reserved. This is very different from MS BASIC with a dynamic heap. The saves memory but requires a garbage collector. Static strings like in this BASIC need more memory but make the execution of time critical code more deterministic. 
+
+A string can be dimensioned with DIM to any length. Example: 
+
+DIM A\$(100), C\$(2)
+
+A string of maximum 100 bytes and a string of 2 bytes are created. The maximum length of a string is 65535 in the default settings of the code. See the hardware section of the manual for more information on this.
+
+Strings are arrays of signed integer. String handling is done through the substring notation. Example: 
+
+A\$="Hello World"
+
+PRINT A\$(1,4), A\$(6,6), A\$(6)
+
+yields 
+
+Hello W World 
+
+as an output. 
+
+Substrings can be the lefthandside of an expression
+
+A\$="Hello World"
+
+A\$(12)=" today"
+
+PRINT A\$
+
+outputs
+
+Hello world today
+
+Please look into the tutorial files string1.bas - string3.bas for more information. The commands LEFT\$, RIGHT\$, and MID\$ do not exist and are not needed.
+
+The length of a string can be found with the LEN command. Example:
+
+A\$="Hello"
+
+PRINT LEN(A\$)
+
+String arrays are possible if the BASIC interpreter is compiled with the respective option. This is an extension of the Apple 1 language set.
+
+### Arrays
+
+Arrays are autodimensioned to length 10. They start with index 1. If a different array length is needed the DIM command can be used. Example: 
+
+DIM A(100)
+
+Array variables can be used like normal variables except that they cannot be active variables in a FOR loop.
+
+Compiled with the multidim options arrays can be two dimensional. This is an extension of the Apple 1 language set.
+
+Arrays range from 1 to the maximum index by default. The statement above reserves array elements from A(1) to A(100). 
+
+With 
+
+SET 12,0
+
+the array lower bound can be changed to 0. The array ranges from A(0) to A(99) now. It still has 100 elements. SET 12 can be used to set any postive lower bound. This holds for all arrays except the special arrays starting with @. It can be changed at any time as SET 12 only modifies the offset but not the memory location.
+
+### Logical expressions NOT, AND, OR
+
+Logical operators NOT, AND, and OR have lowest precedence. They are at the same time bitwise logical operations on integers. Example:
+
+PRINT NOT 0
+
+yields -1 which is an integer with all bits set. Logical expressions like 
+
+IF A=10 AND B=11 THEN PRINT "Yes"
+
+can be formed. 
+
+### Memory access with PEEK and POKE
+
+PEEK is a function which reads one byte of BASIC memory. Example: 
+
+PRINT PEEK(0) 
+
+outputs the first byte of BASIC memory.
+
+POKE writes a byte of memory. Example: 
+
+POKE 1024, 0 
+
+If PEEK and POKE are used with negative numbers they address the EEPROM of an Arduino. -1 is the first memory cell of the EEPROM. Peek and poke return bytes as signed 8 bit integers. 
+
+### THEN
+
+THEN is added for comaptibity reasons. Typical statements would be 
+
+IF A=0 THEN PRINT "Zero"
+
+IF B=10 THEN 100 
+
+### END
+
+END ends a program. On systems with EEPROM dummies in flash memory, END also flushed the buffer. On system with file operations, END flushed the file buffers. 
+
+### CLR
+
+CLR removes all variables and stacks. 
+
+### HIMEM
+
+HIMEM is the topmost free memory cell. The difference SIZE-HIMEM is the size of the stored program. 
+
+### TAB
+
+TAB outputs n whitespace characters. Example: 
+
+TAB 20: PRINT "Hello"
+
+### SGN
+
+The SGN function is 1 for positive arguments and -1 for negative arguments. SGN(0)=0. 
+
+### Multidim and String Array capability
+
+If BASIC is compiled with the HASMULTIDIM option, arrays can be twodimensional. Example: 
+
+DIM A(8,9)
+
+A(5,6)=10
+
+The compile option HASSTRINGARRAYS activates one dimensional string arrays.
+
+DIM A\$(32,10)
+
+dimensions an array of 10 strings of length 32. Assignments are done use double subscripts
+
+A\$()(3)="Hello"
+
+A\$()(4)="World"
+
+PRINT A\$()(3), A\$()(4)
+
+outputs 
+
+Hello World
+
+The first pair of parentheses are the substring part and the second pair the array index.
+
+## Stefan's extension language set
+
+### Introduction
+
+The language extensions here are things I found useful and that were missing in Apple Integer BASIC. They are rather simple extensions of the language.
+
+### FOR loops with CONT and BREAK
+
+FOR loops can be ended with BREAK. Example: 
+
+10 FOR I=1 TO 10
+
+20 PRINT I
+
+30 IF I=8 THEN BREAK
+
+40 NEXT
+
+will end the loop after the 8th iteration. BREAK always ends the innermost loop just like the C break command.
+
+Alternatively CONT can be used to move forward in a loop. Example: 
+
+10 FOR I=1 TO 10 
+
+20 IF I%2=0 THEN CONT
+
+30 PRINT I
+
+40 NEXT
+
+will only display the odd values. CONT skips the entire rest of the loop and skips to the next I. 
+
+Using CONT and BREAK reduces the number of GOTO statements in a program and makes them more readable. 
+
+### Command line CONT
+
+In interactive mode, CONT has a different function. It restarts a program previously stopped with STOP.
+
+### ELSE
+
+ELSE can be used after THEN in one line.
+
+IF A=0 THEN PRINT "Zero" ELSE PRINT "Not zero"
+
+In programs ELSE can also be on the subsequent line
+
+10 IF A=0 THEN PRINT "Zero"
+
+20 ELSE PRINT "Not zero"
+
+### Character output with PUT and GET
+
+Single characters can be written and read with the PUT and GET statement. Like PRINT and INPUT, these commands can take the I/O stream as an argument after the & modifier. Example: 
+
+GET &2, A 
+
+reads a character into variable A from the keyboard I/O stream. 
+
+PUT &2, "H", 65
+
+writes to characters to the display I/O stream. The behaviour of PUT and GET is hardware dependent. On Arduinos they are non blocking byte streams. On POSIX systems GET is blocking input.
+
+### Low level functions USR
+
+USR is a two argument function accessing system properties. See the program hinv.bas in the tutorial for examples. USR can also be used to quickly add functionality to the interpreter. This will be explained in the hardware section of the manual. 
+
+Example for USR:
+
+PRINT "The EEPROM size is ", USR(0,10)
+
+### Low level calls CALL
+
+CALL expects a numerical expression as an argumen. Currently only CALL 0 is implemented. It flushes all open files and ends the interpreter on POSIX systems. On Arduinos CALL 0 restarts the interpreter. 
+
+### Setting system properties with SET
+
+SET is a two argument function setting system property. Please look into the hardware section of the manual for more information.
+
+Example: 
+
+SET 0, 1
+
+activates the debug mode of the interpreter. 
+
+SET 0, 0
+
+ends the debug mode.
+
+### SQR
+
+On an integer BASIC the function calculates an integer approximation of the square root. It is the number closest to the exact result. It can be larger or smaller then the exact result. Example: 
+
+PRINT SQR(8)
+
+In floating point system the library function is used. 
+
+See math.bas in the tutorial for more information.
+
+### POW
+
+This two argument function calulates the n-th power of a number. It replaces the '^' operator of some BASIC dialects. Example: 
+
+PRINT POW(2,4)
+
+In integer systems POW calculates the result in a loop. It returns 0 for negative arguments of the exponent. In floating point systems the C function pow() is used and the result is returned.
+
+See math.bas in the tutorial for more information.
+
+### MAP
+
+MAP is taken from the Arduino library. It maps an integer in a certain range to another ranges using (at least) 32 bit arithmetic. This is useful on 16 bit integer systems. Example: 
+
+M=MAP(V, 1000, 0, 200, 100)
+
+maps the variable V from the range 0 to 1000 to the range 100 to 200.
+
+See math.bas in the tutorial for more information.
+
+### CLS
+
+Clears the screen on display systems. See VT52 capabilities for more information.
+
+### Debugging with DUMP
+
+DUMP writes a memory and EEPROM range to the output. Example:
+
+DUMP 0, 100
+
+writes the first 100 bytes of the program memory. 
+
+DUMP !0, 100
+
+writes the first 100 bytes of the EEPROM. 
+
+### Error Message capability
+
+Error messages are stored in Arduino program memory. For systems with low program memory undefining the #HASERRORMSG flag removes explicit error messages. 
+
+### Terminal emulation and VT52 capability on display systems
+
+BASIC has a minimal set of terminal control characters build in. Compiling the code with the HASVT52 option adds a subset of the VT52 terminal commands for systems with displays. 
+
+Most importantly 
+
+PUT &2, 12
+
+clears the screen.
+
+The special variables @X, @Y contain the cursor position. The variables are read write. 
+
+@X=10: @Y=10: PUT "X"
+
+would write the letter X at position 10, 10.
+
+The array @D() is the display character buffer by column and row. It is also read write and can be used to display characters directly.
+
+Please look into the hardware section for the display driver commands.
+
+## Arduino I/O language set
+
+### Introduction
+
+Most of the standard Arduino I/O functions are available on BASIC. The Arduino standard examples have been ported to BASIC to showcase how they are used. Please look into the repo under examples/01basics to examples/10starter for these programs. 
+
+### PINM 
+
+PINM sets a pin to input, output, or input-pullup. Example: 
+
+PINM 10, 0
+
+PINM 11, 1
+
+PINM 12, 2
+
+sets pin 10 to input, pin 11 to output, and pin 12 to input with the pullup active. The values for the second argument may be implementation specific. Some microcontroller cores use additional values. The number given in BASIC is directly handed through to the pinMode() C++ function.
+
+### DWRITE, DREAD, and LED
+
+Digital I/O is done with DWRITE and DREAD. Examples: 
+
+DWRITE 11, 1 
+
+A=DREAD(10)
+
+sets pin 11 to high and reads the value of pin 10 to variable A.
+
+The constant LED is the builtin LED on system. This can be microcontroller dependent.
+
+PINM LED, 1 
+
+DWRITE LED, 1
+
+lights the buildin led.
+
+### AWRITE, AREAD, and AZERO
+
+For analog I/O the command AWRITE and the function AREAD can be used. The pin number in these commands has to be the low level pin code of the microcontroller. For Arduino AVR systems the lowest analog pin number is the pin after the highest digital pin. On an UNO this is 14. The constant AZERO is the number of the lowest analog pin. Example: 
+
+PINM AZERO, 1
+
+PINM AZERO+1, 1
+
+PINM AZERO+2, 0
+
+sets the analog pin a0 and a1 of an Arduino to output and the pin a2 to input.
+
+AWRITE AZERO, 100
+
+AWRITE AZERO+1, 200
+
+V=AREAD(AZERO+2)
+
+write 100 to pin a0, 200 to pin a1 and reads pin a2. 
+
+Pin numbering can be tricky. More information can be found in the hardware section.
+
+### Timing with MILLIS and DELAY
+
+DELAY triggers a delay of n ms. Example:
+
+DELAY 1000 
+
+waits for one second. 
+
+The function MILLIS measures the time in milliseconds divided by a divisor. Example:
+
+A=MILLIS(1) 
+
+B=MILLIS(1000)
+
+A contains the time since start in milliseconds. B is the time since start in seconds. The divisor can be used in 16 bit systems to control overflow of a variable.
+
+### PULSE and PLAY extensions
+
+Two more compley Arduino I/O function are available from BASIC. 
+
+PULSE reads a pulse on a pin if used as a function. The first argument is the pin number, the second whether a LOW=0 or HIGH=1 state is expected. The third argument is the timeout in milliseconds. Note the difference to the original Arduino pulseIN(). The low level Arduino commands delivers the pulse length in microseconds. PULSE delivers the pulse length in 10 microsecond units to be compatible with integer BASIC number ranges. Example:
+
+A=PULSE(4, 0, 100)
+
+PULSE was named PULSEIN in ealier vesions of BASIC. This was changed in version 1.4.
+
+As a command, PULSE writes pulses on a pin. Example:
+
+PULSE 4, 10
+
+writes a 100 microsecond pulse on pin 4. Optional arguments are the value the pin is to be changed. Default is 1 assuming that the pin has been set to 0 before. Example:
+
+DWRITE 4, 1
+
+PULSE 4, 10, 0
+
+writes a 100 microsecond LOW pulse to the pin and then sets the pin again to HIGH=1.
+
+An number of repetitions and an intervall can be specified as well. Example:
+
+PULSE 4, 1, 1, 10, 100
+
+writes 10 pulses with 1000 ms time difference of length 10 microseconds on pin 4.
+
+The time unit of PULSE can be changes with SET 14, timeunit. Example: 
+
+SET 14, 1 
+
+sets the unit PULSE uses to 1 microsecond.
+
+PLAY is a wrapper around the Arduino tone() function for Arduino systems. For ESP32 VGA systems it is mapped to the sound generator function of the FabGL library. More information on this can be found in the hardware section. 
+
+## File I/O language set
+
+### Introduction 
+
+For systems with a filesystem there is a set of file access commands. Only one directory is supported. The file system command cannot handle subdirectories. One open file for read and one open file for write or append is supported. The file I/O commands mask the different underlying filesystems. Currently EEPROM EFS, SD, ESPSPIFFS and LittleFS are supported. Look for more information in the hardware section.
+
+### Opening and closing files with OPEN and CLOSE
+
+Files are opened with the OPEN command. Open needs a filename and optionally a file open mode as argument. As a file open mode 0 is read, 1 is write and 2 is append. Read mode is the default is no argument is given. Examples:
+
+OPEN "data.txt"
+
+OPEN "data.txt", 0
+
+OPEN "temp.txt", 1
+
+OPEN "append.txt", 2
+
+The first two commands are equivalent, the file "data.txt" is opened for read. The second line opens "temp.txt" for write. A new file is created if it doesn't exist. If the file exists writing starts at the beginning and existing data is overwritten. The third commands opens the file for append. 
+
+File name lengths are filesystem specific. The maximum length in BASIC is 32 characters.
+
+Files that have been written need to be closed not to lose the data. CLOSE without an argument closes the read file. This is not really necessary. CLOSE 1 or CLOSE 2 close the write file. Opening a new file automatically closes an open file. 
+
+OPEN and CLOSE and be used to open and close other I/O streams as well. For this, a file modifier can be added. Example:
+
+OPEN &7, 64, 1
+
+This command opens the Wire stream for write addressing the device 64 as a target. 
+
+If the modifier & is ommited, it is always assumed that the file stream &16 is meant.
+
+See the hardware section for more information on supported filesystems.
+
+### DOS commands CATALOG, DELETE, FDISK
+
+CATALOG lists the files in the filesystem. Am optional string pattern can be used to list only file that begin with it. Example: 
+
+CATALOG
+
+CATALOG "da"
+
+The first command lists all file, the second one all file beginning with the pattern "da".
+
+DELETE deletes one file. The name has to match exactly. No pattern matching is supported.
+
+FDISK formats a file system. This is not supported for all file systems. Arguments depend on the hardware implementation. Please look in the hardware section for more information.
+
+### Reading and writing with INPUT, PRINT, and the error variable @S
+
+Files can be written and read with PRINT and INPUT adding the file stream modifier. The I/O stream number for files is 16. Example:
+
+PRINT &16, "Hello World"
+
+writes "Hello World" to the open write file.
+
+INPUT &16, A\$
+
+reads the string A\$ from the file. INPUT can have comma seperated arguments. Each variable expects the input in a new line of the file. Like for in console input, INPUT does not split the I/O. Example:
+
+INPUT &16, A, B
+
+would read the first line of the file as a number into variable A and the second line into variable B.
+
+I/O operations ususally report no errors on the console and keep the the program running if an error occurs. The variable @S contains the error status of the operation. @S has to be reset explicitly before using it because it remembers and error status of previous operations and is never reset by the interpreter. Example:
+
+@S=0
+
+INPUT &16, A$
+
+IF @S=-1 THEN PRINT "End of file reached"
+
+@S takes the value -1 for the end of file condition. For general error it takes the value 1.
+
+Tutorial: fileio.bas
+
+### Character IO with GET and PUT
+
+Like PRINT and INPUT, the byte I/O command can take a stream modifier. Example: 
+
+GET &16, A
+
+would read one byte from the file putting the signed ASCII value to variable A.
+
+## Float language set
+
+### Introduction
+
+Floating point arithemtic is taken from the standard C float library of the platform. The size of the numbers is the size of the base type number_t in the C code. It is set to float as a default but can be changed to double. 
+
+### SIN, COS, TAN, ATAN
+
+The trigonometric function are standard BASIC. They are using radians as angle format. Examples: 
+
+PI=4* ATAN(1)
+
+PRINT SIN(PI)* SIN(PI)+COS(PI)* COS(PI)
+
+PI is not a predefined constant but can be calculated using ATAN. The second line should output 1.
+
+Tutorial: trig.bas
+
+### LOG and EXP
+
+LOG is the natural logarithm and EXP the exponantial function. 
+
+Tutorial: stir.bas
+
+### Floating point precision 
+
+Floating point numbers are displayed as integers if they are smaller then 1e8. Numbers from 1e8 on are displayed in exponential notation. Numbers smaller then 1e-8 are also displayed in exponential notation. 
+
+The biggest accurate integer in a 32 bit float is 16777216. The number can be recalled in BASIC by USR(0, 5).
+
+## Dartmouth language set
+
+### Introduction
+
+Since the early days of BASIC there were a few language features which I summarized as Dartmouth extension. DATA and DEF were in the First Edition of Dartmouth BASIC in the early 1960. ON appeared in the Fourth Edition in 1968.
+
+### DATA, READ, and RESTORE
+
+Data statements can be anywhere in the program. Data items can be strings or numbers. Example:
+
+10 DATA "Hello", 3.141, "A"
+
+READ A\$ : PRINT A\$
+
+READ A: PRINT A
+
+READ C: PRINT C
+
+Will print 
+
+Hello
+
+3.141
+
+65
+
+Strings have to be in quotes. Reading data with the READ command converts the data in the same way than the assignment commands. Strings reading numbers with contain the respective ASCII character. Numbers reading strings will contain the numerical ASCII code. 
+
+Unlike other BASIC versions, reading past the end of DATA will not lead to an error. The status variable @S will contain the value 1 once one reads past the last DATA item. @S is to reset explicitely after this. 
+
+RESTORE resets the data pointer. 
+
+From BASIC v1.4 on argument lists are also supported in READ. 
+
+In READ, the two index substring notation like A\$(3,3) is not yet supported. READ will interpret this as A\$(3) and append the read string. 
+
+RESTORE can also be used with an argument. In the code segment
+
+10 RESTORE 3
+
+20 READ A: PRINT A
+
+30 DATA 1, 4, 9, 16
+
+the READ statement will access the third argument of the DATA list, hence the output will be 9. 
+
+DATA can be used in expressions. After the code above has run
+
+PRINT DATA
+
+will output 4 indicating that the data pointer will read the 4th argument after the next read. This feature can be used to store a position of the DATA list and then return to it.
+
+10 R=DATA
+
+20 ... some lines doing many READs
+
+100 RESTORE R
+
+the data pointer will be reset to the original position before reading was done.
+
+Tutorial: readdata.bas
+
+### DEF FN
+
+Functions can have one numerical argument and a two character name. Example: 
+
+10 DEF FN TK(X) = X+SIN(X)
+
+Functions have to be DEFed before use. 
+
+Tutorial: func.bas
+
+### ON 
+
+ON is used in combination with GOTO or GOSUB arguments. Examples: 
+
+10 ON X GOTO 100,200,300
+
+Tutorial: ongo.bas 
+
+## Darkarts language set
+
+### Introduction 
+
+The dark arts language set contain a set of command which can cause evil. BASIC is a beginner language and protects the user from dangerous things. This makes it somehow rigid. The three dark arts commands give access to the inner working of the heap and the program storage. They have side effects and can destroy a running program. CLR is extended in dark arts. It can delete variables from the heap.
+
+### MALLOC
+
+MALLOC allocates a junk of memory on the heap and returns the address. The function receives two arguments. One is the identifier. It is a 16 bit integer. The second argument is the number of bytes to be reserved. Example: 
+
+A = MALLOC(1, 64)
+
+This reserves 64 bytes which can be accessed with PEEK and POKE as 8 bit signed integers. 
+
+MALLOC helps to reserve storage in a controlled way. It is no side effects and can be used savely as long as the POKEs stay within the allocated range.
+
+Tutorial: malloc.bas
+
+### FIND
+
+FIND finds a memory segement on the heap. It can be used to find memory segements allocated with MALLOC but it also finds variables, strings and arrays. 
+
+In all of these examples the argument of the function is the name of an object and not an expression. It has to be the pure string or array without any subscripts.
+
+All heap variables can be searched. Example: 
+
+A0=10 
+
+PRINT FIND(A0)
+
+This command outputs the address of the variable A0. The variable is stored with the least significant byte first. The size of the variable area is the size of number_t. It is 2 bytes for integer BASICs and 4 bytes for floating point BASICs.
+
+Arrays are searched by specifiying the array name without arguments. Example:
+
+DIM A(8)
+
+PRINT FIND(A())
+
+Arrays are stored like variables with the lowest array element first. 
+
+Strings can be searched as well. Example: 
+
+A\$="Hello World"
+
+PRINT FIND(A\$)
+
+This command outputs the address of a string. If A$ is a pure string and not a string array, the first byte is the least significant byte of the length of the string. The second byte is the most significant byte of the length for 16 bit strings. All following bytes are payload. Strings are not necessarily 0 terminated. One has to process the length in all code accessing strings directly.
+
+If a memory segment allocated with MALLOC needs to be searched, a numerical expression can be specified. Example: 
+
+A = MALLOC(1, 64)
+
+PRINT FIND(1)
+
+If the segment to be searched is stored in a variable, FIND has to be called like in this example:
+
+M=1
+
+PRINT FIND((M))
+
+Note the inner braces around M. They are needed here as they trigger expression evaluation. This is unusual for BASIC interpreters. 
+
+FIND itself has no side effects but POKEing around in the heap area can kill the interpreter if the structure of the heap list is destroyed.
+
+Tutorial: find.bas
+
+### EVAL
+
+EVAL adds a new line to the BASIC code at runtime. Doing so has many side effects and EVAL does not protect you in any way. Examples: 
+
+10 EVAL 20, "PRINT X"
+
+20 PRINT "Hello World"
+
+RUN 
+
+LIST 
+
+In the examples above line 20 is replaced by the string in the EVAL command.
+
+EVAL includes the line to the program heap. This changes memory addresses of all code behind the inserted line. FOR loops, GOSUB commands, the linenumber cache and READ/DATA statements use plain memory addresses. This means that the DATA pointer, all active FOR loops and active GOSUBs break. A safe way to use EVAL is to change only lines further down in the code outside of any active FOR loop and to RESTORE the DATA pointer after EVAL. 
+
+See eval.bas in the tutorial for more information.
+
+### CLR
+
+In the standard language sets CLR deletes all variables and resets stacks and caches. With dark arts enables it is extended to delete variables from the heap. Example: 
+
+10 DIM A(10)
+
+20 CLR A()
+
+30 DIM A(20)
+
+In this example the array A() is deleted and can be redefined. 
+
+All variables defined after A() are also deleted. Example:
+
+10 DIM A(10)
+
+20 B$="Hello World"
+
+30 CLR A()
+
+40 DIM A(20)
+
+In this examples B$ is also deleted. All variables defined after the object to be clear are deleted as well. The heap is simply reset to the previous state. This mechanism can be used to define local variables in subroutines. Simply clear the first variable defined in the subroutine before calling RETURN.
+
+
+## IOT language set
+
+### Introduction
+
+The IoT language set are commands needed to use IoT services. They help to implement I/O function. This part of the interpreter is under active development. Some commands may change in the future.
+
+### AVAIL
+
+AVAIL returns the number of characters ready for input on an input stream. Example: 
+
+PRINT AVAIL(4)
+
+returns the number of characters on input stream 4 which is the secondary serial port. The function is hardware dependent.
+
+### String commands INSTR, VAL, and STR
+
+INSTR finds a character in a string and returns the index. Example: 
+
+A\$="1, 2, 3"
+
+A=INSTR(",", A\$)
+
+finds the first comma in the string. INSTR can be used to split strings. See splitstr.bas in the tutorial for more information.
+
+VAL scans a string for a number and returns the value. If no number is found the return value is 0. Example: 
+
+A\$="125"
+
+A=VAL(A$)
+
+VAL uses the special variable @V to report back the number of characters in the number. The status of the conversion is stored in @S. If @S is 0 after a conversion a number was found. Otherwise @S is 1. @V is set to the number of characters only if the conversion was succesful. 
+
+STR converts a number to a string. Example: 
+
+A\$=STR(125)
+
+Tutorial: splitstr.bas, converst.bas
+
+### SENSOR
+
+SENSOR is the generic sensor interface. It handles sensor drivers in the hardware dependent code. The first argument of the function is the sensor number. The second argument can be used to indentify interal properties of the sensor. If the second argument is zero, SENSOR returns if the sensor code is available. Example: 
+
+10 IF NOT SENSOR(1, 0) THEN PRINT "no DHT11 sensor detected": END
+
+20 PRINT SENSOR(1, 2)
+
+The first command looks if there is a DHT temperature sensor. The second command read the temperature value.
+
+### SLEEP
+
+SLEEP puts a system into deep sleep mode. It requires one argument which is the sleep time in milliseconds. The command is currently only implemented on ESP8266 and ESP32 systems. The microcontroller restarts after deep sleep. This command needs to be used with an autostart program.
+
+### NETSTAT
+
+In command mode NETSTAT displays the network status. It is implemented for all Wifi systems and Arduino Ethernet. As a arithemtic constant it returns a network status. With 0 the system is not connected. 1 means connected but no MQTT connection. 3 is network and MQTT connected.
+
+The network code is under active development.
+
+## Timers and interrupts
+
+BASIC can handle time interrupt right now. Interrupts of external sources are in preparation. There are two timers implemented. The AFTER timer causes an action once and is then reset. The EVERY timer triggers events periodically until stopped. Both timers use millis() as time source. Timer events are only processed if a program is running. In interactive mode both timers are stopped but continue running. 
+
+### AFTER
+
+The AFTER timer is started with the command 
+
+10 AFTER 1000 GOTO 100
+
+After 1000 milliseconds the interpreter branches to line 100. The command
+
+10 AFTER 500 GOSUB 200
+
+will GOSUB to line 200. A RETURN will resume program execution whereevery the program has been interrupted.
+
+AFTER 0 
+ 
+disables the execution of the after command. 
+
+AFTER 1000 
+
+will start the after timer again with a new time period of 1000 ms. The GOTO and GOSUB argument of the previous after are reused.
+
+### EVERY
+
+EVERY syntax is exactly like AFTER but the event is running periodically. 
+
+### EVENT
+
+EVENT listens to an interrupt and branches to a line number. In the statement 
+
+EVENT 2,0 GOSUB 1000
+
+pin 2 is used as an interrupt pin with mode 0, which is interrupt on low. Every time the pin goes to low BASIC calls the subroutine at line 1000.
+
+EVENT 2,0 
+
+without the GOSUB argument deletes the interrupt. 
+
+After the event is processed, the interrupt is automatically disabled. The RETURN statement enables the interrupt again. 
+
+Allowed interrupt modes are 
+
+0: LOW
+
+1: CHANGE
+
+2: FALLING
+
+3: RISING
+
+The EVENT statement does not set the pin mode of the pin. This has to be done with PINM in the BASIC program. A typical program could look like this:
+
+10 PINM 2,2
+
+20 EVENT 2,2 GOSUB 1000
+
+30 Some code 
+
+1000 PRINT "Event triggered": RETURN
+
+The PINM command sets the pin to INPUT_PULLUP and the EVENT commands waits for the pin to be pulled down to low. It triggers the interrupt on the falling signal. While the PRINT statement is processed, no further interrupt is accepted. After return the interrupt is reenabled.
+
+Events can be disabled with the command 
+
+EVENT STOP
+
+Events can be reenabled with the command 
+
+EVENT CONT
+
+### Credits and a word on timing
+
+Both AFTER and EVERY have been taken from the legendary Locomotive BASIC. In this BASIC dialect, only GOSUB was available and the time scale was 20 ms. There were 4 individual timers. Full featured Locomotive BASIC timers are on the feature list for future releases.
+
+BASIC can handle 1ms interrupts even on an Arduino UNO if there is not much I/O going on. Typically, 35 BASIC commands are processed in a ms by the interpreter core. It is good practice to disable interrupts with EVERY 0 at the beginning of the interrupt subroutine and to reenable it with EVERY n immediately before return. 
+
+## Error handling
+
+### Errors in general
+
+In BASIC there are to types of error. Some conditions are just exceptions and the program will coninue normally. Examples are reading past the end of a file or reading past the last DATA item. These operations set the flag @S to an appropriate value. BASIC language errors clear the stacks, print an error message and the program is terminated. Variables and the program pointer are preserved. The program can be continued with CONT. Effectively, an error leads to a STOP of the program plus loss of GOSUB and FOR stack information by default.
+
+### Error trapping
+
+If BASIC is compiled with the HASERRORHANDLING option, error behaviour can be controlled with the ERROR command.
+
+The code line 
+
+10 ERROR GOTO 1000
+
+would jump to line 1000 when an error is encountered. As the FOR and GOSUB stacks are cleared on error, the code from 1000 on must handle all operations to restart the program if needed. After the jump, the error handling is reset to normal behaviour, i.e. stop on error. Using the keyword ERROR as a variable returns the error code. 
+
+ERROR STOP 
+
+will switch of error handling and go to normal behaviour. It also resets the error code to 0.
+
+ERROR CONT 
+
+causes the program to continue even in case of an error. 
+
+### Error codes
+
+Currently the following error codes are supported. 
+
+Syntax error: 10
+
+Number error: 11
+
+Division by zero: 12
+
+Unknown line: 13
+
+Return not possible: 14
+
+Next not possible: 15
+
+Gosub not possible: 16 
+
+For not possible: 17
+
+Out of memory: 18
+
+Stack error: 19
+
+Wrong dimensioning: 20
+
+Index or parameter out of range: 21
+
+String operation error: 22
+
+Error in variable handling: 23
+
+File errors: 24
+
+Function errors: 25
+
+Number or type of arguments wrong: 26
+
+EEPROM errors: 27
+
+SDcard errors: 28
+
+Some of the errors are technical errors and should never appear if the interpreter works properly. 
+
+## Graphics language set
+
+### Introduction
+
+The graphics language set is a thin layer over the low level graphics functions of the graphics driver. They try to be as generic as possible and avoid driver specific code. Some of the commands behave differently on different platforms. The graphics commands were first implemented with an SD1963 TFT in mind. Currently various monochrome and color displays are supported.
+
+### COLOR
+
+Sets the color of the graphics pen. COLOR either accepts either 3 arguments for rgb color or one argument for vga like colors. The exact color palette depends on the graphics driver. Example: 
+
+COLOR 255 
+
+COLOR 100, 100, 100
+
+### PLOT
+
+PLOT draws one pixel on the display. The coordinate system starts at the upper left corner of the display. First arguments is the x coordinate, second argument is the y coordinate. Example:
+
+PLOT 100, 100
+
+A pixel is drawn in the colour specified by the COLOR command.
+
+### LINE
+
+LINE draws a line from one point to another. Example: 
+
+LINE 100, 100, 200, 200
+
+### CIRCLE and FCIRCLE
+
+CIRCLE and FCIRCLE draw a circle or filled circle around a point on the canvas with radius r. The last argument is the radius. Example:
+
+CIRCLE 100, 100, 50
+
+### RECT and FRECT
+
+RECT and FRECT draw a rectangle or filled rectangle. The first pair of argument is the left lower corner. The second pair is the right upper corner. Example: 
+
+RECT 100, 100, 200, 200
+
+# Hardware drivers 
+
+## I/O Streams
+
+### Introduction
+
+BASIC I/O goes through input output streams. Every stream has an integer number. Sending data to a stream sends it through to a device driver. These device drivers handle the underlying OS or microcontroller cores. The logic is as close as possible to the Arduino stream class. 
+
+Streams are
+
+1: Console input and output
+
+2: Keyboard or keypad input and display output
+
+4: Secondary serial stream
+
+7: I2C protocol 
+
+8: RF24 radio interface
+
+9: MQTT network connection
+
+16: File I/O
+
+All other stream numbers are currently unused but will be allocated to drivers in the future. The stream numbers below 32 should not be used for extensions. 
+
+Stream numbers are agruments of the modifier of OPEN, CLOSE, PRINT, INPUT, GET and PUT. Typical commands would look like:
+
+INPUT &2, A$
+
+PRINT &4, "Hello world"
+
+GET $2, A
+
+PUT &16, "A", "B"
+
+The expression after & is the I/O stream number.
+
+There is a default I/O stream compiled into the code. For systems not compiled with the STANDALONE option this default stream is the console stream 1. If the STANDALONE option is used, the default stream is 2. 
+
+The active I/O stream can be changed by stetting the special variable @O for output and @I for input. The two code lines
+
+10 @O=2: PRINT "Hello World"
+
+and 
+
+10 PRINT &2, "Hello World"
+
+both write "Hello World" to the display. 
+
+The active I/O stream is always reset to the default stream once the interpreter changes to interactive mode. This is a failsafe to avoid a program to shut out a user permanently.
+
+The default stream can be changed permanently with the SET command.
+
+SET 3,0 sets the default output stream to console.
+
+SET 3,1 sets the default output stream to display.
+
+SET 5,0 sets the default input stream to console.
+
+SET 5,1 sets the default input stream to display.
+
+### Serial Stream
+
+Stream 1 is the default serial I/O stream on Arduino IDE programmed microcontrollers and it is standard input and output on POSIX like systems. The behaviour of stream 1 differed between the two version.
+
+On microcontrollers stream 1 is a true byte I/O stream and non blocking. The command
+
+GET A
+
+will return immediately and return 0 in the variable A if no character is available on the stream. The function AVAIL(1) or the special variable @A will return the correct number of characters in the serial buffer. If there is no character, the result will be 0.
+
+On POSIX systems, getchar() is used on OS level. This means that I/O on stream 1 is blocking. 
+
+GET A
+
+will wait for a character. AVAIL(1) or @A will always return 1 to make sure that a program like this
+
+10 IF AVAIL(1) THEN GET A
+
+runs correctly on both archtitectures.
+
+For line oriented input with the INPUT command, the difference is irrelevant. INPUT works in the same way on both system types.
+
+There is currently no mechanism to change the precompiled baud rate of the serial stream at runtime of a BASIC program. Default in the interpreter code is 9600 baud. This can be changed at compile time by changing serial_baudrate in the code.
+
+A line end is LF, which means ASCII 10. This is UNIX style end of line. DOS and other systems usually send CR LF which is 13 10 in decimal ASCII. If you use a terminal program to interact with BASIC, "only LF", should be configured in the settings. Currently stream 1 cannot be reconfigured to use LF CR. Stream 4, the secondary serial stream, can use CR LF. This is mostly relevant for input. 
+
+### Display and keyboard drivers
+
+Keyboard and display are accessed through stream 2. Only one device can be present, i.e. one keyboard and one display. Multidisplay or multikeyboard systems are not supported. Stream 3 is reserved for these usecases but currently not implemented. 
+
+BASIC currently supports either PS2 keyboards and the keypad of the LCDSHIELD as input device. For PS2 keyboards on standard Arduino systems the patches PS2keyboard library should be downloaded from my repo for optimal functionality. It implements keyboard.peek() which has a few advantages. 
+
+PS2 keyboard input is buffered and non blocking. AVAIL(2) gives the correct number of characters in the keyboard buffer. 
+
+GET &2, A
+
+return 0 if no character is present and the ASCII value if a character is there. 
+
+GET &2, A$ 
+
+transfers the result directly in the string A$ as a first character. The string is empty if no key was pressed.
+
+The keymap is compiled into the code. A few standard US or European keymaps are supported.
+
+If the code is compiled with the LCDSHIELD option, the keys of the shield can be used to input data. The "select" key of the shield is mapped to ASCII 10 means "end of line". The arrow keys of the shield are mapped to the digits 1 to 4. 
+
+INPUT &2, A
+
+can be used on an lcd shield for number input. The command returns after select and A has a valid number. Alternatively 
+
+INPUT &2, A$ 
+
+will enter a string consisting of the digits 1 to 4. 
+
+GET &2, A 
+
+will contain either 0 if no key is pressed or the ASCII code of the key. The command will wait until the key is released. Keypad input is unbuffered. No interrupt or timer function is currently implemented on keypads. This will change for future releases of the code. 
+
+ASCII output to a display is sent through the output stream 2. Displays are handled by a generic display driver. For low memory systems the display driver supports a non scrolling / unbuffered mode. Only a few basic display functions are supported. If there is enough memory, the display driver can be compiled in scrolling / buffered mode. For the the option DISPLAYCANSCROLL has to be defined in hardware-arduino.h. All characters are buffered in a display buffer which can be accessed byte wise. 
+
+In non buffered mode the display driver has the following functions: 
+
+The cursor of the display can be accessed special variables @X and @Y. Both variables are read/write. One can find out where the cursor is and set its position. Output with PUT &2 and PRINT &2 goes to the next cursor postion.
+
+ASCII character 7 is the bell character. It calls the dspbell() function which is empty by default. Any action can be implemented here.
+
+ASCII character 8 is backspace and delete. This is needed for compatibility with certain terminals. 
+
+ASCII character 9 is tab to the next multiple of 8 tab stop.
+
+ASCII character 10 goes to the beginning of next line (Unix style LF).
+
+ASCII character 11 is vertical tab, going to the next line in the same column.
+
+ASCII character 12 clears the display. PUT &2, 12 is clear screen on the display.
+
+ASCII character 13 goes to the beginning of the currently line (true CR).
+
+ASCII character 127 goes back one cursor position and clears the character. It is "delete".
+
+ASCII character 27 (ESC) sets the terminal to esc mode and triggers vt52 character interpretation. 
+
+ASCII character 2 (STX) sends the cursor to the home position. This feature will also be used for Epaper support in the future.
+
+ASCII character 3 (ETX) is used for page mode displays to trigger the redraw.
+
+Buffered displays add scrolling. Once the cursor goes beyond the last line, the display is redraw with the first line disappearing. This is simple line based software scrolling. 
+
+Each character in the display is buffered a display buffer. This buffer can be accessed through the special array D(). Writing to the array immediately display the character on the display. Reading from it gives the displayed character at the index position. The array starts from 1. The index advances by column and then by row. 
+
+Currently LCD displays 16x2 and 20x4, Nokia 5110, ILI9486, ILI9488, SSD1306, and SD1963 are supported. All these displays use 8x8 or 16x16 fonts. Nokia has 10 columns and 6 rows. SSD1306 character buffer dimension depend on the display size. 16x8 is the most common size. ILI9488 has 20 columns and 30 rows. It is portrait mode by default. A 7 inch SD1963 has 50 columns and 30 rows. ILI9486 displays are based on the MCUFRIEND library with parallel access.
+
+Some displays use page based low level graphics drivers. These displays mirror the entire canvas in memory on a pixel basis. When one draws to the canvas, nothing is shown until an update command transfers the buffer to the display. SPI bus based monochrome display use this technique. The ILI9488 and SSD1306 Oled driver use this mechanism. By default these displays behave like the other displays and page mode is of. Drawing of graphics and text appears slow.
+
+Activating the page mode is done with
+
+SET 10, 1
+
+after this all updates stay in memory until an ETX code is sent with 
+
+PUT &2, 3
+
+only then the display is redrawn. The display can be set back to character mode by 
+
+SET 10, 0
+
+For epaper displays page mode is default. Epaper disply integration is in preparation.
+
+In addition to the displays, VGA output is supported with the FabGL library on ESP32 systems. These systems are described in the special systems section.
+
+### VT52 terminal emulation
+
+If compiled with HASVT52, BASIC has a full VT52 terminal emulation, including many of the GEMDOS addons. Please look at the wikipedia page https://en.wikipedia.org/wiki/VT52 for a full list of the originally supported ESC sequences.
+
+All standard commands except the keypad and graphics sequences are supported. All GEMDOS extensions except reverse video are supported where it makes sense. On color displays, the color code is sent as a VGA color in the range from 0 to 15. 
+
+The most useful VT52 sequences in a BASIC program are the ons manipulating entire line.
+
+PUT &2, 27, "L" 
+
+inserts a line, while 
+
+PUT &2, 27, "M"
+
+deletes a line. 
+
+ON LCD displays, switching on the cursor is supported.
+
+PUT &2, 27, "e"
+
+switches on a blinking cursor, while 
+
+PUT &2, 27, "f"
+
+switches it off again.
+
+The following ESC sequences are supported right now
+
+ESC A Cursor up - Move cursor one line upwards.
+
+ESC B Cursor down - Move cursor one line downwards.
+
+ESC C Cursor right - Move cursor one column to the right.
+
+ESC D Cursor left - Move cursor one column to the left.
+
+ESC H Cursor home - Move cursor to the upper left corner.
+
+ESC I Reverse line feed - Insert a line above the cursor, then move the cursor into it.
+
+ESC J Clear to end of screen - Clear screen from cursor onwards.
+
+ESC K Clear to end of line - Clear line from cursor onwards.
+
+ESC L Insert line - Insert a line.
+
+ESC M Delete line - Remove line.
+
+ESC Yrc Set cursor position - Move cursor to position c,r, encoded as single characters.
+
+ESC Z ident Identify what the terminal is, see notes below.
+
+ESC E Clear screen - Clear screen and place cursor at top left corner.
+
+ESC b# Foreground color - Set text colour to the selected value (only implemented on color displays).
+
+ESC c# Background color - Set background colour (only implemented on color displays).
+
+ESC d Clear to start of screen - Clear screen from the cursor up to the home position.
+
+ESC e Enable cursor - Makes the cursor visible on the screen (only implemented on LCDs).
+
+ESC f Disable cursor - Makes the cursor invisible (only implemented on LCDs).
+
+ESC j Save cursor - Saves the current position of the cursor in memory.
+
+ESC k Restore cursor - Return the cursor to the settings previously saved with j.
+
+ESC l Clear line - Erase the entire line and positions the cursor on the left.
+
+ESC o Clear to start of line - Clear current line from the start to the left side to the cursor.
+
+ESC p Reverse video - Switch on inverse video text (implemented but with no function).
+
+ESC q Normal video - Switch off inverse video text (implemented but with no function).
+
+ESC v Wrap on - Enable line wrap, removing the need for CR/LF at line endings.
+
+ESC w Wrap off - Disable line wrap.
+
+### VT52 graphics extension
+
+On displays with graphics capabilities, the graphics commands can also be sent to the display with ESC sequences. This is not part of the standard VT52 command set and also not part of the GEMDOS extension.
+
+The graphics code uses three general purpose registers x, y, and z. x and y are 14 bit registers while z is a 7 bit register. Setting a register is done with the sequences 
+
+ESC x low high
+
+ESC y low high
+
+ESC z char
+
+Like in cursor control the arguments are transfered as printable characters. 32 is subtracted from the ASCII value of low, high or char. 
+
+Graphics commands are initiated by 
+
+ESC g command
+
+where command is one character. The following graphics sequences are currently implemented
+
+ESC g s - set the graphics cursor to position x and y
+
+ESC g p - plot a point at the graphics cursor
+
+ESC g l - draw a line from the graphics cursor to position x and y 
+
+ESC g L - draw a line from the graphics cursor to position x and y and move the graphics cursor to x, y
+
+ESC g r - draw a rectangle between the graphics cursor position and x, y (like RECT)
+
+ESC g R - draw a filled rectangle
+
+ESC g c - draw a circle at graphics cursor position with radius x
+
+ESC g C draw filled circle
+
+Color is set with ESC c. 
+
+### Secondary serial stream
+
+The secondary serial stream is addressed through stream number 4. For microcontroller platforms with a hardware secondary serial port, the Serial1 object on the Arduino library is used. This can be changed in hardware-arduino.h by modifiying the functions beginning with prt. For microcontrollers without multiple hardware serial ports Softwareserial is used. The RX and TX pins are set through the macro SOFTSERIALRX and SOFTSERIALTX. Default are pin 11 and 12. This conflicts with the SPI pins. If SPI is to be used the soft serial pins have to be changed.
+
+Default baudrate on the secondary serial port is 9600 baud.
+
+The secondary serial port implements a blockmode function. Blockmode is on by default. Without blockmode an INPUT command would wait until a LF is received. This means that 
+
+INPUT &4, A$
+
+would never return if the sender on the serial port does not send LF. If a modem with AT commands or any other device is on the input port, the BASIC program would stop indefinitely if the sender side misbehaves. With blockmode active, the INPUT command handles I/O differently. 
+
+With the command 
+
+SET 7, 1 
+
+the blockmode parameter can be set to 1. In this mode the entire serial buffer is transfered to the string A$. The number of characters waiting in the serial buffer for transfer can be found by the function AVAIL(4). This number of character is in the string after INPUT &4 with the length of the string set to the value of AVAIL(4) before INPUT. Immediately after read, AVAIL(4) is zero. For secondary serial blockmode 1 is the default.
+
+Setting the blockmode parameter to a value greater 1 the timeout mode is activated. INPUT reads all characters in the buffer and waits timeout microseconds for further input until it returns. It also returns if the string is full. Example: 
+
+SET 7, 500
+
+INPUT &4, A$
+
+In this mode the INPUT command would read all characters, wait for 500ms for further input, and returns latest after this 500ms or when the string is full. 
+
+For communication with modems, the secondary serial channel has one more parameter. Normally only LF is sent after the end of a line. Some modems and other devices on a serial port expect a LF CR sequence at the end of a line. The communication is blocked if CR is not sent. With the command 
+
+SET 6, 1 
+
+CR mode is activated. A print command to the serial channel like 
+
+PRINT &4, "AT"
+
+would print the characters "A", "T", followed by a LF (ASCII 10) and a CR (ASCII 13).
+
+Answer of a model could be collected with the input sequence above.
+
+Unlike the primary serial port, the baudrate of the secondary port can be changed by the BASIC program. Example:
+
+SET 8, 31250 
+
+would set the baudrate to the standard MIDI baudrate of 31250. Any allowed baudrate of the hardware platform can be used. The serial port is reset after this command.
+
+### Wire communication
+
+Stream &7 is used for Wire i.e. the I2C protocol. BASIC uses the implementation of the Arduino Wire library and the Wire object. Actually, the I2C protocol is very compley and the Wire library hides this complexity making it a byte stream. PRINT, INPUT, GET and PUT can deal well with byte streams, therefore most of the Wire libraries functionality can be used from BASIC. There is a master and a slave mode implementation.
+
+In master mode, the OPEN statement for the I2C stream is used in read mode. Example: 
+
+OPEN &7, 104 
+
+prepares I2C to control the slave with address 104. This address is a real time clock. Any valid I2C slave address can be used as an argument in the OPEN statement. OPEN &7 does not transfer any data and it also does not make any calls to the Wire library except if the microcontroller was in slave mode before. Then OPEN restarts the Wire object in master mode.
+
+Sending data can be done with PUT for sequences with just a few bytes. Alternatively the information can be collected in a string and then sent with print. Examples: 
+
+PUT &7, 0 
+
+sends a null byte to the device. 
+
+PRINT &7, A\$ 
+
+sends as many bytes as are stored in A$ to the device. LEN(A$) is the number of bytes transferred. The maximum is 31 bytes, a limit given by the wire libraries internal buffers.
+
+Requesting a byte from the device can either be done with GET or with INPUT.
+
+GET &7, A 
+
+requests one byte from the device.
+
+INPUT &7, A\$
+
+requests as many bytes as fit into the string, maximum 32. After INPUT the string will always have a length of 32 bytes on AVR. The Wire library does not transmit the number of transferred bytes properly despite some comments that indicate otherwise in the documentation. The library returns the number of requested bytes. 
+
+One can request fewer bytes than fit into the string by using the # modifier in the INPUT command. 
+
+INPUT &7, #8, A$
+
+would request 8 bytes from the device. The length of the string will be 8 after the command. Again, this does not mean that the device really sent 8 bytes.
+
+On stream 7 the status variable @S is set after each transmission to the status of the request or sent method. From this one can detect if the transmission has worked.
+
+Wire can be reopen in master mode if one want to communicate with another device by a new OPEN command with a different address. This way multiple devices can be controlled.
+
+See examples/13wire/master* for more info on master mode. This is a port of the example programs of the Arduino library from C++ to BASIC. It shows how easy it is to use Wire from BASIC.
+
+Slave mode is open with OPEN in write mode, i.e. with 1 as a thrid parameter. Example: 
+
+OPEN &7, 8, 1
+
+makes your BASIC Arduino a slave that listens on Wire port 8. This OPEN statement stops the Wire object, interaction with devices where the Arduino has to be master is no longer possible. Any open in master mode will stop the slave mode. 
+
+After slave mode is started the BASIC program continues normally. In the background there is an interrupt handler collecting the data the master sends. The program has to check periodically to see if the master has sent or requested data.
+
+If the master has sent data, AVAIL(7) will be larger than 0. The data sent by the master can be collected by
+
+INPUT &7, A\$
+
+and then processed by the program. It the master sends additional data before the BASIC program has recalled the message, the buffer is overwritten. Only one transaction is stored. This means that a Wire slave needs to check AVAIL(7) in a tight loop.
+
+If the master has requested data, USR(7, 1) has the number of requested bytes. The program should now prepare a string with this number of bytes and send it with
+
+PRINT &7, A\$
+
+After this, USR(7, 1) will be zero once the master has collected the data from the buffer. 
+
+Alternatively, the slave can deposite data in the buffer before the master has even requested it. A master request at a later time will be answered with the data. This would be useful for sensors of all kind. The slave measures data, puts it in the buffer with PRINT &7 and waits a while e.g. with DELAY until it does the next measurement. The new data overwrite the old one after every measurement cycle. A master can request data asynchronously at any time and will receive the data in the buffer. This BASIC program does not need to handle this.
+
+See examples/13wire/slave* for more info on slave mode.
+
+There is a number of example programs in examples/13wire to show how Wire programming works. 
+
+### Radio communication
+
+Stream &8 is used for RF2401 radio communication. For this, BASIC needs to be compiled with the ARDUINORF24 flag and the respective pin definitions set. The open statement can be used to open one stream for read and one writing simulataneously. Example:
+
+OPEN &8, "0815x", 0
+
+OPEN &8, "0815y", 1
+
+The first command opens a stream for reading, using the string given as file name to generate the 5 byte pipe address. The second command opens a write pipe with a different pipe address. 
+
+OPEN on the radio interface sets @S if there is in a error in the module communication. Typically this would mean that the module is not connected properly.
+
+After opening INPUT, PRINT, PUT and GET on stream &8 work similar to Wire. The maximum message length is restricted by the unterlying library to 32 bytes.
+
+The radio module is started with maximum power. To power it down SET 9, x can be used. x is an integer between 0 and 3. 3 is maximum power and 0 is minumum power.
+
+### MQTT
+
+Stream &9 is used for networking with MQTT. MQTT is the only network protocoll that is supported and the code is experimental. The network code is generic and more protocols will be integrated in the future. 
+
+Supported network adapters are Ardunio Ethernet shields, ESP8266 and ESP32 WLAN, Arduino MKR and RP2040 WifiNINA. These network codes have some timing needs like yielding the CPU and refreshing DHCP leases. BASIC integrates this in the central statement loop processing all time critical tasks in the function byield(). This code is best tested and very stable on ESP8266 and ESP32. Other platforms are alpha. 
+
+For Wifi systems, the SSID and password are hardcoded in the BASIC interpreter binary by setting the respective lines in "wifisettings.h". In this file there are two lines defining the MQTT server and port. This data is also compiled into the code. Currently only unencrypted and unautheticated MQTT is supported as this is only a toy. The fiths line in the code is a MAC address which is needed for the Arduino Ethernet shield. For all other hardware platforms this line is ignored.
+
+After startup of the microcontroller it tries to connect to Wifi or Ethernet. The command NETSTAT can be used to see the connection status. This command is meant for interactive use only. 
+
+Finding the connection status in a program can be done by using NETSTAT as a function.
+
+PRINT NETSTAT
+
+or 
+
+A=NETSTAT
+
+will return 0 is the network is not connected, 1 if the network is connected but MQTT is not connected, 3 is network and MQTT are connected. More status values will be added here in the future.
+
+An MQTT topic an be open with the OPEN command using the topic name as a file name. Example: 
+
+OPEN &9, "iotbasic/data", 1
+
+would open the topic "iotbasic/data" for writing because 1 was provided as a third parameter.
+
+OPEN &9, "iotbasic/command", 0
+
+would open the topic "iotbasic/command" for read. 
+
+There can be one read and write topic simulataneously. After opening the topics, data can be written by the commands PRINT, INPUT, GET, and PUT.
+
+Every command will generate one MQTT message. 
+
+PRINT &9, "humidity", A 
+
+would send a message consisting of the string "humidity" and a number from variable A.
+
+The maximum MQTT message length is hardcode to 128 bytes but can be extended. The maximum topic length is 32 bytes.
+
+Incoming messages are buffered in the background. A new message overwrites the old one as there is only one buffer. The function AVAIL(9) has the number of bytes currently in the buffer. If AVAIL(9) is greater then 0 then 
+
+INPUT &9, A\$
+
+transfers the entire message into A\$. From the string the message can be parsed with INSTR and VAL if numerical data was sent. The implementation is "binary data safe". Any set of bytes can be send as a message and be processed.
+
+On POSIX systems not networking is supported as I haven't found a suitable multi platform MQTT library and was too lazy to write one myself.
+
+The network code will be extended in version 1.4. Currently it is only a proof of concept.
+
+### Filesystems
+
+BASIC runs on very different platforms. From small 8 bit AVR based system to 64 bit Macs. These computers have different filesystems and capabilities. The BASIC commands are designed to make a minimal file I/O possible. Only one directory is supported. One file can be open for reading and another for writing simulateously. Stream &16 is used for file I/O.
+
+Supported filesystems are SD on all microcontroller platforms that have it, ESPSPIFFS for ESP8266 and ESP32, LittleFS for Arduino MKR and RP2040 based systems. The file system driver removed leading rootfs names and everything else starting with a '/'. It shows a flat namespace of filenames. BASIC itself limits filenames to a maximum of 32 bytes. Some filesystems cannot handle this. In this case the name is truncated. No check is made if the filename is legal for the particular filesystem. For ESPSPIFFS and LittleFS the FDISK command is supported. Example: 
+
+FDISK 
+
+would answer with the prompt
+
+Format disk (y/N)?
+
+and then format the disk. No parameters are used here.
+
+In addition to the standard filesystems, I developed a minimalist EEPROM filesystem. This filesystem partitions an I2C EEPROM into n equal size slots that can be used for files. Formating this filesystem requires the number of slots as a parameter. Example: 
+
+FDISK 4
+
+would partition the EEPROM to 4 equal slot. For the very common 32kB serial EEPROM it would mean that 4 files of maximum of 8k can be stored. The EEPROM size has to be hard coded into the BASIC interpeter at the moment. This will change in the future.
+
+On POSIX and SD no formating is supported. 
+
+### Real time clock support
+
+Currently the built-in clocks of ESP32, STM32 and Arduino MKR and I2C clocks DS1307, DS3231 and DS3232 are supported and can be accessed through the special array @T() and the special string @T$. The array elements are 
+
+@T(0): seconds
+
+@T(1): minutes
+
+@T(2): hours
+
+@T(3): days
+
+@T(4): month
+
+@T(5): year (0-99)
+
+@T(6): day of week (0-6)
+
+@T(7): temperature (DS1307 only)
+
+@T(8): direct bytewise access to the clocks registers. On a DS1307 the addresses from 8 onwards are the NVRAM memory. On DS3231 and DS3232 these are the clock internal registers for alarm followed by the memory on DS3232. 
+
+Real time clock support for I2C is now built-in. No external library is used for this. For STM32 and Ardunio MKR the clock and low power libraries are automatically used by BASIC. 
+
+For systems without a hardware clock ARDUINORTCEMULATION can be activated in hardware-ardunio.h. It uses millis() to emulate a Unix style real time clock.
+
+## Special systems and hardware components
+
+### Introduction
+
+The hardware section of the interpreter contains mechanism to make the platform look the same. This works for many platforms but there are exceptions. BASIC language features work differently on these systems. In this chapter these exceptions are described.
+
+### POSIX systems
+
+Systems compiled with the POSIX hardware driver use the features of the OS for most I/O operations. They differ from Arduino's and other MCU in some aspects.
+
+Ususally BASIC is started from the command line on these systems. The BASIC interpreter can be started with a file argument. In this case the interpreter starts and runs the file and terminates after the program has ended. 
+
+./basic file.bas
+
+will run the program and after completion the OS shell command prompt will reappear.
+
+The compiler flag TERMINATEAFTERRUN controls this feature. It is set to 1 by default. If set to 0 in basic.h, BASIC will not terminate after the end of the program.
+
+./basic file.bas hello
+
+will pass the argument to the special string @A$. Only the first argument is processed and stored in the string. Multiple arguments need to be quoted
+
+./basic file.bas "hello world"
+
+will pass both words to @A$. 
+
+### Wemos D1R1 systems and shields
+
+These UNO form factor 8266 are really popular as they are cheap and powerful. BASIC supports these boards as datalogger and standalone systems. They are not really UNO hardware compatible, so some precautions are required. 
+
+BASIC uses the raw ESP822 pinout on the right side of this table:
+
+static const uint8_t D0   = 3;
+
+static const uint8_t D1   = 1;
+
+static const uint8_t D2   = 16;
+
+static const uint8_t D3   = 5;
+
+static const uint8_t D4   = 4;
+
+static const uint8_t D5   = 14;
+
+static const uint8_t D6   = 12;
+
+static const uint8_t D7   = 13;
+
+static const uint8_t D8   = 0;
+
+static const uint8_t D9   = 2;
+
+static const uint8_t D10  = 15;
+
+static const uint8_t D11  = 13;
+
+static const uint8_t D12  = 12;
+
+static const uint8_t D13  = 14;
+
+static const uint8_t D14  = 4;
+
+static const uint8_t D15  = 5;
+
+The values on the lefthand side are the lables on the board.
+
+A good discussion can be found here: https://forum.arduino.cc/t/wemos-d1-pins/523831
+
+More on ESP8266: https://tttapa.github.io/ESP8266/Chap04%20-%20Microcontroller.html
+
+### ESP32 VGA with FabGL
+
+BASIC runs on TTGO VGA ESP32 hardware boards. These boards are specifically designed for retro computin applications. They have a PS2 keyboard and mouse, a VGA adapter and an SD card slot. Many old OSes and computer games can run on them. 
+
+I ported the BASIC interpreter to it with a VGA 640x200 screen. The sound generator and the SD is also supported. This makes the TTGO VGA board a fully function 64 kB home computer. 
+
+Unlike other systems with displays, the generic BASIC display driver is not used. Instead, the built-in VT52 terminal emulation of the graphics library FabGL processes text output. This means that cursor positioning with the special variables @X and @X as well as the display array @D() does not exist on these systems. Cursor positioning has to be done with the standard VT52 control sequences. See the extensive documentation of FabGL for more information http://www.fabglib.org.
+
+The sound generator of FabGL can be used with the BASIC PLAY command but the syntax is different from Arduinos. PLAY is called like this
+
+PLAY n, frequency, duration, volume.
+
+The parameters volume and duration are optional. Duration is measured in ms. This is like Arduinos. Setting the volume is not possible for Arduinos. The parameter is directly passed to the FabGL library. On Arduinos this parameter is ignored.
+
+The first parameter n would be the pin number in an Arduino configuation. For FabGL it sets the wave form generator instead. The following values are possible:
+
+128: Sine wave 
+
+129: Symmetric square wave 
+
+130: Sawtooth
+
+131: Triangle
+
+132: VIC noise
+
+133: noise
+
+256-511: Square wave with variable duty cycles, pulse length is n-255.
+
+TTGO VGA hardware is supported for graphics with a 16 color VGA palette. Colors are mapped to this palette if the COLOR command is used with rgb color arguments as best as possible.
+
+The SD card is supported but some cards will cause stability problems of the system. 
+
+Networking is possible but not really supported. There are internal memory conflicts that required to reduce BASIC RAM to 10 kB. This will be solved in version 1.4 of the interpreter.
+
+### SPI RAM systems 
+
+8bit AVR systems have rather small RAM sizes. The UNO has just 2 kB which limits the number of appliactions. Otherwise an Arduino UNO would be a great computer for BASIC. The RAM limitation of the smaller 8bit microcontrollers can be removed by using 64kB serial RAM modules. The chips are really cheap and the can be connected easily. 
+
+Activating the ARDUINOSPIRAM flag on compile time will use the SPI RAM interface for memory access. If a 16 bit integer BASIC is compiled, the computer will show 32 kB of BASIC memory. If a floating point BASIC is compiled, it will see 64 kB of memory. Only 64 kByte ATMEGA 23LCV512 SPI RAM modules are supported. There is no library needed, the device driver is integrated in BASIC. 
+
+All BASIC commands work the same. Most of them with a similar performance as local RAM. This is due to the fact that the interpreter has two memory access mechanisms, one for the program token stream and one for read/write of variables. Both are buffered separately, reducing SPI memory access. 
+
+The one exception is string commands. Strings have to be copied to local memory, can be processed there and have to be compied back. String buffers of 128 bytes handle this task. For this reason, the maximum string length is restructed to 128 bytes when using the SPI RAM interface. Also, string commands should not be nested in complicated expressions. This part of the code is not tested a lot. String code is considerably slower then in direct memory situations but still faster than many old 8 bit homecomputers.
+
+Well behaved BASIC programs like the game library of David Ahl in examples/14games have been tested and run on SPI RAM.
+
+### Raspberry PI Wiring
+
+BASIC for Raspberry PI uses the wiring pinout and not the header pinout. Please look at this table for more details: http://wiringpi.com/pins/
+
+Some more can be found here: https://pi4j.com/1.2/pins/model-b-plus.html
+
+## Low level commands
+
+### SET 
+
+SET changes internal variables of the interpreter. Set has two arguments, the variable or class to be changed and a value. There is no systematic in the numbering of the variables and classes.
+
+SET 0,n switches on the debug mode. The token stream in the statement loop is displayed. SET 0,0 resets the interpreter to normal mode. SET 0,1 shows the token stream of the statement loop. SET 0,2 shows the entire token stream, including arithmetic operations, SET 0,3 displays the memory addresses with this data. The latter two settings produce a lot of output and are meant for interpreter testing.
+
+SET 1,1 activates the autorun mode of the EEPROM. SET 1,0 resets the autorun mode. SET 1,255 marks the EEPROM as not to contain a program. SET 1,1 should only be used if a program was stored with SAVE "!" to the EEPROM. There is no safety net here. A running program in EEPROM autorun mode can always interrupted by sending the break character. This is '#' by default and defined in the BREAKCHAR macro. Alternatively the BREAKPIN macro can be defined in hardware-arduino.h. This this case the pin it is set to will interrupt the program if set to low.
+
+SET 2,1 sets the output to display mode, SET 2,0 to serial mode. This is a deprecated feature. Using @O is a better way to do this.
+
+SET 3,1 sets the default output to display, SET 3,0 to serial mode. This is a risky command. If the output channel is not connected to a device the user can control, they are locked out.
+
+SET 4,1 sets the input to keyboard mode, SET 4,0 to serial mode. This is a deprecated feature. Using @I is a better way to do this.
+
+SET 5,1 sets the default input to keyboard, SET 5,0 to serial mode. This is a risky command. If the input channel is not connected to a device the user can control, you they are locked out.
+
+SET 6,1 sets the CR output of the secondary serial port. A CR is sent after each line. SET 6,0 switches of CR. Default is off.
+
+SET 7,1 switches on blockmode of the secondary serial port input. SET 7, timeout with a number timeout>1 sets an input timeout in ms. In both cases INPUT &4 does not wait for a line feed. SET 7,0 resets block mode. 
+
+SET 8,baud will set the baudrate of the secondary serial port and resets the port. Default is 9600.
+
+SET 9,n will set the radio signal strength. n is between 0 and 3. 3 is maximal signal strength. 
+
+SET 10,1 sets the display update to page mode. In this mode the display does not display text or graphics until am ETX (ASCII 3) is sent.
+
+SET 11,1 sets the TAB command to Microsoft mode. In this mode the TAB position is the absolute character count and not a relative postion. SET 11,0 resets the behaviout.
+
+SET 12,0 sets the lower bound of all arrays to 0. This means that arrays with 8 elements DIMed with DIM A(8) go from 0 to 7 instead of 1 to 8. SET 12, 1 resets the value. This command does not change the array or anything in memory. It merely adds an offset. Any positive value can be used as an argument.
+
+SET 13, 1 sets the keypad to repeat mode. This setting is only used in analog keypads of LCD shields. These keypads normally block on key press until the key is released. This makes GET a semi blocking function. With SET 13, 1 the GET command does not block. It directly returns the pressed key and does not wait for key release. SET 13, 0 resets to blocking mode.
+
+More SET parameter will be implemented in the future.
+
+### USR
+
+USR calls a low level function, passes one value to it and returns the value. Typically USR would be used like
+
+A=USR(function, parameter)
+
+USR(0,x) returns an interpreter parameter or capability. The program can find out which platform it is running on. Please look at examples/00tutorial/hinv.bas for a list of the parameters and return values.
+
+Function numbers 1 to 31 are assigned to the I/O streams. Currently only USR(f, 0) is implemented for all I/O streams. They output the status of the stream. 
+
+Function numbers 32 and above can be used to implement individual commands. See below for more information.
+
+### CALL 
+
+Currently only CALL 0 is implemented. Call 0 flushes all buffers. On POSIX systems it ends the interpreter and returns to the OS. On Arduino AVR and ESP the microcontroller kernel is restarted.
+
+CALL parameters 0 to 31 are reserved. Values from 32 on can be used for implementing own commands. See below for more information.
+
+### SLEEP 
+
+SLEEP n enters sleep mode. This is only implemented on ESPs and SAMD right now. n is the time in milliseconds. For ESP8266 the wiring for sleep mode has to be right. ESP32 can awake from SLEEP without additional wiring. ESPs restart after wakeup. An autorun program is needed for this. Once the restart happens, the program starts from the beginning. Reentry has to be handled in the program. On Arduino SAMD the interpreter uses the low power library. The program resumes after the sleep command. Sleep is experimental right now. 
+
+### Stopping programs
+
+There are two mechanism implemented to stop programs. One listens to the default input stream, in general this is either default serial or the keyboard. The other monitors a pin.
+
+If BREAKCHAR is defined in the BASIC code, this character will stop the program if it is encountered in the input stream. It has to be found as a first character. Default BREAKCHAR is '#'. BREAKCHAR only works on Arduino implementations with keyboard and serial I/O. Posix systems cannot use BREAKCHAR as I/O is blocking on them.
+
+If BREAKPIN is defined, the interpreter will stop once this pin is pulled to low. By default, BREAKPIN is not defined, i.e. there is no BREAKPIN. This mechanism is for use cases where using BREAKCHAR is not practical. One can implement a separate stop button with it. 
+
+If HASSIGNALS is defined in hardware-posix.h then Ctrl-C will stop a running program. This does not work on Arduino because there are no POSIX signals on the platform. This feature is alpha and currently only briefly tested on Mac and Windows. 
+
+### Extending basic 
+
+The BASIC interpreter has several mechanisms to extend the language set without having to work directly with the interpreter data structures. 
+
+USR(N, X) with N greater than 32 will call the function usrfunction(). It gets both arguments as values and can return one number as reault. 
+
+CALL N with N greater than 32 will call the function usrcall(). It gets N as an argument.
+
+@U is a special variable. Reading it will call getusrvar(), writing it will call setusrvar().
+
+@U() is a special array. Reading it will call getusrarray(), writing it will call setusrarray(). In both cases the index is the array is passed on as argument.
+
+@U$ is the user string. It is read only. Reading it will trigger the function makeusrarray(). It can pass an set of characters to BASIC.
+
+
+
+
+
+

data/Basic1/IotBasic/basic.h

@@ -0,0 +1,1526 @@
+/*
+ *
+ *	$Id: basic.h,v 1.13 2023/07/16 14:17:08 stefan Exp stefan $
+ *
+ *	Stefan's basic interpreter 
+ *
+ *	Playing around with frugal programming. See the licence file on 
+ *	https://github.com/slviajero/tinybasic for copyright/left.
+ *    (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)
+ *
+ *	Author: Stefan Lenz, [email protected]
+ *
+ *	basic.h are the core defintions and function protypes
+ *
+ */
+
+/*
+ *	if the PROGMEM macro is define we compile on the Arduino IDE
+ *	we undef all hardware settings otherwise a little odd
+ */
+#ifdef ARDUINO_ARCH_MBED
+#define PROGMEM
+#endif
+
+#ifdef PROGMEM
+#define ARDUINOPROGMEM
+#else
+#undef ARDUINO
+#undef ARDUINOSD
+#undef ARDUINORF24
+#undef ARDUINORTC
+#undef ARDUINOEEPROM
+#undef ARDUINOEEPROMI2C
+#undef ARDUINOWIRE
+#endif
+
+/* 
+ *	MSDOS, Mac, Linux and Windows 
+ */
+#ifndef ARDUINO
+typedef unsigned char uint8_t;
+#define PROGMEM
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HASFLOAT
+#include <math.h>
+#include <float.h>
+#endif
+#include <time.h>
+#include <sys/types.h>
+#include <sys/timeb.h>
+#ifndef MSDOS
+#include <dirent.h>
+#include <unistd.h>
+#else
+#include <dir.h>
+#include <dos.h>
+#endif
+#ifdef MINGW
+#include <windows.h>
+#endif
+#endif
+
+
+#if defined(ARDUINO_ARCH_AVR)
+/* the small memory model with shallow stacks and small buffers */
+#define BUFSIZE 		80
+#define STACKSIZE		15
+#define GOSUBDEPTH      4
+#define FORDEPTH		4
+#define LINECACHESIZE	4
+#else 
+/* the for larger microcontrollers */
+#ifdef ARDUINO
+#define BUFSIZE		   128
+#define STACKSIZE		64
+#define GOSUBDEPTH		8
+#define FORDEPTH		8
+#define LINECACHESIZE	16
+#else 
+/* for real computers */
+#define BUFSIZE         256
+#define STACKSIZE       256
+#define GOSUBDEPTH      64
+#define FORDEPTH        64
+#define LINECACHESIZE   64
+#endif
+#endif
+
+/* on the real small systems we remove the linecache and set a fixed memory size*/
+#ifdef ARDUINO_AVR_DUEMILANOVE
+#undef LINECACHESIZE
+#if MEMSIZE == 0
+#define MEMSIZE 512
+#endif
+#endif
+
+/* more duffers and vars */
+#define SBUFSIZE        32
+#define VARSIZE         26
+/* default sizes of arrays and strings if they are not DIMed */
+#define ARRAYSIZEDEF    10
+#define STRSIZEDEF      32
+
+/*
+ *	the time intervall in ms needed for 
+ *	ESP8266 yields, network client loops 
+ *	and other timing related functions 
+ */
+#define LONGYIELDINTERVAL 1000
+#define YIELDINTERVAL 32
+#define YIELDTIME 2
+
+/* the default EEPROM dummy size */
+#define EEPROMSIZE 1024
+
+/* after run behaviour on POSIX systems, 1 to terminate if started
+    on the command line with a file argument, 0 to stay active and 
+    show a BASIC prompt*/
+#define TERMINATEAFTERRUN 1
+
+/*
+ * The tokens for the BASIC keywords
+ *
+ *	All single character operators are their own tokens
+ *	ASCII values above 0x7f are used for tokens of keywords.
+ *	EOL is a token
+ */
+#define EOL			 0
+#define NUMBER   	 -127
+#define LINENUMBER   -126
+#define STRING   	 -125
+#define VARIABLE 	 -124
+#define STRINGVAR 	 -123
+#define ARRAYVAR     -122
+/* multi character tokens - BASEKEYWORD (3) */
+#define GREATEREQUAL -121
+#define LESSEREQUAL  -120
+#define NOTEQUAL	 -119
+/* this is the Palo Alto Language Set (19) */
+#define TPRINT  -118
+#define TLET    -117
+#define TINPUT  -116
+#define TGOTO   -115
+#define TGOSUB  -114
+#define TRETURN -113
+#define TIF     -112
+#define TFOR    -111
+#define TTO     -110
+#define TSTEP   -109
+#define TNEXT   -108
+#define TSTOP   -107
+#define TLIST	-106
+#define TNEW    -105
+#define TRUN    -104
+#define TABS 	-103
+#define TRND	-102
+#define TSIZE   -101
+#define TREM 	-100
+/* this is the Apple 1 language set in addition to Palo Alto (14) */
+#define TNOT    -99
+#define TAND	-98
+#define TOR 	-97
+#define TLEN	-96
+#define TSGN	-95	
+#define TPEEK	-94
+#define TDIM	-93
+#define TCLR	-92
+#define THIMEM  -91
+#define TTAB 	-90
+#define TTHEN   -89
+#define TEND    -88
+#define TPOKE	-87
+/* Stefan's tinybasic additions (14) */
+#define TCONT   -86
+#define TSQR	-85
+#define TPOW	-84
+#define TMAP	-83
+#define TDUMP 	-82
+#define TBREAK  -81
+#define TSAVE   -80
+#define TLOAD   -79
+#define TGET    -78
+#define TPUT    -77
+#define TSET    -76
+#define TCLS    -75
+#define TLOCATE -74
+#define TELSE   -73
+/* Arduino functions (10) */
+#define TPINM	-72
+#define TDWRITE	-71
+#define TDREAD	-70
+#define TAWRITE	-69
+#define TAREAD	-68
+#define TDELAY	-67
+#define TMILLIS	-66
+#define TTONE	-65
+#define TPULSE	-64
+#define TAZERO	-63
+#define TLED	-62
+/* the DOS functions (5) */
+#define TCATALOG    -61
+#define TDELETE -60
+#define TOPEN 	-59
+#define TCLOSE 	-58
+#define TFDISK  -57
+/* low level access of internal routines (2) */
+#define TUSR	-56
+#define TCALL 	-55
+/* mathematical functions (7) */
+#define TSIN 	-54
+#define TCOS    -53
+#define TTAN 	-52
+#define TATAN   -51
+#define TLOG    -50
+#define TEXP    -49
+#define TINT    -48
+/* graphics - experimental - rudimentary (7) */
+#define TCOLOR 	-47
+#define TPLOT   -46
+#define TLINE 	-45
+#define TCIRCLE -44
+#define TRECT   -43
+#define TFCIRCLE -42
+#define TFRECT   -41
+/* the Dartmouth extensions (6) */
+#define TDATA	-40
+#define TREAD   -39
+#define TRESTORE    -38
+#define TDEF	-37
+#define TFN 	-36
+#define TON     -35
+/* darkarts (3) */
+#define TMALLOC -34
+#define TFIND   -33
+#define TEVAL   -32
+/* iot extensions (9) */
+#define TERROR	-31
+#define TAVAIL	-30
+#define TSTR	-29
+#define TINSTR	-28
+#define TVAL	-27
+#define TNETSTAT    -26
+#define TSENSOR	-25
+#define TWIRE	-24
+#define TSLEEP	-23
+/* events and interrupts */
+#define TAFTER -22
+#define TEVERY -21
+#define TEVENT -20
+/* experimental structured commands, currently partially implemented */
+#define TWHILE -19
+#define TWEND   -18
+#define TREPEAT -17
+#define TUNTIL -16
+#define TSWITCH -15
+#define TCASE -14
+#define TSWEND -13
+#define TDO -12
+#define TDEND -11
+/* these are multibyte token extension, currently unused */
+/* using them would allow over 1000 BASIC keywords */
+#define TEXT1 -3
+/* end of tokens */
+/* constants used for some obscure purposes */
+#define TBUFFER -2
+/* UNKNOWN is not used in the current code, the 
+ * lexer tokenizes everything blindly. There is a UNKNOWN hook 
+ * in statement for a grammar aware lexer */
+#define UNKNOWN -1
+
+/* extension tokens can be in the range from -128 to -255 
+ * one needs to set HASLONGTOKENS
+ */
+#undef HASLONGTOKEN
+#define TTOKEN1 -128
+
+
+/* the number of keywords, and the base index of the keywords 
+ * the number is irrelevant but BASEKEYWORD is used */
+#define NKEYWORDS	3+19+13+14+11+5+2+7+7+6+12+3+9
+#define BASEKEYWORD -121
+
+/*
+ *	Interpreter states 
+ *	SRUN means running from a programm
+ *	SINT means interactive mode
+ *	SERUN means running directly from EEPROM
+ *		(enum would be the right way of doing this.)
+ *	BREAKCHAR is the character stopping the program on Ardunios
+ *  BREAKPIN can be set, it is a pin that needs to go to low to stop a BASIC program
+ *    This should be done in hardware*.h
+ *  BREAKSIGNAL can also be set, should be done in hardware*.h
+ */
+#define SINT 0
+#define SRUN 1
+#define SERUN 2
+#define BREAKCHAR '#'
+
+/* 
+ *	Input and output channels
+ */
+#define OSERIAL 1
+#define ODSP 2
+#define OPRT 4
+#define OWIRE 7
+#define ORADIO 8
+#define OMQTT  9
+#define OFILE 16
+
+#define ISERIAL 1
+#define IKEYBOARD 2
+#define ISERIAL1 4
+#define IWIRE 7
+#define IRADIO 8
+#define IMQTT  9
+#define IFILE 16
+
+/*
+ *	All BASIC keywords for the tokens
+ */
+const char sge[]   PROGMEM = "=>";
+const char sle[]   PROGMEM = "<=";
+const char sne[]   PROGMEM = "<>";
+/* Palo Alto language set */
+const char sprint[]  PROGMEM = "PRINT";
+const char slet[]    PROGMEM = "LET";
+const char sinput[]  PROGMEM = "INPUT";
+const char sgoto[]   PROGMEM = "GOTO";
+const char sgosub[]  PROGMEM = "GOSUB";
+const char sreturn[] PROGMEM = "RETURN";
+const char sif[]     PROGMEM = "IF";
+const char sfor[]    PROGMEM = "FOR";
+const char sto[]     PROGMEM = "TO";
+const char sstep[]   PROGMEM = "STEP";
+const char snext[]   PROGMEM = "NEXT";
+const char sstop[]   PROGMEM = "STOP";
+const char slist[]   PROGMEM = "LIST";
+const char snew[]    PROGMEM = "NEW";
+const char srun[]  	 PROGMEM = "RUN";
+const char sabs[]    PROGMEM = "ABS";
+const char srnd[]    PROGMEM = "RND";
+const char ssize[]   PROGMEM = "SIZE";
+const char srem[]    PROGMEM = "REM";
+/* Apple 1 language set */
+#ifdef HASAPPLE1
+const char snot[]    PROGMEM = "NOT";
+const char sand[]    PROGMEM = "AND";
+const char sor[]     PROGMEM = "OR";
+const char slen[]    PROGMEM = "LEN";
+const char ssgn[]    PROGMEM = "SGN";
+const char speek[]   PROGMEM = "PEEK";
+const char sdim[]    PROGMEM = "DIM";
+const char sclr[]    PROGMEM = "CLR";
+const char shimem[]  PROGMEM = "HIMEM";
+const char stab[]    PROGMEM = "TAB";
+const char sthen[]   PROGMEM = "THEN";
+const char sbend[]   PROGMEM = "END";
+const char spoke[]   PROGMEM = "POKE";
+#endif
+/* Stefan's basic additions */
+#ifdef HASSTEFANSEXT
+const char scont[]   PROGMEM = "CONT";
+const char ssqr[]    PROGMEM = "SQR";
+const char spow[]    PROGMEM = "POW";
+const char smap[]    PROGMEM = "MAP";
+const char sdump[]   PROGMEM = "DUMP";
+const char sbreak[]  PROGMEM = "BREAK";
+#endif
+/* LOAD and SAVE is always there */
+const char ssave[]   PROGMEM = "SAVE";
+const char sload[]   PROGMEM = "LOAD";
+#ifdef HASSTEFANSEXT
+const char sget[]    PROGMEM = "GET";
+const char sput[]    PROGMEM = "PUT";
+const char sset[]    PROGMEM = "SET";
+const char scls[]    PROGMEM = "CLS";
+const char slocate[]  PROGMEM  = "LOCATE";
+const char selse[]  PROGMEM  = "ELSE";
+#endif
+/* Arduino functions */
+#ifdef HASARDUINOIO
+const char spinm[]    PROGMEM = "PINM";
+const char sdwrite[]  PROGMEM = "DWRITE";
+const char sdread[]   PROGMEM = "DREAD";
+const char sawrite[]  PROGMEM = "AWRITE";
+const char saread[]   PROGMEM = "AREAD";
+const char sdelay[]   PROGMEM = "DELAY";
+const char smillis[]	PROGMEM = "MILLIS";
+const char sazero[]	PROGMEM = "AZERO";
+const char sled[]	PROGMEM = "LED";
+#endif
+#ifdef HASTONE
+const char stone[]    PROGMEM = "PLAY";
+#endif
+#ifdef HASPULSE
+const char spulse[] PROGMEM = "PULSE";
+#endif
+/* DOS functions */
+#ifdef HASFILEIO
+const char scatalog[] PROGMEM = "CATALOG";
+const char sdelete[]  PROGMEM = "DELETE";
+const char sfopen[]   PROGMEM = "OPEN";
+const char sfclose[]  PROGMEM = "CLOSE";
+const char sfdisk[]   PROGMEM = "FDISK";
+#endif
+/* low level access functions */
+#ifdef HASSTEFANSEXT
+const char susr[]   PROGMEM = "USR";
+const char scall[]  PROGMEM = "CALL";
+#endif
+/* mathematics */
+#ifdef HASFLOAT
+const char ssin[]   PROGMEM = "SIN";
+const char scos[]   PROGMEM = "COS";
+const char stan[]   PROGMEM = "TAN";
+const char satan[]  PROGMEM = "ATAN";
+const char slog[]   PROGMEM = "LOG";
+const char sexp[]   PROGMEM = "EXP";
+#endif
+/* INT is always needed to make float/int programs compatible */
+const char sint[]   PROGMEM = "INT"; 
+/* elemetars graphics */
+#ifdef HASGRAPH
+const char scolor[]     PROGMEM  = "COLOR";
+const char splot[]      PROGMEM  = "PLOT";
+const char sline[]      PROGMEM  = "LINE";
+const char scircle[]    PROGMEM  = "CIRCLE";
+const char srect[]      PROGMEM  = "RECT";
+const char sfcircle[]   PROGMEM  = "FCIRCLE";
+const char sfrect[]     PROGMEM  = "FRECT";
+#endif
+/* Dartmouth BASIC extensions */
+#ifdef HASDARTMOUTH
+const char sdata[]      PROGMEM  = "DATA";
+const char sread[]      PROGMEM  = "READ";
+const char srestore[]   PROGMEM  = "RESTORE";
+const char sdef[]       PROGMEM  = "DEF";
+const char sfn[]        PROGMEM  = "FN";
+const char son[]        PROGMEM  = "ON";
+#endif
+/* The Darkarts commands unthinkable in Dartmouth */
+#ifdef HASDARKARTS
+const char smalloc[]	PROGMEM  = "MALLOC";
+const char sfind[]		PROGMEM  = "FIND";
+const char seval[]		PROGMEM  = "EVAL";
+#endif
+/* complex error handling */
+#ifdef HASERRORHANDLING
+const char serror[]     PROGMEM  = "ERROR";
+#endif
+/* iot extensions */
+#ifdef HASIOT
+const char savail[]		PROGMEM  = "AVAIL";
+const char sstr[]		PROGMEM  = "STR";
+const char sinstr[]		PROGMEM  = "INSTR";
+const char sval[]		PROGMEM  = "VAL";
+const char snetstat[]	PROGMEM  = "NETSTAT";
+const char ssensor[]	PROGMEM  = "SENSOR";
+const char swire[]		PROGMEM  = "WIRE";
+const char ssleep[]		PROGMEM  = "SLEEP";
+#endif
+/* events and interrupts */
+#ifdef HASTIMER
+const char safter[]     PROGMEM  = "AFTER";
+const char severy[]     PROGMEM  = "EVERY";
+#endif
+#ifdef HASEVENTS
+const char sevent[]     PROGMEM  = "EVENT";
+#endif
+#ifdef HASSTRUCT
+const char swhile[]		PROGMEM	= "WHILE";
+const char swend[]      PROGMEM = "WEND";
+const char srepeat[]	PROGMEM	= "REPEAT";
+const char suntil[]     PROGMEM	= "UNTIL";
+const char sswitch[]	PROGMEM	= "SWITCH";
+const char scase[]		PROGMEM	= "CASE";
+const char sswend[]     PROGMEM = "SWEND";
+const char sdo[]        PROGMEM = "DO";
+const char sdend[]      PROGMEM = "DEND";
+#endif
+
+
+/* zero terminated keyword storage */
+const char* const keyword[] PROGMEM = {
+	sge, sle, sne, sprint, slet, sinput, 
+	sgoto, sgosub, sreturn, sif, sfor, sto,
+	sstep, snext, sstop, slist, snew, srun,
+	sabs, srnd, ssize, srem,
+#ifdef HASAPPLE1
+	snot, sand, sor, slen, ssgn, speek, sdim,
+	sclr, shimem, stab, sthen, 
+	sbend, spoke,
+#endif
+#ifdef HASSTEFANSEXT
+	scont, ssqr, spow, smap, sdump, sbreak, 
+#endif
+	ssave, sload, 
+#ifdef HASSTEFANSEXT
+	sget, sput, sset, scls, slocate, selse,
+#endif
+#ifdef HASARDUINOIO
+    spinm, sdwrite, sdread, sawrite, saread, 
+    sdelay, smillis, sazero, sled,
+#endif
+#ifdef HASTONE
+	stone,
+#endif
+#ifdef HASPULSE
+	spulse,
+#endif
+#ifdef HASFILEIO
+    scatalog, sdelete, sfopen, sfclose, sfdisk,
+#endif
+#ifdef HASSTEFANSEXT
+    susr, scall,
+#endif
+#ifdef HASFLOAT
+    ssin, scos, stan, satan, slog, sexp,
+#endif
+    sint,
+#ifdef HASGRAPH
+    scolor, splot, sline, scircle, srect, 
+    sfcircle, sfrect,
+#endif
+#ifdef HASDARTMOUTH
+	sdata, sread, srestore, sdef, sfn, son,
+#endif
+#ifdef HASDARKARTS
+	smalloc, sfind, seval, 
+#endif
+/* complex error handling */
+#ifdef HASERRORHANDLING
+    serror,
+#endif
+#ifdef HASIOT
+	savail, sstr, sinstr, sval, 
+	snetstat, ssensor, swire, ssleep, 
+#endif
+#ifdef HASTIMER
+    safter, severy,
+#endif
+#ifdef HASEVENTS
+    sevent,
+#endif
+#ifdef HASSTRUCT
+	swhile, swend, srepeat, suntil, sswitch, scase, sswend,	
+    sdo, sdend, 
+#endif 
+	0
+};
+
+/* the zero terminated token dictonary needed for scalability */
+const signed char tokens[] PROGMEM = {
+	GREATEREQUAL, LESSEREQUAL, NOTEQUAL, TPRINT, TLET,    
+    TINPUT, TGOTO, TGOSUB, TRETURN, TIF, TFOR, TTO, TSTEP,
+    TNEXT, TSTOP, TLIST, TNEW, TRUN, TABS, TRND, TSIZE, TREM,
+#ifdef HASAPPLE1
+    TNOT, TAND, TOR, TLEN, TSGN, TPEEK, TDIM, TCLR,
+    THIMEM, TTAB, TTHEN, TEND, TPOKE,
+#endif
+#ifdef HASSTEFANSEXT
+	TCONT, TSQR, TPOW, TMAP, TDUMP, TBREAK, 
+#endif
+	TSAVE, TLOAD, 
+#ifdef HASSTEFANSEXT	
+	TGET, TPUT, TSET, TCLS, TLOCATE, TELSE,
+#endif
+#ifdef HASARDUINOIO
+	TPINM, TDWRITE, TDREAD, TAWRITE, TAREAD, TDELAY, TMILLIS,
+	TAZERO, TLED,
+#endif
+#ifdef HASTONE
+	TTONE, 
+#endif
+#ifdef HASPULSE
+	TPULSE, 
+#endif
+#ifdef HASFILEIO
+	TCATALOG, TDELETE, TOPEN, TCLOSE, TFDISK,
+#endif
+#ifdef HASSTEFANSEXT
+	TUSR, TCALL,
+#endif
+#ifdef HASFLOAT
+	TSIN, TCOS, TTAN, TATAN, TLOG, TEXP,
+#endif
+	TINT,
+#ifdef HASGRAPH
+	TCOLOR, TPLOT, TLINE, TCIRCLE, TRECT, 
+	TFCIRCLE, TFRECT,
+#endif
+#ifdef HASDARTMOUTH
+	TDATA, TREAD, TRESTORE, TDEF, TFN, TON, 
+#endif
+#ifdef HASDARKARTS
+	TMALLOC, TFIND, TEVAL, 
+#endif
+#ifdef HASERRORHANDLING
+    TERROR, 
+#endif
+#ifdef HASIOT
+	TAVAIL, TSTR, TINSTR, TVAL, TNETSTAT,
+	TSENSOR, TWIRE, TSLEEP,
+#endif
+#ifdef HASTIMER
+    TAFTER, TEVERY,
+#endif
+#ifdef HASEVENTS
+    TEVENT, 
+#endif
+#ifdef HASSTRUCT
+	TWHILE, TWEND, TREPEAT, TUNTIL, TSWITCH, TCASE, TSWEND,
+    TDO, TDEND, 
+#endif
+	0
+};
+
+/*
+ *	the message catalog
+ */
+#define MFILE		0
+#define MPROMPT		1
+#define MGREET		2
+#define MLINE		3
+#define MNUMBER		4
+#define MVARIABLE	5
+#define MARRAY		6
+#define MSTRING		7
+#define MSTRINGVAR	8
+#define EGENERAL 	 9
+#define EUNKNOWN	 10
+#define ENUMBER      11
+#define EDIVIDE		 12
+#define ELINE        13
+#define EOUTOFMEMORY 14
+#define ESTACK 		 15
+#define EORANGE 	 16
+#define ESTRING      17
+#define EVARIABLE	 18
+#define ELOOP        19
+#define EFILE 		 20
+#define EFUN 		 21
+#define EARGS       22
+#define EEEPROM	    23
+#define ESDCARD     24
+
+const char mfile[]    	PROGMEM = "file.bas";
+const char mprompt[]	PROGMEM = "> ";
+const char mgreet[]		PROGMEM = "Stefan's Basic 1.4";
+const char mline[]		PROGMEM = "LINE";
+const char mnumber[]	PROGMEM = "NUMBER";
+const char mvariable[]	PROGMEM = "VARIABLE";
+const char marray[]		PROGMEM = "ARRAY";
+const char mstring[]	PROGMEM = "STRING";
+const char mstringv[]	PROGMEM = "STRINGVAR";
+const char egeneral[]  	PROGMEM = "Error";
+#ifdef HASERRORMSG
+const char eunknown[]  	PROGMEM = "Syntax";
+const char enumber[]	PROGMEM = "Number";
+const char edivide[]  	PROGMEM = "Div by 0";
+const char eline[]  	PROGMEM = "Unknown Line";
+const char emem[]  	   	PROGMEM = "Memory";
+const char estack[]    	PROGMEM = "Stack";
+const char erange[]  	PROGMEM = "Range";
+const char estring[]	PROGMEM = "String";
+const char evariable[]  PROGMEM = "Variable";
+const char eloop[]      PROGMEM = "Loop";
+const char efile[]  	PROGMEM = "File";
+const char efun[] 	 	PROGMEM = "Function";
+const char eargs[]  	PROGMEM = "Args";
+const char eeeprom[]	PROGMEM = "EEPROM";
+const char esdcard[]	PROGMEM = "SD card";
+#endif
+
+const char* const message[] PROGMEM = {
+	mfile, mprompt, mgreet, 
+	mline, mnumber, mvariable, marray, 
+	mstring, mstringv,
+	egeneral
+#ifdef HASERRORMSG
+	, eunknown, enumber, edivide, eline, 
+	emem, estack, erange,
+	estring, evariable, eloop, efile, efun, eargs, 
+	eeeprom, esdcard
+#endif
+};
+
+/*
+ *	code for variable numbers and addresses sizes
+ *	the original code was 16 bit but can be extended here
+ * 	to arbitrary types 
+ *
+ *	number_t is the type for numerical work - either float or int
+ *  wnumber_t is the type containing the largest printable integer, 
+ *    for float keep this int on 32 bit and long on 8 bit unless you 
+ *    want to use very long integers, like 64 or 128 bit types. 
+ *  address_t is an unsigned type adddressing memory, default 16bit 
+ *  mem_t is a SIGNED 8bit character type.
+ *	index_t is a SIGNED minimum 16 bit integer type
+ *
+ *	works with the tacit assumption that 
+ *	sizeof(number_t) >= sizeof(address_t) 
+ *	and that the entire memory is smaller than the positive
+ * 	part of number type (!!)
+ *
+ *	we assume that float >= 4 bytes in the following
+ *
+ *	maxnum: the maximum accurate(!) integer of a 
+ *		32 bit float 
+ *	strindexsize: the index size of strings either 
+ *		1 byte or 2 bytes - no other values supported
+ */
+#ifdef HASFLOAT
+typedef float number_t;
+const number_t maxnum=16777216; 
+typedef long wnumber_t;
+#else
+typedef int number_t;
+typedef int wnumber_t;
+const number_t maxnum=(number_t)~((number_t)1<<(sizeof(number_t)*8-1));
+#endif
+typedef unsigned short address_t; /* this type addresses memory */
+const int numsize=sizeof(number_t);
+const int addrsize=sizeof(address_t);
+const int eheadersize=sizeof(address_t)+1;
+const int strindexsize=2; /* default in the meantime, strings up to unsigned 16 bit length */
+const address_t maxaddr=(address_t)(~0); 
+typedef signed char mem_t; /* a signed 8 bit type for the memory */
+typedef int index_t; /* this type counts at least 16 bit */
+#ifndef HASLONGTOKENS
+typedef signed char token_t; /* the type of tokens, normally mem_t with a maximum of 127 commands and data types */
+#else
+typedef short token_t; /* token type extension, allows an extra of 127 commands and symbols */
+#endif
+
+/* this type maps numbers to bytes */
+typedef struct {mem_t l; mem_t h;} twobytes_t;
+typedef union { number_t i; address_t a; twobytes_t b; mem_t c[sizeof(number_t)]; } accu_t;
+
+/* the memreader function type */
+typedef mem_t (*memreader_t)(address_t);
+
+/* 
+ * system type identifiers
+ */
+
+#define SYSTYPE_UNKNOWN	0
+#define SYSTYPE_AVR 	1
+#define SYSTYPE_ESP8266 2
+#define SYSTYPE_ESP32	3
+#define SYSTYPE_RP2040  4
+#define SYSTYPE_SAM     5
+#define SYSTYPE_XMC		6
+#define SYSTYPE_SMT32	7
+#define SYSTYPE_NRENESA 8
+#define SYSTYPE_POSIX	32
+#define SYSTYPE_MSDOS	33
+#define SYSTYPE_MINGW   34
+#define SYSTYPE_RASPPI  35
+
+/*
+ *	The basic interpreter is implemented as a stack machine
+ *	with global variable for the interpreter state, the memory
+ *	and the arithmetic during run time.
+ */
+
+/* the stack, all BASIC arithmetic is done here */
+number_t stack[STACKSIZE];
+address_t sp=0; 
+
+/* a small buffer to process string arguments, mostly used for Arduino PROGMEM */
+char sbuffer[SBUFSIZE];
+
+/* the input buffer, the lexer can tokenize this and run from it, bi is an index to this.
+   bi must be global as it is the program cursor in interactive mode */
+char ibuffer[BUFSIZE] = "\0";
+char *bi;
+
+/* a static array of variables A-Z for the small systems that have no heap */
+number_t vars[VARSIZE];
+
+/* the BASIC working memory, either malloced or allocated as a global array */
+#if MEMSIZE != 0
+mem_t mem[MEMSIZE];
+#else
+mem_t* mem;
+#endif
+address_t himem, memsize;
+
+/* the for stack - remembers the variable, indices, and optionally a type for stuctured BASIC */
+struct forstackitem {mem_t varx; mem_t vary; address_t here; number_t to; number_t step; 
+#ifdef HASSTRUCT
+mem_t type;
+#endif
+} forstack[FORDEPTH];
+index_t forsp = 0;
+ 
+/* the GOSUB stack remembers an address to jump to */
+address_t gosubstack[GOSUBDEPTH];
+index_t gosubsp = 0;
+
+/* this variable stores the location in pushlocation() and poplocation(), used to rewind the program cursor */
+address_t slocation;
+
+/* arithmetic accumulators - used by many statements, y may be obsolete in future*/
+number_t x, y;
+
+/* the names of a variable and small integer accumulator */
+mem_t xc, yc;
+
+/* an address accumulator, used a lot in string operations */
+address_t ax;
+
+/* z is another accumulator used to convert numbers and addressed to bytes and vice versa */
+/* this union is used to store larger objects into byte oriented memory */
+accu_t z;
+
+/* string index registers */
+char *ir, *ir2;
+
+/* the active token */
+token_t token;
+
+/* the curent error, can be a token, hance token type */
+token_t er;
+
+/* a trapable error */
+mem_t ert;
+
+/* the interpreter state, interactive, run or run from EEPROM */
+mem_t st; 
+
+/* the current program location or "cursor" */
+address_t here; 
+
+/* the topmost byte of a program in memory, beginning of free BASIC RAM */
+address_t top;
+
+/* the number of variables on the heap */
+address_t nvars = 0; 
+
+/* used to format output with # */
+mem_t form = 0;
+
+/* counts the outputed characters on streams 0-3, used to emulate a real tab */
+#ifdef HASMSTAB
+mem_t charcount[3]; /* devices 1-4 support tabing */
+mem_t reltab = 0;
+#endif
+
+/* the lower limit of the array is one by default, can be a variable */
+#ifdef HASARRAYLIMIT
+address_t arraylimit = 1;
+#else 
+const address_t arraylimit = 1;
+#endif
+
+/* the number of arguments parsed from a command */
+mem_t args;
+
+/* the random number seed, this is unsigned hence address_t */
+#ifndef HASFLOAT
+address_t rd;
+#else 
+unsigned long rd;
+#endif
+
+/* output and input channels, used to direct output to various devices */
+mem_t id;
+mem_t od;
+
+/* default IO - not constant, can be changed at runtime through a user call */
+mem_t idd = ISERIAL;
+mem_t odd = OSERIAL;
+
+/* the runtime debuglevel */
+mem_t debuglevel = 0;
+
+/* DATA pointer, where is the current READ statement  */
+#ifdef HASDARTMOUTH
+address_t data = 0;
+address_t datarc = 1;
+#endif
+    
+/* 
+ * process command line arguments in the POSIX world 
+ * bnointafterrun is a flag to remember if called as command
+ * line argument, in this case we don't return to interactive 
+ */
+#ifndef ARDUINO
+int bargc;
+char** bargv;
+mem_t bnointafterrun = 0;
+#endif
+
+/*
+ * Yield counter, we count when we did yield the last time
+ *	lastyield controlls the client loops of network functions 
+ *	like mqtt, scanned keyboard, and USB.
+ *
+ *	lastlongyield controls longterm functions like DHCP lease 
+ *	renewal in Ethernet 
+ * 
+ * there variables are only needed if the platform has background 
+ *  tasks
+ */
+long lastyield=0;
+long lastlongyield=0;
+
+/* formaters lastouttoken and spaceafterkeyword to make a nice LIST */
+mem_t lastouttoken;
+mem_t spaceafterkeyword;
+mem_t outliteral = 0;
+mem_t lexliteral = 0; 
+
+/* 
+ * the cache for the heap search - helps the string code 
+ * the last found object on the heap is remembered. This is needed
+ * because the string code sometime searches the heap twice during the 
+ * same operation. 
+ */
+#ifdef HASAPPLE1
+mem_t bfindc, bfindd, bfindt;
+address_t bfinda, bfindz;
+#endif
+
+/*
+ * a variable for some string operations 
+ */
+int vlength;
+
+/* the timer code - very simple needs to to to a struct */
+/* timer type */
+typedef struct {
+    mem_t enabled;
+    unsigned long last;
+    unsigned long interval; 
+    mem_t type;
+    address_t linenumber;
+} btimer_t;
+
+#ifdef HASTIMER
+btimer_t after_timer = {0, 0, 0, 0, 0};
+btimer_t every_timer = {0, 0, 0, 0, 0};
+#endif
+
+/* the event code */
+#ifdef HASEVENTS
+
+#define EVENTLISTSIZE 4
+
+/* event type */
+typedef struct {
+    mem_t enabled;
+    mem_t pin;
+    mem_t mode; 
+    mem_t type;
+    address_t linenumber;
+    mem_t active;
+} bevent_t;
+
+/* the event list */
+int nevents = 0;
+int ievent = 0;
+static mem_t events_enabled = 1;
+static volatile bevent_t eventlist[EVENTLISTSIZE];
+
+/* the extension of the GOSUB stack */
+static mem_t gosubarg[GOSUBDEPTH];
+
+/* handle the event list */
+mem_t addevent(mem_t, mem_t, mem_t, address_t);
+void deleteevent(mem_t);
+volatile bevent_t* findevent(mem_t);
+mem_t eventindex(mem_t);
+#endif
+
+#ifdef HASERRORHANDLING
+/* the error handler type, very simple for now */
+typedef struct {
+    mem_t type;
+    address_t linenumber;
+} berrorh_t;
+
+berrorh_t berrorh = {0 , 0};
+mem_t erh = 0;
+#endif
+
+/* the string for real time clocks */
+char rtcstring[20] = { 0 }; 
+
+/* the units pulse operates on, in microseconds*/
+short bpulseunit = 10; 
+
+/* only needed for POSIXNONBLOCKING */
+mem_t breakcondition = 0;
+
+/* 
+ * Function prototypes, ordered by layers
+ * HAL - hardware abstraction
+ * Layer 0 - memory and I/O
+ * Layer 1 - Program storage and control
+ * Layer 2 - Where stuff happens
+ */
+
+/*
+ *	HAL - see hardware-*.h
+ *  This is the hardware abstraction layer of the BASIC
+ *	interpreter 
+ */
+
+/* setup codes */
+void timeinit();
+void wiringbegin();
+
+/* low level mem and hardware features */
+long freeRam();
+long freememorysize();
+void restartsystem();
+void activatesleep(long t);
+
+/* start the spi bus */
+void spibegin();
+
+/* 
+ * the hardware interface display driver functions, need to be 
+ * 	implemented for the display driver to work 
+ *	dspupdate() only for display like Epapers
+ */
+void dspbegin();
+void dspprintchar(char, mem_t, mem_t);
+void dspclear();
+void dspupdate();
+
+/* keyboard code */
+void kbdbegin();
+int kbdstat(char);
+char kbdavailable();
+char kbdread();
+char kbdcheckch();
+
+/* graphics functions */
+void rgbcolor(int, int, int);
+void vgacolor(short c);
+void vgascale(int*, int*);
+void plot(int, int);
+void line(int, int, int, int);  
+void rect(int, int, int, int);
+void frect(int, int, int, int);
+void circle(int, int, int);
+void fcircle(int, int, int);
+
+/* text output to a VGA display */
+void vgabegin();
+int vgastat(char);
+void vgawrite(char);
+
+/* generic display code */
+void dspwrite(char);
+void dspbegin();
+int dspstat(char);
+char dspwaitonscroll();
+char dspactive();
+void dspsetupdatemode(char);
+char dspgetupdatemode();
+void dspgraphupdate();
+void dspsetscrollmode(char, short);
+void dspsetcursor(short, short);
+void dspbufferclear();
+void dspscroll(mem_t, mem_t);
+void dspreversescroll(mem_t);
+void dspvt52(char *);
+
+/* real time clock */
+char* rtcmkstr();
+void rtcset(uint8_t, short);
+short rtcget(short); 
+
+/* network and mqtt functions */
+void netbegin();
+char netconnected();
+void mqttsetname();
+void mqttbegin();
+int mqttstat(char);
+int  mqttstate();
+void mqttsubscribe(char*);
+void mqttsettopic(char*);
+void mqttouts(char *, short);
+void mqttins(char *, short);
+char mqttinch();
+
+/* low level EEPROM handling */
+void ebegin();
+void eflush();
+address_t elength();
+mem_t eread(address_t);
+void eupdate(address_t, mem_t);
+
+/* arduino io functions */
+void aread();
+void dread();
+void awrite(address_t, address_t);
+void dwrite(address_t, address_t);
+void pinm(address_t, address_t);
+void bmillis();
+void bpulsein();
+void xpulse();
+void bpulseout(short);
+void btone(short);
+
+/* timing control for ESP and network */
+void byield();
+void bdelay(unsigned long);
+void fastticker();
+void yieldfunction();
+void longyieldfunction();
+
+/* the file interface */
+char* mkfilename(const char*);
+const char* rmrootfsprefix(const char*);
+void fsbegin(char);
+int fsstat(char);
+void filewrite(char);
+char fileread();
+char ifileopen(const char*);
+void ifileclose();
+char ofileopen(char*, const char*);
+void ofileclose();
+int fileavailable();
+void rootopen();
+int rootnextfile();
+int rootisfile();
+const char* rootfilename();
+long rootfilesize();
+void rootfileclose();
+void rootclose();
+void removefile(char*);
+void formatdisk(short);
+
+/* low level serial code */
+void picogetchar(char);
+void picowrite(char);
+void picobegin(unsigned long);
+void picoins(char, short);
+void serialbegin();
+int serialstat(char);
+char serialread();
+void serialwrite(char);
+short serialcheckch();
+short serialavailable();
+void serialflush();
+void consins(char*, short);
+void prtbegin();
+int prtstat(char);
+void prtset(int);
+char prtopen(char *, int);
+void prtclose();
+char prtread();
+void prtwrite(char);
+short prtcheckch();
+short prtavailable();
+
+/* generic wire access */
+void wirebegin();
+int wirestat(char);
+void wireopen(char, char);
+void wireins(char*, uint8_t);
+void wireouts(char*, uint8_t);
+short wireavailable();
+short wirereadbyte(short);
+void  wirewritebyte(short, short);
+
+/* RF24 radio input */
+int radiostat(char);
+void radioset(int);
+#ifdef ARDUINO 
+uint64_t pipeaddr(char*);
+#else
+long pipeaddr(char*);
+#endif
+void iradioopen(char*);
+void oradioopen(char*);
+void radioins(char*, short);
+void radioouts(char* , short);
+short radioavailable();
+
+/* sensor control */
+void sensorbegin();
+number_t sensorread(short, short);
+
+/* SPI RAM code */
+address_t spirambegin();
+void spiramrawwrite(address_t, mem_t);
+mem_t spiramrawread(address_t );
+
+/*
+ * Layer 0 functions - I/O and memory management 
+ */
+
+/* make room for BASIC */
+address_t ballocmem(); 
+
+/* handle files im EEPROM */
+void eload();
+void esave();
+char autorun();
+
+/* the variable heap from Apple 1 BASIC */
+address_t bmalloc(mem_t, mem_t, mem_t, address_t);
+address_t bfind(mem_t, mem_t, mem_t);
+address_t bfree(mem_t, mem_t, mem_t);
+address_t blength (mem_t, mem_t, mem_t);
+
+/* normal variables of number_t */
+number_t getvar(mem_t, mem_t);
+void setvar(mem_t, mem_t, number_t);
+void clrvars();
+
+/*	low level memory access packing n*8bit bit into n 8 bit objects
+	e* is for Arduino EEPROM */
+void getnumber(address_t, mem_t);
+void setnumber(address_t, mem_t);
+void egetnumber(address_t, mem_t);
+void esetnumber(address_t, mem_t);
+void pgetnumber(address_t, mem_t);
+
+/* array and string handling */
+/* the multidim extension is experimental, here only 2 array dimensions implemented as test */
+address_t createarray(mem_t, mem_t, address_t, address_t);
+void array(mem_t, mem_t, mem_t, address_t, address_t, number_t*);
+address_t createstring(char, char, address_t, address_t);
+char* getstring(char, char, address_t, address_t);
+number_t arraydim(char, char);
+address_t stringdim(char, char);
+address_t lenstring(char, char, address_t);
+void setstringlength(char, char, address_t, address_t);
+void setstring(char, char, address_t, char *, address_t, address_t);
+
+/* the user defined extension functions */
+number_t getusrvar();
+void setusrvar(number_t);
+number_t getusrarray(address_t);
+void setusrarray(address_t, number_t);
+void makeusrstring();
+number_t usrfunction(address_t, number_t);
+void usrcall(address_t);
+
+/* get keywords and tokens from PROGMEM */
+char* getkeyword(unsigned short);
+char* getmessage(char);
+signed char gettokenvalue(char);
+void printmessage(char);
+
+/* error handling */
+void error(token_t);
+void reseterror();
+void debugtoken();
+void bdebug(const char*);
+
+/* the arithemtic stack */
+void push(number_t);
+number_t pop();
+address_t popaddress();
+void drop();
+void clearst();
+
+/* READ DATA handling */
+void clrdata();
+
+/* FOR NEXT GOSUB stacks */
+void pushforstack();
+void popforstack();
+void dropforstack();
+void clrforstack();
+void pushgosubstack(mem_t);
+void popgosubstack();
+void dropgosubstack();
+void clrgosubstack();
+
+/* general I/O initialisation */
+void ioinit();
+void iodefaults();
+
+/* signal handling */
+void signalon();
+void signaloff();
+void signalhandler(int);
+
+/* character and string I/O functions */
+/* we live in world where char may be signed or unsigned and keep it 
+    that way on the lowest level, hence this function, fully defined here, 
+    mostly inlined anyway*/
+int cheof(int c) { if ((c == -1) || (c == 255)) return 1; else return 0; }
+/* input */
+char inch();
+char checkch();
+short availch();
+void inb(char*, index_t);
+void ins(char*, address_t); 
+
+/* output */
+void outch(char);
+void outcr();
+void outspc();
+void outs(char*, address_t);
+void outsc(const char*);
+void outscf(const char *, index_t);
+
+/* I/O of number_t - floats and integers */
+address_t parsenumber(char*, number_t*);
+address_t parsenumber2(char*, number_t*);
+address_t writenumber(char*, wnumber_t); 
+address_t writenumber2(char*, number_t);
+address_t tinydtostrf(number_t, index_t, char*);
+char innumber(number_t*);
+void outnumber(number_t);
+
+/* 	
+ * Layer 1 functions, provide data and do the heavy lifting 
+ * for layer 2 including lexical analysis, storing programs 
+ * and expression evaluation 
+ */
+
+/* lexical analysis */
+void whitespaces();
+void nexttoken();
+
+/* storing and retrieving programs */
+char nomemory(number_t);
+void storetoken(); 
+mem_t memread(address_t);
+mem_t memread2(address_t);
+void memwrite2(address_t, mem_t);
+void gettoken();
+void firstline();
+void nextline();
+
+void clrlinecache();
+void addlinecache(address_t, address_t);
+address_t findinlinecache(address_t);
+void findline(address_t);
+address_t myline(address_t);
+void moveblock(address_t, address_t, address_t);
+void zeroblock(address_t, address_t);
+void diag();
+void storeline();
+
+/* read arguments from the token stream and process them */
+char termsymbol();
+char expect(token_t, mem_t);
+char expectexpr();
+void parsearguments();
+void parsenarguments(char);
+void parsesubscripts();
+void parsefunction(void (*)(), short);
+void parseoperator(void (*)());
+void parsesubstring();
+
+/* mathematics and other functions for int and float */
+void xabs();
+void xsgn();
+void xpeek();
+void xmap();
+void rnd();
+void sqr();
+void xpow();
+number_t bpow(number_t, number_t);
+
+/* string values and string evaluation */
+char stringvalue();
+void streval();
+
+/* floating point functions */
+void xsin();
+void xcos();
+void xtan();
+void xatan();
+void xlog();
+void xexp();
+void xint();
+
+/* expression evaluation */
+void factor();
+void term();
+void addexpression();
+void compexpression();
+void notexpression();
+void andexpression();
+void expression();
+
+/* 
+ * Layer 2 - statements and functions 
+ * use the global variables 
+ */
+
+/* basic commands of the core language set */
+void xprint();
+void lefthandside(address_t*, address_t*, address_t*, mem_t*);
+void assignnumber(signed char, char, char, address_t, address_t, char);
+void assignment();
+void showprompt();
+void xinput();
+void xgoto();
+void xreturn();
+void xif();
+
+/* FOR NEXT loops */
+void findnextcmd();
+void findbraket(token_t, token_t);
+void xfor();
+void xbreak();
+void xcont();
+void xnext();
+
+/* WHILE WEND*/
+void xwhile();
+void xwend();
+
+/* REPEAT UNTIL */
+void xrepeat();
+void xuntil();
+
+/* control commands and misc */
+void outputtoken();
+void xlist();
+void xrun();
+void xnew();
+void xrem();
+void xclr();
+void xdim();
+void xpoke();
+void xtab();
+void xdump();
+void dumpmem(address_t, address_t, char);
+void xlocate();
+
+/* file access and other i/o */
+void stringtobuffer(char*);
+void getfilename(char*, char);
+void xsave();
+void xload(const char*);
+void xget();
+void xput();
+void xset();
+void xnetstat();
+
+/* Arduino IO control interface */
+void xdwrite();
+void xawrite();
+void xpinm();
+void xdelay();
+void xtone();
+
+/* graphics commands */
+void xcolor();
+void xplot();
+void xline();
+void xrect();
+void xcircle();
+void xfrect();
+void xfcircle();
+
+/* the darkarts */
+void xmalloc();
+void xfind();
+void xeval();
+
+/* IoT commands */
+void xassign();
+void xavail();
+void xfsensor();
+void xsleep();
+void xwire();
+void xfwire();
+
+/* timers */
+void xafter();
+void xevent();
+
+/* File I/O functions */
+char streq(const char*, char*);
+void xcatalog();
+void xdelete();
+void xopen();
+void xfopen();
+void xclose();
+void xfdisk();
+
+/* low level access functions */
+void xcall();
+void xusr();
+
+/* the dartmouth stuff */
+void xdata();
+void nextdatarecord();
+void xread();
+void xrestore();
+void xdef();
+void xfn();
+void xon();
+
+/* timers and interrupts */
+void xtimer();
+void resettimer(btimer_t*);
+
+/* structured BASIC extensions */
+void xwhile();
+void xwend(); 
+void xrepeat();
+void xuntil();
+void xswitch();
+void xcase();
+void xendswitch();
+
+/* the emulation of tone using the byield loop */
+void toggletone();
+void playtone(int, int, int);
+
+/* the statement loop */
+void statement();
+
+/* the extension functions */
+void bsetup();
+void bloop();
+

data/Basic1/IotBasic/wifisettings.h

@@ -0,0 +1,5 @@
+const char* ssid = "myssid";
+const char* password = "mypasswd";
+const char* mqtt_server = "test.mosquitto.org";
+const short mqtt_port = 1883;
+byte mac[] = {0xDE, 0xAD, 0xBE, 0xE9, 0xE9, 0xE9};

data/Basic1/TinyVT52/TinyVT52.ino

@@ -0,0 +1,110 @@
+/*
+ *
+ *  $Id: TinyVT52.ino,v 1.1 2022/12/13 19:00:16 stefan Exp stefan $ 
+ *
+ *  Stefan's TinyVT52 derived from the IoT BASIC interpreter 
+ *
+ *  See the licence file on 
+ *  https://github.com/slviajero/tinybasic for copyright/left.
+ *    (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)
+ *
+ *  Author: Stefan Lenz, [email protected]
+ *
+ * Device drivers and low level I/O routines are used from the BASIC code
+ * These definitions are in basic.h and hardware-arduino.h. These two files 
+ * are exactly identical to the BASIC language files to make sure that further
+ * work on the device drivers can be used here without changes.
+ * 
+ * To use the terminal, the hardware definition in hardware-arduino.h need to be set
+ * 
+ * Any one of the following macros need to be defined 
+ * 
+ * Always set #define DISPLAYCANSCROLL
+ * 
+ * Displays: define one(!) of the following displays in hardware
+ *  ARDUINOLCDI2C, ARDUINONOKIA51, ARDUINOILI9488, ARDUINOSSD1306
+ *  ARDUINOMCUFRIEND, ARDUINOGRAPHDUMMY, LCDSHIELD, ARDUINOTFT
+ * 
+ * Keyboards:
+ *  ARDUINOPS2, ARDUINOUSBKBD (alpha!!), ARDUINOZX81KBD
+ * 
+ * Printers:
+ *  ARDUINOPRT 
+ *
+ */
+
+/* which serial port is used for terminal I/O */
+#define SERIALPORT Serial
+
+/* which serial port is used for printer IO */
+#define PRTSERIAL Serial3
+
+/* the only language feature of BASIC that we need is the VT52 component */
+#define HASVT52
+
+/* should the VT52 also handle Wiring */
+#define VT52WIRING
+
+/* the device driver code from BASIC */
+#include "basic.h"
+#include "hardware-arduino.h"
+
+/* XON and XOFF characters */
+#define XON 0x11
+#define XOFF 0x13
+
+/* a shallow buffer */
+#define VT52BUFSIZE 64
+char vt52sbuf[VT52BUFSIZE];
+int vt52sbi = 0;
+
+void setup() {
+
+/* start the terminal interface */
+  SERIALPORT.begin(9600);
+
+/* start the display stream */
+  dspbegin();  
+
+/* if a printer port is defined, start the printer, this is Serial1 of Software Serial */
+#if defined(ARDUINOPRT)
+  prtbegin();
+#endif
+
+/* if any wire subsystem is requested, start it as well */
+#if defined(NEEDSWIRE)
+  wirebegin();
+#endif
+
+/* and then there is SPI */
+#if defined(ARDUINOSPI)
+  spibegin();
+#endif
+
+}
+
+void loop() {
+  char ch;
+
+/* first test, just use the serial port as in */
+
+/* read a chunk of characters */
+/* display output is slow, it is an operation at the timescale of 10 ms per character, XOFF while we do it*/
+  if (SERIALPORT.available()) {
+/* send XOFF to hold the output */
+    SERIALPORT.write(XOFF);
+/* free the serial buffer immediately to be ready for characters sent before XOFF could be processes*/
+    while (SERIALPORT.available() && vt52bi < VT52BUFSIZE) vt52sbuf[vt52bi++]=SERIALPORT.read();
+/* now empty the buffer completely */
+    for (int i=0; i<vt52bi; i++) dspwrite(vt52sbuf[i]);
+    vt52bi=0;
+/* send XON to continue output */
+    SERIALPORT.write(XON);
+  }
+  
+/* send all characters from the display to the serial stream */
+  while (kbdavailable()) {
+    ch=kbdread();
+    SERIALPORT.write(ch);
+  } 
+}

data/Basic1/TinyVT52/basic.h

@@ -0,0 +1,1312 @@
+/*
+ *
+ *	$Id: basic.h,v 1.9 2022/08/15 18:08:56 stefan Exp stefan $
+ *
+ *	Stefan's basic interpreter 
+ *
+ *	Playing around with frugal programming. See the licence file on 
+ *	https://github.com/slviajero/tinybasic for copyright/left.
+ *    (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)
+ *
+ *	Author: Stefan Lenz, [email protected]
+ *
+ *	basic.h are the core defintions and function protypes
+ *
+ */
+
+/*
+ *	if the PROGMEM macro is define we compile on the Arduino IDE
+ *	we undef all hardware settings otherwise a little odd
+ */
+#ifdef ARDUINO_ARCH_MBED
+#define PROGMEM
+#endif
+
+#ifdef PROGMEM
+#define ARDUINOPROGMEM
+#else
+#undef ARDUINO
+#undef ARDUINOSD
+#undef ARDUINORF24
+#undef ARDUINORTC
+#undef ARDUINOEEPROM
+#undef ARDUINOEEPROMI2C
+#undef ARDUINOWIRE
+#endif
+
+/* 
+ *	MSDOS, Mac, Linux and Windows 
+ */
+#ifndef ARDUINO
+typedef unsigned char uint8_t;
+#define PROGMEM
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HASFLOAT
+#include <math.h>
+#include <float.h>
+#endif
+#include <time.h>
+#include <sys/types.h>
+#include <sys/timeb.h>
+#ifndef MSDOS
+#include <dirent.h>
+#include <unistd.h>
+#else
+#include <dir.h>
+#include <dos.h>
+#endif
+#ifdef MINGW
+#include <windows.h>
+#endif
+#ifdef RASPPI
+#include <wiringPi.h>
+#endif
+#endif
+
+
+#if defined(ARDUINO_ARCH_AVR)
+/* the small memory model with shallow stacks and small buffers */
+#define BUFSIZE 		80
+#define STACKSIZE		15
+#define GOSUBDEPTH		4
+#define FORDEPTH		4
+#define LINECACHESIZE	4
+#else 
+/* the for larger microcontrollers and real computers */
+#define BUFSIZE 		128
+#define STACKSIZE		64
+#define GOSUBDEPTH		8
+#define FORDEPTH		8
+#define LINECACHESIZE	16
+#endif
+/* more duffers and vars */
+#define SBUFSIZE		32
+#define VARSIZE			26
+/* default sizes of arrays and strings if they are not DIMed */
+#define ARRAYSIZEDEF	10
+#define STRSIZEDEF		32
+
+/*
+ *	the time intervall in ms needed for 
+ *	ESP8266 yields, network client loops 
+ *	and other timing related functions 
+ */
+#define LONGYIELDINTERVAL 1000
+#define YIELDINTERVAL 32
+#define YIELDTIME 2
+
+/* the default EEPROM dummy size */
+#define EEPROMSIZE 1024
+
+/*
+ * The tokens for the BASIC keywords
+ *
+ *	All single character operators are their own tokens
+ *	ASCII values above 0x7f are used for tokens of keywords.
+ *	EOL is a token
+ */
+#define EOL			 0
+#define NUMBER   	 -127
+#define LINENUMBER   -126
+#define STRING   	 -125
+#define VARIABLE 	 -124
+#define STRINGVAR 	 -123
+#define ARRAYVAR     -122
+/* multi character tokens - BASEKEYWORD (3) */
+#define GREATEREQUAL -121
+#define LESSEREQUAL  -120
+#define NOTEQUAL	 -119
+/* this is the Palo Alto Language Set (19) */
+#define TPRINT  -118
+#define TLET    -117
+#define TINPUT  -116
+#define TGOTO   -115
+#define TGOSUB  -114
+#define TRETURN -113
+#define TIF     -112
+#define TFOR    -111
+#define TTO     -110
+#define TSTEP   -109
+#define TNEXT   -108
+#define TSTOP   -107
+#define TLIST	-106
+#define TNEW    -105
+#define TRUN    -104
+#define TABS 	-103
+#define TRND	-102
+#define TSIZE   -101
+#define TREM 	-100
+/* this is the Apple 1 language set in addition to Palo Alto (14) */
+#define TNOT    -99
+#define TAND	-98
+#define TOR 	-97
+#define TLEN	-96
+#define TSGN	-95	
+#define TPEEK	-94
+#define TDIM	-93
+#define TCLR	-92
+#define THIMEM  -91
+#define TTAB 	-90
+#define TTHEN   -89
+#define TEND    -88
+#define TPOKE	-87
+/* Stefan's tinybasic additions (12) */
+#define TCONT   -86
+#define TSQR	-85
+#define TPOW	-84
+#define TMAP	-83
+#define TDUMP 	-82
+#define TBREAK  -81
+#define TSAVE   -80
+#define TLOAD   -79
+#define TGET    -78
+#define TPUT    -77
+#define TSET    -76
+#define TCLS    -75
+/* Arduino functions (10) */
+#define TPINM	-74
+#define TDWRITE	-73
+#define TDREAD	-72
+#define TAWRITE	-71
+#define TAREAD	-70
+#define TDELAY	-69
+#define TMILLIS	-68
+#define TTONE	-67
+#define TPULSEIN	-66
+#define TAZERO	-65
+#define TLED	-64
+/* the DOS functions (5) */
+#define TCATALOG	-63
+#define TDELETE	-62
+#define TOPEN 	-61
+#define TCLOSE 	-60
+#define TFDISK  -59
+/* low level access of internal routines (2) */
+#define TUSR	-58
+#define TCALL 	-57
+/* mathematical functions (7) */
+#define TSIN 	-56
+#define TCOS    -55
+#define TTAN 	-54
+#define TATAN   -53
+#define TLOG    -52
+#define TEXP    -51
+#define TINT    -50
+/* graphics - experimental - rudimentary (7) */
+#define TCOLOR 	-49
+#define TPLOT   -48
+#define TLINE 	-47
+#define TCIRCLE -46
+#define TRECT   -45
+#define TFCIRCLE -44
+#define TFRECT   -43
+/* the Dartmouth extensions (6) */
+#define TDATA	-42
+#define TREAD   -41
+#define TRESTORE -40
+#define TDEF	-39
+#define TFN 	-38
+#define TON     -37
+/* the latecomer ELSE */
+#define TELSE 	-36
+/* darkarts (3) */
+#define TMALLOC -35
+#define TFIND   -34
+#define TEVAL   -33
+/* iot extensions (9) */
+#define TASSIGN	-32
+#define TAVAIL	-31
+#define TSTR	-30
+#define TINSTR	-29
+#define TVAL	-28
+#define TNETSTAT	-27
+#define TSENSOR	-26
+#define TWIRE	-25
+#define TSLEEP	-24
+/* constants used for some obscure purposes */
+#define TBUFFER -2
+/* UNKNOWN is not used in the current code, the 
+ * lexer tokenizes everything blindly. There is a UNKNOWN hook 
+ * in statement for a grammar aware lexer */
+#define UNKNOWN -1
+
+/* the number of keywords, and the base index of the keywords */
+#define NKEYWORDS	3+19+13+12+11+5+2+7+7+7+12
+#define BASEKEYWORD -121
+
+/*
+ *	Interpreter states 
+ *	SRUN means running from a programm
+ *	SINT means interactive mode
+ *	SERUN means running directly from EEPROM
+ *		(enum would be the right way of doing this.)
+ *	BREAKCHAR is the character stopping the program on Ardunios
+ *  BREAKPIN can be set, it is a pin that needs to go to low to stop a BASIC program
+ *    This should be done in hardware*.h
+ * 
+ */
+#define SINT 0
+#define SRUN 1
+#define SERUN 2
+#define BREAKCHAR '#'
+
+/* 
+ *	Arduino input and output channels
+ */
+#define OSERIAL 1
+#define ODSP 2
+#define OPRT 4
+#define OWIRE 7
+#define ORADIO 8
+#define OMQTT  9
+#define OFILE 16
+
+#define ISERIAL 1
+#define IKEYBOARD 2
+#define ISERIAL1 4
+#define IWIRE 7
+#define IRADIO 8
+#define IMQTT  9
+#define IFILE 16
+
+/*
+ *	All BASIC keywords for the tokens
+ */
+const char sge[]   PROGMEM = "=>";
+const char sle[]   PROGMEM = "<=";
+const char sne[]   PROGMEM = "<>";
+/* Palo Alto language set */
+const char sprint[]  PROGMEM = "PRINT";
+const char slet[]    PROGMEM = "LET";
+const char sinput[]  PROGMEM = "INPUT";
+const char sgoto[]   PROGMEM = "GOTO";
+const char sgosub[]  PROGMEM = "GOSUB";
+const char sreturn[] PROGMEM = "RETURN";
+const char sif[]     PROGMEM = "IF";
+const char sfor[]    PROGMEM = "FOR";
+const char sto[]     PROGMEM = "TO";
+const char sstep[]   PROGMEM = "STEP";
+const char snext[]   PROGMEM = "NEXT";
+const char sstop[]   PROGMEM = "STOP";
+const char slist[]   PROGMEM = "LIST";
+const char snew[]    PROGMEM = "NEW";
+const char srun[]  	 PROGMEM = "RUN";
+const char sabs[]    PROGMEM = "ABS";
+const char srnd[]    PROGMEM = "RND";
+const char ssize[]   PROGMEM = "SIZE";
+const char srem[]    PROGMEM = "REM";
+/* Apple 1 language set */
+#ifdef HASAPPLE1
+const char snot[]    PROGMEM = "NOT";
+const char sand[]    PROGMEM = "AND";
+const char sor[]     PROGMEM = "OR";
+const char slen[]    PROGMEM = "LEN";
+const char ssgn[]    PROGMEM = "SGN";
+const char speek[]   PROGMEM = "PEEK";
+const char sdim[]    PROGMEM = "DIM";
+const char sclr[]    PROGMEM = "CLR";
+const char shimem[]  PROGMEM = "HIMEM";
+const char stab[]    PROGMEM = "TAB";
+const char sthen[]   PROGMEM = "THEN";
+const char sbend[]   PROGMEM = "END";
+const char spoke[]   PROGMEM = "POKE";
+#endif
+/* Stefan's basic additions */
+#ifdef HASSTEFANSEXT
+const char scont[]   PROGMEM = "CONT";
+const char ssqr[]    PROGMEM = "SQR";
+const char spow[]    PROGMEM = "POW";
+const char smap[]    PROGMEM = "MAP";
+const char sdump[]   PROGMEM = "DUMP";
+const char sbreak[]  PROGMEM = "BREAK";
+#endif
+/* LOAD and SAVE is always there */
+const char ssave[]   PROGMEM = "SAVE";
+const char sload[]   PROGMEM = "LOAD";
+#ifdef HASSTEFANSEXT
+const char sget[]    PROGMEM = "GET";
+const char sput[]    PROGMEM = "PUT";
+const char sset[]    PROGMEM = "SET";
+const char scls[]    PROGMEM = "CLS";
+#endif
+/* Arduino functions */
+#ifdef HASARDUINOIO
+const char spinm[]    PROGMEM = "PINM";
+const char sdwrite[]  PROGMEM = "DWRITE";
+const char sdread[]   PROGMEM = "DREAD";
+const char sawrite[]  PROGMEM = "AWRITE";
+const char saread[]   PROGMEM = "AREAD";
+const char sdelay[]   PROGMEM = "DELAY";
+const char smillis[]	PROGMEM = "MILLIS";
+const char sazero[]	PROGMEM = "AZERO";
+const char sled[]	PROGMEM = "LED";
+#endif
+#ifdef HASTONE
+const char stone[]    PROGMEM = "PLAY";
+#endif
+#ifdef HASPULSE
+const char splusein[] PROGMEM = "PULSEIN";
+#endif
+/* DOS functions */
+#ifdef HASFILEIO
+const char scatalog[] PROGMEM = "CATALOG";
+const char sdelete[]  PROGMEM = "DELETE";
+const char sfopen[]   PROGMEM = "OPEN";
+const char sfclose[]  PROGMEM = "CLOSE";
+const char sfdisk[]  PROGMEM = "FDISK";
+#endif
+/* low level access functions */
+#ifdef HASSTEFANSEXT
+const char susr[]  PROGMEM = "USR";
+const char scall[] PROGMEM = "CALL";
+#endif
+/* mathematics */
+#ifdef HASFLOAT
+const char ssin[]  PROGMEM = "SIN";
+const char scos[]  PROGMEM = "COS";
+const char stan[]  PROGMEM = "TAN";
+const char satan[] PROGMEM = "ATAN";
+const char slog[]  PROGMEM = "LOG";
+const char sexp[]  PROGMEM = "EXP";
+#endif
+/* INT is always needed to make float/int programs compatible */
+const char sint[]  PROGMEM = "INT"; 
+/* elemetars graphics */
+#ifdef HASGRAPH
+const char scolor[]  PROGMEM  = "COLOR";
+const char splot[]   PROGMEM  = "PLOT";
+const char sline[]   PROGMEM  = "LINE";
+const char scircle[] PROGMEM  = "CIRCLE";
+const char srect[]   PROGMEM  = "RECT";
+const char sfcircle[] PROGMEM  = "FCIRCLE";
+const char sfrect[]   PROGMEM  = "FRECT";
+#endif
+/* Dartmouth BASIC extensions */
+#ifdef HASDARTMOUTH
+const char sdata[]  	PROGMEM  = "DATA";
+const char sread[]  	PROGMEM  = "READ";
+const char srestore[]   PROGMEM  = "RESTORE";
+const char sdef[] 	PROGMEM  = "DEF";
+const char sfn[]   	PROGMEM  = "FN";
+const char son[]   	PROGMEM  = "ON";
+#endif
+/* a latecomer the ELSE command */
+#ifdef HASSTEFANSEXT
+const char selse[]	PROGMEM  = "ELSE";
+#endif
+/* The Darkarts commands unthinkable in Dartmouth */
+#ifdef HASDARKARTS
+const char smalloc[]	PROGMEM  = "MALLOC";
+const char sfind[]		PROGMEM  = "FIND";
+const char seval[]		PROGMEM  = "EVAL";
+#endif
+/* iot extensions */
+#ifdef HASIOT
+const char sassign[]	PROGMEM  = "ASSIGN";
+const char savail[]		PROGMEM  = "AVAIL";
+const char sstr[]		PROGMEM  = "STR";
+const char sinstr[]		PROGMEM  = "INSTR";
+const char sval[]		PROGMEM  = "VAL";
+const char snetstat[]	PROGMEM  = "NETSTAT";
+const char ssensor[]	PROGMEM  = "SENSOR";
+const char swire[]		PROGMEM  = "WIRE";
+const char ssleep[]		PROGMEM  = "SLEEP";
+#endif
+
+/* zero terminated keyword storage */
+const char* const keyword[] PROGMEM = {
+	sge, sle, sne, sprint, slet, sinput, 
+	sgoto, sgosub, sreturn, sif, sfor, sto,
+	sstep, snext, sstop, slist, snew, srun,
+	sabs, srnd, ssize, srem,
+#ifdef HASAPPLE1
+	snot, sand, sor, slen, ssgn, speek, sdim,
+	sclr, shimem, stab, sthen, 
+	sbend, spoke,
+#endif
+#ifdef HASSTEFANSEXT
+	scont, ssqr, spow, smap, sdump, sbreak, 
+#endif
+	ssave, sload, 
+#ifdef HASSTEFANSEXT
+	sget, sput, sset, scls,
+#endif
+#ifdef HASARDUINOIO
+    spinm, sdwrite, sdread, sawrite, saread, 
+    sdelay, smillis, sazero, sled,
+#endif
+#ifdef HASTONE
+	stone,
+#endif
+#ifdef HASPULSE
+	splusein,
+#endif
+#ifdef HASFILEIO
+    scatalog, sdelete, sfopen, sfclose, sfdisk,
+#endif
+#ifdef HASSTEFANSEXT
+    susr, scall,
+#endif
+#ifdef HASFLOAT
+    ssin, scos, stan, satan, slog, sexp,
+#endif
+    sint,
+#ifdef HASGRAPH
+    scolor, splot, sline, scircle, srect, 
+    sfcircle, sfrect,
+#endif
+#ifdef HASDARTMOUTH
+	sdata, sread, srestore, sdef, sfn, son,
+#endif
+#ifdef HASSTEFANSEXT
+	selse,
+#endif
+#ifdef HASDARKARTS
+	smalloc, sfind, seval, 
+#endif
+#ifdef HASIOT
+	sassign, savail, sstr, sinstr, sval, 
+	snetstat, ssensor, swire, ssleep, 
+#endif
+	0
+};
+
+/* the zero terminated token dictonary needed for scalability */
+const signed char tokens[] PROGMEM = {
+	GREATEREQUAL, LESSEREQUAL, NOTEQUAL, TPRINT, TLET,    
+    TINPUT, TGOTO, TGOSUB, TRETURN, TIF, TFOR, TTO, TSTEP,
+    TNEXT, TSTOP, TLIST, TNEW, TRUN, TABS, TRND, TSIZE, TREM,
+#ifdef HASAPPLE1
+    TNOT, TAND, TOR, TLEN, TSGN, TPEEK, TDIM, TCLR,
+    THIMEM, TTAB, TTHEN, TEND, TPOKE,
+#endif
+#ifdef HASSTEFANSEXT
+	TCONT, TSQR, TPOW, TMAP, TDUMP, TBREAK, 
+#endif
+	TSAVE, TLOAD, 
+#ifdef HASSTEFANSEXT	
+	TGET, TPUT, TSET, TCLS,
+#endif
+#ifdef HASARDUINOIO
+	TPINM, TDWRITE, TDREAD, TAWRITE, TAREAD, TDELAY, TMILLIS,
+	TAZERO, TLED,
+#endif
+#ifdef HASTONE
+	TTONE, 
+#endif
+#ifdef HASPULSE
+	TPULSEIN, 
+#endif
+#ifdef HASFILEIO
+	TCATALOG, TDELETE, TOPEN, TCLOSE, TFDISK,
+#endif
+#ifdef HASSTEFANSEXT
+	TUSR, TCALL,
+#endif
+#ifdef HASFLOAT
+	TSIN, TCOS, TTAN, TATAN, TLOG, TEXP,
+#endif
+	TINT,
+#ifdef HASGRAPH
+	TCOLOR, TPLOT, TLINE, TCIRCLE, TRECT, 
+	TFCIRCLE, TFRECT,
+#endif
+#ifdef HASDARTMOUTH
+	TDATA, TREAD, TRESTORE, TDEF, TFN, TON, 
+#endif
+#ifdef HASSTEFANSEXT
+	TELSE,
+#endif
+#ifdef HASDARKARTS
+	TMALLOC, TFIND, TEVAL, 
+#endif
+#ifdef HASIOT
+	TASSIGN, TAVAIL, TSTR, TINSTR, TVAL, TNETSTAT,
+	TSENSOR, TWIRE, TSLEEP,
+#endif
+	0
+};
+
+/*
+ *	the message catalog
+ */
+#define MFILE		0
+#define MPROMPT		1
+#define MGREET		2
+#define MLINE		3
+#define MNUMBER		4
+#define MVARIABLE	5
+#define MARRAY		6
+#define MSTRING		7
+#define MSTRINGVAR	8
+#define EGENERAL 	 9
+#define EUNKNOWN	 10
+#define ENUMBER      11
+#define EDIVIDE		 12
+#define ELINE        13
+#define ERETURN      14
+#define ENEXT        15
+#define EGOSUB       16 
+#define EFOR         17
+#define EOUTOFMEMORY 18
+#define ESTACK 		 19
+#define EDIM         20
+#define EORANGE 	 21
+#define ESTRING      22
+#define EVARIABLE	 23
+#define EFILE 		 24
+#define EFUN 		 25
+#define EARGS		 26
+#define EEEPROM		 27
+#define ESDCARD		 28
+
+const char mfile[]    	PROGMEM = "file.bas";
+const char mprompt[]	PROGMEM = "> ";
+const char mgreet[]		PROGMEM = "Stefan's Basic 1.4a";
+const char mline[]		PROGMEM = "LINE";
+const char mnumber[]	PROGMEM = "NUMBER";
+const char mvariable[]	PROGMEM = "VARIABLE";
+const char marray[]		PROGMEM = "ARRAY";
+const char mstring[]	PROGMEM = "STRING";
+const char mstringv[]	PROGMEM = "STRINGVAR";
+const char egeneral[]  	PROGMEM = "Error";
+#ifdef HASERRORMSG
+const char eunknown[]  	PROGMEM = "Syntax";
+const char enumber[]	PROGMEM = "Number";
+const char edivide[]  	PROGMEM = "Div by 0";
+const char eline[]  	PROGMEM = "Unknown Line";
+const char ereturn[]    PROGMEM = "Return";
+const char enext[]		PROGMEM = "Next";
+const char egosub[] 	PROGMEM = "GOSUB";
+const char efor[]		PROGMEM = "FOR";
+const char emem[]  	   	PROGMEM = "Memory";
+const char estack[]    	PROGMEM = "Stack";
+const char edim[]		PROGMEM = "DIM";
+const char erange[]  	PROGMEM = "Range";
+const char estring[]	PROGMEM = "String";
+const char evariable[]  PROGMEM = "Variable";
+const char efile[]  	PROGMEM = "File";
+const char efun[] 	 	PROGMEM = "Function";
+const char eargs[]  	PROGMEM = "Args";
+const char eeeprom[]	PROGMEM = "EEPROM";
+const char esdcard[]	PROGMEM = "SD card";
+#endif
+
+const char* const message[] PROGMEM = {
+	mfile, mprompt, mgreet, 
+	mline, mnumber, mvariable, marray, 
+	mstring, mstringv,
+	egeneral
+#ifdef HASERRORMSG
+	, eunknown, enumber, edivide, eline, ereturn, 
+	enext, egosub, efor, emem, estack, edim, erange,
+	estring, evariable, efile, efun, eargs, 
+	eeeprom, esdcard
+#endif
+};
+
+/*
+ *	code for variable numbers and addresses sizes
+ *	the original code was 16 bit but can be extended here
+ * 	to arbitrary types 
+ *
+ *	number_t is the type for numerical work - either float or int
+ *  wnumber_t is the type containing the largest printable integer, 
+ *    for float keep this int on 32 bit and long on 8 bit unless you 
+ *    want to use very long integers, like 64 or 128 bit types. 
+ *  address_t is an unsigned type adddressing memory 
+ *  mem_t is a SIGNED 8bit character type.
+ *	index_t is a SIGNED minimum 16 bit integer type
+ *
+ *	works with the tacit assumption that 
+ *	sizeof(number_t) >= sizeof(address_t) 
+ *	and that the entire memory is smaller than the positive
+ * 	part of number type (!!)
+ *
+ *	we assume that float >= 4 bytes in the following
+ *
+ *	maxnum: the maximum accurate(!) integer of a 
+ *		32 bit float 
+ *	strindexsize: the index size of strings either 
+ *		1 byte or 2 bytes - no other values supported
+ *
+ *
+ */
+#ifdef HASFLOAT
+typedef float number_t;
+const number_t maxnum=16777216; 
+typedef long wnumber_t;
+#else
+typedef int number_t;
+typedef int wnumber_t;
+const number_t maxnum=(number_t)~((number_t)1<<(sizeof(number_t)*8-1));
+#endif
+typedef unsigned short address_t; /* this type addresses memory */
+const int numsize=sizeof(number_t);
+const int addrsize=sizeof(address_t);
+const int eheadersize=sizeof(address_t)+1;
+const int strindexsize=2; /* default in the meantime, strings up to unsigned 16 bit length */
+const address_t maxaddr=(address_t)(~0); 
+typedef signed char mem_t; /* a signed 8 bit type for the memory */
+typedef short index_t; /* this type counts at least 16 bit */
+
+/* 
+ * system type identifiers
+ */
+
+#define SYSTYPE_UNKNOWN	0
+#define SYSTYPE_AVR 	1
+#define SYSTYPE_ESP8266 2
+#define SYSTYPE_ESP32	3
+#define SYSTYPE_RP2040  4
+#define SYSTYPE_SAM     5
+#define SYSTYPE_POSIX	32
+#define SYSTYPE_MSDOS	33
+
+/*
+ *	The basic interpreter is implemented as a stack machine
+ *	with global variable for the interpreter state, the memory
+ *	and the arithmetic during run time.
+ *
+ *	stack is the stack memory and sp controls the stack.
+ *
+ *	ibuffer is an input buffer and *bi a pointer to it.
+ *
+ *	sbuffer is a short buffer for arduino progmem access. 
+ *
+ *	vars is a static array of 26 single character variables.
+ *
+ *	mem is the working memory of the basic interperter.
+ *
+ *	x, y, xc, yc are two n*8 bit and two 8 bit accumulators.
+ *
+ *	ax, ax are address type accumulators.
+ *
+ *	z is a mixed n*8 bit accumulator
+ *
+ *	ir, ir2 are general index registers for string processing.
+ *
+ *	token contains the actually processes token.
+ *
+ *	er is the nontrapable error status
+ *
+ *	ert is the trapable error status 
+ *
+ *	st, here and top are the interpreter runtime controls.
+ *
+ *	nvars is the number of vars the interpreter has stored.
+ *
+ *	form is used for number formation Palo Alto BASIC style.
+ *
+ *	charcount counts the printed characters to create a real TAB
+ *		only implemented on the serial stream
+ *	reltab controls if the relative char mechanisms is active
+ *
+ *	rd is the random number storage.
+ *
+ *	fnc counts the depth of for - next loop nesting
+ *
+ *	args is the global arg count variable
+ *
+ *	id and od are the input and output model for an arduino
+ *		they are set to serial by default
+ *
+ *	idd and odd are the default values of the above
+ *
+ *	debuglevel is the statement loop debug level
+ *
+ *	data is the data pointer of the READ/DATA mechanism
+ *
+ * static keyword here is obsolete on most platforms
+ *
+ */
+
+static number_t stack[STACKSIZE];
+static address_t sp=0; 
+
+static char sbuffer[SBUFSIZE];
+
+static char ibuffer[BUFSIZE] = "\0";
+static char *bi;
+
+static number_t vars[VARSIZE];
+
+#if MEMSIZE != 0
+static mem_t mem[MEMSIZE];
+#else
+static mem_t* mem;
+#endif
+static address_t himem, memsize;
+
+static struct {mem_t varx; mem_t vary; address_t here; number_t to; number_t step;} forstack[FORDEPTH];
+static index_t forsp = 0;
+static mem_t fnc; 
+
+static address_t gosubstack[GOSUBDEPTH];
+static index_t gosubsp = 0;
+
+static number_t x, y;
+static mem_t xc, yc;
+
+static address_t ax, ay;
+
+/* this union is used to store larger objects into byte oriented memory */
+struct twobytes {mem_t l; mem_t h;};
+static union accunumber { number_t i; address_t a; struct twobytes b; mem_t c[sizeof(number_t)]; } z;
+
+static char *ir, *ir2;
+static mem_t token;
+static mem_t er;
+static mem_t ert;
+
+static mem_t st; 
+static address_t here; 
+static address_t top;
+
+static address_t nvars = 0; 
+
+static mem_t form = 0;
+
+#ifdef HASMSTAB
+static mem_t charcount = 0;
+static mem_t reltab = 0;
+#endif
+
+#ifdef HASARRAYLIMIT
+static address_t arraylimit = 1;
+#else 
+const static address_t arraylimit = 1;
+#endif
+
+static mem_t args;
+
+/* this is unsigned hence address_t */
+static address_t rd;
+
+/* output and input vector */
+static mem_t id;
+static mem_t od;
+
+/* default IO - not constant, can be changed at runtime 
+	through a user call */
+static mem_t idd = ISERIAL;
+static mem_t odd = OSERIAL;
+
+/* the runtime debuglevel */
+static mem_t debuglevel = 0;
+
+/* data pointer */
+#ifdef HASDARTMOUTH
+static address_t data = 0;
+#endif
+    
+/* 
+ * process command line arguments in the POSIX world 
+ * bnointafterrun is a flag to remember if called as command
+ * line argument, in this case we don't return to interactive 
+ */
+#ifndef ARDUINO
+int bargc;
+char** bargv;
+mem_t bnointafterrun = 0;
+#endif
+
+/*
+ * Yield counter, we count when we did yield the last time
+ *	lastyield controlls the client loops of network functions 
+ *	like mqtt, scanned keyboard, and USB.
+ *
+ *	lastlongyield controls longterm functions like DHCP lease 
+ *	renewal in Ethernet 
+ * 
+ * there variables are only needed if the platform has background 
+ *  tasks
+ */
+static long lastyield=0;
+static long lastlongyield=0;
+
+/* formaters lastouttoken and spaceafterkeyword to make a nice LIST */
+static mem_t lastouttoken;
+static mem_t spaceafterkeyword;
+
+/* 
+ * the cache for the heap search - helps the string code 
+ * the last found object on the heap is remembered. This is needed
+ * because the string code sometime searches the heap twice during the 
+ * same operation. 
+ */
+#ifdef HASAPPLE1
+static mem_t bfindc, bfindd, bfindt;
+static address_t bfinda, bfindz;
+#endif
+
+/* the interrupt vector - not yet implemented */
+#ifdef HASINTERRUPTS
+static short interruptvector;
+#endif
+
+/* 
+ * Function prototypes, ordered by layers
+ * HAL - hardware abstraction
+ * Layer 0 - memory and I/O
+ * Layer 1 - Program storage and control
+ * Layer 2 - Where stuff happens
+ */
+
+/*
+ *	HAL - see hardware-*.h
+ *  This is the hardware abstraction layer of the BASIC
+ *	interpreter 
+ */
+
+/* setup codes */
+void timeinit();
+void wiringbegin();
+
+/* low level mem and hardware features */
+long freeRam();
+long freememorysize();
+void restartsystem();
+void activatesleep(long t);
+
+/* start the spi bus */
+void spibegin();
+
+/* 
+ * the hardware interface display driver functions, need to be 
+ * 	implemented for the display driver to work 
+ *	dspupdate() only for display like Epapers
+ */
+void dspbegin();
+void dspprintchar(char, mem_t, mem_t);
+void dspclear();
+void dspupdate();
+
+/* keyboard code */
+void kbdbegin();
+int kbdstat(char);
+char kbdavailable();
+char kbdread();
+char kbdcheckch();
+
+/* graphics functions */
+void rgbcolor(int, int, int);
+void vgacolor(short c);
+void vgascale(int*, int*);
+void plot(int, int);
+void line(int, int, int, int);  
+void rect(int, int, int, int);
+void frect(int, int, int, int);
+void circle(int, int, int);
+void fcircle(int, int, int);
+
+/* text output to a VGA display */
+void vgabegin();
+int vgastat(char);
+void vgawrite(char);
+
+/* generic display code */
+void dspwrite(char);
+void dspbegin();
+int dspstat(char);
+char dspwaitonscroll();
+char dspactive();
+void dspsetupdatemode(char);
+char dspgetupdatemode();
+void dspgraphupdate();
+void dspsetscrollmode(char, short);
+void dspsetcursor(short, short);
+void dspbufferclear();
+void dspscroll(mem_t, mem_t);
+void dspreversescroll(mem_t);
+void dspvt52(char *);
+
+/* real time clock */
+char* rtcmkstr();
+void rtcset(uint8_t, short);
+short rtcget(short); 
+
+/* network and mqtt functions */
+void netbegin();
+char netconnected();
+void mqttsetname();
+void mqttbegin();
+int mqttstat(char);
+int  mqttstate();
+void mqttsubscribe(char*);
+void mqttsettopic(char*);
+void mqttouts(char *, short);
+void mqttins(char *, short);
+char mqttinch();
+
+/* low level EEPROM handling */
+void ebegin();
+void eflush();
+address_t elength();
+short eread(address_t);
+void eupdate(address_t, short);
+
+/* arduino io functions */
+void aread();
+void dread();
+void awrite(number_t, number_t);
+void dwrite(number_t, number_t);
+void pinm(number_t, number_t);
+void bmillis();
+void bpulsein();
+void btone(short);
+
+/* timing control for ESP and network */
+void byield();
+void yieldfunction();
+void longyieldfunction();
+
+/* the file interface */
+char* mkfilename(const char*);
+const char* rmrootfsprefix(const char*);
+void fsbegin(char);
+int fsstat(char);
+void filewrite(char);
+char fileread();
+char ifileopen(const char*);
+void ifileclose();
+char ofileopen(char*, const char*);
+void ofileclose();
+int fileavailable();
+void rootopen();
+int rootnextfile();
+int rootisfile();
+const char* rootfilename();
+int rootfilesize();
+void rootfileclose();
+void rootclose();
+void formatdisk(short i);
+
+/* low level serial code */
+void picogetchar(char);
+void picowrite(char);
+void picobegin(uint32_t);
+void picoins(char, short);
+void serialbegin();
+int serialstat(char);
+char serialread();
+void serialwrite(char);
+short serialcheckch();
+short serialavailable();
+void consins(char*, short);
+void prtbegin();
+int prtstat(char);
+void prtset(int);
+char prtopen(char *, int);
+void prtclose();
+char prtread();
+void prtwrite(char);
+short prtcheckch();
+short prtavailable();
+
+/* generic wire access */
+void wirebegin();
+int wirestat(char);
+void wireopen(char, char);
+void wireins(char*, uint8_t);
+void wireouts(char*, uint8_t);
+short wireavailable();
+
+/* RF24 radio input */
+int radiostat(char);
+void radioset(int);
+#ifdef ARDUINO 
+uint64_t pipeaddr(char*);
+#else
+long pipeaddr(char*);
+#endif
+void iradioopen(char*);
+void oradioopen(char*);
+void radioins(char*, short);
+void radioouts(char* , short);
+short radioavailable();
+
+/* sensor control */
+void sensorbegin();
+number_t sensorread(short, short);
+
+/* SPI RAM code */
+address_t spirambegin();
+void spiramrawwrite(address_t, mem_t);
+mem_t spiramrawread(address_t );
+
+/*
+ * Layer 0 functions - I/O and memory management 
+ */
+
+/* make room for BASIC */
+address_t ballocmem(); 
+
+/* handle files im EEPROM */
+void eload();
+void esave();
+char autorun();
+
+/* the variable heap from Apple 1 BASIC */
+address_t bmalloc(mem_t, mem_t, mem_t, address_t);
+address_t bfind(mem_t, mem_t, mem_t);
+address_t blength (mem_t, mem_t, mem_t);
+
+/* normal variables of number_t */
+void createvar(mem_t, mem_t);
+number_t getvar(mem_t, mem_t);
+void setvar(mem_t, mem_t, number_t);
+void clrvars();
+
+/*	low level memory access packing n*8bit bit into n 8 bit objects
+	e* is for Arduino EEPROM */
+void getnumber(address_t, mem_t);
+void setnumber(address_t, mem_t);
+void egetnumber(address_t, mem_t);
+void esetnumber(address_t, mem_t);
+
+/* array and string handling */
+/* the multidim extension is experimental, here only 2 array dimensions implemented as test */
+address_t createarray(mem_t, mem_t, address_t, address_t);
+void array(mem_t, mem_t, mem_t, address_t, address_t, number_t*);
+address_t createstring(char, char, address_t, address_t);
+char* getstring(char, char, address_t, address_t);
+number_t arraydim(char, char);
+address_t stringdim(char, char);
+address_t lenstring(char, char, address_t);
+void setstringlength(char, char, address_t, address_t);
+void setstring(char, char, address_t, char *, address_t, address_t);
+
+/* get keywords and tokens from PROGMEM */
+char* getkeyword(unsigned short);
+char* getmessage(char);
+signed char gettokenvalue(char);
+void printmessage(char);
+
+/* error handling */
+void error(mem_t);
+void reseterror();
+void debugtoken();
+void bdebug(const char*);
+
+/* the arithemtic stack */
+void push(number_t);
+number_t pop();
+void drop();
+void clearst();
+
+/* READ DATA handling */
+void clrdata();
+
+/* FOR NEXT GOSUB stacks */
+void pushforstack();
+void popforstack();
+void dropforstack();
+void clrforstack();
+void pushgosubstack();
+void popgosubstack();
+void dropgosubstack();
+void clrgosubstack();
+
+/* general I/O initialisation */
+void ioinit();
+void iodefaults();
+
+/* character and string I/O functions */
+/* input */
+char inch();
+char checkch();
+short availch();
+void inb(char*, short);
+void ins(char*, address_t); 
+
+/* output */
+void outch(char);
+void outcr();
+void outspc();
+void outs(char*, address_t);
+void outsc(const char*);
+void outscf(const char *, short);
+
+/* I/O of number_t - floats and integers */
+address_t parsenumber(char*, number_t*);
+address_t parsenumber2(char*, number_t*);
+address_t writenumber(char*, wnumber_t); 
+address_t writenumber2(char*, number_t);
+char innumber(number_t*);
+void outnumber(number_t);
+
+/* 	
+ * Layer 1 functions, provide data and do the heavy lifting 
+ * for layer 2 including lexical analysis, storing programs 
+ * and expression evaluation 
+ */
+
+/* lexical analysis */
+void whitespaces();
+void nexttoken();
+
+/* storing and retrieving programs */
+char nomemory(number_t);
+void storetoken(); 
+mem_t memread(address_t);
+mem_t memread2(address_t);
+void memwrite2(address_t, mem_t);
+void gettoken();
+void firstline();
+void nextline();
+
+void clrlinecache();
+void addlinecache(address_t, address_t);
+address_t findinlinecache(address_t);
+void findline(address_t);
+address_t myline(address_t);
+void moveblock(address_t, address_t, address_t);
+void zeroblock(address_t, address_t);
+void diag();
+void storeline();
+
+/* read arguments from the token stream and process them */
+char termsymbol();
+char expect(mem_t, mem_t);
+char expectexpr();
+void parsearguments();
+void parsenarguments(char);
+void parsesubscripts();
+void parsefunction(void (*)(), short);
+void parseoperator(void (*)());
+void parsesubstring();
+
+/* mathematics and other functions for int and float */
+void xabs();
+void xsgn();
+void xpeek();
+void xmap();
+void rnd();
+void sqr();
+void xpow();
+
+/* string values and string evaluation */
+char stringvalue();
+void streval();
+
+/* floating point functions */
+void xsin();
+void xcos();
+void xtan();
+void xatan();
+void xlog();
+void xexp();
+void xint();
+
+/* expression evaluation */
+void factor();
+void term();
+void addexpression();
+void compexpression();
+void notexpression();
+void andexpression();
+void expression();
+
+/* 
+ * Layer 2 - statements and functions 
+ * use the global variables 
+ */
+
+/* basic commands of the core language set */
+void xprint();
+void lefthandside(address_t*, address_t*, address_t*, mem_t*);
+void assignnumber(signed char, char, char, address_t, address_t, char);
+void assignment();
+void showprompt();
+void xinput();
+void xgoto();
+void xreturn();
+void xif();
+
+/* optional FOR NEXT loops */
+void findnextcmd();
+void xfor();
+void xbreak();
+void xcont();
+void xnext();
+
+/* control commands and misc */
+void outputtoken();
+void xlist();
+void xrun();
+void xnew();
+void xrem();
+void xclr();
+void xdim();
+void xpoke();
+void xtab();
+void xdump();
+void dumpmem(address_t, address_t);
+
+/* file access and other i/o */
+void stringtobuffer();
+void getfilename(char*, char);
+void xsave();
+void xload(const char* f);
+void xget();
+void xput();
+void xset();
+void xnetstat();
+
+/* Arduino IO control interface */
+void xdwrite();
+void xawrite();
+void xpinm();
+void xdelay();
+void xtone();
+
+/* graphics commands */
+void xcolor();
+void xplot();
+void xline();
+void xrect();
+void xcircle();
+void xfrect();
+void xfcircle();
+
+/* the darkarts */
+void xmalloc();
+void xfind();
+void xfind2();
+void xeval();
+
+/* IoT commands */
+void xassign();
+void xavail();
+void xfsensor();
+void xsleep();
+
+/* File I/O functions */
+char streq(const char*, char*);
+void xcatalog();
+void xdelete();
+void xopen();
+void xfopen();
+void xclose();
+void xfdisk();
+
+/* low level access functions */
+void xcall();
+void xusr();
+
+/* the dartmouth stuff */
+void xdata();
+void nextdatarecord();
+void xread();
+void xrestore();
+void xdef();
+void xfn();
+void xon();
+
+/* the statement loop */
+void statement();
+
+/* stub for the interrupt code */
+void handleinterrupt();

data/Basic1/TinybasicArduino/basic.h

@@ -0,0 +1,1526 @@
+/*
+ *
+ *	$Id: basic.h,v 1.13 2023/07/16 14:17:08 stefan Exp stefan $
+ *
+ *	Stefan's basic interpreter 
+ *
+ *	Playing around with frugal programming. See the licence file on 
+ *	https://github.com/slviajero/tinybasic for copyright/left.
+ *    (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)
+ *
+ *	Author: Stefan Lenz, [email protected]
+ *
+ *	basic.h are the core defintions and function protypes
+ *
+ */
+
+/*
+ *	if the PROGMEM macro is define we compile on the Arduino IDE
+ *	we undef all hardware settings otherwise a little odd
+ */
+#ifdef ARDUINO_ARCH_MBED
+#define PROGMEM
+#endif
+
+#ifdef PROGMEM
+#define ARDUINOPROGMEM
+#else
+#undef ARDUINO
+#undef ARDUINOSD
+#undef ARDUINORF24
+#undef ARDUINORTC
+#undef ARDUINOEEPROM
+#undef ARDUINOEEPROMI2C
+#undef ARDUINOWIRE
+#endif
+
+/* 
+ *	MSDOS, Mac, Linux and Windows 
+ */
+#ifndef ARDUINO
+typedef unsigned char uint8_t;
+#define PROGMEM
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HASFLOAT
+#include <math.h>
+#include <float.h>
+#endif
+#include <time.h>
+#include <sys/types.h>
+#include <sys/timeb.h>
+#ifndef MSDOS
+#include <dirent.h>
+#include <unistd.h>
+#else
+#include <dir.h>
+#include <dos.h>
+#endif
+#ifdef MINGW
+#include <windows.h>
+#endif
+#endif
+
+
+#if defined(ARDUINO_ARCH_AVR)
+/* the small memory model with shallow stacks and small buffers */
+#define BUFSIZE 		80
+#define STACKSIZE		15
+#define GOSUBDEPTH      4
+#define FORDEPTH		4
+#define LINECACHESIZE	4
+#else 
+/* the for larger microcontrollers */
+#ifdef ARDUINO
+#define BUFSIZE		   128
+#define STACKSIZE		64
+#define GOSUBDEPTH		8
+#define FORDEPTH		8
+#define LINECACHESIZE	16
+#else 
+/* for real computers */
+#define BUFSIZE         256
+#define STACKSIZE       256
+#define GOSUBDEPTH      64
+#define FORDEPTH        64
+#define LINECACHESIZE   64
+#endif
+#endif
+
+/* on the real small systems we remove the linecache and set a fixed memory size*/
+#ifdef ARDUINO_AVR_DUEMILANOVE
+#undef LINECACHESIZE
+#if MEMSIZE == 0
+#define MEMSIZE 512
+#endif
+#endif
+
+/* more duffers and vars */
+#define SBUFSIZE        32
+#define VARSIZE         26
+/* default sizes of arrays and strings if they are not DIMed */
+#define ARRAYSIZEDEF    10
+#define STRSIZEDEF      32
+
+/*
+ *	the time intervall in ms needed for 
+ *	ESP8266 yields, network client loops 
+ *	and other timing related functions 
+ */
+#define LONGYIELDINTERVAL 1000
+#define YIELDINTERVAL 32
+#define YIELDTIME 2
+
+/* the default EEPROM dummy size */
+#define EEPROMSIZE 1024
+
+/* after run behaviour on POSIX systems, 1 to terminate if started
+    on the command line with a file argument, 0 to stay active and 
+    show a BASIC prompt*/
+#define TERMINATEAFTERRUN 1
+
+/*
+ * The tokens for the BASIC keywords
+ *
+ *	All single character operators are their own tokens
+ *	ASCII values above 0x7f are used for tokens of keywords.
+ *	EOL is a token
+ */
+#define EOL			 0
+#define NUMBER   	 -127
+#define LINENUMBER   -126
+#define STRING   	 -125
+#define VARIABLE 	 -124
+#define STRINGVAR 	 -123
+#define ARRAYVAR     -122
+/* multi character tokens - BASEKEYWORD (3) */
+#define GREATEREQUAL -121
+#define LESSEREQUAL  -120
+#define NOTEQUAL	 -119
+/* this is the Palo Alto Language Set (19) */
+#define TPRINT  -118
+#define TLET    -117
+#define TINPUT  -116
+#define TGOTO   -115
+#define TGOSUB  -114
+#define TRETURN -113
+#define TIF     -112
+#define TFOR    -111
+#define TTO     -110
+#define TSTEP   -109
+#define TNEXT   -108
+#define TSTOP   -107
+#define TLIST	-106
+#define TNEW    -105
+#define TRUN    -104
+#define TABS 	-103
+#define TRND	-102
+#define TSIZE   -101
+#define TREM 	-100
+/* this is the Apple 1 language set in addition to Palo Alto (14) */
+#define TNOT    -99
+#define TAND	-98
+#define TOR 	-97
+#define TLEN	-96
+#define TSGN	-95	
+#define TPEEK	-94
+#define TDIM	-93
+#define TCLR	-92
+#define THIMEM  -91
+#define TTAB 	-90
+#define TTHEN   -89
+#define TEND    -88
+#define TPOKE	-87
+/* Stefan's tinybasic additions (14) */
+#define TCONT   -86
+#define TSQR	-85
+#define TPOW	-84
+#define TMAP	-83
+#define TDUMP 	-82
+#define TBREAK  -81
+#define TSAVE   -80
+#define TLOAD   -79
+#define TGET    -78
+#define TPUT    -77
+#define TSET    -76
+#define TCLS    -75
+#define TLOCATE -74
+#define TELSE   -73
+/* Arduino functions (10) */
+#define TPINM	-72
+#define TDWRITE	-71
+#define TDREAD	-70
+#define TAWRITE	-69
+#define TAREAD	-68
+#define TDELAY	-67
+#define TMILLIS	-66
+#define TTONE	-65
+#define TPULSE	-64
+#define TAZERO	-63
+#define TLED	-62
+/* the DOS functions (5) */
+#define TCATALOG    -61
+#define TDELETE -60
+#define TOPEN 	-59
+#define TCLOSE 	-58
+#define TFDISK  -57
+/* low level access of internal routines (2) */
+#define TUSR	-56
+#define TCALL 	-55
+/* mathematical functions (7) */
+#define TSIN 	-54
+#define TCOS    -53
+#define TTAN 	-52
+#define TATAN   -51
+#define TLOG    -50
+#define TEXP    -49
+#define TINT    -48
+/* graphics - experimental - rudimentary (7) */
+#define TCOLOR 	-47
+#define TPLOT   -46
+#define TLINE 	-45
+#define TCIRCLE -44
+#define TRECT   -43
+#define TFCIRCLE -42
+#define TFRECT   -41
+/* the Dartmouth extensions (6) */
+#define TDATA	-40
+#define TREAD   -39
+#define TRESTORE    -38
+#define TDEF	-37
+#define TFN 	-36
+#define TON     -35
+/* darkarts (3) */
+#define TMALLOC -34
+#define TFIND   -33
+#define TEVAL   -32
+/* iot extensions (9) */
+#define TERROR	-31
+#define TAVAIL	-30
+#define TSTR	-29
+#define TINSTR	-28
+#define TVAL	-27
+#define TNETSTAT    -26
+#define TSENSOR	-25
+#define TWIRE	-24
+#define TSLEEP	-23
+/* events and interrupts */
+#define TAFTER -22
+#define TEVERY -21
+#define TEVENT -20
+/* experimental structured commands, currently partially implemented */
+#define TWHILE -19
+#define TWEND   -18
+#define TREPEAT -17
+#define TUNTIL -16
+#define TSWITCH -15
+#define TCASE -14
+#define TSWEND -13
+#define TDO -12
+#define TDEND -11
+/* these are multibyte token extension, currently unused */
+/* using them would allow over 1000 BASIC keywords */
+#define TEXT1 -3
+/* end of tokens */
+/* constants used for some obscure purposes */
+#define TBUFFER -2
+/* UNKNOWN is not used in the current code, the 
+ * lexer tokenizes everything blindly. There is a UNKNOWN hook 
+ * in statement for a grammar aware lexer */
+#define UNKNOWN -1
+
+/* extension tokens can be in the range from -128 to -255 
+ * one needs to set HASLONGTOKENS
+ */
+#undef HASLONGTOKEN
+#define TTOKEN1 -128
+
+
+/* the number of keywords, and the base index of the keywords 
+ * the number is irrelevant but BASEKEYWORD is used */
+#define NKEYWORDS	3+19+13+14+11+5+2+7+7+6+12+3+9
+#define BASEKEYWORD -121
+
+/*
+ *	Interpreter states 
+ *	SRUN means running from a programm
+ *	SINT means interactive mode
+ *	SERUN means running directly from EEPROM
+ *		(enum would be the right way of doing this.)
+ *	BREAKCHAR is the character stopping the program on Ardunios
+ *  BREAKPIN can be set, it is a pin that needs to go to low to stop a BASIC program
+ *    This should be done in hardware*.h
+ *  BREAKSIGNAL can also be set, should be done in hardware*.h
+ */
+#define SINT 0
+#define SRUN 1
+#define SERUN 2
+#define BREAKCHAR '#'
+
+/* 
+ *	Input and output channels
+ */
+#define OSERIAL 1
+#define ODSP 2
+#define OPRT 4
+#define OWIRE 7
+#define ORADIO 8
+#define OMQTT  9
+#define OFILE 16
+
+#define ISERIAL 1
+#define IKEYBOARD 2
+#define ISERIAL1 4
+#define IWIRE 7
+#define IRADIO 8
+#define IMQTT  9
+#define IFILE 16
+
+/*
+ *	All BASIC keywords for the tokens
+ */
+const char sge[]   PROGMEM = "=>";
+const char sle[]   PROGMEM = "<=";
+const char sne[]   PROGMEM = "<>";
+/* Palo Alto language set */
+const char sprint[]  PROGMEM = "PRINT";
+const char slet[]    PROGMEM = "LET";
+const char sinput[]  PROGMEM = "INPUT";
+const char sgoto[]   PROGMEM = "GOTO";
+const char sgosub[]  PROGMEM = "GOSUB";
+const char sreturn[] PROGMEM = "RETURN";
+const char sif[]     PROGMEM = "IF";
+const char sfor[]    PROGMEM = "FOR";
+const char sto[]     PROGMEM = "TO";
+const char sstep[]   PROGMEM = "STEP";
+const char snext[]   PROGMEM = "NEXT";
+const char sstop[]   PROGMEM = "STOP";
+const char slist[]   PROGMEM = "LIST";
+const char snew[]    PROGMEM = "NEW";
+const char srun[]  	 PROGMEM = "RUN";
+const char sabs[]    PROGMEM = "ABS";
+const char srnd[]    PROGMEM = "RND";
+const char ssize[]   PROGMEM = "SIZE";
+const char srem[]    PROGMEM = "REM";
+/* Apple 1 language set */
+#ifdef HASAPPLE1
+const char snot[]    PROGMEM = "NOT";
+const char sand[]    PROGMEM = "AND";
+const char sor[]     PROGMEM = "OR";
+const char slen[]    PROGMEM = "LEN";
+const char ssgn[]    PROGMEM = "SGN";
+const char speek[]   PROGMEM = "PEEK";
+const char sdim[]    PROGMEM = "DIM";
+const char sclr[]    PROGMEM = "CLR";
+const char shimem[]  PROGMEM = "HIMEM";
+const char stab[]    PROGMEM = "TAB";
+const char sthen[]   PROGMEM = "THEN";
+const char sbend[]   PROGMEM = "END";
+const char spoke[]   PROGMEM = "POKE";
+#endif
+/* Stefan's basic additions */
+#ifdef HASSTEFANSEXT
+const char scont[]   PROGMEM = "CONT";
+const char ssqr[]    PROGMEM = "SQR";
+const char spow[]    PROGMEM = "POW";
+const char smap[]    PROGMEM = "MAP";
+const char sdump[]   PROGMEM = "DUMP";
+const char sbreak[]  PROGMEM = "BREAK";
+#endif
+/* LOAD and SAVE is always there */
+const char ssave[]   PROGMEM = "SAVE";
+const char sload[]   PROGMEM = "LOAD";
+#ifdef HASSTEFANSEXT
+const char sget[]    PROGMEM = "GET";
+const char sput[]    PROGMEM = "PUT";
+const char sset[]    PROGMEM = "SET";
+const char scls[]    PROGMEM = "CLS";
+const char slocate[]  PROGMEM  = "LOCATE";
+const char selse[]  PROGMEM  = "ELSE";
+#endif
+/* Arduino functions */
+#ifdef HASARDUINOIO
+const char spinm[]    PROGMEM = "PINM";
+const char sdwrite[]  PROGMEM = "DWRITE";
+const char sdread[]   PROGMEM = "DREAD";
+const char sawrite[]  PROGMEM = "AWRITE";
+const char saread[]   PROGMEM = "AREAD";
+const char sdelay[]   PROGMEM = "DELAY";
+const char smillis[]	PROGMEM = "MILLIS";
+const char sazero[]	PROGMEM = "AZERO";
+const char sled[]	PROGMEM = "LED";
+#endif
+#ifdef HASTONE
+const char stone[]    PROGMEM = "PLAY";
+#endif
+#ifdef HASPULSE
+const char spulse[] PROGMEM = "PULSE";
+#endif
+/* DOS functions */
+#ifdef HASFILEIO
+const char scatalog[] PROGMEM = "CATALOG";
+const char sdelete[]  PROGMEM = "DELETE";
+const char sfopen[]   PROGMEM = "OPEN";
+const char sfclose[]  PROGMEM = "CLOSE";
+const char sfdisk[]   PROGMEM = "FDISK";
+#endif
+/* low level access functions */
+#ifdef HASSTEFANSEXT
+const char susr[]   PROGMEM = "USR";
+const char scall[]  PROGMEM = "CALL";
+#endif
+/* mathematics */
+#ifdef HASFLOAT
+const char ssin[]   PROGMEM = "SIN";
+const char scos[]   PROGMEM = "COS";
+const char stan[]   PROGMEM = "TAN";
+const char satan[]  PROGMEM = "ATAN";
+const char slog[]   PROGMEM = "LOG";
+const char sexp[]   PROGMEM = "EXP";
+#endif
+/* INT is always needed to make float/int programs compatible */
+const char sint[]   PROGMEM = "INT"; 
+/* elemetars graphics */
+#ifdef HASGRAPH
+const char scolor[]     PROGMEM  = "COLOR";
+const char splot[]      PROGMEM  = "PLOT";
+const char sline[]      PROGMEM  = "LINE";
+const char scircle[]    PROGMEM  = "CIRCLE";
+const char srect[]      PROGMEM  = "RECT";
+const char sfcircle[]   PROGMEM  = "FCIRCLE";
+const char sfrect[]     PROGMEM  = "FRECT";
+#endif
+/* Dartmouth BASIC extensions */
+#ifdef HASDARTMOUTH
+const char sdata[]      PROGMEM  = "DATA";
+const char sread[]      PROGMEM  = "READ";
+const char srestore[]   PROGMEM  = "RESTORE";
+const char sdef[]       PROGMEM  = "DEF";
+const char sfn[]        PROGMEM  = "FN";
+const char son[]        PROGMEM  = "ON";
+#endif
+/* The Darkarts commands unthinkable in Dartmouth */
+#ifdef HASDARKARTS
+const char smalloc[]	PROGMEM  = "MALLOC";
+const char sfind[]		PROGMEM  = "FIND";
+const char seval[]		PROGMEM  = "EVAL";
+#endif
+/* complex error handling */
+#ifdef HASERRORHANDLING
+const char serror[]     PROGMEM  = "ERROR";
+#endif
+/* iot extensions */
+#ifdef HASIOT
+const char savail[]		PROGMEM  = "AVAIL";
+const char sstr[]		PROGMEM  = "STR";
+const char sinstr[]		PROGMEM  = "INSTR";
+const char sval[]		PROGMEM  = "VAL";
+const char snetstat[]	PROGMEM  = "NETSTAT";
+const char ssensor[]	PROGMEM  = "SENSOR";
+const char swire[]		PROGMEM  = "WIRE";
+const char ssleep[]		PROGMEM  = "SLEEP";
+#endif
+/* events and interrupts */
+#ifdef HASTIMER
+const char safter[]     PROGMEM  = "AFTER";
+const char severy[]     PROGMEM  = "EVERY";
+#endif
+#ifdef HASEVENTS
+const char sevent[]     PROGMEM  = "EVENT";
+#endif
+#ifdef HASSTRUCT
+const char swhile[]		PROGMEM	= "WHILE";
+const char swend[]      PROGMEM = "WEND";
+const char srepeat[]	PROGMEM	= "REPEAT";
+const char suntil[]     PROGMEM	= "UNTIL";
+const char sswitch[]	PROGMEM	= "SWITCH";
+const char scase[]		PROGMEM	= "CASE";
+const char sswend[]     PROGMEM = "SWEND";
+const char sdo[]        PROGMEM = "DO";
+const char sdend[]      PROGMEM = "DEND";
+#endif
+
+
+/* zero terminated keyword storage */
+const char* const keyword[] PROGMEM = {
+	sge, sle, sne, sprint, slet, sinput, 
+	sgoto, sgosub, sreturn, sif, sfor, sto,
+	sstep, snext, sstop, slist, snew, srun,
+	sabs, srnd, ssize, srem,
+#ifdef HASAPPLE1
+	snot, sand, sor, slen, ssgn, speek, sdim,
+	sclr, shimem, stab, sthen, 
+	sbend, spoke,
+#endif
+#ifdef HASSTEFANSEXT
+	scont, ssqr, spow, smap, sdump, sbreak, 
+#endif
+	ssave, sload, 
+#ifdef HASSTEFANSEXT
+	sget, sput, sset, scls, slocate, selse,
+#endif
+#ifdef HASARDUINOIO
+    spinm, sdwrite, sdread, sawrite, saread, 
+    sdelay, smillis, sazero, sled,
+#endif
+#ifdef HASTONE
+	stone,
+#endif
+#ifdef HASPULSE
+	spulse,
+#endif
+#ifdef HASFILEIO
+    scatalog, sdelete, sfopen, sfclose, sfdisk,
+#endif
+#ifdef HASSTEFANSEXT
+    susr, scall,
+#endif
+#ifdef HASFLOAT
+    ssin, scos, stan, satan, slog, sexp,
+#endif
+    sint,
+#ifdef HASGRAPH
+    scolor, splot, sline, scircle, srect, 
+    sfcircle, sfrect,
+#endif
+#ifdef HASDARTMOUTH
+	sdata, sread, srestore, sdef, sfn, son,
+#endif
+#ifdef HASDARKARTS
+	smalloc, sfind, seval, 
+#endif
+/* complex error handling */
+#ifdef HASERRORHANDLING
+    serror,
+#endif
+#ifdef HASIOT
+	savail, sstr, sinstr, sval, 
+	snetstat, ssensor, swire, ssleep, 
+#endif
+#ifdef HASTIMER
+    safter, severy,
+#endif
+#ifdef HASEVENTS
+    sevent,
+#endif
+#ifdef HASSTRUCT
+	swhile, swend, srepeat, suntil, sswitch, scase, sswend,	
+    sdo, sdend, 
+#endif 
+	0
+};
+
+/* the zero terminated token dictonary needed for scalability */
+const signed char tokens[] PROGMEM = {
+	GREATEREQUAL, LESSEREQUAL, NOTEQUAL, TPRINT, TLET,    
+    TINPUT, TGOTO, TGOSUB, TRETURN, TIF, TFOR, TTO, TSTEP,
+    TNEXT, TSTOP, TLIST, TNEW, TRUN, TABS, TRND, TSIZE, TREM,
+#ifdef HASAPPLE1
+    TNOT, TAND, TOR, TLEN, TSGN, TPEEK, TDIM, TCLR,
+    THIMEM, TTAB, TTHEN, TEND, TPOKE,
+#endif
+#ifdef HASSTEFANSEXT
+	TCONT, TSQR, TPOW, TMAP, TDUMP, TBREAK, 
+#endif
+	TSAVE, TLOAD, 
+#ifdef HASSTEFANSEXT	
+	TGET, TPUT, TSET, TCLS, TLOCATE, TELSE,
+#endif
+#ifdef HASARDUINOIO
+	TPINM, TDWRITE, TDREAD, TAWRITE, TAREAD, TDELAY, TMILLIS,
+	TAZERO, TLED,
+#endif
+#ifdef HASTONE
+	TTONE, 
+#endif
+#ifdef HASPULSE
+	TPULSE, 
+#endif
+#ifdef HASFILEIO
+	TCATALOG, TDELETE, TOPEN, TCLOSE, TFDISK,
+#endif
+#ifdef HASSTEFANSEXT
+	TUSR, TCALL,
+#endif
+#ifdef HASFLOAT
+	TSIN, TCOS, TTAN, TATAN, TLOG, TEXP,
+#endif
+	TINT,
+#ifdef HASGRAPH
+	TCOLOR, TPLOT, TLINE, TCIRCLE, TRECT, 
+	TFCIRCLE, TFRECT,
+#endif
+#ifdef HASDARTMOUTH
+	TDATA, TREAD, TRESTORE, TDEF, TFN, TON, 
+#endif
+#ifdef HASDARKARTS
+	TMALLOC, TFIND, TEVAL, 
+#endif
+#ifdef HASERRORHANDLING
+    TERROR, 
+#endif
+#ifdef HASIOT
+	TAVAIL, TSTR, TINSTR, TVAL, TNETSTAT,
+	TSENSOR, TWIRE, TSLEEP,
+#endif
+#ifdef HASTIMER
+    TAFTER, TEVERY,
+#endif
+#ifdef HASEVENTS
+    TEVENT, 
+#endif
+#ifdef HASSTRUCT
+	TWHILE, TWEND, TREPEAT, TUNTIL, TSWITCH, TCASE, TSWEND,
+    TDO, TDEND, 
+#endif
+	0
+};
+
+/*
+ *	the message catalog
+ */
+#define MFILE		0
+#define MPROMPT		1
+#define MGREET		2
+#define MLINE		3
+#define MNUMBER		4
+#define MVARIABLE	5
+#define MARRAY		6
+#define MSTRING		7
+#define MSTRINGVAR	8
+#define EGENERAL 	 9
+#define EUNKNOWN	 10
+#define ENUMBER      11
+#define EDIVIDE		 12
+#define ELINE        13
+#define EOUTOFMEMORY 14
+#define ESTACK 		 15
+#define EORANGE 	 16
+#define ESTRING      17
+#define EVARIABLE	 18
+#define ELOOP        19
+#define EFILE 		 20
+#define EFUN 		 21
+#define EARGS       22
+#define EEEPROM	    23
+#define ESDCARD     24
+
+const char mfile[]    	PROGMEM = "file.bas";
+const char mprompt[]	PROGMEM = "> ";
+const char mgreet[]		PROGMEM = "Stefan's Basic 1.4";
+const char mline[]		PROGMEM = "LINE";
+const char mnumber[]	PROGMEM = "NUMBER";
+const char mvariable[]	PROGMEM = "VARIABLE";
+const char marray[]		PROGMEM = "ARRAY";
+const char mstring[]	PROGMEM = "STRING";
+const char mstringv[]	PROGMEM = "STRINGVAR";
+const char egeneral[]  	PROGMEM = "Error";
+#ifdef HASERRORMSG
+const char eunknown[]  	PROGMEM = "Syntax";
+const char enumber[]	PROGMEM = "Number";
+const char edivide[]  	PROGMEM = "Div by 0";
+const char eline[]  	PROGMEM = "Unknown Line";
+const char emem[]  	   	PROGMEM = "Memory";
+const char estack[]    	PROGMEM = "Stack";
+const char erange[]  	PROGMEM = "Range";
+const char estring[]	PROGMEM = "String";
+const char evariable[]  PROGMEM = "Variable";
+const char eloop[]      PROGMEM = "Loop";
+const char efile[]  	PROGMEM = "File";
+const char efun[] 	 	PROGMEM = "Function";
+const char eargs[]  	PROGMEM = "Args";
+const char eeeprom[]	PROGMEM = "EEPROM";
+const char esdcard[]	PROGMEM = "SD card";
+#endif
+
+const char* const message[] PROGMEM = {
+	mfile, mprompt, mgreet, 
+	mline, mnumber, mvariable, marray, 
+	mstring, mstringv,
+	egeneral
+#ifdef HASERRORMSG
+	, eunknown, enumber, edivide, eline, 
+	emem, estack, erange,
+	estring, evariable, eloop, efile, efun, eargs, 
+	eeeprom, esdcard
+#endif
+};
+
+/*
+ *	code for variable numbers and addresses sizes
+ *	the original code was 16 bit but can be extended here
+ * 	to arbitrary types 
+ *
+ *	number_t is the type for numerical work - either float or int
+ *  wnumber_t is the type containing the largest printable integer, 
+ *    for float keep this int on 32 bit and long on 8 bit unless you 
+ *    want to use very long integers, like 64 or 128 bit types. 
+ *  address_t is an unsigned type adddressing memory, default 16bit 
+ *  mem_t is a SIGNED 8bit character type.
+ *	index_t is a SIGNED minimum 16 bit integer type
+ *
+ *	works with the tacit assumption that 
+ *	sizeof(number_t) >= sizeof(address_t) 
+ *	and that the entire memory is smaller than the positive
+ * 	part of number type (!!)
+ *
+ *	we assume that float >= 4 bytes in the following
+ *
+ *	maxnum: the maximum accurate(!) integer of a 
+ *		32 bit float 
+ *	strindexsize: the index size of strings either 
+ *		1 byte or 2 bytes - no other values supported
+ */
+#ifdef HASFLOAT
+typedef float number_t;
+const number_t maxnum=16777216; 
+typedef long wnumber_t;
+#else
+typedef int number_t;
+typedef int wnumber_t;
+const number_t maxnum=(number_t)~((number_t)1<<(sizeof(number_t)*8-1));
+#endif
+typedef unsigned short address_t; /* this type addresses memory */
+const int numsize=sizeof(number_t);
+const int addrsize=sizeof(address_t);
+const int eheadersize=sizeof(address_t)+1;
+const int strindexsize=2; /* default in the meantime, strings up to unsigned 16 bit length */
+const address_t maxaddr=(address_t)(~0); 
+typedef signed char mem_t; /* a signed 8 bit type for the memory */
+typedef int index_t; /* this type counts at least 16 bit */
+#ifndef HASLONGTOKENS
+typedef signed char token_t; /* the type of tokens, normally mem_t with a maximum of 127 commands and data types */
+#else
+typedef short token_t; /* token type extension, allows an extra of 127 commands and symbols */
+#endif
+
+/* this type maps numbers to bytes */
+typedef struct {mem_t l; mem_t h;} twobytes_t;
+typedef union { number_t i; address_t a; twobytes_t b; mem_t c[sizeof(number_t)]; } accu_t;
+
+/* the memreader function type */
+typedef mem_t (*memreader_t)(address_t);
+
+/* 
+ * system type identifiers
+ */
+
+#define SYSTYPE_UNKNOWN	0
+#define SYSTYPE_AVR 	1
+#define SYSTYPE_ESP8266 2
+#define SYSTYPE_ESP32	3
+#define SYSTYPE_RP2040  4
+#define SYSTYPE_SAM     5
+#define SYSTYPE_XMC		6
+#define SYSTYPE_SMT32	7
+#define SYSTYPE_NRENESA 8
+#define SYSTYPE_POSIX	32
+#define SYSTYPE_MSDOS	33
+#define SYSTYPE_MINGW   34
+#define SYSTYPE_RASPPI  35
+
+/*
+ *	The basic interpreter is implemented as a stack machine
+ *	with global variable for the interpreter state, the memory
+ *	and the arithmetic during run time.
+ */
+
+/* the stack, all BASIC arithmetic is done here */
+number_t stack[STACKSIZE];
+address_t sp=0; 
+
+/* a small buffer to process string arguments, mostly used for Arduino PROGMEM */
+char sbuffer[SBUFSIZE];
+
+/* the input buffer, the lexer can tokenize this and run from it, bi is an index to this.
+   bi must be global as it is the program cursor in interactive mode */
+char ibuffer[BUFSIZE] = "\0";
+char *bi;
+
+/* a static array of variables A-Z for the small systems that have no heap */
+number_t vars[VARSIZE];
+
+/* the BASIC working memory, either malloced or allocated as a global array */
+#if MEMSIZE != 0
+mem_t mem[MEMSIZE];
+#else
+mem_t* mem;
+#endif
+address_t himem, memsize;
+
+/* the for stack - remembers the variable, indices, and optionally a type for stuctured BASIC */
+struct forstackitem {mem_t varx; mem_t vary; address_t here; number_t to; number_t step; 
+#ifdef HASSTRUCT
+mem_t type;
+#endif
+} forstack[FORDEPTH];
+index_t forsp = 0;
+ 
+/* the GOSUB stack remembers an address to jump to */
+address_t gosubstack[GOSUBDEPTH];
+index_t gosubsp = 0;
+
+/* this variable stores the location in pushlocation() and poplocation(), used to rewind the program cursor */
+address_t slocation;
+
+/* arithmetic accumulators - used by many statements, y may be obsolete in future*/
+number_t x, y;
+
+/* the names of a variable and small integer accumulator */
+mem_t xc, yc;
+
+/* an address accumulator, used a lot in string operations */
+address_t ax;
+
+/* z is another accumulator used to convert numbers and addressed to bytes and vice versa */
+/* this union is used to store larger objects into byte oriented memory */
+accu_t z;
+
+/* string index registers */
+char *ir, *ir2;
+
+/* the active token */
+token_t token;
+
+/* the curent error, can be a token, hance token type */
+token_t er;
+
+/* a trapable error */
+mem_t ert;
+
+/* the interpreter state, interactive, run or run from EEPROM */
+mem_t st; 
+
+/* the current program location or "cursor" */
+address_t here; 
+
+/* the topmost byte of a program in memory, beginning of free BASIC RAM */
+address_t top;
+
+/* the number of variables on the heap */
+address_t nvars = 0; 
+
+/* used to format output with # */
+mem_t form = 0;
+
+/* counts the outputed characters on streams 0-3, used to emulate a real tab */
+#ifdef HASMSTAB
+mem_t charcount[3]; /* devices 1-4 support tabing */
+mem_t reltab = 0;
+#endif
+
+/* the lower limit of the array is one by default, can be a variable */
+#ifdef HASARRAYLIMIT
+address_t arraylimit = 1;
+#else 
+const address_t arraylimit = 1;
+#endif
+
+/* the number of arguments parsed from a command */
+mem_t args;
+
+/* the random number seed, this is unsigned hence address_t */
+#ifndef HASFLOAT
+address_t rd;
+#else 
+unsigned long rd;
+#endif
+
+/* output and input channels, used to direct output to various devices */
+mem_t id;
+mem_t od;
+
+/* default IO - not constant, can be changed at runtime through a user call */
+mem_t idd = ISERIAL;
+mem_t odd = OSERIAL;
+
+/* the runtime debuglevel */
+mem_t debuglevel = 0;
+
+/* DATA pointer, where is the current READ statement  */
+#ifdef HASDARTMOUTH
+address_t data = 0;
+address_t datarc = 1;
+#endif
+    
+/* 
+ * process command line arguments in the POSIX world 
+ * bnointafterrun is a flag to remember if called as command
+ * line argument, in this case we don't return to interactive 
+ */
+#ifndef ARDUINO
+int bargc;
+char** bargv;
+mem_t bnointafterrun = 0;
+#endif
+
+/*
+ * Yield counter, we count when we did yield the last time
+ *	lastyield controlls the client loops of network functions 
+ *	like mqtt, scanned keyboard, and USB.
+ *
+ *	lastlongyield controls longterm functions like DHCP lease 
+ *	renewal in Ethernet 
+ * 
+ * there variables are only needed if the platform has background 
+ *  tasks
+ */
+long lastyield=0;
+long lastlongyield=0;
+
+/* formaters lastouttoken and spaceafterkeyword to make a nice LIST */
+mem_t lastouttoken;
+mem_t spaceafterkeyword;
+mem_t outliteral = 0;
+mem_t lexliteral = 0; 
+
+/* 
+ * the cache for the heap search - helps the string code 
+ * the last found object on the heap is remembered. This is needed
+ * because the string code sometime searches the heap twice during the 
+ * same operation. 
+ */
+#ifdef HASAPPLE1
+mem_t bfindc, bfindd, bfindt;
+address_t bfinda, bfindz;
+#endif
+
+/*
+ * a variable for some string operations 
+ */
+int vlength;
+
+/* the timer code - very simple needs to to to a struct */
+/* timer type */
+typedef struct {
+    mem_t enabled;
+    unsigned long last;
+    unsigned long interval; 
+    mem_t type;
+    address_t linenumber;
+} btimer_t;
+
+#ifdef HASTIMER
+btimer_t after_timer = {0, 0, 0, 0, 0};
+btimer_t every_timer = {0, 0, 0, 0, 0};
+#endif
+
+/* the event code */
+#ifdef HASEVENTS
+
+#define EVENTLISTSIZE 4
+
+/* event type */
+typedef struct {
+    mem_t enabled;
+    mem_t pin;
+    mem_t mode; 
+    mem_t type;
+    address_t linenumber;
+    mem_t active;
+} bevent_t;
+
+/* the event list */
+int nevents = 0;
+int ievent = 0;
+static mem_t events_enabled = 1;
+static volatile bevent_t eventlist[EVENTLISTSIZE];
+
+/* the extension of the GOSUB stack */
+static mem_t gosubarg[GOSUBDEPTH];
+
+/* handle the event list */
+mem_t addevent(mem_t, mem_t, mem_t, address_t);
+void deleteevent(mem_t);
+volatile bevent_t* findevent(mem_t);
+mem_t eventindex(mem_t);
+#endif
+
+#ifdef HASERRORHANDLING
+/* the error handler type, very simple for now */
+typedef struct {
+    mem_t type;
+    address_t linenumber;
+} berrorh_t;
+
+berrorh_t berrorh = {0 , 0};
+mem_t erh = 0;
+#endif
+
+/* the string for real time clocks */
+char rtcstring[20] = { 0 }; 
+
+/* the units pulse operates on, in microseconds*/
+short bpulseunit = 10; 
+
+/* only needed for POSIXNONBLOCKING */
+mem_t breakcondition = 0;
+
+/* 
+ * Function prototypes, ordered by layers
+ * HAL - hardware abstraction
+ * Layer 0 - memory and I/O
+ * Layer 1 - Program storage and control
+ * Layer 2 - Where stuff happens
+ */
+
+/*
+ *	HAL - see hardware-*.h
+ *  This is the hardware abstraction layer of the BASIC
+ *	interpreter 
+ */
+
+/* setup codes */
+void timeinit();
+void wiringbegin();
+
+/* low level mem and hardware features */
+long freeRam();
+long freememorysize();
+void restartsystem();
+void activatesleep(long t);
+
+/* start the spi bus */
+void spibegin();
+
+/* 
+ * the hardware interface display driver functions, need to be 
+ * 	implemented for the display driver to work 
+ *	dspupdate() only for display like Epapers
+ */
+void dspbegin();
+void dspprintchar(char, mem_t, mem_t);
+void dspclear();
+void dspupdate();
+
+/* keyboard code */
+void kbdbegin();
+int kbdstat(char);
+char kbdavailable();
+char kbdread();
+char kbdcheckch();
+
+/* graphics functions */
+void rgbcolor(int, int, int);
+void vgacolor(short c);
+void vgascale(int*, int*);
+void plot(int, int);
+void line(int, int, int, int);  
+void rect(int, int, int, int);
+void frect(int, int, int, int);
+void circle(int, int, int);
+void fcircle(int, int, int);
+
+/* text output to a VGA display */
+void vgabegin();
+int vgastat(char);
+void vgawrite(char);
+
+/* generic display code */
+void dspwrite(char);
+void dspbegin();
+int dspstat(char);
+char dspwaitonscroll();
+char dspactive();
+void dspsetupdatemode(char);
+char dspgetupdatemode();
+void dspgraphupdate();
+void dspsetscrollmode(char, short);
+void dspsetcursor(short, short);
+void dspbufferclear();
+void dspscroll(mem_t, mem_t);
+void dspreversescroll(mem_t);
+void dspvt52(char *);
+
+/* real time clock */
+char* rtcmkstr();
+void rtcset(uint8_t, short);
+short rtcget(short); 
+
+/* network and mqtt functions */
+void netbegin();
+char netconnected();
+void mqttsetname();
+void mqttbegin();
+int mqttstat(char);
+int  mqttstate();
+void mqttsubscribe(char*);
+void mqttsettopic(char*);
+void mqttouts(char *, short);
+void mqttins(char *, short);
+char mqttinch();
+
+/* low level EEPROM handling */
+void ebegin();
+void eflush();
+address_t elength();
+mem_t eread(address_t);
+void eupdate(address_t, mem_t);
+
+/* arduino io functions */
+void aread();
+void dread();
+void awrite(address_t, address_t);
+void dwrite(address_t, address_t);
+void pinm(address_t, address_t);
+void bmillis();
+void bpulsein();
+void xpulse();
+void bpulseout(short);
+void btone(short);
+
+/* timing control for ESP and network */
+void byield();
+void bdelay(unsigned long);
+void fastticker();
+void yieldfunction();
+void longyieldfunction();
+
+/* the file interface */
+char* mkfilename(const char*);
+const char* rmrootfsprefix(const char*);
+void fsbegin(char);
+int fsstat(char);
+void filewrite(char);
+char fileread();
+char ifileopen(const char*);
+void ifileclose();
+char ofileopen(char*, const char*);
+void ofileclose();
+int fileavailable();
+void rootopen();
+int rootnextfile();
+int rootisfile();
+const char* rootfilename();
+long rootfilesize();
+void rootfileclose();
+void rootclose();
+void removefile(char*);
+void formatdisk(short);
+
+/* low level serial code */
+void picogetchar(char);
+void picowrite(char);
+void picobegin(unsigned long);
+void picoins(char, short);
+void serialbegin();
+int serialstat(char);
+char serialread();
+void serialwrite(char);
+short serialcheckch();
+short serialavailable();
+void serialflush();
+void consins(char*, short);
+void prtbegin();
+int prtstat(char);
+void prtset(int);
+char prtopen(char *, int);
+void prtclose();
+char prtread();
+void prtwrite(char);
+short prtcheckch();
+short prtavailable();
+
+/* generic wire access */
+void wirebegin();
+int wirestat(char);
+void wireopen(char, char);
+void wireins(char*, uint8_t);
+void wireouts(char*, uint8_t);
+short wireavailable();
+short wirereadbyte(short);
+void  wirewritebyte(short, short);
+
+/* RF24 radio input */
+int radiostat(char);
+void radioset(int);
+#ifdef ARDUINO 
+uint64_t pipeaddr(char*);
+#else
+long pipeaddr(char*);
+#endif
+void iradioopen(char*);
+void oradioopen(char*);
+void radioins(char*, short);
+void radioouts(char* , short);
+short radioavailable();
+
+/* sensor control */
+void sensorbegin();
+number_t sensorread(short, short);
+
+/* SPI RAM code */
+address_t spirambegin();
+void spiramrawwrite(address_t, mem_t);
+mem_t spiramrawread(address_t );
+
+/*
+ * Layer 0 functions - I/O and memory management 
+ */
+
+/* make room for BASIC */
+address_t ballocmem(); 
+
+/* handle files im EEPROM */
+void eload();
+void esave();
+char autorun();
+
+/* the variable heap from Apple 1 BASIC */
+address_t bmalloc(mem_t, mem_t, mem_t, address_t);
+address_t bfind(mem_t, mem_t, mem_t);
+address_t bfree(mem_t, mem_t, mem_t);
+address_t blength (mem_t, mem_t, mem_t);
+
+/* normal variables of number_t */
+number_t getvar(mem_t, mem_t);
+void setvar(mem_t, mem_t, number_t);
+void clrvars();
+
+/*	low level memory access packing n*8bit bit into n 8 bit objects
+	e* is for Arduino EEPROM */
+void getnumber(address_t, mem_t);
+void setnumber(address_t, mem_t);
+void egetnumber(address_t, mem_t);
+void esetnumber(address_t, mem_t);
+void pgetnumber(address_t, mem_t);
+
+/* array and string handling */
+/* the multidim extension is experimental, here only 2 array dimensions implemented as test */
+address_t createarray(mem_t, mem_t, address_t, address_t);
+void array(mem_t, mem_t, mem_t, address_t, address_t, number_t*);
+address_t createstring(char, char, address_t, address_t);
+char* getstring(char, char, address_t, address_t);
+number_t arraydim(char, char);
+address_t stringdim(char, char);
+address_t lenstring(char, char, address_t);
+void setstringlength(char, char, address_t, address_t);
+void setstring(char, char, address_t, char *, address_t, address_t);
+
+/* the user defined extension functions */
+number_t getusrvar();
+void setusrvar(number_t);
+number_t getusrarray(address_t);
+void setusrarray(address_t, number_t);
+void makeusrstring();
+number_t usrfunction(address_t, number_t);
+void usrcall(address_t);
+
+/* get keywords and tokens from PROGMEM */
+char* getkeyword(unsigned short);
+char* getmessage(char);
+signed char gettokenvalue(char);
+void printmessage(char);
+
+/* error handling */
+void error(token_t);
+void reseterror();
+void debugtoken();
+void bdebug(const char*);
+
+/* the arithemtic stack */
+void push(number_t);
+number_t pop();
+address_t popaddress();
+void drop();
+void clearst();
+
+/* READ DATA handling */
+void clrdata();
+
+/* FOR NEXT GOSUB stacks */
+void pushforstack();
+void popforstack();
+void dropforstack();
+void clrforstack();
+void pushgosubstack(mem_t);
+void popgosubstack();
+void dropgosubstack();
+void clrgosubstack();
+
+/* general I/O initialisation */
+void ioinit();
+void iodefaults();
+
+/* signal handling */
+void signalon();
+void signaloff();
+void signalhandler(int);
+
+/* character and string I/O functions */
+/* we live in world where char may be signed or unsigned and keep it 
+    that way on the lowest level, hence this function, fully defined here, 
+    mostly inlined anyway*/
+int cheof(int c) { if ((c == -1) || (c == 255)) return 1; else return 0; }
+/* input */
+char inch();
+char checkch();
+short availch();
+void inb(char*, index_t);
+void ins(char*, address_t); 
+
+/* output */
+void outch(char);
+void outcr();
+void outspc();
+void outs(char*, address_t);
+void outsc(const char*);
+void outscf(const char *, index_t);
+
+/* I/O of number_t - floats and integers */
+address_t parsenumber(char*, number_t*);
+address_t parsenumber2(char*, number_t*);
+address_t writenumber(char*, wnumber_t); 
+address_t writenumber2(char*, number_t);
+address_t tinydtostrf(number_t, index_t, char*);
+char innumber(number_t*);
+void outnumber(number_t);
+
+/* 	
+ * Layer 1 functions, provide data and do the heavy lifting 
+ * for layer 2 including lexical analysis, storing programs 
+ * and expression evaluation 
+ */
+
+/* lexical analysis */
+void whitespaces();
+void nexttoken();
+
+/* storing and retrieving programs */
+char nomemory(number_t);
+void storetoken(); 
+mem_t memread(address_t);
+mem_t memread2(address_t);
+void memwrite2(address_t, mem_t);
+void gettoken();
+void firstline();
+void nextline();
+
+void clrlinecache();
+void addlinecache(address_t, address_t);
+address_t findinlinecache(address_t);
+void findline(address_t);
+address_t myline(address_t);
+void moveblock(address_t, address_t, address_t);
+void zeroblock(address_t, address_t);
+void diag();
+void storeline();
+
+/* read arguments from the token stream and process them */
+char termsymbol();
+char expect(token_t, mem_t);
+char expectexpr();
+void parsearguments();
+void parsenarguments(char);
+void parsesubscripts();
+void parsefunction(void (*)(), short);
+void parseoperator(void (*)());
+void parsesubstring();
+
+/* mathematics and other functions for int and float */
+void xabs();
+void xsgn();
+void xpeek();
+void xmap();
+void rnd();
+void sqr();
+void xpow();
+number_t bpow(number_t, number_t);
+
+/* string values and string evaluation */
+char stringvalue();
+void streval();
+
+/* floating point functions */
+void xsin();
+void xcos();
+void xtan();
+void xatan();
+void xlog();
+void xexp();
+void xint();
+
+/* expression evaluation */
+void factor();
+void term();
+void addexpression();
+void compexpression();
+void notexpression();
+void andexpression();
+void expression();
+
+/* 
+ * Layer 2 - statements and functions 
+ * use the global variables 
+ */
+
+/* basic commands of the core language set */
+void xprint();
+void lefthandside(address_t*, address_t*, address_t*, mem_t*);
+void assignnumber(signed char, char, char, address_t, address_t, char);
+void assignment();
+void showprompt();
+void xinput();
+void xgoto();
+void xreturn();
+void xif();
+
+/* FOR NEXT loops */
+void findnextcmd();
+void findbraket(token_t, token_t);
+void xfor();
+void xbreak();
+void xcont();
+void xnext();
+
+/* WHILE WEND*/
+void xwhile();
+void xwend();
+
+/* REPEAT UNTIL */
+void xrepeat();
+void xuntil();
+
+/* control commands and misc */
+void outputtoken();
+void xlist();
+void xrun();
+void xnew();
+void xrem();
+void xclr();
+void xdim();
+void xpoke();
+void xtab();
+void xdump();
+void dumpmem(address_t, address_t, char);
+void xlocate();
+
+/* file access and other i/o */
+void stringtobuffer(char*);
+void getfilename(char*, char);
+void xsave();
+void xload(const char*);
+void xget();
+void xput();
+void xset();
+void xnetstat();
+
+/* Arduino IO control interface */
+void xdwrite();
+void xawrite();
+void xpinm();
+void xdelay();
+void xtone();
+
+/* graphics commands */
+void xcolor();
+void xplot();
+void xline();
+void xrect();
+void xcircle();
+void xfrect();
+void xfcircle();
+
+/* the darkarts */
+void xmalloc();
+void xfind();
+void xeval();
+
+/* IoT commands */
+void xassign();
+void xavail();
+void xfsensor();
+void xsleep();
+void xwire();
+void xfwire();
+
+/* timers */
+void xafter();
+void xevent();
+
+/* File I/O functions */
+char streq(const char*, char*);
+void xcatalog();
+void xdelete();
+void xopen();
+void xfopen();
+void xclose();
+void xfdisk();
+
+/* low level access functions */
+void xcall();
+void xusr();
+
+/* the dartmouth stuff */
+void xdata();
+void nextdatarecord();
+void xread();
+void xrestore();
+void xdef();
+void xfn();
+void xon();
+
+/* timers and interrupts */
+void xtimer();
+void resettimer(btimer_t*);
+
+/* structured BASIC extensions */
+void xwhile();
+void xwend(); 
+void xrepeat();
+void xuntil();
+void xswitch();
+void xcase();
+void xendswitch();
+
+/* the emulation of tone using the byield loop */
+void toggletone();
+void playtone(int, int, int);
+
+/* the statement loop */
+void statement();
+
+/* the extension functions */
+void bsetup();
+void bloop();
+

data/Basic1/TinybasicArduino/wifisettings.h

@@ -0,0 +1,5 @@
+const char* ssid = "daheim-iot";
+const char* password = "xacobeo7";
+const char* mqtt_server = "test.mosquitto.org";
+const short mqtt_port = 1883;
+byte mac[] = {0xDE, 0xAD, 0xBE, 0xE9, 0xE9, 0xE9};

data/Basic1/basic.h

@@ -0,0 +1,1526 @@
+/*
+ *
+ *	$Id: basic.h,v 1.13 2023/07/16 14:17:08 stefan Exp stefan $
+ *
+ *	Stefan's basic interpreter 
+ *
+ *	Playing around with frugal programming. See the licence file on 
+ *	https://github.com/slviajero/tinybasic for copyright/left.
+ *    (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)
+ *
+ *	Author: Stefan Lenz, [email protected]
+ *
+ *	basic.h are the core defintions and function protypes
+ *
+ */
+
+/*
+ *	if the PROGMEM macro is define we compile on the Arduino IDE
+ *	we undef all hardware settings otherwise a little odd
+ */
+#ifdef ARDUINO_ARCH_MBED
+#define PROGMEM
+#endif
+
+#ifdef PROGMEM
+#define ARDUINOPROGMEM
+#else
+#undef ARDUINO
+#undef ARDUINOSD
+#undef ARDUINORF24
+#undef ARDUINORTC
+#undef ARDUINOEEPROM
+#undef ARDUINOEEPROMI2C
+#undef ARDUINOWIRE
+#endif
+
+/* 
+ *	MSDOS, Mac, Linux and Windows 
+ */
+#ifndef ARDUINO
+typedef unsigned char uint8_t;
+#define PROGMEM
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HASFLOAT
+#include <math.h>
+#include <float.h>
+#endif
+#include <time.h>
+#include <sys/types.h>
+#include <sys/timeb.h>
+#ifndef MSDOS
+#include <dirent.h>
+#include <unistd.h>
+#else
+#include <dir.h>
+#include <dos.h>
+#endif
+#ifdef MINGW
+#include <windows.h>
+#endif
+#endif
+
+
+#if defined(ARDUINO_ARCH_AVR)
+/* the small memory model with shallow stacks and small buffers */
+#define BUFSIZE 		80
+#define STACKSIZE		15
+#define GOSUBDEPTH      4
+#define FORDEPTH		4
+#define LINECACHESIZE	4
+#else 
+/* the for larger microcontrollers */
+#ifdef ARDUINO
+#define BUFSIZE		   128
+#define STACKSIZE		64
+#define GOSUBDEPTH		8
+#define FORDEPTH		8
+#define LINECACHESIZE	16
+#else 
+/* for real computers */
+#define BUFSIZE         256
+#define STACKSIZE       256
+#define GOSUBDEPTH      64
+#define FORDEPTH        64
+#define LINECACHESIZE   64
+#endif
+#endif
+
+/* on the real small systems we remove the linecache and set a fixed memory size*/
+#ifdef ARDUINO_AVR_DUEMILANOVE
+#undef LINECACHESIZE
+#if MEMSIZE == 0
+#define MEMSIZE 512
+#endif
+#endif
+
+/* more duffers and vars */
+#define SBUFSIZE        32
+#define VARSIZE         26
+/* default sizes of arrays and strings if they are not DIMed */
+#define ARRAYSIZEDEF    10
+#define STRSIZEDEF      32
+
+/*
+ *	the time intervall in ms needed for 
+ *	ESP8266 yields, network client loops 
+ *	and other timing related functions 
+ */
+#define LONGYIELDINTERVAL 1000
+#define YIELDINTERVAL 32
+#define YIELDTIME 2
+
+/* the default EEPROM dummy size */
+#define EEPROMSIZE 1024
+
+/* after run behaviour on POSIX systems, 1 to terminate if started
+    on the command line with a file argument, 0 to stay active and 
+    show a BASIC prompt*/
+#define TERMINATEAFTERRUN 1
+
+/*
+ * The tokens for the BASIC keywords
+ *
+ *	All single character operators are their own tokens
+ *	ASCII values above 0x7f are used for tokens of keywords.
+ *	EOL is a token
+ */
+#define EOL			 0
+#define NUMBER   	 -127
+#define LINENUMBER   -126
+#define STRING   	 -125
+#define VARIABLE 	 -124
+#define STRINGVAR 	 -123
+#define ARRAYVAR     -122
+/* multi character tokens - BASEKEYWORD (3) */
+#define GREATEREQUAL -121
+#define LESSEREQUAL  -120
+#define NOTEQUAL	 -119
+/* this is the Palo Alto Language Set (19) */
+#define TPRINT  -118
+#define TLET    -117
+#define TINPUT  -116
+#define TGOTO   -115
+#define TGOSUB  -114
+#define TRETURN -113
+#define TIF     -112
+#define TFOR    -111
+#define TTO     -110
+#define TSTEP   -109
+#define TNEXT   -108
+#define TSTOP   -107
+#define TLIST	-106
+#define TNEW    -105
+#define TRUN    -104
+#define TABS 	-103
+#define TRND	-102
+#define TSIZE   -101
+#define TREM 	-100
+/* this is the Apple 1 language set in addition to Palo Alto (14) */
+#define TNOT    -99
+#define TAND	-98
+#define TOR 	-97
+#define TLEN	-96
+#define TSGN	-95	
+#define TPEEK	-94
+#define TDIM	-93
+#define TCLR	-92
+#define THIMEM  -91
+#define TTAB 	-90
+#define TTHEN   -89
+#define TEND    -88
+#define TPOKE	-87
+/* Stefan's tinybasic additions (14) */
+#define TCONT   -86
+#define TSQR	-85
+#define TPOW	-84
+#define TMAP	-83
+#define TDUMP 	-82
+#define TBREAK  -81
+#define TSAVE   -80
+#define TLOAD   -79
+#define TGET    -78
+#define TPUT    -77
+#define TSET    -76
+#define TCLS    -75
+#define TLOCATE -74
+#define TELSE   -73
+/* Arduino functions (10) */
+#define TPINM	-72
+#define TDWRITE	-71
+#define TDREAD	-70
+#define TAWRITE	-69
+#define TAREAD	-68
+#define TDELAY	-67
+#define TMILLIS	-66
+#define TTONE	-65
+#define TPULSE	-64
+#define TAZERO	-63
+#define TLED	-62
+/* the DOS functions (5) */
+#define TCATALOG    -61
+#define TDELETE -60
+#define TOPEN 	-59
+#define TCLOSE 	-58
+#define TFDISK  -57
+/* low level access of internal routines (2) */
+#define TUSR	-56
+#define TCALL 	-55
+/* mathematical functions (7) */
+#define TSIN 	-54
+#define TCOS    -53
+#define TTAN 	-52
+#define TATAN   -51
+#define TLOG    -50
+#define TEXP    -49
+#define TINT    -48
+/* graphics - experimental - rudimentary (7) */
+#define TCOLOR 	-47
+#define TPLOT   -46
+#define TLINE 	-45
+#define TCIRCLE -44
+#define TRECT   -43
+#define TFCIRCLE -42
+#define TFRECT   -41
+/* the Dartmouth extensions (6) */
+#define TDATA	-40
+#define TREAD   -39
+#define TRESTORE    -38
+#define TDEF	-37
+#define TFN 	-36
+#define TON     -35
+/* darkarts (3) */
+#define TMALLOC -34
+#define TFIND   -33
+#define TEVAL   -32
+/* iot extensions (9) */
+#define TERROR	-31
+#define TAVAIL	-30
+#define TSTR	-29
+#define TINSTR	-28
+#define TVAL	-27
+#define TNETSTAT    -26
+#define TSENSOR	-25
+#define TWIRE	-24
+#define TSLEEP	-23
+/* events and interrupts */
+#define TAFTER -22
+#define TEVERY -21
+#define TEVENT -20
+/* experimental structured commands, currently partially implemented */
+#define TWHILE -19
+#define TWEND   -18
+#define TREPEAT -17
+#define TUNTIL -16
+#define TSWITCH -15
+#define TCASE -14
+#define TSWEND -13
+#define TDO -12
+#define TDEND -11
+/* these are multibyte token extension, currently unused */
+/* using them would allow over 1000 BASIC keywords */
+#define TEXT1 -3
+/* end of tokens */
+/* constants used for some obscure purposes */
+#define TBUFFER -2
+/* UNKNOWN is not used in the current code, the 
+ * lexer tokenizes everything blindly. There is a UNKNOWN hook 
+ * in statement for a grammar aware lexer */
+#define UNKNOWN -1
+
+/* extension tokens can be in the range from -128 to -255 
+ * one needs to set HASLONGTOKENS
+ */
+#undef HASLONGTOKEN
+#define TTOKEN1 -128
+
+
+/* the number of keywords, and the base index of the keywords 
+ * the number is irrelevant but BASEKEYWORD is used */
+#define NKEYWORDS	3+19+13+14+11+5+2+7+7+6+12+3+9
+#define BASEKEYWORD -121
+
+/*
+ *	Interpreter states 
+ *	SRUN means running from a programm
+ *	SINT means interactive mode
+ *	SERUN means running directly from EEPROM
+ *		(enum would be the right way of doing this.)
+ *	BREAKCHAR is the character stopping the program on Ardunios
+ *  BREAKPIN can be set, it is a pin that needs to go to low to stop a BASIC program
+ *    This should be done in hardware*.h
+ *  BREAKSIGNAL can also be set, should be done in hardware*.h
+ */
+#define SINT 0
+#define SRUN 1
+#define SERUN 2
+#define BREAKCHAR '#'
+
+/* 
+ *	Input and output channels
+ */
+#define OSERIAL 1
+#define ODSP 2
+#define OPRT 4
+#define OWIRE 7
+#define ORADIO 8
+#define OMQTT  9
+#define OFILE 16
+
+#define ISERIAL 1
+#define IKEYBOARD 2
+#define ISERIAL1 4
+#define IWIRE 7
+#define IRADIO 8
+#define IMQTT  9
+#define IFILE 16
+
+/*
+ *	All BASIC keywords for the tokens
+ */
+const char sge[]   PROGMEM = "=>";
+const char sle[]   PROGMEM = "<=";
+const char sne[]   PROGMEM = "<>";
+/* Palo Alto language set */
+const char sprint[]  PROGMEM = "PRINT";
+const char slet[]    PROGMEM = "LET";
+const char sinput[]  PROGMEM = "INPUT";
+const char sgoto[]   PROGMEM = "GOTO";
+const char sgosub[]  PROGMEM = "GOSUB";
+const char sreturn[] PROGMEM = "RETURN";
+const char sif[]     PROGMEM = "IF";
+const char sfor[]    PROGMEM = "FOR";
+const char sto[]     PROGMEM = "TO";
+const char sstep[]   PROGMEM = "STEP";
+const char snext[]   PROGMEM = "NEXT";
+const char sstop[]   PROGMEM = "STOP";
+const char slist[]   PROGMEM = "LIST";
+const char snew[]    PROGMEM = "NEW";
+const char srun[]  	 PROGMEM = "RUN";
+const char sabs[]    PROGMEM = "ABS";
+const char srnd[]    PROGMEM = "RND";
+const char ssize[]   PROGMEM = "SIZE";
+const char srem[]    PROGMEM = "REM";
+/* Apple 1 language set */
+#ifdef HASAPPLE1
+const char snot[]    PROGMEM = "NOT";
+const char sand[]    PROGMEM = "AND";
+const char sor[]     PROGMEM = "OR";
+const char slen[]    PROGMEM = "LEN";
+const char ssgn[]    PROGMEM = "SGN";
+const char speek[]   PROGMEM = "PEEK";
+const char sdim[]    PROGMEM = "DIM";
+const char sclr[]    PROGMEM = "CLR";
+const char shimem[]  PROGMEM = "HIMEM";
+const char stab[]    PROGMEM = "TAB";
+const char sthen[]   PROGMEM = "THEN";
+const char sbend[]   PROGMEM = "END";
+const char spoke[]   PROGMEM = "POKE";
+#endif
+/* Stefan's basic additions */
+#ifdef HASSTEFANSEXT
+const char scont[]   PROGMEM = "CONT";
+const char ssqr[]    PROGMEM = "SQR";
+const char spow[]    PROGMEM = "POW";
+const char smap[]    PROGMEM = "MAP";
+const char sdump[]   PROGMEM = "DUMP";
+const char sbreak[]  PROGMEM = "BREAK";
+#endif
+/* LOAD and SAVE is always there */
+const char ssave[]   PROGMEM = "SAVE";
+const char sload[]   PROGMEM = "LOAD";
+#ifdef HASSTEFANSEXT
+const char sget[]    PROGMEM = "GET";
+const char sput[]    PROGMEM = "PUT";
+const char sset[]    PROGMEM = "SET";
+const char scls[]    PROGMEM = "CLS";
+const char slocate[]  PROGMEM  = "LOCATE";
+const char selse[]  PROGMEM  = "ELSE";
+#endif
+/* Arduino functions */
+#ifdef HASARDUINOIO
+const char spinm[]    PROGMEM = "PINM";
+const char sdwrite[]  PROGMEM = "DWRITE";
+const char sdread[]   PROGMEM = "DREAD";
+const char sawrite[]  PROGMEM = "AWRITE";
+const char saread[]   PROGMEM = "AREAD";
+const char sdelay[]   PROGMEM = "DELAY";
+const char smillis[]	PROGMEM = "MILLIS";
+const char sazero[]	PROGMEM = "AZERO";
+const char sled[]	PROGMEM = "LED";
+#endif
+#ifdef HASTONE
+const char stone[]    PROGMEM = "PLAY";
+#endif
+#ifdef HASPULSE
+const char spulse[] PROGMEM = "PULSE";
+#endif
+/* DOS functions */
+#ifdef HASFILEIO
+const char scatalog[] PROGMEM = "CATALOG";
+const char sdelete[]  PROGMEM = "DELETE";
+const char sfopen[]   PROGMEM = "OPEN";
+const char sfclose[]  PROGMEM = "CLOSE";
+const char sfdisk[]   PROGMEM = "FDISK";
+#endif
+/* low level access functions */
+#ifdef HASSTEFANSEXT
+const char susr[]   PROGMEM = "USR";
+const char scall[]  PROGMEM = "CALL";
+#endif
+/* mathematics */
+#ifdef HASFLOAT
+const char ssin[]   PROGMEM = "SIN";
+const char scos[]   PROGMEM = "COS";
+const char stan[]   PROGMEM = "TAN";
+const char satan[]  PROGMEM = "ATAN";
+const char slog[]   PROGMEM = "LOG";
+const char sexp[]   PROGMEM = "EXP";
+#endif
+/* INT is always needed to make float/int programs compatible */
+const char sint[]   PROGMEM = "INT"; 
+/* elemetars graphics */
+#ifdef HASGRAPH
+const char scolor[]     PROGMEM  = "COLOR";
+const char splot[]      PROGMEM  = "PLOT";
+const char sline[]      PROGMEM  = "LINE";
+const char scircle[]    PROGMEM  = "CIRCLE";
+const char srect[]      PROGMEM  = "RECT";
+const char sfcircle[]   PROGMEM  = "FCIRCLE";
+const char sfrect[]     PROGMEM  = "FRECT";
+#endif
+/* Dartmouth BASIC extensions */
+#ifdef HASDARTMOUTH
+const char sdata[]      PROGMEM  = "DATA";
+const char sread[]      PROGMEM  = "READ";
+const char srestore[]   PROGMEM  = "RESTORE";
+const char sdef[]       PROGMEM  = "DEF";
+const char sfn[]        PROGMEM  = "FN";
+const char son[]        PROGMEM  = "ON";
+#endif
+/* The Darkarts commands unthinkable in Dartmouth */
+#ifdef HASDARKARTS
+const char smalloc[]	PROGMEM  = "MALLOC";
+const char sfind[]		PROGMEM  = "FIND";
+const char seval[]		PROGMEM  = "EVAL";
+#endif
+/* complex error handling */
+#ifdef HASERRORHANDLING
+const char serror[]     PROGMEM  = "ERROR";
+#endif
+/* iot extensions */
+#ifdef HASIOT
+const char savail[]		PROGMEM  = "AVAIL";
+const char sstr[]		PROGMEM  = "STR";
+const char sinstr[]		PROGMEM  = "INSTR";
+const char sval[]		PROGMEM  = "VAL";
+const char snetstat[]	PROGMEM  = "NETSTAT";
+const char ssensor[]	PROGMEM  = "SENSOR";
+const char swire[]		PROGMEM  = "WIRE";
+const char ssleep[]		PROGMEM  = "SLEEP";
+#endif
+/* events and interrupts */
+#ifdef HASTIMER
+const char safter[]     PROGMEM  = "AFTER";
+const char severy[]     PROGMEM  = "EVERY";
+#endif
+#ifdef HASEVENTS
+const char sevent[]     PROGMEM  = "EVENT";
+#endif
+#ifdef HASSTRUCT
+const char swhile[]		PROGMEM	= "WHILE";
+const char swend[]      PROGMEM = "WEND";
+const char srepeat[]	PROGMEM	= "REPEAT";
+const char suntil[]     PROGMEM	= "UNTIL";
+const char sswitch[]	PROGMEM	= "SWITCH";
+const char scase[]		PROGMEM	= "CASE";
+const char sswend[]     PROGMEM = "SWEND";
+const char sdo[]        PROGMEM = "DO";
+const char sdend[]      PROGMEM = "DEND";
+#endif
+
+
+/* zero terminated keyword storage */
+const char* const keyword[] PROGMEM = {
+	sge, sle, sne, sprint, slet, sinput, 
+	sgoto, sgosub, sreturn, sif, sfor, sto,
+	sstep, snext, sstop, slist, snew, srun,
+	sabs, srnd, ssize, srem,
+#ifdef HASAPPLE1
+	snot, sand, sor, slen, ssgn, speek, sdim,
+	sclr, shimem, stab, sthen, 
+	sbend, spoke,
+#endif
+#ifdef HASSTEFANSEXT
+	scont, ssqr, spow, smap, sdump, sbreak, 
+#endif
+	ssave, sload, 
+#ifdef HASSTEFANSEXT
+	sget, sput, sset, scls, slocate, selse,
+#endif
+#ifdef HASARDUINOIO
+    spinm, sdwrite, sdread, sawrite, saread, 
+    sdelay, smillis, sazero, sled,
+#endif
+#ifdef HASTONE
+	stone,
+#endif
+#ifdef HASPULSE
+	spulse,
+#endif
+#ifdef HASFILEIO
+    scatalog, sdelete, sfopen, sfclose, sfdisk,
+#endif
+#ifdef HASSTEFANSEXT
+    susr, scall,
+#endif
+#ifdef HASFLOAT
+    ssin, scos, stan, satan, slog, sexp,
+#endif
+    sint,
+#ifdef HASGRAPH
+    scolor, splot, sline, scircle, srect, 
+    sfcircle, sfrect,
+#endif
+#ifdef HASDARTMOUTH
+	sdata, sread, srestore, sdef, sfn, son,
+#endif
+#ifdef HASDARKARTS
+	smalloc, sfind, seval, 
+#endif
+/* complex error handling */
+#ifdef HASERRORHANDLING
+    serror,
+#endif
+#ifdef HASIOT
+	savail, sstr, sinstr, sval, 
+	snetstat, ssensor, swire, ssleep, 
+#endif
+#ifdef HASTIMER
+    safter, severy,
+#endif
+#ifdef HASEVENTS
+    sevent,
+#endif
+#ifdef HASSTRUCT
+	swhile, swend, srepeat, suntil, sswitch, scase, sswend,	
+    sdo, sdend, 
+#endif 
+	0
+};
+
+/* the zero terminated token dictonary needed for scalability */
+const signed char tokens[] PROGMEM = {
+	GREATEREQUAL, LESSEREQUAL, NOTEQUAL, TPRINT, TLET,    
+    TINPUT, TGOTO, TGOSUB, TRETURN, TIF, TFOR, TTO, TSTEP,
+    TNEXT, TSTOP, TLIST, TNEW, TRUN, TABS, TRND, TSIZE, TREM,
+#ifdef HASAPPLE1
+    TNOT, TAND, TOR, TLEN, TSGN, TPEEK, TDIM, TCLR,
+    THIMEM, TTAB, TTHEN, TEND, TPOKE,
+#endif
+#ifdef HASSTEFANSEXT
+	TCONT, TSQR, TPOW, TMAP, TDUMP, TBREAK, 
+#endif
+	TSAVE, TLOAD, 
+#ifdef HASSTEFANSEXT	
+	TGET, TPUT, TSET, TCLS, TLOCATE, TELSE,
+#endif
+#ifdef HASARDUINOIO
+	TPINM, TDWRITE, TDREAD, TAWRITE, TAREAD, TDELAY, TMILLIS,
+	TAZERO, TLED,
+#endif
+#ifdef HASTONE
+	TTONE, 
+#endif
+#ifdef HASPULSE
+	TPULSE, 
+#endif
+#ifdef HASFILEIO
+	TCATALOG, TDELETE, TOPEN, TCLOSE, TFDISK,
+#endif
+#ifdef HASSTEFANSEXT
+	TUSR, TCALL,
+#endif
+#ifdef HASFLOAT
+	TSIN, TCOS, TTAN, TATAN, TLOG, TEXP,
+#endif
+	TINT,
+#ifdef HASGRAPH
+	TCOLOR, TPLOT, TLINE, TCIRCLE, TRECT, 
+	TFCIRCLE, TFRECT,
+#endif
+#ifdef HASDARTMOUTH
+	TDATA, TREAD, TRESTORE, TDEF, TFN, TON, 
+#endif
+#ifdef HASDARKARTS
+	TMALLOC, TFIND, TEVAL, 
+#endif
+#ifdef HASERRORHANDLING
+    TERROR, 
+#endif
+#ifdef HASIOT
+	TAVAIL, TSTR, TINSTR, TVAL, TNETSTAT,
+	TSENSOR, TWIRE, TSLEEP,
+#endif
+#ifdef HASTIMER
+    TAFTER, TEVERY,
+#endif
+#ifdef HASEVENTS
+    TEVENT, 
+#endif
+#ifdef HASSTRUCT
+	TWHILE, TWEND, TREPEAT, TUNTIL, TSWITCH, TCASE, TSWEND,
+    TDO, TDEND, 
+#endif
+	0
+};
+
+/*
+ *	the message catalog
+ */
+#define MFILE		0
+#define MPROMPT		1
+#define MGREET		2
+#define MLINE		3
+#define MNUMBER		4
+#define MVARIABLE	5
+#define MARRAY		6
+#define MSTRING		7
+#define MSTRINGVAR	8
+#define EGENERAL 	 9
+#define EUNKNOWN	 10
+#define ENUMBER      11
+#define EDIVIDE		 12
+#define ELINE        13
+#define EOUTOFMEMORY 14
+#define ESTACK 		 15
+#define EORANGE 	 16
+#define ESTRING      17
+#define EVARIABLE	 18
+#define ELOOP        19
+#define EFILE 		 20
+#define EFUN 		 21
+#define EARGS       22
+#define EEEPROM	    23
+#define ESDCARD     24
+
+const char mfile[]    	PROGMEM = "file.bas";
+const char mprompt[]	PROGMEM = "> ";
+const char mgreet[]		PROGMEM = "Stefan's Basic 1.4";
+const char mline[]		PROGMEM = "LINE";
+const char mnumber[]	PROGMEM = "NUMBER";
+const char mvariable[]	PROGMEM = "VARIABLE";
+const char marray[]		PROGMEM = "ARRAY";
+const char mstring[]	PROGMEM = "STRING";
+const char mstringv[]	PROGMEM = "STRINGVAR";
+const char egeneral[]  	PROGMEM = "Error";
+#ifdef HASERRORMSG
+const char eunknown[]  	PROGMEM = "Syntax";
+const char enumber[]	PROGMEM = "Number";
+const char edivide[]  	PROGMEM = "Div by 0";
+const char eline[]  	PROGMEM = "Unknown Line";
+const char emem[]  	   	PROGMEM = "Memory";
+const char estack[]    	PROGMEM = "Stack";
+const char erange[]  	PROGMEM = "Range";
+const char estring[]	PROGMEM = "String";
+const char evariable[]  PROGMEM = "Variable";
+const char eloop[]      PROGMEM = "Loop";
+const char efile[]  	PROGMEM = "File";
+const char efun[] 	 	PROGMEM = "Function";
+const char eargs[]  	PROGMEM = "Args";
+const char eeeprom[]	PROGMEM = "EEPROM";
+const char esdcard[]	PROGMEM = "SD card";
+#endif
+
+const char* const message[] PROGMEM = {
+	mfile, mprompt, mgreet, 
+	mline, mnumber, mvariable, marray, 
+	mstring, mstringv,
+	egeneral
+#ifdef HASERRORMSG
+	, eunknown, enumber, edivide, eline, 
+	emem, estack, erange,
+	estring, evariable, eloop, efile, efun, eargs, 
+	eeeprom, esdcard
+#endif
+};
+
+/*
+ *	code for variable numbers and addresses sizes
+ *	the original code was 16 bit but can be extended here
+ * 	to arbitrary types 
+ *
+ *	number_t is the type for numerical work - either float or int
+ *  wnumber_t is the type containing the largest printable integer, 
+ *    for float keep this int on 32 bit and long on 8 bit unless you 
+ *    want to use very long integers, like 64 or 128 bit types. 
+ *  address_t is an unsigned type adddressing memory, default 16bit 
+ *  mem_t is a SIGNED 8bit character type.
+ *	index_t is a SIGNED minimum 16 bit integer type
+ *
+ *	works with the tacit assumption that 
+ *	sizeof(number_t) >= sizeof(address_t) 
+ *	and that the entire memory is smaller than the positive
+ * 	part of number type (!!)
+ *
+ *	we assume that float >= 4 bytes in the following
+ *
+ *	maxnum: the maximum accurate(!) integer of a 
+ *		32 bit float 
+ *	strindexsize: the index size of strings either 
+ *		1 byte or 2 bytes - no other values supported
+ */
+#ifdef HASFLOAT
+typedef float number_t;
+const number_t maxnum=16777216; 
+typedef long wnumber_t;
+#else
+typedef int number_t;
+typedef int wnumber_t;
+const number_t maxnum=(number_t)~((number_t)1<<(sizeof(number_t)*8-1));
+#endif
+typedef unsigned short address_t; /* this type addresses memory */
+const int numsize=sizeof(number_t);
+const int addrsize=sizeof(address_t);
+const int eheadersize=sizeof(address_t)+1;
+const int strindexsize=2; /* default in the meantime, strings up to unsigned 16 bit length */
+const address_t maxaddr=(address_t)(~0); 
+typedef signed char mem_t; /* a signed 8 bit type for the memory */
+typedef int index_t; /* this type counts at least 16 bit */
+#ifndef HASLONGTOKENS
+typedef signed char token_t; /* the type of tokens, normally mem_t with a maximum of 127 commands and data types */
+#else
+typedef short token_t; /* token type extension, allows an extra of 127 commands and symbols */
+#endif
+
+/* this type maps numbers to bytes */
+typedef struct {mem_t l; mem_t h;} twobytes_t;
+typedef union { number_t i; address_t a; twobytes_t b; mem_t c[sizeof(number_t)]; } accu_t;
+
+/* the memreader function type */
+typedef mem_t (*memreader_t)(address_t);
+
+/* 
+ * system type identifiers
+ */
+
+#define SYSTYPE_UNKNOWN	0
+#define SYSTYPE_AVR 	1
+#define SYSTYPE_ESP8266 2
+#define SYSTYPE_ESP32	3
+#define SYSTYPE_RP2040  4
+#define SYSTYPE_SAM     5
+#define SYSTYPE_XMC		6
+#define SYSTYPE_SMT32	7
+#define SYSTYPE_NRENESA 8
+#define SYSTYPE_POSIX	32
+#define SYSTYPE_MSDOS	33
+#define SYSTYPE_MINGW   34
+#define SYSTYPE_RASPPI  35
+
+/*
+ *	The basic interpreter is implemented as a stack machine
+ *	with global variable for the interpreter state, the memory
+ *	and the arithmetic during run time.
+ */
+
+/* the stack, all BASIC arithmetic is done here */
+number_t stack[STACKSIZE];
+address_t sp=0; 
+
+/* a small buffer to process string arguments, mostly used for Arduino PROGMEM */
+char sbuffer[SBUFSIZE];
+
+/* the input buffer, the lexer can tokenize this and run from it, bi is an index to this.
+   bi must be global as it is the program cursor in interactive mode */
+char ibuffer[BUFSIZE] = "\0";
+char *bi;
+
+/* a static array of variables A-Z for the small systems that have no heap */
+number_t vars[VARSIZE];
+
+/* the BASIC working memory, either malloced or allocated as a global array */
+#if MEMSIZE != 0
+mem_t mem[MEMSIZE];
+#else
+mem_t* mem;
+#endif
+address_t himem, memsize;
+
+/* the for stack - remembers the variable, indices, and optionally a type for stuctured BASIC */
+struct forstackitem {mem_t varx; mem_t vary; address_t here; number_t to; number_t step; 
+#ifdef HASSTRUCT
+mem_t type;
+#endif
+} forstack[FORDEPTH];
+index_t forsp = 0;
+ 
+/* the GOSUB stack remembers an address to jump to */
+address_t gosubstack[GOSUBDEPTH];
+index_t gosubsp = 0;
+
+/* this variable stores the location in pushlocation() and poplocation(), used to rewind the program cursor */
+address_t slocation;
+
+/* arithmetic accumulators - used by many statements, y may be obsolete in future*/
+number_t x, y;
+
+/* the names of a variable and small integer accumulator */
+mem_t xc, yc;
+
+/* an address accumulator, used a lot in string operations */
+address_t ax;
+
+/* z is another accumulator used to convert numbers and addressed to bytes and vice versa */
+/* this union is used to store larger objects into byte oriented memory */
+accu_t z;
+
+/* string index registers */
+char *ir, *ir2;
+
+/* the active token */
+token_t token;
+
+/* the curent error, can be a token, hance token type */
+token_t er;
+
+/* a trapable error */
+mem_t ert;
+
+/* the interpreter state, interactive, run or run from EEPROM */
+mem_t st; 
+
+/* the current program location or "cursor" */
+address_t here; 
+
+/* the topmost byte of a program in memory, beginning of free BASIC RAM */
+address_t top;
+
+/* the number of variables on the heap */
+address_t nvars = 0; 
+
+/* used to format output with # */
+mem_t form = 0;
+
+/* counts the outputed characters on streams 0-3, used to emulate a real tab */
+#ifdef HASMSTAB
+mem_t charcount[3]; /* devices 1-4 support tabing */
+mem_t reltab = 0;
+#endif
+
+/* the lower limit of the array is one by default, can be a variable */
+#ifdef HASARRAYLIMIT
+address_t arraylimit = 1;
+#else 
+const address_t arraylimit = 1;
+#endif
+
+/* the number of arguments parsed from a command */
+mem_t args;
+
+/* the random number seed, this is unsigned hence address_t */
+#ifndef HASFLOAT
+address_t rd;
+#else 
+unsigned long rd;
+#endif
+
+/* output and input channels, used to direct output to various devices */
+mem_t id;
+mem_t od;
+
+/* default IO - not constant, can be changed at runtime through a user call */
+mem_t idd = ISERIAL;
+mem_t odd = OSERIAL;
+
+/* the runtime debuglevel */
+mem_t debuglevel = 0;
+
+/* DATA pointer, where is the current READ statement  */
+#ifdef HASDARTMOUTH
+address_t data = 0;
+address_t datarc = 1;
+#endif
+    
+/* 
+ * process command line arguments in the POSIX world 
+ * bnointafterrun is a flag to remember if called as command
+ * line argument, in this case we don't return to interactive 
+ */
+#ifndef ARDUINO
+int bargc;
+char** bargv;
+mem_t bnointafterrun = 0;
+#endif
+
+/*
+ * Yield counter, we count when we did yield the last time
+ *	lastyield controlls the client loops of network functions 
+ *	like mqtt, scanned keyboard, and USB.
+ *
+ *	lastlongyield controls longterm functions like DHCP lease 
+ *	renewal in Ethernet 
+ * 
+ * there variables are only needed if the platform has background 
+ *  tasks
+ */
+long lastyield=0;
+long lastlongyield=0;
+
+/* formaters lastouttoken and spaceafterkeyword to make a nice LIST */
+mem_t lastouttoken;
+mem_t spaceafterkeyword;
+mem_t outliteral = 0;
+mem_t lexliteral = 0; 
+
+/* 
+ * the cache for the heap search - helps the string code 
+ * the last found object on the heap is remembered. This is needed
+ * because the string code sometime searches the heap twice during the 
+ * same operation. 
+ */
+#ifdef HASAPPLE1
+mem_t bfindc, bfindd, bfindt;
+address_t bfinda, bfindz;
+#endif
+
+/*
+ * a variable for some string operations 
+ */
+int vlength;
+
+/* the timer code - very simple needs to to to a struct */
+/* timer type */
+typedef struct {
+    mem_t enabled;
+    unsigned long last;
+    unsigned long interval; 
+    mem_t type;
+    address_t linenumber;
+} btimer_t;
+
+#ifdef HASTIMER
+btimer_t after_timer = {0, 0, 0, 0, 0};
+btimer_t every_timer = {0, 0, 0, 0, 0};
+#endif
+
+/* the event code */
+#ifdef HASEVENTS
+
+#define EVENTLISTSIZE 4
+
+/* event type */
+typedef struct {
+    mem_t enabled;
+    mem_t pin;
+    mem_t mode; 
+    mem_t type;
+    address_t linenumber;
+    mem_t active;
+} bevent_t;
+
+/* the event list */
+int nevents = 0;
+int ievent = 0;
+static mem_t events_enabled = 1;
+static volatile bevent_t eventlist[EVENTLISTSIZE];
+
+/* the extension of the GOSUB stack */
+static mem_t gosubarg[GOSUBDEPTH];
+
+/* handle the event list */
+mem_t addevent(mem_t, mem_t, mem_t, address_t);
+void deleteevent(mem_t);
+volatile bevent_t* findevent(mem_t);
+mem_t eventindex(mem_t);
+#endif
+
+#ifdef HASERRORHANDLING
+/* the error handler type, very simple for now */
+typedef struct {
+    mem_t type;
+    address_t linenumber;
+} berrorh_t;
+
+berrorh_t berrorh = {0 , 0};
+mem_t erh = 0;
+#endif
+
+/* the string for real time clocks */
+char rtcstring[20] = { 0 }; 
+
+/* the units pulse operates on, in microseconds*/
+short bpulseunit = 10; 
+
+/* only needed for POSIXNONBLOCKING */
+mem_t breakcondition = 0;
+
+/* 
+ * Function prototypes, ordered by layers
+ * HAL - hardware abstraction
+ * Layer 0 - memory and I/O
+ * Layer 1 - Program storage and control
+ * Layer 2 - Where stuff happens
+ */
+
+/*
+ *	HAL - see hardware-*.h
+ *  This is the hardware abstraction layer of the BASIC
+ *	interpreter 
+ */
+
+/* setup codes */
+void timeinit();
+void wiringbegin();
+
+/* low level mem and hardware features */
+long freeRam();
+long freememorysize();
+void restartsystem();
+void activatesleep(long t);
+
+/* start the spi bus */
+void spibegin();
+
+/* 
+ * the hardware interface display driver functions, need to be 
+ * 	implemented for the display driver to work 
+ *	dspupdate() only for display like Epapers
+ */
+void dspbegin();
+void dspprintchar(char, mem_t, mem_t);
+void dspclear();
+void dspupdate();
+
+/* keyboard code */
+void kbdbegin();
+int kbdstat(char);
+char kbdavailable();
+char kbdread();
+char kbdcheckch();
+
+/* graphics functions */
+void rgbcolor(int, int, int);
+void vgacolor(short c);
+void vgascale(int*, int*);
+void plot(int, int);
+void line(int, int, int, int);  
+void rect(int, int, int, int);
+void frect(int, int, int, int);
+void circle(int, int, int);
+void fcircle(int, int, int);
+
+/* text output to a VGA display */
+void vgabegin();
+int vgastat(char);
+void vgawrite(char);
+
+/* generic display code */
+void dspwrite(char);
+void dspbegin();
+int dspstat(char);
+char dspwaitonscroll();
+char dspactive();
+void dspsetupdatemode(char);
+char dspgetupdatemode();
+void dspgraphupdate();
+void dspsetscrollmode(char, short);
+void dspsetcursor(short, short);
+void dspbufferclear();
+void dspscroll(mem_t, mem_t);
+void dspreversescroll(mem_t);
+void dspvt52(char *);
+
+/* real time clock */
+char* rtcmkstr();
+void rtcset(uint8_t, short);
+short rtcget(short); 
+
+/* network and mqtt functions */
+void netbegin();
+char netconnected();
+void mqttsetname();
+void mqttbegin();
+int mqttstat(char);
+int  mqttstate();
+void mqttsubscribe(char*);
+void mqttsettopic(char*);
+void mqttouts(char *, short);
+void mqttins(char *, short);
+char mqttinch();
+
+/* low level EEPROM handling */
+void ebegin();
+void eflush();
+address_t elength();
+mem_t eread(address_t);
+void eupdate(address_t, mem_t);
+
+/* arduino io functions */
+void aread();
+void dread();
+void awrite(address_t, address_t);
+void dwrite(address_t, address_t);
+void pinm(address_t, address_t);
+void bmillis();
+void bpulsein();
+void xpulse();
+void bpulseout(short);
+void btone(short);
+
+/* timing control for ESP and network */
+void byield();
+void bdelay(unsigned long);
+void fastticker();
+void yieldfunction();
+void longyieldfunction();
+
+/* the file interface */
+char* mkfilename(const char*);
+const char* rmrootfsprefix(const char*);
+void fsbegin(char);
+int fsstat(char);
+void filewrite(char);
+char fileread();
+char ifileopen(const char*);
+void ifileclose();
+char ofileopen(char*, const char*);
+void ofileclose();
+int fileavailable();
+void rootopen();
+int rootnextfile();
+int rootisfile();
+const char* rootfilename();
+long rootfilesize();
+void rootfileclose();
+void rootclose();
+void removefile(char*);
+void formatdisk(short);
+
+/* low level serial code */
+void picogetchar(char);
+void picowrite(char);
+void picobegin(unsigned long);
+void picoins(char, short);
+void serialbegin();
+int serialstat(char);
+char serialread();
+void serialwrite(char);
+short serialcheckch();
+short serialavailable();
+void serialflush();
+void consins(char*, short);
+void prtbegin();
+int prtstat(char);
+void prtset(int);
+char prtopen(char *, int);
+void prtclose();
+char prtread();
+void prtwrite(char);
+short prtcheckch();
+short prtavailable();
+
+/* generic wire access */
+void wirebegin();
+int wirestat(char);
+void wireopen(char, char);
+void wireins(char*, uint8_t);
+void wireouts(char*, uint8_t);
+short wireavailable();
+short wirereadbyte(short);
+void  wirewritebyte(short, short);
+
+/* RF24 radio input */
+int radiostat(char);
+void radioset(int);
+#ifdef ARDUINO 
+uint64_t pipeaddr(char*);
+#else
+long pipeaddr(char*);
+#endif
+void iradioopen(char*);
+void oradioopen(char*);
+void radioins(char*, short);
+void radioouts(char* , short);
+short radioavailable();
+
+/* sensor control */
+void sensorbegin();
+number_t sensorread(short, short);
+
+/* SPI RAM code */
+address_t spirambegin();
+void spiramrawwrite(address_t, mem_t);
+mem_t spiramrawread(address_t );
+
+/*
+ * Layer 0 functions - I/O and memory management 
+ */
+
+/* make room for BASIC */
+address_t ballocmem(); 
+
+/* handle files im EEPROM */
+void eload();
+void esave();
+char autorun();
+
+/* the variable heap from Apple 1 BASIC */
+address_t bmalloc(mem_t, mem_t, mem_t, address_t);
+address_t bfind(mem_t, mem_t, mem_t);
+address_t bfree(mem_t, mem_t, mem_t);
+address_t blength (mem_t, mem_t, mem_t);
+
+/* normal variables of number_t */
+number_t getvar(mem_t, mem_t);
+void setvar(mem_t, mem_t, number_t);
+void clrvars();
+
+/*	low level memory access packing n*8bit bit into n 8 bit objects
+	e* is for Arduino EEPROM */
+void getnumber(address_t, mem_t);
+void setnumber(address_t, mem_t);
+void egetnumber(address_t, mem_t);
+void esetnumber(address_t, mem_t);
+void pgetnumber(address_t, mem_t);
+
+/* array and string handling */
+/* the multidim extension is experimental, here only 2 array dimensions implemented as test */
+address_t createarray(mem_t, mem_t, address_t, address_t);
+void array(mem_t, mem_t, mem_t, address_t, address_t, number_t*);
+address_t createstring(char, char, address_t, address_t);
+char* getstring(char, char, address_t, address_t);
+number_t arraydim(char, char);
+address_t stringdim(char, char);
+address_t lenstring(char, char, address_t);
+void setstringlength(char, char, address_t, address_t);
+void setstring(char, char, address_t, char *, address_t, address_t);
+
+/* the user defined extension functions */
+number_t getusrvar();
+void setusrvar(number_t);
+number_t getusrarray(address_t);
+void setusrarray(address_t, number_t);
+void makeusrstring();
+number_t usrfunction(address_t, number_t);
+void usrcall(address_t);
+
+/* get keywords and tokens from PROGMEM */
+char* getkeyword(unsigned short);
+char* getmessage(char);
+signed char gettokenvalue(char);
+void printmessage(char);
+
+/* error handling */
+void error(token_t);
+void reseterror();
+void debugtoken();
+void bdebug(const char*);
+
+/* the arithemtic stack */
+void push(number_t);
+number_t pop();
+address_t popaddress();
+void drop();
+void clearst();
+
+/* READ DATA handling */
+void clrdata();
+
+/* FOR NEXT GOSUB stacks */
+void pushforstack();
+void popforstack();
+void dropforstack();
+void clrforstack();
+void pushgosubstack(mem_t);
+void popgosubstack();
+void dropgosubstack();
+void clrgosubstack();
+
+/* general I/O initialisation */
+void ioinit();
+void iodefaults();
+
+/* signal handling */
+void signalon();
+void signaloff();
+void signalhandler(int);
+
+/* character and string I/O functions */
+/* we live in world where char may be signed or unsigned and keep it 
+    that way on the lowest level, hence this function, fully defined here, 
+    mostly inlined anyway*/
+int cheof(int c) { if ((c == -1) || (c == 255)) return 1; else return 0; }
+/* input */
+char inch();
+char checkch();
+short availch();
+void inb(char*, index_t);
+void ins(char*, address_t); 
+
+/* output */
+void outch(char);
+void outcr();
+void outspc();
+void outs(char*, address_t);
+void outsc(const char*);
+void outscf(const char *, index_t);
+
+/* I/O of number_t - floats and integers */
+address_t parsenumber(char*, number_t*);
+address_t parsenumber2(char*, number_t*);
+address_t writenumber(char*, wnumber_t); 
+address_t writenumber2(char*, number_t);
+address_t tinydtostrf(number_t, index_t, char*);
+char innumber(number_t*);
+void outnumber(number_t);
+
+/* 	
+ * Layer 1 functions, provide data and do the heavy lifting 
+ * for layer 2 including lexical analysis, storing programs 
+ * and expression evaluation 
+ */
+
+/* lexical analysis */
+void whitespaces();
+void nexttoken();
+
+/* storing and retrieving programs */
+char nomemory(number_t);
+void storetoken(); 
+mem_t memread(address_t);
+mem_t memread2(address_t);
+void memwrite2(address_t, mem_t);
+void gettoken();
+void firstline();
+void nextline();
+
+void clrlinecache();
+void addlinecache(address_t, address_t);
+address_t findinlinecache(address_t);
+void findline(address_t);
+address_t myline(address_t);
+void moveblock(address_t, address_t, address_t);
+void zeroblock(address_t, address_t);
+void diag();
+void storeline();
+
+/* read arguments from the token stream and process them */
+char termsymbol();
+char expect(token_t, mem_t);
+char expectexpr();
+void parsearguments();
+void parsenarguments(char);
+void parsesubscripts();
+void parsefunction(void (*)(), short);
+void parseoperator(void (*)());
+void parsesubstring();
+
+/* mathematics and other functions for int and float */
+void xabs();
+void xsgn();
+void xpeek();
+void xmap();
+void rnd();
+void sqr();
+void xpow();
+number_t bpow(number_t, number_t);
+
+/* string values and string evaluation */
+char stringvalue();
+void streval();
+
+/* floating point functions */
+void xsin();
+void xcos();
+void xtan();
+void xatan();
+void xlog();
+void xexp();
+void xint();
+
+/* expression evaluation */
+void factor();
+void term();
+void addexpression();
+void compexpression();
+void notexpression();
+void andexpression();
+void expression();
+
+/* 
+ * Layer 2 - statements and functions 
+ * use the global variables 
+ */
+
+/* basic commands of the core language set */
+void xprint();
+void lefthandside(address_t*, address_t*, address_t*, mem_t*);
+void assignnumber(signed char, char, char, address_t, address_t, char);
+void assignment();
+void showprompt();
+void xinput();
+void xgoto();
+void xreturn();
+void xif();
+
+/* FOR NEXT loops */
+void findnextcmd();
+void findbraket(token_t, token_t);
+void xfor();
+void xbreak();
+void xcont();
+void xnext();
+
+/* WHILE WEND*/
+void xwhile();
+void xwend();
+
+/* REPEAT UNTIL */
+void xrepeat();
+void xuntil();
+
+/* control commands and misc */
+void outputtoken();
+void xlist();
+void xrun();
+void xnew();
+void xrem();
+void xclr();
+void xdim();
+void xpoke();
+void xtab();
+void xdump();
+void dumpmem(address_t, address_t, char);
+void xlocate();
+
+/* file access and other i/o */
+void stringtobuffer(char*);
+void getfilename(char*, char);
+void xsave();
+void xload(const char*);
+void xget();
+void xput();
+void xset();
+void xnetstat();
+
+/* Arduino IO control interface */
+void xdwrite();
+void xawrite();
+void xpinm();
+void xdelay();
+void xtone();
+
+/* graphics commands */
+void xcolor();
+void xplot();
+void xline();
+void xrect();
+void xcircle();
+void xfrect();
+void xfcircle();
+
+/* the darkarts */
+void xmalloc();
+void xfind();
+void xeval();
+
+/* IoT commands */
+void xassign();
+void xavail();
+void xfsensor();
+void xsleep();
+void xwire();
+void xfwire();
+
+/* timers */
+void xafter();
+void xevent();
+
+/* File I/O functions */
+char streq(const char*, char*);
+void xcatalog();
+void xdelete();
+void xopen();
+void xfopen();
+void xclose();
+void xfdisk();
+
+/* low level access functions */
+void xcall();
+void xusr();
+
+/* the dartmouth stuff */
+void xdata();
+void nextdatarecord();
+void xread();
+void xrestore();
+void xdef();
+void xfn();
+void xon();
+
+/* timers and interrupts */
+void xtimer();
+void resettimer(btimer_t*);
+
+/* structured BASIC extensions */
+void xwhile();
+void xwend(); 
+void xrepeat();
+void xuntil();
+void xswitch();
+void xcase();
+void xendswitch();
+
+/* the emulation of tone using the byield loop */
+void toggletone();
+void playtone(int, int, int);
+
+/* the statement loop */
+void statement();
+
+/* the extension functions */
+void bsetup();
+void bloop();
+

data/Basic1/hardware-posix.h

@@ -0,0 +1,1502 @@
+/*
+ *
+ * $Id: hardware-posix.h,v 1.7 2023/07/16 14:17:08 stefan Exp stefan $
+ *
+ *	Stefan's basic interpreter 
+ *
+ *	Playing around with frugal programming. See the licence file on 
+ *	https://github.com/slviajero/tinybasic for copyright/left.
+ *	(GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)
+ *
+ *	Author: Stefan Lenz, [email protected]
+ *
+ *	Hardware definition file coming with basic.c aka TinybasicArduino.ino
+ *
+ *	Link to some of the POSIX OS features to mimic a microcontroller platform
+ *	See hardware-arduino for more details on the interface.
+ *
+ *	Supported: filesystem, real time clock, (serial) I/O on the text console
+ *	Not supported: radio, wire, SPI, MQTT
+ *
+ *	Partially supported: Wiring library on Raspberry PI
+ *
+ */
+
+#if ! defined(ARDUINO) && ! defined(__HARDWAREH__)
+#define __HARDWAREH__ 
+
+/* 
+ * Hardware flags of the POSIX systems 
+ * POSIXTERMINAL, POSIXVT52TOANSI: ensure compatibility of BASIC programs  
+ * 	control characters of BASIC are translated to ANSI, bringing the Aruino 
+ * 	VT52 commands to POSIX
+ * POSIXSIGNALS: enables signal handling of ^C interrupting programs
+ * POSIXNONBLOCKING: non blocking I/O to handle GET and the BREAKCHAR 
+ * 	tricky on DOS, not very portable, experimental, use signals instead
+ * POSIXFRAMEBUFFER: directly draw to the frame buffer of Raspberry PI
+ * 	only tested on this platform
+ * POSIXWIRE: simple Raspberry PI wire code
+ * POSIXMQTT: analogous to ARDUINOMQTT, send and receive MQTT messages (unfinished)
+ * POSIXWIRING: use the (deprectated) wiring code for gpio on Raspberry Pi
+ * POSIXPIGPIO: use the pigpio library on a Raspberry PI 
+ */
+
+#define POSIXTERMINAL
+#define POSIXVT52TOANSI
+#define POSIXSIGNALS
+#undef POSIXNONBLOCKING
+#undef POSIXFRAMEBUFFER
+#undef POSIXWIRE
+#undef POSIXMQTT
+#undef POSIXWIRING
+#undef POSIXPIGPIO
+
+/* simulates SPI RAM, only test code, keep undefed if you don't want to do something special */
+#undef SPIRAMSIMULATOR
+
+/* use a serial port as printer interface - unfinished - similar to Arduino */
+#define ARDUINOPRT
+
+/* used pins and other parameters */
+
+/* set this is you want pin 4 on low interrupting the interpreter */
+/* #define BREAKPIN 4 */
+#undef BREAKPIN
+
+/* the SIGNAL the interpreters listens to for interrupt */
+#define BREAKSIGNAL SIGINT
+
+/* in case of non blocking IO turn on background tasks */
+#ifdef POSIXNONBLOCKING
+#define BASICBGTASK
+#endif
+
+/* frame buffer health check - currently only supported on Raspberry */ 
+#ifndef RASPPI
+#undef POSIXFRAMEBUFFER
+#endif
+
+/* wire parameters for Raspberry*/
+#define POSIXI2CBUS 1
+
+/* Wiring Code, which library to use */
+#ifdef POSIXWIRING
+#include <wiringPi.h>
+#endif
+
+#ifdef POSIXPIGPIO
+#include <pigpiod_if2.h>
+#undef POSIXWIRING
+static int pigpio_pi = 0;
+#endif
+
+/* 
+ * the system type and system capabilities
+ */
+
+#if defined(MSDOS)
+const char bsystype = SYSTYPE_MSDOS
+#elif defined(RASPPI)
+const char bsystype = SYSTYPE_PASPPI
+#elif defined(MINGW)
+const char bsystype = SYSTYPE_MINGW
+#else
+const char bsystype = SYSTYPE_POSIX;
+#endif
+
+/* 
+ * Arduino default serial baudrate and serial flags for the 
+ * two supported serial interfaces. Set to 0 on POSIX OSes 
+ */
+const int serial_baudrate = 0;
+const int serial1_baudrate = 0;
+char sendcr = 0;
+short blockmode = 0;
+
+/*  handling time, remember when we started, needed in millis() */
+struct timeb start_time;
+void timeinit() { ftime(&start_time); }
+
+/* starting wiring for raspberry */
+void wiringbegin() {
+#ifdef POSIXWIRING
+	wiringPiSetup();
+#endif
+#ifdef POSIXPIGPIO
+	pigpio_pi=pigpio_start("localhost","8888");
+	printf("** GPIO started with result %d\n", pigpio_pi);
+	printf("** pigpio version %d.\n", get_pigpio_version(pigpio_pi));
+	printf("** Hardware revision %d.\n", get_hardware_revision(pigpio_pi));
+#endif
+}
+
+/*
+ * signal handling 
+ */
+#ifdef POSIXSIGNALS
+#include <signal.h>
+mem_t breaksignal = 0;
+
+/* simple signal handler */
+void signalhandler(int sig){
+	breaksignal=1;
+	signal(BREAKSIGNAL, signalhandler);
+}
+
+/* activate signal handling */
+void signalon() {
+	signal(BREAKSIGNAL, signalhandler);
+}
+
+/* deactivate signal handling unused and not yet done*/
+void signaloff() {}
+
+#endif
+
+/*
+ * helper functions OS, heuristic on how much memory is 
+ * available in BASIC
+ */
+long freememorysize() {
+#ifdef MSDOS
+	return 48000;
+#else
+	return 65536;
+#endif  
+}
+
+long freeRam() {
+	return freememorysize();
+}
+
+/* 
+ * the sleep and restart functions
+ */
+void restartsystem() { exit(0);}
+void activatesleep(long t) {}
+
+/* 
+ * start the SPI bus 
+ */
+void spibegin() {}
+
+
+/*
+ * DISPLAY driver code section, the hardware models define a set of 
+ * of functions and definitions needed for the display driver. These are 
+ *
+ * dsp_rows, dsp_columns: size of the display
+ * dspbegin(), dspprintchar(c, col, row), dspclear()
+ * 
+ * All displays which have this functions can be used with the 
+ * generic display driver below.
+ * 
+ * Graphics displays need to implement the functions 
+ * 
+ * rgbcolor(), vgacolor()
+ * plot(), line(), rect(), frect(), circle(), fcircle() 
+ * 
+ * Color is currently either 24 bit or 4 bit 16 color vga.
+ */
+const int dsp_rows=0;
+const int dsp_columns=0;
+void dspsetupdatemode(char c) {}
+void dspwrite(char c){}
+void dspbegin() {}
+int dspstat(char c) {return 0; }
+char dspwaitonscroll() { return 0; }
+char dspactive() {return 0; }
+void dspsetscrollmode(char c, short l) {}
+void dspsetcursor(short c, short r) {}
+
+#ifndef POSIXFRAMEBUFFER
+/* these are the graphics commands */
+void rgbcolor(int r, int g, int b) {}
+void vgacolor(short c) {}
+void plot(int x, int y) {}
+void line(int x0, int y0, int x1, int y1)   {}
+void rect(int x0, int y0, int x1, int y1)   {}
+void frect(int x0, int y0, int x1, int y1)  {}
+void circle(int x0, int y0, int r) {}
+void fcircle(int x0, int y0, int r) {}
+
+/* stubs for the vga code part analogous to ESP32 */
+void vgabegin(){}
+void vgawrite(char c){}
+#else
+/* 
+ * This is the first draft of the linux framebuffer code 
+ * currently very raw, works only if the framebuffer is 24 bit 
+ * very few checks, all kind of stuff can go wrong here.
+ * 
+ * Main ideas and some part of the code came from this
+ * article https://www.mikrocontroller.net/topic/379335
+ * by Andy W.
+ * 
+ * Bresenham's algorithm came from the Wikipedia article 
+ * and this very comprehensive discussion
+ * http://members.chello.at/~easyfilter/bresenham.html
+ * by Alois Zingl from the Vienna Technikum. I also recommend
+ * his thesis: http://members.chello.at/%7Eeasyfilter/Bresenham.pdf
+ * 
+ */
+#include <sys/fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/fb.h>
+#include <sys/mman.h>
+#include <string.h>
+
+/* 'global' variables to store screen info */
+char *framemem = 0;
+int framedesc = 0;
+
+/* info from the frame buffer itself */
+struct fb_var_screeninfo vinfo;
+struct fb_fix_screeninfo finfo;
+struct fb_var_screeninfo orig_vinfo;
+
+/* the color variable of the frame buffer */
+long framecolor = 0xffffff;
+int  framevgacolor = 0x0f;
+long framescreensize = 0;
+int framecolordepth = 0;
+
+/* prepare the framebuffer device */
+void vgabegin() {
+
+/* see if we can open the framebuffer device */
+	framedesc = open("/dev/fb0", O_RDWR);
+	if (!framedesc) {
+		printf("** error opening frame buffer \n");
+		return;
+	} 
+
+/* now get the variable info of the screen */
+	if (ioctl(framedesc, FBIOGET_VSCREENINFO, &vinfo)) {
+		printf("** error reading screen information \n");
+		return;
+	}
+	printf("** detected screen %dx%d, %dbpp \n", vinfo.xres, vinfo.yres, vinfo.bits_per_pixel);
+
+/* BASIC currently does 24 bit color only */
+	memcpy(&orig_vinfo, &vinfo, sizeof(struct fb_var_screeninfo)); 
+/*
+	vinfo.bits_per_pixel = 24; 
+	if (ioctl(framedesc, FBIOPUT_VSCREENINFO, &vinfo)) {
+		printf("** error setting variable information \n");
+		return;
+	}
+*/
+
+/* how much color have we got */
+	framecolordepth = vinfo.bits_per_pixel;
+
+/* get the fixed information of the screen */
+	if (ioctl(framedesc, FBIOGET_FSCREENINFO, &finfo)) {
+		printf("Error reading fixed information.\n");
+		return;
+	}
+
+/* now ready to memory map the screen - evil, we assume 24 bit without checking */
+
+	framescreensize = (framecolordepth/8) * vinfo.xres * vinfo.yres;  
+	framemem = (char*)mmap(0, framescreensize, PROT_READ | PROT_WRITE, MAP_SHARED, framedesc, 0);
+	if ((int)framemem == -1) {
+		printf("** error failed to mmap.\n");
+		framemem=0;
+		return;
+	}
+
+/* if all went well we have valid non -1 framemem and can continue */
+}
+
+/* this function does not exist in the ESP32 world because we don't care there */
+void vgaend() {
+	if ((int)framemem) munmap(framemem, framescreensize); 
+	if (ioctl(framedesc, FBIOPUT_VSCREENINFO, &orig_vinfo)) {
+		printf("** error re-setting variable information \n");
+	}
+	close(framedesc);
+}
+
+/* set the color variable depending on the color depth*/
+void rgbcolor(int r, int g, int b) {
+	switch (framecolordepth/8) {
+	case 4:
+		framecolor = (((long)r << 16) & 0x00ff0000) | (((long)g << 8) & 0x0000ff00) | ((long)b & 0x000000ff); /* untested */
+		break;
+	case 3:
+		framecolor = (((long)r << 16) & 0x00ff0000) | (((long)g << 8) & 0x0000ff00) | ((long)b & 0x000000ff);
+		break;
+	case 2:
+		framecolor = ((long) (r & 0xff) >> 3) << 10 | ((long) (g & 0xff) >> 2) << 6 | ((long) (b & 0xff) >> 3); /* untested */
+		break;
+	case 1:
+		framecolor = ((long) (r & 0xff) >> 5) << 5 | ((long) (g & 0xff) >> 5) << 2 | ((long) (b & 0xff) >> 6); /* untested */
+		break;
+	}
+}
+
+/* this is taken from the Arduino TFT code */
+void vgacolor(short c) {
+  short base=128;
+  framevgacolor=c;
+  if (c==8) { rgbcolor(64, 64, 64); return; }
+  if (c>8) base=255;
+  rgbcolor(base*(c&1), base*((c&2)/2), base*((c&4)/4));  
+}
+
+/* plot directly into the framebuffer */
+void plot(int x, int y) {
+	unsigned long pix_offset;
+
+/* is everything in range, no error here */
+	if (x < 0 || y < 0 || x >= vinfo.xres || y >= vinfo.yres) return; 
+
+/* find the memory location */
+	pix_offset = (framecolordepth/8) * x + y * finfo.line_length;
+
+	if (pix_offset < 0 || pix_offset+ (framecolordepth/8-1) > framescreensize) return;
+
+/* write to the buffer */
+	switch (framecolordepth/8) {
+	case 4:
+		*((char*)(framemem + pix_offset  )) = (unsigned char)(framecolor         & 0x000000ff);
+		*((char*)(framemem + pix_offset+1)) = (unsigned char)((framecolor >>  8) & 0x000000ff);
+		*((char*)(framemem + pix_offset+3)) = (unsigned char)((framecolor >> 16) & 0x000000ff);
+		break;
+	case 3:
+		*((char*)(framemem + pix_offset  )) = (unsigned char)(framecolor         & 0x000000ff);
+		*((char*)(framemem + pix_offset+1)) = (unsigned char)((framecolor >>  8) & 0x000000ff);
+		*((char*)(framemem + pix_offset+2)) = (unsigned char)((framecolor >> 16) & 0x000000ff);
+		break;
+	case 2:
+		*((char*)(framemem + pix_offset  )) = (unsigned char)((framecolor & 0x1f) + (((framecolor >> 5) & 0x03) << 6));
+		*((char*)(framemem + pix_offset+1)) = (unsigned char)((framecolor >> 7) & 0xff);
+		break;
+	case 1:
+		*((char*)(framemem + pix_offset  )) = (unsigned char)(framecolor         & 0x000000ff);
+		break;
+	}
+
+}
+
+/* Bresenham's algorith from Wikipedia */
+void line(int x0, int y0, int x1, int y1) {
+	int dx, dy, sx, sy;
+	int error, e2;
+	
+	dx=abs(x0-x1);
+	sx=x0 < x1 ? 1 : -1;
+	dy=-abs(y1-y0);
+	sy=y0 < y1 ? 1 : -1;
+	error=dx+dy;
+
+	while(1) {
+		plot(x0, y0);
+		if (x0 == x1 && y0 == y1) break;
+		e2=2*error;
+		if (e2 > dy) {
+			if (x0 == x1) break;
+			error=error+dy;
+			x0=x0+sx;
+		}
+		if (e2 <= dx) {
+			if (y0 == y1) break;
+			error=error+dx;
+			y0=y0+sy;
+		}
+	}
+}
+
+/* rects could also be drawn with hline and vline */
+void rect(int x0, int y0, int x1, int y1) {
+	line(x0, y0, x1, y0);
+	line(x1, y0, x1, y1);
+	line(x1, y1, x0, y1);
+	line(x0, y1, x0, y0); 
+}
+
+/* filled rect, also just using line right now */
+void frect(int x0, int y0, int x1, int y1) {
+	int dx, sx;
+	int x;
+	sx=x0 < x1 ? 1 : -1;
+	for(x=x0; x != x1; x=x+sx) line(x, y0, x, y1);
+}
+
+/* Bresenham for circles, based on Alois Zingl's work */
+void circle(int x0, int y0, int r) {
+	int x, y, err;
+	x=-r;
+	y=0; 
+	err=2-2*r;
+	do {
+		plot(x0-x, y0+y);
+		plot(x0-y, y0-x);
+		plot(x0+x, y0-y);
+		plot(x0+y, y0+x);
+		r=err;
+		if (r <= y) err+=++y*2+1;
+		if (r > x || err > y) err+=++x*2+1;
+	} while (x < 0);
+}
+
+/* for filled circles draw lines instead of points */
+void fcircle(int x0, int y0, int r) {
+	int x, y, err;
+	x=-r;
+	y=0; 
+	err=2-2*r;
+	do {
+		line(x0-x, y0+y, x0+x, y0+y);
+		line(x0+x, y0-y, x0-x, y0-y);
+		r=err;
+		if (r <= y) err+=++y*2+1;
+		if (r > x || err > y) err+=++x*2+1;
+	} while (x < 0);
+}
+
+/* not needed really, now, later yes ;-) */
+void vgawrite(char c) {}
+#endif
+
+/* 
+ * Keyboard code stubs
+ * keyboards can implement 
+ * 	kbdbegin()
+ * they need to provide
+ * 	kbdavailable(), kbdread(), kbdcheckch()
+ * the later is for interrupting running BASIC code
+ */
+void kbdbegin() {}
+int kbdstat(char c) {return 0; }
+char kbdavailable(){ return 0;}
+char kbdread() { return 0;}
+char kbdcheckch() { return 0;}
+
+/* vt52 code stubs - unused here - needed for basic.c */
+mem_t vt52avail() {return 0;}
+char vt52read() { return 0; }
+
+/* Display driver would be here, together with vt52 */
+
+/* 
+ * Real Time clock code 
+ */
+#define HASCLOCK
+
+void rtcbegin() {}
+
+short rtcget(short i) {
+	struct timeb thetime;
+	struct tm *ltime;
+	ftime(&thetime);
+	ltime=localtime(&thetime.time);
+	switch (i) {
+		case 0: 
+			return ltime->tm_sec;
+		case 1:
+			return ltime->tm_min;
+		case 2:
+			return ltime->tm_hour;
+		case 3:
+			return ltime->tm_wday;
+		case 4:
+			return ltime->tm_mday;
+		case 5:
+			return ltime->tm_mon+1;
+		case 6:
+			return ltime->tm_year-100;
+		default:
+			return 0;
+	}
+}
+
+void rtcset(uint8_t i, short v) {}
+
+
+/* 
+ * Wifi and MQTT code 
+ */
+#ifndef POSIXMQTT
+void netbegin() {}
+char netconnected() { return 0; }
+void mqttbegin() {}
+int mqttstat(char c) {return 0; }
+int  mqttstate() {return -1;}
+void mqttsubscribe(char *t) {}
+void mqttsettopic(char *t) {}
+void mqttouts(char *m, short l) {}
+void mqttins(char *b, short nb) { z.a=0; };
+char mqttinch() {return 0;};
+#else 
+/* we use mosquitto */
+#include <mosquitto.h>
+/* we assume to be on the network */
+void netbegin() {}
+char netconnected() { return 1; }
+/* the mqtt code */
+void mqttbegin() {}
+int mqttstat(char c) {return 0; }
+int  mqttstate() {return -1;}
+void mqttsubscribe(char *t) {}
+void mqttsettopic(char *t) {}
+void mqttouts(char *m, short l) {}
+void mqttins(char *b, short nb) { z.a=0; };
+char mqttinch() {return 0;};
+#endif
+
+/* 
+ *	EEPROM handling, these function enable the @E array and 
+ *	loading and saving to EEPROM with the "!" mechanism
+ *	a filesystem based dummy
+ */ 
+signed char eeprom[EEPROMSIZE];
+void ebegin(){ 
+	int i;
+	FILE* efile;
+	for (i=0; i<EEPROMSIZE; i++) eeprom[i]=-1;
+	efile=fopen("eeprom.dat", "r");
+	if (efile) fread(eeprom, EEPROMSIZE, 1, efile);
+}
+
+void eflush(){
+	FILE* efile;
+	efile=fopen("eeprom.dat", "w");
+	if (efile) fwrite(eeprom, EEPROMSIZE, 1, efile);
+	fclose(efile);
+}
+
+address_t elength() { return EEPROMSIZE; }
+void eupdate(address_t a, mem_t c) { if (a>=0 && a<EEPROMSIZE) eeprom[a]=c; }
+mem_t eread(address_t a) { if (a>=0 && a<EEPROMSIZE) return eeprom[a]; else return -1;  }
+
+/* 
+ *	the wrappers of the arduino io functions, to avoid 
+ */	
+#if !defined(POSIXWIRING) && !defined(POSIXPIGPIO)
+void aread(){ pop(); push(0); }
+void dread(){ pop(); push(0); }
+void awrite(address_t p, address_t v){}
+void dwrite(address_t p, address_t v){}
+void pinm(address_t p, address_t m){}
+#endif
+
+#ifdef POSIXWIRING
+void aread(){ push(analogRead(pop())); }
+void dread(){ push(digitalRead(pop())); }
+
+
+void awrite(address_t p, address_t v){
+	if (v >= 0 && v<256) analogWrite(p, v);
+	else error(EORANGE);
+}
+
+void dwrite(address_t p, address_t v){
+	if (v == 0) digitalWrite(p, LOW);
+	else if (v == 1) digitalWrite(p, HIGH);
+	else error(EORANGE);
+}
+
+/* pin Modes without range check, values in wiringPi are different from Arduino*/
+void pinm(address_t p, address_t m){
+	if (m>=0) pinMode(p, m);
+	else error(EORANGE); 
+}
+#endif
+
+/* the pigpio library */
+#ifdef POSIXPIGPIO
+
+
+void aread(){ pop(); push(0); }
+
+
+void dread(){ 
+	push(gpio_read(pigpio_pi, pop()));
+}
+
+void awrite(address_t p, address_t v){
+	set_PWM_dutycycle(pigpio_pi, p, v);
+}
+
+
+void dwrite(address_t p, address_t v){
+	gpio_write(pigpio_pi, p, v);
+}
+
+void pinm(address_t p, address_t m){
+	set_mode(pigpio_pi, p, m);
+}
+#endif
+
+/* we need to do millis by hand except for RASPPI with wiring */
+#if !defined(POSIXWIRING)
+unsigned long millis() { 
+	struct timeb thetime;
+	ftime(&thetime);
+	return (thetime.time-start_time.time)*1000+(thetime.millitm-start_time.millitm);
+}
+#endif
+
+void bpulsein() { pop(); pop(); pop(); push(0); }
+void bpulseout(short a) { while (a--) pop(); }
+void btone(short a) { pop(); pop(); if (a == 3) pop(); }
+
+/* the POSIX code has no yield as it runs on an OS */
+void yieldfunction() {}
+
+void longyieldfunction() {
+#ifdef BASICBGTASK
+/* polling for the BREAKCHAR */
+#ifdef POSIXNONBLOCKING
+	if (checkch() == BREAKCHAR) breakcondition=1;
+#endif
+#endif
+}
+
+void yieldschedule() {}
+
+/* 
+ *	The file system driver - all methods needed to support BASIC fs access
+ *	MSDOS to be done 
+ *
+ * file system code is a wrapper around the POSIX API
+ */
+void fsbegin(char v) {}
+#define FILESYSTEMDRIVER
+FILE* ifile;
+FILE* ofile;
+#ifndef MSDOS
+DIR* root;
+struct dirent* file; 
+#else
+void* root;
+void* file;
+#endif 
+
+/* POSIX OSes always have filesystems */
+int fsstat(char c) {return 1; }
+
+/*
+ *	File I/O function on an Arduino
+ * 
+ * filewrite(), fileread(), fileavailable() as byte access
+ * open and close is handled separately by (i/o)file(open/close)
+ * only one file can be open for write and read at the same time
+ */
+void filewrite(char c) { 
+	if (ofile) 
+		fputc(c, ofile); 
+	else 
+		ert=1;
+}
+
+char fileread(){
+	char c;
+	if (ifile) c=fgetc(ifile); else { ert=1; return 0; }
+	if (cheof(c)) ert=-1;
+	return c;
+}
+
+char ifileopen(const char* filename){
+	ifile=fopen(filename, "r");
+	// return (int) ifile;
+	return ifile!=0;
+}
+
+void ifileclose(){
+	if (ifile) fclose(ifile);
+	ifile=0;	
+}
+
+char ofileopen(char* filename, const char* m){
+	ofile=fopen(filename, m);
+	// return (int) ofile; 
+	return ofile!=0;
+}
+
+void ofileclose(){ 
+	if (ofile) fclose(ofile); 
+	ofile=0;
+}
+
+int fileavailable(){ return !feof(ifile); }
+
+/*
+ * directory handling for the catalog function
+ * these methods are needed for a walkthtrough of 
+ * one directory
+ *
+ * rootopen()
+ * while rootnextfile()
+ * 	if rootisfile() print rootfilename() rootfilesize()
+ *	rootfileclose()
+ * rootclose()
+ */
+#ifdef MSDOS
+#include <dos.h>
+#include <dir.h>
+struct ffblk *bffblk; 
+#endif
+
+void rootopen() {
+#ifndef MSDOS
+	root=opendir ("./");
+#else 
+	(void) findfirst("*.*", bffblk, 0);
+#endif
+}
+
+int rootnextfile() {
+#ifndef MSDOS
+  file = readdir(root);
+  return (file != 0);
+#else 
+  return (findnext(bffblk) == 0);
+#endif
+}
+
+int rootisfile() {
+#if !defined(MSDOS) && !defined(MINGW)
+  return (file->d_type == DT_REG);
+#else
+  return 1;
+#endif
+}
+
+const char* rootfilename() { 
+#ifndef MSDOS
+  return (file->d_name);
+#else
+  return (bffblk->ff_name);
+#endif  
+}
+
+long rootfilesize() { 
+#ifndef MSDOS
+	return 0;
+#else
+	return (bffblk->ff_fsize);
+#endif
+}
+
+void rootfileclose() {}
+void rootclose(){
+#ifndef MSDOS
+  (void) closedir(root);
+#endif  
+}
+
+/*
+ * remove method for files
+ */
+void removefile(char *filename) {
+	remove(filename);
+}
+
+/*
+ * formatting for fdisk of the internal filesystems
+ */
+void formatdisk(short i) {
+	outsc("Format not implemented on this platform\n");
+}
+
+/*
+ * Primary serial code, if NONBLOCKING is set, 
+ * platform dependent I/O is used. This means that 
+ * UNIXes use fcntl() to implement a serialcheckch
+ * and MSDOS as well als WIndows use kbhit(). 
+ * This serves only to interrupt programs with 
+ * BREAKCHAR at the moment. 
+ */
+#ifdef POSIXNONBLOCKING
+#if !defined(MSDOS) && !defined(MINGW)
+#include <fcntl.h>
+
+/* we need to poll the serial port in non blocking mode 
+		this slows it down so that we don't block an entire core 
+		read speed here is one character per millisecond which
+		is 8000 baud, no one can type that fast but tedious when
+		from stdin */
+/*
+void freecpu() {
+	struct timespec intervall;
+	struct timespec rtmp;
+	intervall.tv_sec=0;
+	intervall.tv_nsec=1000000;
+	nanosleep(&intervall, &rtmp);
+}
+*/
+
+/* for non blocking I/O try to modify the stdin file descriptor */
+void serialbegin() {
+/* we keep I/O mostly blocking here */
+/*
+ fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
+*/
+}
+
+/* get and unget the character in a non blocking way */
+short serialcheckch(){ 
+ 	fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
+	int ch=getchar();
+	ungetc(ch, stdin);
+	fcntl(0, F_SETFL, fcntl(0, F_GETFL) & ~O_NONBLOCK);
+	return ch;
+}
+
+/* check EOF, don't use feof()) here */
+short serialavailable() { 
+ if (cheof(serialcheckch())) return 0; else return 1;
+}
+
+/* two versions of serialread */
+char serialread() { 
+	char ch;
+/* blocking to let the OS handle the wait - this means: no call to byield() in interaction */
+	ch=getchar();
+	return ch;
+/* this is the code that waits - calls byield() often just like on the Arduino */
+/*
+	while (cheof(serialcheckch())) { byield(); freecpu(); }
+	return getchar(); 
+*/
+}
+
+/* flushes the serial code in non blocking mode */
+void serialflush() {
+	fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
+	while (!cheof(getchar()));
+	fcntl(0, F_SETFL, fcntl(0, F_GETFL) & ~O_NONBLOCK);
+}
+#else
+/* the non blocking MSDOS and MINGW code */
+#include <conio.h>
+/* we go way back in time here and do it like DOS did it */ 
+void serialbegin(){}
+
+/* we go through the terminal on read */
+char serialread() { 
+	return getchar();
+}
+
+/* check if a key is hit, get it and return it */
+short serialcheckch(){ 
+	if (kbhit()) return getch();
+}
+
+/* simple version */
+short serialavailable() {
+	return 1;
+}
+
+/* simple version */
+void serialflush() { }
+#endif
+#else 
+/* the blocking code only uses puchar and getchar */
+void serialbegin(){}
+char serialread() { return getchar(); }
+short serialcheckch(){ return 1; }
+short serialavailable() { return 1; }
+void serialflush() {}
+#endif
+
+int serialstat(char c) {
+	if (c == 0) return 1;
+	if (c == 1) return serial_baudrate;
+	return 0;
+}
+
+/* send the CSI sequence to start with ANSI */
+void sendcsi() {
+	putchar(27); putchar('['); /* CSI */
+}
+
+/* the vt52 state engine */
+#ifdef POSIXVT52TOANSI
+#include <stdlib.h>
+mem_t dspesc = 0;
+mem_t vt52s = 0;
+int cursory = 0;
+mem_t vt52active = 1;
+
+/* something little */
+uint8_t vt52number(char c) {
+	uint8_t b=c;
+	if (b>31) return b-32; else return 0;
+}
+
+/* set the cursor */
+void dspsetcursory(int i) {
+	cursory=i;
+}
+
+/* remember the position */
+void dspsetcursorx(int i) {
+	sendcsi();
+	printf("%d;%dH", abs(cursory)+1, abs(i)+1);
+}
+
+/* set colors, vga here */
+void dspsetfgcolor(int co) {
+	sendcsi();
+	if (co < 8) {
+		putchar('3');
+	} else {
+		putchar('9');
+		co=co-8;
+	}
+	putchar('0'+co);
+	putchar('m');
+}
+
+void dspsetbgcolor(int co) {
+	sendcsi();
+	if (co < 8) {
+		putchar('4');
+	} else {
+		putchar('1'); putchar('0');
+		co=co-8;
+	}
+	putchar('0'+co);
+	putchar('m');
+}
+
+/* vt52 state engine, a smaller version of the Arduino code*/
+void dspvt52(char* c){
+  
+/* reading and processing multi byte commands */
+  switch (vt52s) {
+    case 'Y':
+      if (dspesc == 2) { 
+        dspsetcursory(vt52number(*c));
+        dspesc=1; 
+        *c=0;
+        return;
+      }
+      if (dspesc == 1) { 
+        dspsetcursorx(vt52number(*c)); 
+        *c=0; 
+      }
+      vt52s=0; 
+      break;
+    case 'b':
+      dspsetfgcolor(vt52number(*c));
+      *c=0;
+      vt52s=0;
+      break;
+    case 'c':
+      dspsetbgcolor(vt52number(*c));
+      *c=0;
+      vt52s=0;
+      break;
+  }
+ 
+/* commands of the terminal in text mode */
+  switch (*c) {
+    case 'v': /* GEMDOS / TOS extension enable wrap */
+      break;
+    case 'w': /* GEMDOS / TOS extension disable wrap */
+      break;
+    case '^': /* Printer extensions - print on */
+      break;
+    case '_': /* Printer extensions - print off */
+      break;
+    case 'W': /* Printer extensions - print without display on */
+      break;
+    case 'X': /* Printer extensions - print without display off */
+      break;
+    case 'V': /* Printer extensions - print cursor line */
+      break;
+    case ']': /* Printer extension - print screen */
+      break;
+    case 'F': /* enter graphics mode */
+      break;
+    case 'G': /* exit graphics mode */
+      break;
+    case 'Z': // Ident 
+      break;
+    case '=': // alternate keypad on 
+    case '>': // alternate keypad off 
+      break;
+    case 'b': // GEMDOS / TOS extension text color 
+    case 'c': // GEMDOS / TOS extension background color 
+      vt52s=*c;
+      dspesc=1;
+      *c=0;
+      return;
+    case 'e': // GEMDOS / TOS extension enable cursor
+      break;
+    case 'f': // GEMDOS / TOS extension disable cursor 
+      break;
+    case 'p': // GEMDOS / TOS extension reverse video 
+      break;
+    case 'q': // GEMDOS / TOS extension normal video 
+      break;
+    case 'A': // cursor up
+    	sendcsi();
+    	putchar('A');
+      break;
+    case 'B': // cursor down 
+    	sendcsi();
+    	putchar('B');
+      break;
+    case 'C': // cursor right 
+    	sendcsi();
+    	putchar('C');
+      break; 
+    case 'D': // cursor left 
+    	sendcsi();
+    	putchar('D');
+      break;
+    case 'E': // GEMDOS / TOS extension clear screen 
+    	*c=12; 
+    	dspesc=0;
+      return;
+    case 'H': // cursor home 
+    	*c=2;
+    	dspesc=0;
+      return;  
+    case 'Y': // Set cursor position 
+      vt52s='Y';
+      dspesc=2;
+      *c=0;
+      return;
+    case 'J': // clear to end of screen 
+    	sendcsi();
+    	putchar('J');
+      break;
+    case 'd': // GEMDOS / TOS extension clear to start of screen 
+    	sendcsi();
+    	putchar('1'); putchar('J');
+      break;
+    case 'K': // clear to the end of line
+    	sendcsi();
+    	putchar('K');
+      break;
+    case 'l': // GEMDOS / TOS extension clear line 
+    	sendcsi();
+    	putchar('2'); putchar('K');
+      break;
+    case 'o': // GEMDOS / TOS extension clear to start of line
+    	sendcsi();
+    	putchar('1'); putchar('K');
+      break;
+    case 'k': // GEMDOS / TOS extension restore cursor
+      break;
+    case 'j': // GEMDOS / TOS extension save cursor
+      break;
+    case 'I': // reverse line feed
+    	putchar(27);
+    	putchar('M');
+      break;
+    case 'L': // Insert line
+      break;
+    case 'M': // Delete line - questionable 
+    	sendcsi();
+    	putchar('2'); putchar('K');
+      break;
+  }
+  dspesc=0;
+  *c=0;
+}
+#endif
+
+void serialwrite(char c) { 
+
+/* the vt52 state engine */
+#ifdef POSIXVT52TOANSI
+  if (dspesc) { 
+    dspvt52(&c); 
+    if (c == 0) return;
+  }
+
+/* ESC is caught here and we only listen to VT52 not to ANSI */
+  if (c == 27 && vt52active) {
+  	dspesc=1;
+  	return;
+  }
+#endif
+
+/* this is the character translation routine to convert the Arduino 
+	style characters 12 for CLS and 2 for HOME to ANSI, makes 
+	BASIC programs more compatible */
+#ifdef POSIXTERMINAL
+	switch (c) {
+/* form feed is clear screen - compatibility with Arduino code */
+		case 12:
+			sendcsi();
+			putchar('2'); putchar('J');
+/* home sequence in the arduino code */
+		case 2: 
+			sendcsi();
+			putchar('H');
+			return;
+	}
+#endif
+
+/* finally send the plain character */	
+	putchar(c);
+}
+
+
+/*
+ * reading from the console with inch 
+ * this mixes interpreter levels as inch is used here 
+ * this code needs to go to the main interpreter section after 
+ * thorough rewrite
+ */
+void consins(char *b, short nb) {
+	char c;
+	
+	z.a=1;
+	while(z.a < nb) {
+		c=inch();
+		if (c == '\r') c=inch();
+		if (c == '\n' || cheof(c)) { /* terminal character is either newline or EOF */
+			break;
+		} else {
+			b[z.a++]=c;
+		} 
+	}
+	b[z.a]=0x00;
+	z.a--;
+	b[0]=(unsigned char)z.a;
+}
+
+/* 
+ * handling the second serial interface - only done on Mac so far 
+ * test code
+ * 
+ * Tried to learn from https://www.pololu.com/docs/0J73/15.5
+ *
+ */
+#ifdef ARDUINOPRT
+#include <fcntl.h>
+#if !defined(MSDOS) && !defined(MINGW)
+#include <termios.h>
+#endif
+
+/* the file name of the printer port */
+int prtfile;
+
+/* the buffer to read one character */
+char prtbuf = 0;
+
+
+void prtbegin() {}
+
+char prtopen(char* filename, int mode) {
+#if !defined(MSDOS) && !defined(MINGW)
+
+/* try to open the device file */
+	prtfile=open(filename, O_RDWR | O_NOCTTY);
+	if (prtfile == -1) {
+		perror(filename);
+		return 0;
+	} 
+
+/* get rid of garbage */
+	tcflush(prtfile, TCIOFLUSH);
+
+/* configure the device */
+	struct termios opt;
+	(void) tcgetattr(prtfile, &opt);
+
+
+/* raw terminal settings
+  opt.c_iflag &= ~(INLCR | IGNCR | ICRNL | IXON | IXOFF);
+  opt.c_oflag &= ~(ONLCR | OCRNL);
+  opt.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
+*/
+
+/* timeout settings on read 100ms, read every character */
+  opt.c_cc[VTIME] = 1;
+  opt.c_cc[VMIN] = 0;
+
+/* set the baudrate */
+  switch (mode) {
+  	case 9600: 
+			cfsetospeed(&opt, B9600);
+			break;
+		default:
+			cfsetospeed(&opt, B9600);
+			break;
+  }
+  cfsetispeed(&opt, cfgetospeed(&opt));
+
+/* set the termin attributes */
+  tcsetattr(prtfile, TCSANOW, &opt);
+#endif
+
+	return 1;
+}
+
+void prtclose() {
+	if (prtfile) close(prtfile);
+}
+
+int prtstat(char c) {return 1; }
+void prtset(int s) {}
+
+/* write the characters byte by byte */
+void prtwrite(char c) {
+	int i=write(prtfile, &c, 1);
+	if (i != 1) ert=1;
+}
+
+/* read just one byte, map no bytes to EOF = -1 */
+char prtread() {
+	char c;
+
+/* something in the buffer? return it! */
+	if (prtbuf) {
+		c=prtbuf;
+		prtbuf=0;
+	} else {
+/* try to read */
+		int i=read(prtfile, &c, 1);
+		if (i < 0) {
+			ert=1;
+			return 0;
+		} 
+		if (i == 0) return -1;
+	}
+	return c;
+}
+
+/* not yet implemented */
+short prtcheckch(){ 
+	if (!prtbuf) { /* try to read */
+		int i=read(prtfile, &prtbuf, 1);
+		if (i <= 0) prtbuf=0;
+	}
+	return prtbuf; 
+}
+
+short prtavailable(){ 
+	return prtcheckch()!=0; 
+}
+
+#else
+void prtbegin() {}
+int prtstat(char c) {return 0; }
+void prtset(int s) {}
+void prtwrite(char c) {}
+char prtread() {return 0;}
+short prtcheckch(){ return 0; }
+short prtavailable(){ return 0; }
+#endif
+
+
+/* 
+ * The wire code 
+ */ 
+#if defined(POSIXWIRE) && defined(POSIXPIGPIO)
+#define HASWIRE
+uint8_t wire_slaveid = 0;
+
+/* open the wire connection in pigpio */
+void wirebegin() {
+}
+
+/* we return the handle here, inconsistent with the Arduino code */
+int wirestat(char c) {
+	return 1; 
+}
+
+void wireopen(char s, char m) {
+	if (m == 0) {
+		wire_slaveid=s;
+	} else if ( m == 1 ) { 
+		outsc("** wire slave mode not implemented"); outcr();
+	} else 
+		error(EORANGE);
+}
+
+
+/* read a number of bytes, depending on the string length */
+void wireins(char *b, uint8_t l) {
+	int handle;
+
+	handle=i2c_open(pigpio_pi, POSIXI2CBUS, wire_slaveid, 0);
+	if (handle < 0) { 
+		printf("** wire handle %d returned \n", handle);
+		ert=1; 
+	}
+
+	z.a=i2c_read_device(pigpio_pi, handle, b+1, l);
+
+	if (z.a < 0) {
+		ert=-1;
+		z.a=0;
+	} 
+	b[0]=z.a;
+
+	i2c_close(pigpio_pi, handle);
+}
+
+
+
+void wireouts(char *b, uint8_t l) {
+	int handle;
+
+	handle=i2c_open(pigpio_pi, POSIXI2CBUS, wire_slaveid, 0);
+	if (handle < 0) { 
+		printf("** wire handle %d returned \n", handle);
+		ert=1; 
+	}
+
+	if (i2c_write_device(pigpio_pi, handle, b, l) < 0) ert=-1;
+
+	i2c_close(pigpio_pi, handle);
+}
+
+short wireavailable() { return 1; }
+
+/* the register access functions */
+short wirereadbyte(short port) { 
+	int res, handle;
+	handle=i2c_open(pigpio_pi, POSIXI2CBUS, port, 0);
+	if (handle < 0) { 
+		printf("** wire handle %d returned \n", handle);
+		ert=1; 
+		return -1; 
+	}
+	
+	res=i2c_read_byte(pigpio_pi, handle);
+	i2c_close(pigpio_pi, handle);
+	return res; 
+}
+
+/* use the simple wire byte function */ 
+void wirewritebyte(short port, short data) { 
+	int res, handle;
+	handle=i2c_open(pigpio_pi, POSIXI2CBUS, port, 0);
+	if (handle < 0) { ert=1; return; }
+	
+	ert=i2c_write_byte(pigpio_pi, handle, data);
+
+	i2c_close(pigpio_pi, handle);
+}
+
+
+/* this code used the write byte function twice */
+/*
+void wirewriteword(short port, short data1, short data2) { 
+	int res, handle;
+	handle=i2c_open(pigpio_pi, POSIXI2CBUS, port, 0);
+	if (handle < 0) { ert=1; return; }
+	
+	ert=i2c_write_byte(pigpio_pi, handle, data1);
+	ert+=i2c_write_byte(pigpio_pi, handle, data2);
+
+	i2c_close(pigpio_pi, handle);
+}
+*/
+
+/* use the raw access function in a buffer */
+void wirewriteword(short port, short data1, short data2) { 
+	int res, handle;
+	mem_t buf[2];
+
+	handle=i2c_open(pigpio_pi, POSIXI2CBUS, port, 0);
+	if (handle < 0) { ert=1; return; }
+
+	buf[0]=data1;
+	buf[1]=data2;
+
+	if (i2c_write_device(pigpio_pi, handle, buf, 2) <0 ) ert=-1;
+
+	i2c_close(pigpio_pi, handle);
+}
+
+#else
+void wirebegin() {}
+int wirestat(char c) {return 0; }
+void wireopen(char s, char m) {}
+void wireins(char *b, uint8_t l) { b[0]=0; z.a=0; }
+void wireouts(char *b, uint8_t l) {}
+short wireavailable() { return 1; }
+short wirereadbyte(short port) { return 0; }
+void wirewritebyte(short port, short data) { return; }
+void wirewriteword(short port, short data1, short data2) { return; }
+#endif
+
+/* 
+ *	Read from the radio interface, radio is always block 
+ *	oriented. 
+ */
+int radiostat(char c) {return 0; }
+void radioset(int s) {}
+void radioins(char *b, short nb) { b[0]=0; b[1]=0; z.a=0; }
+void radioouts(char *b, short l) {}
+void iradioopen(char *filename) {}
+void oradioopen(char *filename) {}
+short radioavailable() { return 0; }
+
+/* Arduino sensors */
+void sensorbegin() {}
+number_t sensorread(short s, short v) {return 0;};
+
+/*
+ * Experimental code to simulate 64kb SPI SRAM modules
+ * 
+ * currently used to test the string code of the mem 
+ * interface
+ *
+ */
+
+#ifdef SPIRAMSIMULATOR
+#define USEMEMINTERFACE
+
+static mem_t* spiram;
+
+/* the RAM begin method sets the RAM to byte mode */
+address_t spirambegin() {
+  spiram=(mem_t*)malloc(65536);
+  if (maxnum>32767) return 65534; else return 32766;  
+}
+
+/* the simple unbuffered byte write, with a cast to signed char */
+void spiramrawwrite(address_t a, mem_t c) {spiram[a]=c;}
+
+/* the simple unbuffered byte read, with a cast to signed char */
+mem_t spiramrawread(address_t a) {return spiram[a];}
+
+/* the buffers calls, also only simulated here */
+
+void spiram_rwbufferwrite(address_t a, mem_t c) {spiram[a]=c;}
+
+mem_t spiram_rwbufferread(address_t a) {return spiram[a];}
+
+mem_t spiram_robufferread(address_t a) {return spiram[a];}
+
+/* to handle strings in SPIRAM situations two more buffers are needed 
+ * they store intermediate results of string operations. The buffersize 
+ * limits the maximum string length indepents of how big strings are set
+ */
+#define SPIRAMSBSIZE 128
+char spistrbuf1[SPIRAMSBSIZE];
+char spistrbuf2[SPIRAMSBSIZE];
+#endif
+
+/* stub for events */
+#ifdef HASEVENTS
+mem_t enableevent(mem_t pin) {
+	int i;
+  if ((i=eventindex(pin))<0) return 0; 
+  else {
+  	eventlist[i].enabled=1; 
+  	return 1;
+  }
+}
+void disableevent(mem_t pin) {}
+#endif
+
+
+#endif
+

data/Basic2/IoTBasic/Makefile

@@ -0,0 +1,91 @@
+###############################################################################
+# Makefile to compile code with arduino-cli for defined boards
+# on the command line.
+#
+# Author: Dirk Selbach, [email protected]
+# Inspired by: https://github.com/digiampietro/arduino-makefile/tree/master
+# 
+# Build targets:
+# 1) Build all defined boards
+#    make all
+# 2) Build ELF for an individual board
+#    make build/<short-name-of-the-board>/IoTBasic.ino.elf 
+#    e.g. make build/d1_mini/IoTBasic.ino.elf to build ELF for d1_mini board
+# 3) Remove build dir for all boards
+#    make clean
+# 4) Remove build dir for an individual board
+#    TODO
+#
+# Adding additional boards:
+# 1) Get FQBN name of the board you want to add: arduino-cli board listall
+# 2) Add the FQBN to the list in FQBN variable below
+# 3) Add short name (last part of FQBN) to the list in SBN variable below
+#
+###############################################################################
+
+# Let's check if arduino-cli is installed
+ifeq (, $(shell which arduino-cli))
+$(error "arduino-cli command not found. Please install and add to PATH. See: https://arduino.github.io/arduino-cli/1.2/")
+endif
+
+OSFAMILY	:= $(shell ( uname | sed "s/-.*//" ))
+MAKE_DIR	:= $(PWD)
+GIT_VERSION	:= $(shell git describe --abbrev=4 --dirty --always --tags)
+
+ifdef GIT_VERSION
+  CFLAGS = --build-property compiler.cpp.extra_flags=-DMYVERSION=\"$(GIT_VERSION)\"
+else
+  CFLAGS =
+endif
+
+# Fully qualified board name
+# For a full list of FQBNs see: arduino-cli board listall
+# To add a board add the FQBN to the list and the sort name to the SBN list below.
+FQBN	:= esp32:esp32:d1_mini32 esp8266:esp8266:d1_mini esp8266:esp8266:nodemcuv2
+
+# board short names (=last part of the FQBN)
+SBN	:= d1_mini32 d1_mini nodemcuv2
+
+#  Rule to extract the FQBN based on the short name
+get_full_name = $(filter %$(1),$(FQBN))
+
+# Verbosity level, e.g., -v for verbose output
+#VFLAG	:= -v
+VFLAG	:=
+
+# Sources and headers
+SRCINO	:= $(wildcard *.ino)
+SRC	:= $(wildcard *.ino *.c *.cpp mylib/*/*.ino)
+HDRS	:= $(wildcard *.h mylib/*/*.h)
+
+# Build directory (subdirs for the boards will be created within ELF build target)
+BUILD_DIR	:= build
+
+# Define the .elf output file for each board
+ELF_FILES	:= $(addprefix $(BUILD_DIR)/,$(addsuffix /$(SRCINO).elf,$(SBN)))
+
+$(info OSFAMILY     is [${OSFAMILY}])
+$(info MAKE_DIR     is [${MAKE_DIR}])
+$(info BUILD_DIR    is [${BUILD_DIR}])
+$(info SRCINO       is [${SRCINO}])
+$(info SRC          is [${SRC}])
+$(info HDRS         is [${HDRS}])
+$(info ELF_FILES    is [${ELF_FILES}])
+
+# Default target to build for all boards
+all: $(ELF_FILES)
+.PHONY: all
+
+# Build target for each board
+$(ELF_FILES): $(SRC) $(HDRS)
+#	echo "target: $@ prereq: $<"
+	@echo "Building for board: $(call get_full_name,$(patsubst build/%/IoTBasic.ino.elf,%,$@))"
+	@mkdir -p $(dir $@)
+	arduino-cli compile -b $(call get_full_name,$(patsubst build/%/IoTBasic.ino.elf,%,$@)) --build-path $(dir $@) $(VFLAG) $(CFLAGS)
+
+# Cleanup build dir (all boards)
+clean:
+	@echo "Cleaning the build directory completely"
+	rm -rf $(BUILD_DIR)
+.PHONY: clean
+

data/Basic2/IoTBasic/basic.h

@@ -0,0 +1,831 @@
+/*
+ *
+ *	$Id: basic.h,v 1.1 2023/09/27 15:23:20 stefan Exp stefan $
+ *
+ *	Stefan's basic interpreter 
+ *
+ *	See the licence file on 
+ *	https://github.com/slviajero/tinybasic for copyright/left.
+ *    (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)
+ *
+ *	Author: Stefan Lenz, [email protected]
+ *
+ *	basic.h are the core defintions and function protypes.
+ *
+ */
+
+/* 
+ * A few of the buffers and vars come from hardware.h. These are
+ * 
+ * #define BUFSIZE         
+ * #define STACKSIZE      
+ * #define GOSUBDEPTH      
+ * #define FORDEPTH        
+ * #define LINECACHESIZE
+ * 
+ * They depend on the hardware architecture and are configured there.
+ *
+ */
+
+/* Additional buffers and vars, VARSIZE only needed for Tinybasics */
+#define SBUFSIZE       	16*sizeof(number_t) 
+#define VARSIZE         26
+
+/* Default sizes of arrays and strings if they are not DIMed */
+#define ARRAYSIZEDEF    10
+#define STRSIZEDEF      32
+
+/* the maximum name length */
+#define MAXNAME         32
+
+/*
+ * The tokens for the BASIC keywords
+ *
+ *	All single character operators are their own tokens
+ *	ASCII values above 0x7f are used for tokens of keywords.
+ *	EOL is a token. 
+ * 
+ *  The two byte tokens are possible to extend the language beyond 
+ *  127 keywords.
+ */
+#define EOL			 0
+#define NUMBER   	 -127
+#define LINENUMBER   -126
+#define STRING   	 -125
+#define VARIABLE 	 -124
+#define STRINGVAR 	 -123
+#define ARRAYVAR     -122
+/* multi character tokens - BASEKEYWORD (3) */
+#define GREATEREQUAL -121
+#define LESSEREQUAL  -120
+#define NOTEQUAL	 -119
+/* this is the Palo Alto Language Set (19) */
+#define TPRINT  -118
+#define TLET    -117
+#define TINPUT  -116
+#define TGOTO   -115
+#define TGOSUB  -114
+#define TRETURN -113
+#define TIF     -112
+#define TFOR    -111
+#define TTO     -110
+#define TSTEP   -109
+#define TNEXT   -108
+#define TSTOP   -107
+#define TLIST   -106
+#define TNEW    -105
+#define TRUN    -104
+#define TABS    -103
+#define TRND    -102
+#define TSIZE   -101
+#define TREM    -100
+/* this is the Apple 1 language set in addition to Palo Alto (14) */
+#define TNOT    -99
+#define TAND	-98
+#define TOR 	-97
+#define TLEN	-96
+#define TSGN	-95	
+#define TPEEK	-94
+#define TDIM	-93
+#define TCLR	-92
+#define THIMEM  -91
+#define TTAB 	-90
+#define TTHEN   -89
+#define TEND    -88
+#define TPOKE	-87
+/* Stefan's tinybasic additions (14) */
+#define TCONT   -86
+#define TSQR	-85
+#define TPOW	-84
+#define TMAP	-83
+#define TDUMP 	-82
+#define TBREAK  -81
+#define TSAVE   -80
+#define TLOAD   -79
+#define TGET    -78
+#define TPUT    -77
+#define TSET    -76
+#define TCLS    -75
+#define TLOCATE -74
+#define TELSE   -73
+/* Arduino functions (10) */
+#define TPINM	-72
+#define TDWRITE	-71
+#define TDREAD	-70
+#define TAWRITE	-69
+#define TAREAD	-68
+#define TDELAY	-67
+#define TMILLIS	-66
+#define TTONE	-65
+#define TPULSE	-64
+#define TAZERO	-63
+#define TLED	-62
+/* the DOS functions (5) */
+#define TCATALOG    -61
+#define TDELETE -60
+#define TOPEN 	-59
+#define TCLOSE 	-58
+#define TFDISK  -57
+/* low level access of internal routines (2) */
+#define TUSR	-56
+#define TCALL 	-55
+/* mathematical functions (7) */
+#define TSIN 	-54
+#define TCOS    -53
+#define TTAN 	-52
+#define TATAN   -51
+#define TLOG    -50
+#define TEXP    -49
+#define TINT    -48
+/* graphics - rudimentary (7) */
+#define TCOLOR 	-47
+#define TPLOT   -46
+#define TLINE 	-45
+#define TCIRCLE -44
+#define TRECT   -43
+#define TFCIRCLE -42
+#define TFRECT   -41
+/* the Dartmouth extensions (6) */
+#define TDATA	-40
+#define TREAD   -39
+#define TRESTORE -38
+#define TDEF	-37
+#define TFN 	-36
+#define TON     -35
+/* darkarts (3) */
+#define TMALLOC -34
+#define TFIND   -33
+#define TEVAL   -32
+/* iot extensions (9) */
+#define TERROR	-31
+#define TAVAIL	-30
+#define TSTR	-29
+#define TINSTR	-28
+#define TVAL	-27
+#define TNETSTAT -26
+#define TSENSOR	-25
+#define TWIRE	-24
+#define TSLEEP	-23
+/* events and interrupts */
+#define TAFTER -22
+#define TEVERY -21
+#define TEVENT -20
+/* structured commands */
+#define TWHILE -19
+#define TWEND   -18
+#define TREPEAT -17
+#define TUNTIL -16
+#define TSWITCH -15
+#define TCASE -14
+#define TSWEND -13
+#define TDO -12
+#define TDEND -11
+/* multiline function extension */
+#define TFEND -10
+/* these are multibyte token extension, currently unused */
+/* using them would allow over 1000 BASIC keywords */
+#define TEXT7 -9
+#define TEXT6 -8
+#define TEXT5 -7
+#define TEXT4 -6
+#define TEXT3 -5
+#define TEXT2 -4 
+#define TEXT1 -3
+/* end of tokens */
+/* constants used for some purposes other than token */
+/* Indentifying a buffer on the heap */
+#define TBUFFER -2
+/* UNKNOWN is not used in the current code, the 
+ * lexer tokenizes everything blindly. There is a UNKNOWN hook 
+ * in statement for a grammar aware lexer */
+#define UNKNOWN -1
+
+/* alternative implementation using positive token values */
+#define TASC 1
+#define TCHR 2
+#define TRIGHT 3
+#define TLEFT 4
+#define TMID 5
+#define TSPC 6
+
+/* The editor and other helpers */
+#define TEDIT 7
+#define THELP 8
+
+/* bitwise operations, avoid 10 as a token value */
+#define TSHL 9
+#define TSHR 11
+#define TBIT 12
+/* 
+ * Extension tokens can be in the range from -128 upwards.
+ * one needs to set HASLONGTOKENS. Currently ony one set of 
+ * extension tokens is implemented ranging from -128 to -255.
+ *
+ * ****  right now unused and untested **** */
+
+ #define TCAM -128
+
+/* BASEKEYWORD is used by the lexer. From this keyword on it tries to match. */
+#define BASEKEYWORD -121
+
+/*
+ *	Interpreter states 
+ *	SRUN means running from a programm
+ *	SINT means interactive mode
+ *	SERUN means running directly from EEPROM
+ *		(enum would be the right way of doing this.)
+ */
+#define SINT 0
+#define SRUN 1
+#define SERUN 2
+
+/*
+ *	the message catalog
+ */
+#define MFILE		0
+#define MPROMPT		1
+#define MGREET		2
+#define MLINE		3
+#define MNUMBER		4
+#define MVARIABLE	5
+#define MARRAY		6
+#define MSTRING		7
+#define MSTRINGVAR	8
+#define EGENERAL    9
+#define EUNKNOWN    10
+#define ENUMBER     11
+#define EDIVIDE     12
+#define ELINE        13
+#define EOUTOFMEMORY 14
+#define ESTACK 		 15
+#define EORANGE 	 16
+#define ESTRING      17
+#define EVARIABLE	 18
+#define ELOOP        19
+#define EFILE 		 20
+#define EFUN 		 21
+#define EARGS       22
+#define EEEPROM	    23
+#define ESDCARD     24
+#define MBASICLANGSET 25
+#define MLANGSET    26
+#define MKEYWORDS    27
+
+
+/*
+ *	code for variable numbers and addresses sizes
+ *	the original code was 16 bit but can be extended here
+ * 	to arbitrary types 
+ *
+ *	number_t is the type for numerical work - either float or int
+ *  wnumber_t is the type containing the largest printable integer, 
+ *    for float keep this int on 32 bit and long on 8 bit unless you 
+ *    want to use very long integers, like 64 or 128 bit types. 
+ *  address_t is an unsigned type adddressing memory, default 16bit 
+ *  mem_t is a SIGNED 8bit character type.
+ *	index_t is a SIGNED minimum 16 bit integer type
+ *
+ *	works with the tacit assumption that 
+ *	sizeof(number_t) >= sizeof(address_t) 
+ *	and that the entire memory is smaller than the positive
+ * 	part of number type (!!)
+ *
+ *	we assume that float >= 4 bytes in the following
+ *
+ *	maxnum: the maximum accurate(!) integer of a 
+ *		32 bit float 
+ *	strindexsize: the index size of strings either 
+ *		1 byte or 2 bytes - no other values supported
+ */
+#ifdef HASFLOAT
+#ifdef HAS64BIT
+typedef double number_t;
+typedef long long wnumber_t;
+#else
+typedef float number_t;
+typedef long long wnumber_t;
+#endif
+#else
+#ifdef HAS64BIT
+typedef int64_t number_t;
+typedef int64_t wnumber_t;
+#elif defined(HAS32BITINT)
+typedef int32_t number_t;
+typedef int32_t wnumber_t;
+#else
+typedef int number_t;
+typedef int wnumber_t;
+#endif
+#endif
+/* default is 16bit addresses and max 64k memory, setting MEMSIZE in hardware.h overrides this */
+#if !defined(MEMSIZE) || MEMSIZE < 65536
+typedef uint16_t address_t; /* this type addresses memory */
+#else
+/* use this for large memory systems, tested occassionally */
+typedef uint32_t address_t;
+#endif
+typedef int8_t mem_t; /* a signed 8 bit type for the memory */
+typedef int index_t; /* this type counts at least 16 bit */
+#ifndef HASLONGTOKENS
+typedef int8_t token_t; /* the type of tokens, normally mem_t with a maximum of 127 commands and data types */
+#else
+typedef int16_t token_t; /* token type extension, allows more commands and symbols */
+#endif
+
+/* the memreader function type, a function accessing memory has to have this shape */
+typedef mem_t (*memreader_t)(address_t);
+typedef void (*memwriter_t)(address_t, mem_t);
+
+/* the worker function type - experimental */
+typedef void (*bworkfunction_t)();
+
+/* the location type, this is the cursor on the actual interpreter location */
+typedef struct { 
+    address_t location; 
+    token_t token; 
+} blocation_t;
+
+
+/* the new string type used in the reimplementation of the string functions */
+/* 
+ * stringlength_t is the maximum length of a string, currently only 2 bytes is really tested.
+ *      one byte lengthes may work, will be fixed soon to arbitrary types
+ *
+ * string_t says where we can find a string. It is either in BASIC memory and has a valid BASIC memory
+ *      address a, or it is in C memory outside mem[]. Then ir says where the string can be found.
+ *      This is necessary because BASIC can handle different memory layouts, EEPROM models and serial
+ *      memory chips. We cannot simply rely on data to be found in BASIC memory like in old 8 bit
+ *      computers or all in C memory like on modern Linux/Windows/Mac systems. 
+ *      
+ *      Components of the string_t:
+ *          - the address of the string in BASIC memory
+ *          - the C memory pointer ir to the string location, if this is 0, the string is somewhere outside C memory
+ *          - the length of the entire string 
+ *          - the dimension of the string strdim, this is the length of the memory segment reserved for the string
+ *          - the dimension of the string array, arraydim
+ */
+
+typedef uint16_t stringlength_t;
+
+typedef struct {
+    address_t address; 
+    char* ir; 
+    stringlength_t length;
+    address_t strdim; 
+    address_t arraydim;
+} string_t;
+
+/* 
+ * Two types for identifiying objects and lefthandsides.
+ *      name_t is the type for variable names and types.
+ *      lhsobject_t identifies an assignable object like variables,
+ *      arrays and strings.
+ * 
+ * Currently name_t only implements two letter objects and lhsobject_t
+ * only implements two dimensional arrays and one dimensional strings.
+ */
+typedef struct { 
+    token_t token; 
+    mem_t c[MAXNAME]; 
+    mem_t l;
+} name_t;
+
+/* used to identify mostly lefthandsides and some righthandsides with these conventions */
+typedef struct { 
+    name_t name;    /* the name of a variable */
+    address_t i;    /* the start value of a substring or the first index of a number array */
+    address_t j;    /*  the second index of an array */
+    address_t i2;   /* the second value of a substring string */
+    mem_t ps;       /* flag to indicate a pure string */
+} lhsobject_t;
+
+/* heap objects have a name a size and a payload address */
+typedef struct { 
+    name_t name; 
+    address_t address; 
+    address_t size; 
+} heap_t;
+
+/* 
+ * a general loop time, needed for the reimplementation of all loops 
+ * the loop time knows the variable of a for loop or alternatively 
+ * the type of the for loop. For this the token field of the name is 
+ * reused. At also knows the here address of the loops beginning and optinally 
+ * the end and the step
+ */
+typedef struct {
+    name_t var;
+    address_t varaddress; /* experimental to speed up loops */
+    address_t here;
+    number_t to;
+    number_t step;
+} bloop_t;
+
+/* 
+ * The accumulator type, used for the stack and the 
+ * arithmetic operations. 
+ */
+typedef union { 
+    number_t n; 
+    address_t a; 
+    index_t i;
+    stringlength_t s; 
+    mem_t c[sizeof(number_t)]; 
+} accu_t;
+
+/* the timer type, knows the linenumber and all the data of the timer */
+typedef struct {
+    mem_t enabled;
+    unsigned long last;
+    unsigned long interval; 
+    mem_t type;
+    address_t linenumber;
+} btimer_t;
+
+/* 
+ * The events API for Arduino with interrupt service routines
+ * analogous to the timer API.
+ * 
+ * we use raw modes here 
+ *
+ * #define CHANGE 1
+ * #define FALLING 2
+ * #define RISING 3
+ *
+ */
+
+/* event type for external events */
+typedef struct {
+    mem_t enabled;
+    mem_t pin;
+    mem_t mode;
+    mem_t type;
+    address_t linenumber;
+    mem_t active;
+} bevent_t;
+
+/* 
+ * Function prototypes, ordered by layers
+ * HAL - hardware abstraction
+ * Layer 0 - memory and I/O
+ * Layer 1 - Program storage and control
+ * Layer 2 - Where stuff happens
+ */
+
+/*
+ * Layer 0 functions - I/O and memory management 
+ */
+
+/* event types and functions */
+void bintroutine0();
+void bintroutine1();
+void bintroutine2();
+void bintroutine3();
+mem_t enableevent(mem_t);
+void disableevent(mem_t);
+mem_t eventindex(mem_t);
+mem_t addevent(mem_t, mem_t, mem_t, address_t);
+void deleteevent(mem_t);
+volatile bevent_t* findevent(mem_t);
+
+/* make room for BASIC */
+address_t ballocmem(); 
+
+/* handle files im EEPROM */
+void eload();
+void esave();
+
+/* starts programs from the filesystem */
+char autorun();
+
+/* display a startup banner */
+void displaybanner();
+
+/* the variable heap from Apple 1 BASIC */
+address_t bmalloc(name_t*, address_t);
+address_t bfind(name_t*);
+address_t bfree(name_t*);
+address_t blength (name_t*);
+
+/* normal variables of number_t */
+number_t getvar(name_t*);
+void setvar(name_t*, number_t);
+void clrvars();
+
+/* the new set of functions for memory access */
+number_t getnumber(address_t, memreader_t);
+address_t getaddress(address_t, memreader_t); 
+stringlength_t getstrlength(address_t, memreader_t);
+void setnumber(address_t, memwriter_t, number_t);
+void setaddress(address_t, memwriter_t, address_t);
+void setstrlength(address_t, memwriter_t, stringlength_t);
+
+/* setting names */
+address_t setname_heap(address_t, name_t*);
+address_t setname_pgm(address_t, name_t*);
+address_t getname(address_t, name_t*, memreader_t);
+mem_t cmpname(name_t*, name_t*);
+void zeroname(name_t*);
+void zeroheap(heap_t*);
+
+/* array and string handling */
+/* the multidim extension is experimental, here only 2 array dimensions implemented as test */
+address_t createarray(name_t*, address_t, address_t);
+void array(lhsobject_t*, mem_t, number_t*);
+address_t createstring(name_t*, address_t, address_t);
+void getstring(string_t*, name_t*, address_t, address_t);
+void setstringlength(name_t*, address_t, address_t);
+
+/* the user defined extension functions */
+number_t getusrvar();
+void setusrvar(number_t);
+number_t getusrarray(address_t);
+void setusrarray(address_t, number_t);
+void makeusrstring();
+number_t usrfunction(address_t, number_t);
+void usrcall(address_t);
+
+/* get keywords and tokens from PROGMEM */
+char* getkeyword(address_t);
+char* getmessage(char);
+token_t gettokenvalue(address_t);
+void printmessage(char);
+
+/* error handling */
+void error(token_t);
+void reseterror();
+void debugtoken();
+void bdebug(const char*);
+
+/* the arithemtic stack */
+void push(number_t);
+number_t pop();
+address_t popaddress();
+void drop();
+void clearst();
+
+/* READ DATA handling */
+void clrdata();
+
+/* FOR NEXT GOSUB stacks */
+void pushforstack(name_t*, number_t, number_t);
+void popforstack(name_t*, number_t*, number_t*);
+void dropforstack();
+void clrforstack();
+void pushgosubstack(mem_t);
+void popgosubstack();
+void dropgosubstack();
+void clrgosubstack();
+
+/* handling location rewinds */
+void pushlocation(blocation_t*);
+void poplocation(blocation_t*); 
+
+/* signal handling */
+void signalon();
+void signaloff();
+void signalhandler(int);
+
+/* output */
+void outcr();
+void outspc();
+void outsc(const char*);
+void outscf(const char *, index_t);
+
+/* console logger as external function for runtime */
+void consolelog(char*);
+void consolelognum(int);
+
+/* output a name */
+void outname(name_t*);
+
+/* I/O of number_t - floats and integers */
+address_t parsenumber(char*, number_t*);
+address_t parsenumbern(char*, number_t*); /* can do hex,oct,bin */
+address_t parsenumber2(char*, number_t*);
+address_t writenumber(char*, wnumber_t); 
+address_t writenumbern(char*, wnumber_t, mem_t); /* can do hex,oct,bin */
+address_t writenumber2(char*, number_t);
+address_t tinydtostrf(number_t, index_t, char*);
+int innumber(number_t*, char*, address_t);
+void outnumber(number_t);
+
+/* 	
+ * Layer 1 functions, provide data and do the heavy lifting 
+ * for layer 2 including lexical analysis, storing programs 
+ * and expression evaluation 
+ */
+
+/* lexical analysis */
+void whitespaces();
+void nexttoken();
+
+/* storing and retrieving programs */
+char nomemory(number_t);
+void storetoken(); 
+mem_t memread(address_t);
+mem_t memread2(address_t);
+void memwrite2(address_t, mem_t);
+mem_t beread(address_t);
+void beupdate(address_t, mem_t);
+void gettoken();
+void firstline();
+void nextline();
+
+void clrlinecache();
+void addlinecache(address_t, address_t);
+address_t findinlinecache(address_t);
+void findline(address_t);
+address_t myline(address_t);
+void moveblock(address_t, address_t, address_t);
+void zeroblock(address_t, address_t);
+void diag();
+void storeline();
+
+/* read arguments from the token stream and process them */
+char termsymbol();
+char expect(token_t, mem_t);
+char expectexpr();
+void parsearguments();
+void parsenarguments(char);
+void parsesubscripts();
+void parsefunction(void (*)(), short);
+void parseoperator(void (*)());
+void parsesubstring();
+
+/* mathematics and other functions for int and float */
+void xabs();
+void xsgn();
+void xpeek();
+void xmap();
+number_t rnd(); 
+void xrnd();
+void sqr();
+void xpow();
+number_t bpow(number_t, number_t);
+
+/* string values and string evaluation */
+void parsestringvar(string_t*, lhsobject_t*);
+char stringvalue(string_t*);
+void streval();
+
+/* floating point functions */
+void xsin();
+void xcos();
+void xtan();
+void xatan();
+void xlog();
+void xexp();
+void xint();
+
+/* expression evaluation */
+void factor();
+void power();
+void term();
+void addexpression();
+void compexpression();
+void notexpression();
+void andexpression();
+void expression();
+
+/* real time clock string stuff */
+void rtcmkstr();
+
+/* 
+ * Layer 2 - statements and functions 
+ * use the global variables 
+ */
+
+/* basic commands of the core language set */
+void xprint();
+void getstringtobuffer(string_t*, char*, stringlength_t);
+void lefthandside(lhsobject_t*);
+void assignnumber(lhsobject_t, number_t);
+void assignstring(string_t*, string_t*, stringlength_t);
+void assignment();
+void showprompt();
+void xinput();
+void xgoto();
+void xreturn();
+void xif();
+
+/* FOR NEXT loops */
+void findnextcmd();
+void findbraket(token_t, token_t);
+void xfor();
+void xbreak();
+void xcont();
+void xnext();
+
+/* WHILE WEND*/
+void xwhile();
+void xwend();
+
+/* REPEAT UNTIL */
+void xrepeat();
+void xuntil();
+
+/* control commands and misc */
+void outputtoken();
+void xlist();
+void xrun();
+void xnew();
+void xrem();
+void xclr();
+void xdim();
+void xpoke();
+void xtab();
+void xdump();
+void dumpmem(address_t, address_t, char);
+void xlocate();
+
+/* file access and other i/o */
+void stringtobuffer(char*, string_t*);
+void getfilename(char*, char);
+void xsave();
+void xload(const char*);
+void xget();
+void xput();
+void xset();
+void xnetstat();
+
+/* Arduino IO control interface */
+void xaread();
+void xdread();
+void xdwrite();
+void xawrite();
+void xpinm();
+void xdelay();
+void xtone();
+void btone(int);
+void bpulsein();
+
+/* graphics commands */
+void xcolor();
+void xplot();
+void xline();
+void xrect();
+void xcircle();
+void xfrect();
+void xfcircle();
+
+/* the darkarts */
+void xmalloc();
+void xfind();
+void xeval();
+
+/* IoT commands */
+void xavail();
+void xfsensor();
+void xsleep();
+void xwire();
+void xfwire();
+
+/* timers */
+void xafter();
+void xevent();
+
+/* File I/O functions */
+char streq(const char*, char*);
+void xcatalog();
+void xdelete();
+void xopen();
+void xfopen();
+void xclose();
+void xfdisk();
+
+/* low level access functions */
+void xcall();
+void xusr();
+
+/* the dartmouth stuff */
+void xdata();
+void nextdatarecord();
+void xread();
+void xrestore();
+void xdef();
+void xfn(mem_t);
+void xon();
+
+/* timers and interrupts */
+void xtimer();
+void resettimer(btimer_t*);
+
+/* structured BASIC extensions */
+void xwhile();
+void xwend(); 
+void xrepeat();
+void xuntil();
+void xswitch();
+void xcase();
+void xendswitch();
+
+/* the editor */
+void xedit(); 
+
+/* the statement loop */
+void statement();
+
+/* the extension functions */
+void bsetup();
+void bloop();

data/Basic2/IoTBasic/boards/aim65.h

@@ -0,0 +1,6 @@
+/* the AIM 65 lookalike */
+#define ARDUINOPS2
+#define DISPLAYCANSCROLL
+#define ARDUINOLCDI2C
+#define ARDUINOEEPROM
+#define STANDALONE

data/Basic2/IoTBasic/boards/avrlcd.h

@@ -0,0 +1,3 @@
+/* an AVR ARDUINO (UNO or MEGA) with the classical LCD shield */
+#define DISPLAYCANSCROLL
+#define LCDSHIELD

data/Basic2/IoTBasic/boards/avrmcufriend.h

@@ -0,0 +1,3 @@
+/* an AVR ARDUINO (UNO or MEGA) with a parallel TFT  */
+#define DISPLAYCANSCROLL
+#define ARDUINOMCUFRIEND

data/Basic2/IoTBasic/boards/duetft.h

@@ -0,0 +1,16 @@
+/*
+ * DUE with a TFT shield, standalone by default
+ */
+#undef  ARDUINOEEPROM
+#define ARDUINOPS2
+#undef ARDUINOUSBKBD
+#define DISPLAYCANSCROLL
+#define ARDUINOTFT
+#define ARDUINOSD
+#define ARDUINOWIRE
+#define ARDUINOPRT
+#define ARDUINORTC
+#define PS2DATAPIN 9
+#define PS2IRQPIN  8
+#define SDPIN 53
+#define STANDALONE

data/Basic2/IoTBasic/boards/esp01board.h

@@ -0,0 +1,25 @@
+i/* an ESP01 board, using the internal flash 
+ *  with the ESP01-8266 only pins 0 and 2 are usable freely
+ *  on ESP01-ESP32C3 this is 9 and 2 while 2 is an analog pin
+ *  9 cannot be pulled on low by any peripheral on boot because this 
+ *  brings the board to flash mode
+ */
+#undef ARDUINOEEPROM
+#define ESPSPIFFS
+#define ARDUINOMQTT
+#define ARDUINOWIRE
+#if defined(ARDUINOWIRE) && defined(ARDUINO_ARCH_ESP8266)
+#define SDA_PIN 0
+#define SCL_PIN 2
+#endif
+/* see:  https://github.com/espressif/arduino-esp32/issues/6376 
+ *  nothing should block the port, e.g. DHT or anything
+ */
+#if defined(ARDUINOWIRE) && defined(ARDUINO_ARCH_ESP32)
+#define SDA_PIN 9
+#define SCL_PIN 2
+#endif
+/*
+ *
+ * Currently only 8=SDA and 9=SCL works / tested with AHT10
+ */

data/Basic2/IoTBasic/boards/esp32board.h

@@ -0,0 +1,13 @@
+/* an ESP32 board with an ILI9488 display, 
+   some SD problems here with some hardware */
+#define ILI_CS 12
+#define ILI_DC 27
+#define ILI_RST 14
+#define ILI_LED 26
+#undef ARDUINOPICOSERIAL
+#define ESPSPIFFS
+#define DISPLAYCANSCROLL
+#define ARDUINOILI9488
+#define ARDUINOEEPROM
+#define ARDUINOMQTT
+#define ARDUINOWIRE

data/Basic2/IoTBasic/boards/esp32cam.h

@@ -0,0 +1,3 @@
+/* the ESP32 camera */
+/* needs an MMC SD card and has its own drivers */
+#define ESPSDCAM

data/Basic2/IoTBasic/boards/megaboard.h

@@ -0,0 +1,14 @@
+/*
+ *  A board for the MEGA with 64 kB RAM, SD Card, and real time clock
+ */
+#undef ARDUINOPICOSERIAL
+#define DISPLAYCANSCROLL
+#define ARDUINOLCDI2C
+#define ARDUINOEEPROM
+#define ARDUINOPRT
+#define ARDUINOSD
+#define ARDUINOWIRE
+#define ARDUINORTC 
+#define ARDUINOSPIRAM
+#define RAMPIN 53
+#define SDPIN  49

data/Basic2/IoTBasic/boards/megashield.h

@@ -0,0 +1,13 @@
+/*
+ * Mega with a Ethernet shield 
+ * standalone capable, Ethernet is not enabled by default
+ */
+#define ARDUINOEEPROM
+#define ARDUINOPS2
+#define DISPLAYCANSCROLL
+#define ARDUINOLCDI2C
+#define ARDUINOSD
+#define ARDUINOWIRE
+#define ARDUINOPRT
+#define SDPIN	4
+//#define ARDUINOETH

data/Basic2/IoTBasic/boards/megatft.h

@@ -0,0 +1,14 @@
+/*
+ * MEGA with a TFT shield, standalone by default
+ */
+#define ARDUINOEEPROM
+#define ARDUINOPS2
+#define DISPLAYCANSCROLL
+#define ARDUINOTFT
+#define ARDUINOSD
+#define ARDUINOWIRE
+#define ARDUINOPRT
+#define PS2DATAPIN 18
+#define PS2IRQPIN  19
+#define SDPIN 53
+#define STANDALONE

data/Basic2/IoTBasic/boards/mkr1010board.h

@@ -0,0 +1,18 @@
+/* a board based on the Arduino MKR 1010 Wifi 
+ *  made for low energy games 
+ */
+#define ILI_CS 7
+#define ILI_DC 4
+#define ILI_RST 6
+#define ILI_LED A3
+#undef  ARDUINOPICOSERIAL
+#define DISPLAYCANSCROLL
+#define ARDUINOILI9488
+#define ARDUINOEFS
+#define ARDUINOMQTT
+#define ARDUINOWIRE
+/* EEPROM emulation is possible, takes 2k of memory */
+#undef ARDUINOEEPROM
+/* careful with the setting, lockout possible easily */
+#undef ARDUINOUSBKBD
+#undef STANDALONE

data/Basic2/IoTBasic/boards/nanoboard.h

@@ -0,0 +1,14 @@
+/*
+ *Arduino Nano Every board with PS2 keyboard and sensor
+ */
+#undef ARDUINOPICOSERIAL 
+#define ARDUINOPS2
+#define DISPLAYCANSCROLL
+#define ARDUINOLCDI2C
+#define ARDUINOEEPROM
+#define ARDUINOPRT
+#define ARDUINOEFS
+#define ARDUINORTC
+#define ARDUINOWIRE
+#define EFSEEPROMADDR 0x050 /* use clock EEPROM 0x057, set to 0x050 for external EEPROM */
+#define STANDALONE

data/Basic2/IoTBasic/boards/rp2040board.h

@@ -0,0 +1,14 @@
+/* an RP2040 based board with an ILI9488 display */
+#undef ARDUINOPICOSERIAL
+#define DISPLAYCANSCROLL
+#define ARDUINOILI9488
+#undef ARDUINOEEPROM
+#define ARDUINOI2CEEPROM
+#define ARDUINOPRT
+#define ARDUINOSD
+#undef RP2040LITTLEFS
+#define ARDUINOWIRE
+#define ARDUINORTC 
+#define ARDUINOPS2
+#define ARDUINOMQTT
+#define  STANDALONE

data/Basic2/IoTBasic/boards/rp2040board2.h

@@ -0,0 +1,17 @@
+/* an RP2040 Raspberry Pi Pico based board with an ILI9488 display */
+#undef ARDUINOPICOSERIAL
+#define DISPLAYCANSCROLL
+#define ARDUINOILI9488
+#undef ARDUINOEEPROM
+#undef ARDUINOPRT
+#undef ARDUINOSD
+#define RP2040LITTLEFS
+#undef ARDUINOWIRE
+#undef ARDUINORTC 
+#undef ARDUINOPS2
+#undef ARDUINOMQTT
+#undef STANDALONE
+#define ILI_LED A2
+#define ILI_CS  15
+#define ILI_RST 14
+#define ILI_DC  13

data/Basic2/IoTBasic/boards/tdeck.h

@@ -0,0 +1,69 @@
+i/* 
+ *  The Liligo T-Deck configuration
+ *    supports the internal FFAT right now, SD not yet done
+ */
+/* these are the PIN definition from Lilygos utilities.h file */
+#define BOARD_POWERON       10
+#define BOARD_I2S_WS        5
+#define BOARD_I2S_BCK       7
+#define BOARD_I2S_DOUT      6
+#define BOARD_I2C_SDA       18
+#define BOARD_I2C_SCL       8
+#define BOARD_BAT_ADC       4
+#define BOARD_TOUCH_INT     16
+#define BOARD_KEYBOARD_INT  46
+#define BOARD_SDCARD_CS     39
+#define BOARD_TFT_CS        12
+#define RADIO_CS_PIN        9
+#define BOARD_TFT_DC        11
+#define BOARD_TFT_BACKLIGHT 42
+#define BOARD_SPI_MOSI      41
+#define BOARD_SPI_MISO      38
+#define BOARD_SPI_SCK       40
+#define BOARD_TBOX_G02      2
+#define BOARD_TBOX_G01      3
+#define BOARD_TBOX_G04      1
+#define BOARD_TBOX_G03      15
+#define BOARD_ES7210_MCLK   48
+#define BOARD_ES7210_LRCK   21
+#define BOARD_ES7210_SCK    47
+#define BOARD_ES7210_DIN    14
+#define RADIO_BUSY_PIN      13
+#define RADIO_RST_PIN       17
+#define RADIO_DIO1_PIN      45
+#define BOARD_BOOT_PIN      0
+#define BOARD_BL_PIN        42
+#define BOARD_GPS_TX_PIN    43
+#define BOARD_GPS_RX_PIN    44
+#ifndef RADIO_FREQ
+#define RADIO_FREQ           868.0
+#endif
+#ifndef RADIO_BANDWIDTH
+#define RADIO_BANDWIDTH      125.0
+#endif
+#ifndef RADIO_SF
+#define RADIO_SF             10
+#endif
+#ifndef RADIO_CR
+#define RADIO_CR             6
+#endif
+#ifndef RADIO_TX_POWER
+#define RADIO_TX_POWER       22
+#endif
+#define DEFAULT_OPA          100
+/* and now the BASIC stuff begins */
+/* either use the buildin FAT as a file system */
+#undef ESP32FAT
+/* or the SD card */
+#define ARDUINOSD
+#define SDPIN BOARD_SDCARD_CS
+/* the display */
+#define TFTESPI
+#define DISPLAYCANSCROLL
+/*the keyboard */
+#define ARDUINOI2CKBD
+#define SDA_PIN BOARD_I2C_SDA
+#define SCL_PIN BOARD_I2C_SCL
+#define I2CKBDADDR 0x55
+/* can run standalone now */
+#define STANDALONE

data/Basic2/IoTBasic/boards/ttgovga.h

@@ -0,0 +1,75 @@
+/* 
+ * VGA system with SD card, based on the TTGO VGA 1.4 
+ * ESP32 
+ * standalone by default, with MQTT
+ */
+#define ARDUINOEEPROM
+#define ARDUINOVGA
+#define ARDUINOSD
+#define SDPIN   13
+#define STANDALONE
+/*
+ * This is a large screen with 48 kB memory, good fonts. 
+ * with these settings a circle is round in my old 4:3 TFT.
+ * should work for most situations. Ideally the canvas 
+ * matches the TFT screen resolution.
+ * 
+ * Set COLUMNS and ROW for a smaller terminal.
+ * 
+ * The font is set automatically. Can be changed here for 
+ * smaller terminals. 
+ */
+#define TTGOVGACONTROLLER VGA16Controller
+#define TTGOVGARESOLUTION VGA_512x384_60Hz
+#define TTGOVGAFONT FONT_8x16
+#define TTGOVGACOLUMNS -1
+#define TTGOVGAROWS -1
+#define MEMSIZE 48000
+#undef ARDUINOMQTT
+// Runnings configs:
+/* VGA4 and network - flickery screen 640*480 */
+/* 
+#define TTGOVGACONTROLLER VGA4Controller
+#define TTGOVGACOLUMNS -1
+#define TTGOVGAROWS -1
+#define MEMSIZE 48000
+#define ARDUINOMQTT
+*/
+/* VGA4 and network - flickery screen 640*480 */
+/*
+#define TTGOVGACONTROLLER VGA4Controller
+#define TTGOVGARESOLUTION VGA_512x384_60Hz
+#define TTGOVGACOLUMNS -1
+#define TTGOVGAROWS -1
+#define MEMSIZE 64000
+#define ARDUINOMQTT
+*/
+/* VGA16, no network, stable sreen 640*480 */
+/*
+#define TTGOVGACONTROLLER VGA16Controller
+#define TTGOVGACOLUMNS -1
+#define TTGOVGAROWS -1
+#define MEMSIZE 32000
+#undef ARDUINOMQTT
+*/
+/* full VGA controller at 320*200 an 32 kB */
+/*
+#define TTGOVGACONTROLLER VGAController
+#define TTGOVGARESOLUTION VGA_320x200_75HzRetro 
+#define TTGOVGAFONT FONT_8x8
+#define TTGOVGACOLUMNS -1
+#define TTGOVGAROWS -1
+#define MEMSIZE 32000
+#undef ARDUINOMQTT
+*/
+/* A 4:3 screen with full VGA */
+/*
+#define TTGOVGACONTROLLER VGAController
+#define TTGOVGARESOLUTION VGA_400x300_60Hz
+#define TTGOVGAFONT FONT_8x8
+#define TTGOVGACOLUMNS -1
+#define TTGOVGAROWS -1
+#define MEMSIZE 32000
+#undef ARDUINOMQTT
+*/
+

data/Basic2/IoTBasic/boards/unoboard.h

@@ -0,0 +1,7 @@
+/* a UNO shield with memory and EFS EEPROM */
+#define ARDUINOEEPROM
+#define ARDUINOSPIRAM
+#define ARDUINOEFS
+#define ARDUINOWIRE
+#define EFSEEPROMADDR 0x050
+#define EFSEEPROMSIZE 65534

data/Basic2/IoTBasic/boards/wemosshield.h

@@ -0,0 +1,15 @@
+/*
+ * a Wemos ESP8266 with a mdified datalogger shield 
+ * standalone capable, with Wire and MQTT.
+ */
+#define ARDUINOEEPROM
+#define ARDUINOPS2
+#define DISPLAYCANSCROLL
+#define ARDUINOLCDI2C
+#define ARDUINOSD
+#define ARDUINORTC
+#define ARDUINOWIRE
+#define SDPIN 			D8
+#define PS2DATAPIN	D2
+#define PS2IRQPIN		D9
+#define ARDUINOMQTT

data/Basic2/IoTBasic/buildin/buildin-arduinotest.h

@@ -0,0 +1,84 @@
+const char buildin_pgm1[] PROGMEM = {
+"10 REM Test program for integer BASICs\n"
+"100 PRINT \"*** Core language features ***\"\n"
+"110 A=5: B=19: C=A-B: D=A+B: E=A*B: F=INT(B/A)\n"
+"120 PRINT \"Math:\"\n"
+"130 PRINT A,B,C,D,E,F\n"
+"140 PRINT A,B,A-B,A+B,A*B,INT(B/A)\n"
+"150 PRINT \"5 19 -14 24 95 3\"\n"
+"200 PRINT \"Loop and GOTO:\"\n"
+"210 FOR I=1 TO 10\n"
+"220 PRINT I,\n"
+"230 NEXT: PRINT \n"
+"240 FOR I=1\n"
+"250 PRINT I,: IF I=10 BREAK\n"
+"260 NEXT: PRINT\n"
+"270 I=1\n"
+"280 PRINT I,: I=I+1: IF I<=10: GOTO 280\n"
+"290 PRINT\n"
+"300 PRINT \"GOSUB and RETURN\"\n"
+"310 GOSUB 340\n"
+"320 PRINT \"Returned\"\n"
+"330 GOTO 400\n"
+"340 PRINT \"In GOSUB\"\n"
+"350 RETURN\n"
+"400 PRINT \"Functions\"\n"
+"410 A=-1: B=1: @R=1\n"
+"420 PRINT SGN(A), SGN(B), ABS(A), RND(10)\n"
+"430 PRINT \"-1 1 1\"\n"
+"500 PRINT \"*** Arduino features ***\"\n"
+"510 PRINT \"Blink\"\n"
+"520 PINM LED, 1\n"
+"530 FOR I=1 TO 4: DWRITE LED, 1: DELAY 200: DWRITE LED, 0: NEXT\n"
+"540 PRINT \"Time\"\n"
+"550 PRINT MILLIS(1): DELAY 200: PRINT MILLIS(1)\n"
+"560 PRINT \"EEPROM\"\n"
+"570 PRINT \"Size:\", @E\n"
+"580 FOR I=1 TO 4: PRINT I, @E(I): NEXT\n"
+"590 @E(1)=10: PRINT \"10=\",@E(1)\n"
+"600 PRINT \"*** Dartmouth features ***\"\n"
+"610 DEF FNF(X)=X*X \n"
+"620 X=5: PRINT \"X=\", X \n"
+"630 PRINT \"FNF(7)=\", FNF(7)\n"
+"640 PRINT \"X=\",X \n"
+"650 FOR I=1 TO 3\n"
+"660 ON I GOSUB 700, 710, 720\n"
+"670 NEXT\n"
+"680 GOTO 800\n"
+"700 PRINT \"One\": RETURN\n"
+"710 PRINT \"Two\": RETURN\n"
+"720 PRINT \"Three\": RETURN\n"
+"730 DATA \"Hello\", \"World\", 31414\n"
+"800 READ A$, B$: PRINT A$,B$\n"
+"810 READ A: PRINT \"PI is\",A\n"
+"820 PRINT \"DATA pointer is\", DATA\n"
+"900 PRINT \"*** Strings ***\"\n"
+"910 A$=\"Hello World\"\n"
+"920 PRINT A$, \":\", LEN(A$)\n"
+"930 FOR I=1 TO LEN(A$)\n"
+"940 PRINT TAB(I-1);A$(I)\n"
+"950 NEXT\n"
+"960 FOR I=1 TO LEN(A$)\n"
+"970 PRINT A$(1,I)\n"
+"980 NEXT\n"
+"990 B$=\"Arduino says \"\n"
+"1000 B$=B$+A$: PRINT B$\n"
+"1010 B$=STR$(A): PRINT \"PI is\", B$\n"
+"1020 B=VAL(B$): PRINT \"PI is\", B \n"
+"1030 PRINT \"String length pointer is\", @V\n"
+"1040 FOR I=1 TO 5\n"
+"1050 PRINT TAB(I-1);MID$(A$,I,LEN(A$)-2*I+1)\n"
+"1060 NEXT\n"
+"1070 FOR I=1 TO 5: PRINT LEFT$(A$,I): NEXT\n"
+"1080 FOR I=1 TO 5: PRINT TAB(5-I);RIGHT$(A$,I): NEXT\n"
+"\f"
+};
+const char buildin_pgm1_name[] PROGMEM = "*corep.bas";
+const char* const buildin_programs[] PROGMEM = {
+buildin_pgm1,
+0
+};
+const char* const buildin_program_names[] PROGMEM = {
+buildin_pgm1_name,
+0
+};

data/Basic2/IoTBasic/buildin/buildin-games.h

@@ -0,0 +1,324 @@
+const char buildin_pgm1[] PROGMEM = {
+"10 REM \"TIC TAC TOE from 101 BASIC games\"\n"
+"20 REM \"by David Ahl.\"\n"
+"30 REM \"Ported to Stefan's BASIC in 2021\"\n"
+"40 REM \"The machine goes first\"\n"
+"100 PRINT \"Welcome to tictactoe\"\n"
+"110 PRINT \"The game board is numbered:\"\n"
+"120 PRINT\n"
+"130 PRINT \"1  2  3\"\n"
+"140 PRINT \"8  9  4\"\n"
+"150 PRINT \"7  6  5\"\n"
+"160 PRINT\n"
+"200 REM \"Main Program\"\n"
+"210 PRINT \"Staring a new game\"\n"
+"230 A=9\n"
+"240 M=A\n"
+"250 GOSUB 800 \n"
+"260 P=M\n"
+"270 B=P%8+1\n"
+"280 M=B\n"
+"290 GOSUB 800 \n"
+"300 Q=M\n"
+"310 IF Q=(B+3)%8+1 GOTO 360\n"
+"320 C=(B+3)%8+1\n"
+"330 M=C\n"
+"340 GOSUB 900 \n"
+"350 GOTO 640 \n"
+"360 C=(B+1)%8+1\n"
+"370 M=C\n"
+"380 GOSUB 800 \n"
+"390 R=M\n"
+"400 IF R=(C+3)%8+1 GOTO 450\n"
+"410 D=(C+3)%8+1\n"
+"420 M=D\n"
+"430 GOSUB 900\n"
+"440 GOTO 640 \n"
+"450 IF P%2<>0 GOTO 500\n"
+"460 D=(C+6)%8+1\n"
+"470 M=D\n"
+"480 GOSUB 900\n"
+"490 GOTO 640 \n"
+"500 D=(C+2)%8+1\n"
+"510 M=D\n"
+"520 GOSUB 800 \n"
+"530 S=M\n"
+"540 IF S=(D+3)%8+1 GOTO 590\n"
+"550 E=(D+3)%8+1\n"
+"560 M=E\n"
+"570 GOSUB 900\n"
+"580 REM \"Game is a draw\"\n"
+"590 E=(D+5)%8+1\n"
+"600 M=E\n"
+"610 GOSUB 900\n"
+"620 PRINT \"The game is a draw.\"\n"
+"630 GOTO 200\n"
+"640 PRINT \"and wins!  ********\"\n"
+"650 GOTO 200\n"
+"800 REM \"Subroutine to ask user for the move\"\n"
+"810 GOSUB 900\n"
+"820 INPUT \"Your move? \", M\n"
+"830 RETURN\n"
+"900 REM \"Subroutine to display move\"\n"
+"910 PRINT \"Computer moves:\",M\n"
+"920 RETURN\n"
+"\f"
+};
+const char buildin_pgm1_name[] PROGMEM = "*tictac.bas";
+const char buildin_pgm2[] PROGMEM = {
+"10 REM \"Rocket from 101 Basic Games\"\n"
+"20 REM \"Ported to Stefan's BASIC in 2021\"\n"
+"30 PRINT\n"
+"100 PRINT \"LUNAR LANDING SIMULATION\"\n"
+"110 PRINT \"----- ------- ----------\":PRINT \n"
+"120 INPUT \"DO YOU WANT INSTRUCTIONS (YES OR NO)? \";A$\n"
+"130 IF A$(1,1)=\"N\" OR A$(1,1)=\"n\" THEN 390\n"
+"140 CLS \n"
+"150 PRINT \n"
+"200 PRINT \"YOU ARE LANDING ON THE MOON AND AND HAVE\"\n"
+"210 PRINT \"TAKEN OVER MANUAL CONTROL 1000 FEET\"\n"
+"215 PRINT \"ABOVE A GOOD LANDING SPOT.\": PRINT \n"
+"220 PRINT \"YOU HAVE A DOWNWARD VELOCITY OF 50 FEET/SEC.\"\n"
+"225 PRINT \"150 UNITS OF FUEL REMAIN.\": PRINT \n"
+"230 PRINT \"HERE ARE THE RULES THAT GOVERN YOUR DESCENT\"\n"
+"240 PRINT \"(1) AFTER EACH SECOND THE HEIGHT, VELOCITY, AND\"\n"
+"250 PRINT \"    REMAINING FUEL WILL BE REPORTED BY YOUR\"\n"
+"255 PRINT \"    ON-BOARD COMPUTER.\"\n"
+"260 PRINT \"(2) AFTER THE REPORT A '?' WILL APPEAR. ENTER\"\n"
+"270 PRINT \"    THE NUMBER OF UNITS OF FUEL YOU WISH TO BURN\"\n"
+"280 PRINT \"    DURING THE NEXT SECOND. EACH UNIT OF FUEL\"\n"
+"285 PRINT \"    WILL SLOW YOUR DESCENT BY 1 FOOT/SEC.\"\n"
+"310 PRINT \"(3) THE MAXIMUM THRUST OF YOUR ENGINE IS \"\n"
+"315 PRINT \"    30 FEET/SEC/SEC OR 30 UNITS OF FUEL\"\n"
+"320 PRINT \"    PER SECOND.\"\n"
+"330 PRINT \"(4) WHEN YOU CONTACT THE LUNAR SURFACE. YOUR \"\n"
+"340 PRINT \"    DESCENT ENGINE WILL AUTOMATICALLY SHUT DOWN\"\n"
+"345 PRINT \"    AND YOU WILL BE GIVEN A REPORT OF YOUR \"\n"
+"350 PRINT \"    LANDING SPEED AND REMAINING FUEL.\"\n"
+"360 PRINT \"(5) IF YOU RUN OUT OF FUEL THE '?' WILL NO\"\n"
+"370 PRINT \"    LONGER APPEAR BUT YOUR SECOND BY SECOND\"\n"
+"380 PRINT \"    REPORT WILL CONTINUE UNTIL YOU CONTACT THE\"\n"
+"385 PRINT \"    LUNAR SURFACE.\":PRINT \n"
+"390 PRINT \"BEGINNING LANDING PROCEDURE..........\":PRINT \n"
+"400 PRINT \"G O O D  L U C K ! ! !\"\n"
+"420 PRINT\n"
+"425 INPUT \"Read to go - press return \", A$\n"
+"426 CLS \n"
+"430 PRINT \"SEC  FEET  SPEED  FUEL \"\n"
+"450 PRINT\n"
+"455 T=0: H=1000: V=50: F=150\n"
+"490 PRINT #6,T,H,V,F;\" I\";\n"
+"495 TAB(H/70): PRINT \"*\"\n"
+"500 INPUT B\n"
+"510 IF B<0 THEN 650\n"
+"520 IF B>30 THEN B=30\n"
+"530 IF B>F THEN B=F\n"
+"540 V1=V-B+5\n"
+"560 F=F-B\n"
+"570 H=H-(V+V1)/2\n"
+"580 IF H<=0 THEN 670\n"
+"590 T=T+1\n"
+"600 V=V1\n"
+"610 IF F>0 THEN 490\n"
+"615 IF B=0 THEN 640\n"
+"620 PRINT \"**** OUT OF FUEL ****\"\n"
+"640 PRINT #6,T,H,V,F;\" I\";\n"
+"645 TAB(H/70): PRINT \"*\"\n"
+"650 B=0\n"
+"660 GOTO 540\n"
+"670 PRINT \"***** CONTACT *****\"\n"
+"680 H=H+(V1+V)/2\n"
+"690 IF B=5 THEN 720\n"
+"700 D=(-V+SQR(V*V+H*(10-2*B)))/(5-B)\n"
+"710 GOTO 730\n"
+"720 D=H/V\n"
+"730 V1=V+(5-B)*D\n"
+"760 PRINT \"TOUCHDOWN AT\"; T+D; \"SECONDS.\"\n"
+"770 PRINT \"LANDING VELOCITY=\"; V1; \"FEET/SEC.\"\n"
+"780 PRINT F; \"UNITS OF FUEL REMAINING.\"\n"
+"790 IF V1<>0 THEN 810\n"
+"800 PRINT \"CONGRATULATIONS! A PERFECT LANDING!!\"\n"
+"805 PRINT \"YOUR LICENSE WILL BE RENEWED.......LATER.\"\n"
+"810 IF ABS(V1)<2 THEN 840\n"
+"820 PRINT \"***** SORRY, BUT YOU BLEW IT!!!!\"\n"
+"830 PRINT \"APPROPRIATE CONDOLENCES WILL BE SENT TO YOUR NEXT OF KIN.\"\n"
+"840 PRINT\n"
+"850 INPUT \"ANOTHER MISSION? \"; A$\n"
+"860 IF A$(1,1)=\"Y\" OR A$(1,1)=\"y\" THEN 390\n"
+"870 PRINT: PRINT \"CONTROL OUT.\": PRINT \n"
+"999 END \n"
+"\f"
+};
+const char buildin_pgm2_name[] PROGMEM = "*rocket.bas";
+const char buildin_pgm3[] PROGMEM = {
+"100 REM \"NIM\"\n"
+"110 REM \"Ported by Stefan in 2022\"\n"
+"120 REM\n"
+"210 DIM A(100),B(100,11),D(2)\n"
+"220 PRINT \"THIS IS THE GAME OF NIM.\"\n"
+"230 PRINT \"DO YOU WANT INSTRUCTIONS\";\n"
+"240 INPUT Z$\n"
+"250 IF Z$=\"NO\" THEN 440\n"
+"260 IF Z$=\"no\" THEN 440\n"
+"270 IF Z$=\"YES\" THEN 310\n"
+"280 IF Z$=\"yes\" THEN 310\n"
+"290 PRINT \"PLEASE ANSWER YES OR NO\"\n"
+"300 GOTO 240\n"
+"310 PRINT \"THE GAME IS PLAYED WITH A NUMBER OF PILES OF OBJECTS.\"\n"
+"320 PRINT \"ANY NUMBER OF OBJECTS ARE REMOVED FROM ONE PILE BY YOU AND\"\n"
+"330 PRINT \"THE MACHINE ALTERNATELY.  ON YOUR TURN, YOU MAY TAKE\"\n"
+"340 PRINT \"ALL THE OBJECTS THAT REMAIN IN ANY PILE, BUT YOU MUST\"\n"
+"350 PRINT \"TAKE AT LEAST ONE OBJECT, AND YOU MAY TAKE OBJECTS FROM\"\n"
+"360 PRINT \"ONLY ONE PILE ON A SINGLE TURN.  YOU MUST SPECIFY WHETHER\"\n"
+"370 PRINT \"WINNING IS DEFINED AS TAKING OR NOT TAKING THE LAST OBJECT,\"\n"
+"380 PRINT \"THE NUMBER OF PILES IN THE GAME, AND HOW MANY OBJECTS ARE\"\n"
+"390 PRINT \"ORIGINALLY IN EACH PILE.  EACH PILE MAY CONTAIN A\"\n"
+"400 PRINT \"DIFFERENT NUMBER OF OBJECTS.\"\n"
+"410 PRINT \"THE MACHINE WILL SHOW ITS MOVE BY LISTING EACH PILE AND THE\"\n"
+"420 PRINT \"NUMBER OF OBJECTS REMAINING IN THE PILES AFTER  EACH OF ITS\"\n"
+"430 PRINT \"MOVES.\"\n"
+"440 PRINT\n"
+"450 PRINT \"ENTER WIN OPTION - 1 TO TAKE LAST, 2 TO AVOID LAST\";\n"
+"460 INPUT W\n"
+"470 IF W=1 THEN 490\n"
+"480 IF W<>2 THEN 450\n"
+"490 PRINT \"ENTER NUMBER OF PILES\";\n"
+"500 INPUT N\n"
+"510 IF N>100 THEN 490\n"
+"520 IF N<1 THEN 490\n"
+"530 IF N<>INT(N) THEN 490\n"
+"540 PRINT \"ENTER PILE SIZES\"\n"
+"550 FOR I=1 TO N\n"
+"560 PRINT I;\n"
+"570 INPUT A(I)\n"
+"580 IF A(I)>2000 THEN 560\n"
+"590 IF A(I)<1 THEN 560\n"
+"600 IF A(I)<>INT(A(I)) THEN 560\n"
+"610 NEXT I\n"
+"620 PRINT \"DO YOU WANT TO MOVE FIRST\";\n"
+"630 INPUT Q9$\n"
+"640 IF Q9$=\"YES\" THEN 1450\n"
+"650 IF Q9$=\"yes\" THEN 1450\n"
+"660 IF Q9$=\"NO\" THEN 700\n"
+"670 IF Q9$=\"no\" THEN 700\n"
+"680 PRINT \"PLEASE ANSWER YES OR NO.\"\n"
+"690 GOTO 630\n"
+"700 IF W=1 THEN 940\n"
+"710 LET C=0\n"
+"720 FOR I=1 TO N\n"
+"730 IF A(I)=0 THEN 770\n"
+"740 LET C=C+1\n"
+"750 IF C=3 THEN 840\n"
+"760 LET D(C)=I\n"
+"770 NEXT I\n"
+"780 IF C=2 THEN 920\n"
+"790 IF A(D(1))>1 THEN 820\n"
+"800 PRINT \"MACHINE LOSES\"\n"
+"810 GOTO 1640\n"
+"820 PRINT \"MACHINE WINS\"\n"
+"830 GOTO 1640\n"
+"840 LET C=0\n"
+"850 FOR I=1 TO N\n"
+"860 IF A(I)>1 THEN 940\n"
+"870 IF A(I)=0 THEN 890\n"
+"880 LET C=C+1\n"
+"890 NEXT I\n"
+"900 IF C/2<>INT(C/2) THEN 800\n"
+"910 GOTO 940\n"
+"920 IF A(D(1))=1 THEN 820\n"
+"930 IF A(D(2))=1 THEN 820\n"
+"940 FOR I=1 TO N\n"
+"950 LET E=A(I)\n"
+"960 FOR J=0 TO 10\n"
+"970 LET F=E/2\n"
+"980 LET B(I,J+1)=2*(F-INT(F))\n"
+"990 LET E=INT(F)\n"
+"1000 NEXT J\n"
+"1010 NEXT I\n"
+"1020 FOR J=10 TO 0 STEP -1\n"
+"1030 LET C=0\n"
+"1040 LET H=0\n"
+"1050 FOR I=1 TO N\n"
+"1060 IF B(I,J+1)=0 THEN 1110\n"
+"1070 LET C=C+1\n"
+"1080 IF A(I)<=H THEN 1110\n"
+"1090 LET H=A(I)\n"
+"1100 LET G=I\n"
+"1110 NEXT I\n"
+"1120 IF C/2<>INT(C/2) THEN 1190\n"
+"1130 NEXT J\n"
+"1140 LET E=INT(N*RND(1)+1)\n"
+"1150 IF A(E)=0 THEN 1140\n"
+"1160 LET F=INT(A(E)*RND(1)+1)\n"
+"1170 LET A(E)=A(E)-F\n"
+"1180 GOTO 1380\n"
+"1190 LET A(G)=0\n"
+"1200 FOR J=0 TO 10\n"
+"1210 LET B(G,J+1)=0\n"
+"1220 LET C=0\n"
+"1230 FOR I=1 TO N\n"
+"1240 IF B(I,J+1)=0 THEN 1260\n"
+"1250 LET C=C+1\n"
+"1260 NEXT I\n"
+"1270 LET A(G)=A(G)+2*(C/2-INT(C/2))*POW(2,J)\n"
+"1280 NEXT J\n"
+"1290 IF W=1 THEN 1380\n"
+"1300 LET C=0\n"
+"1310 FOR I=1 TO N\n"
+"1320 IF A(I)>1 THEN 1380\n"
+"1330 IF A(I)=0 THEN 1350\n"
+"1340 LET C=C+1\n"
+"1350 NEXT I\n"
+"1360 IF C/2<>INT(C/2) THEN 1380\n"
+"1370 LET A(G)=1-A(G)\n"
+"1380 PRINT \"PILE  SIZE\"\n"
+"1390 FOR I=1 TO N\n"
+"1400 PRINT #8;I,A(I)\n"
+"1410 NEXT I\n"
+"1420 IF W=2 THEN 1450\n"
+"1430 GOSUB 1570\n"
+"1440 IF Z=1 THEN 820\n"
+"1450 PRINT \"YOUR MOVE - PILE, NUMBER TO BE REMOVED\";\n"
+"1460 INPUT X,Y\n"
+"1470 IF X>N THEN 1450\n"
+"1480 IF X<1 THEN 1450\n"
+"1490 IF X<>INT(X) THEN 1450\n"
+"1500 IF Y>A(X) THEN 1450\n"
+"1510 IF Y<1 THEN 1450\n"
+"1520 IF Y<>INT(Y) THEN 1450\n"
+"1530 LET A(X)=A(X)-Y\n"
+"1540 GOSUB 1570\n"
+"1550 IF Z=1 THEN 800\n"
+"1560 GOTO 700\n"
+"1570 LET Z=0\n"
+"1580 FOR I=1 TO N\n"
+"1590 IF A(I)=0 THEN 1610\n"
+"1600 RETURN\n"
+"1610 NEXT I\n"
+"1620 LET Z=1\n"
+"1630 RETURN\n"
+"1640 PRINT \"DO YOU WANT TO PLAY ANOTHER GAME\";\n"
+"1650 INPUT Q9$\n"
+"1660 IF Q9$=\"YES\" THEN 1720\n"
+"1670 IF Q9$=\"yes\" THEN 1720\n"
+"1680 IF Q9$=\"NO\" THEN 1730\n"
+"1690 IF Q9$=\"no\" THEN 1730\n"
+"1700 PRINT \"PLEASE.  YES OR NO.\"\n"
+"1710 GOTO 1650 \n"
+"1720 GOTO 440\n"
+"1730 END\n"
+"\f"
+};
+const char buildin_pgm3_name[] PROGMEM = "*nim.bas";
+const char* const buildin_programs[] PROGMEM = {
+buildin_pgm1,
+buildin_pgm2,
+buildin_pgm3,
+0
+};
+const char* const buildin_program_names[] PROGMEM = {
+buildin_pgm1_name,
+buildin_pgm2_name,
+buildin_pgm3_name,
+0
+};

data/Basic2/IoTBasic/buildin/buildin-tutorial.h

@@ -0,0 +1,288 @@
+const char buildin_pgm1[] PROGMEM = {
+"100 REM \"CALCULATING PI FOR HUNDREDS OF DIGITS\"\n"
+"110 REM \"THX TO ROSETTACODE.ORG FOR THE BASE OF THE PROGRAM\"\n"
+"120 REM \"SHOULD BE A BENCHMARK FOR THE BASIC INTERPRETER/COMPILER\"\n"
+"130 REM \"WRITTEN IN 2023 FOR FORUM.CLASSIC-COMPUTING.DE BY PETER DASSOW\"\n"
+"135 REM \"Ported to IoT BASIC by Guido Lehwalder\"\n"
+"136 REM \"Added some IoT BASIC features - Stefan Lenz, 2023\"\n"
+"137 CLS\n"
+"140 PRINT \"Calculating Pi as a BASIC benchmark.\"\n"
+"150 PRINT \"Enter number of digits: \";\n"
+"160 INPUT S$\n"
+"170 IF S$=\"\" THEN PRINT \"Nothing done.\": END\n"
+"180 N=VAL(S$): IF N<1 THEN PRINT \"Not a valid number.\":  GOTO 150\n"
+"190 REM \"N DETERMINES ALSO THE ARRAY (ABOUT 3-4 TIMES BIGGER)\"\n"
+"200 LN=INT(10*N/3)+16\n"
+"204 REM \"@ is the space on the heap for numbers, reserve 64 bytes\"\n"
+"205 IF LN>(@-64) THEN PRINT \"Not enough memory\": GOTO 150\n"
+"210 ND=1\n"
+"220 SM=MILLIS(1)\n"
+"225 REM \"Delete the array if already there\"\n"
+"230 IF FIND(A())<>0 THEN CLR A()\n"
+"235 REM \"Then redim\"\n"
+"240 DIM A(LN)\n"
+"250 N9=0\n"
+"260 PD=0\n"
+"270 REM\n"
+"280 FOR J=1 TO LN\n"
+"290 A(J)=2\n"
+"300 NEXT J\n"
+"310 REM \"Use of the modulo operator % speeds things up\"\n"
+"320 FOR J=1 TO N\n"
+"330 Q=0\n"
+"340 FOR I=LN TO 1 STEP -1\n"
+"350 X=10*A(I)+Q*I\n"
+"360 A(I)=X%(2*I-1)\n"
+"370 Q=INT(X/(2*I-1))\n"
+"380 NEXT I\n"
+"390 A(1)=Q%10\n"
+"400 Q=INT(Q/10)\n"
+"410 IF Q=9 THEN N9=N9+1:  GOTO 610\n"
+"420 IF Q<>10 THEN  GOTO 540\n"
+"430 REM \"Q==10\"\n"
+"440 D=PD+1:  GOSUB 670\n"
+"450 IF N9<=0 THEN  GOTO 500\n"
+"460 FOR K=1 TO N9\n"
+"470 D=0:  GOSUB 670\n"
+"480 NEXT K\n"
+"490 REM \"END IF\"\n"
+"500 PD=0\n"
+"510 N9=0\n"
+"520 GOTO 610\n"
+"530 REM \"Q<>10\"\n"
+"540 D=PD:  GOSUB 670\n"
+"550 PD=Q\n"
+"560 IF N9=0 THEN  GOTO 610\n"
+"570 FOR K=1 TO N9\n"
+"580 D=9:  GOSUB 670\n"
+"590 NEXT K\n"
+"600 N9=0\n"
+"610 NEXT J\n"
+"620 C$=(\"0\"+PD%10)\n"
+"621 PRINT C$\n"
+"630 EM=MILLIS(1)-SM\n"
+"635 PRINT \"Calculation time \";EM/1000;\" seconds.\"\n"
+"640 GOTO 140\n"
+"650 REM\n"
+"660 REM \"OUTPUT DIGITS\"\n"
+"670 C$=(\"0\"+D%10)\n"
+"671 IF ND=0 THEN PRINT C$;: RETURN\n"
+"680 IF D=0 THEN RETURN\n"
+"691 PRINT C$;\".\";\n"
+"700 ND=0\n"
+"710 RETURN\n"
+"\f"
+};
+const char buildin_pgm1_name[] PROGMEM = "*cpinew2.bas";
+const char buildin_pgm2[] PROGMEM = {
+"10 REM \"Solves the Euler 9 problem \"\n"
+"20 REM \"See https://projecteuler.net/problem=9 for details\"\n"
+"30 REM \"with a number theoretical approach\"\n"
+"100 PRINT \"Enter the circumference K of a triangle\"\n"
+"110 PRINT \"The program finds a pythagorean triangle\"\n"
+"120 PRINT \"a^2 + b^2 = c^2\"\n"
+"130 INPUT \"K= (0 to end) \",K \n"
+"140 IF K=0 THEN END \n"
+"150 IF K%2=0 THEN U=K/2: GOTO 200 \n"
+"160 PRINT \"K is odd, no solution\": GOTO 130 \n"
+"200 REM \"Main Program\"\n"
+"210 F=0 \n"
+"220 X=SQR(U/2)\n"
+"230 FOR I=1 TO X \n"
+"240 IF U%I<>0 THEN CONT \n"
+"250 FOR J=1 TO I \n"
+"260 D=I+J \n"
+"270 IF U%D<>0 THEN CONT \n"
+"280 IF D%2=0 THEN CONT \n"
+"290 R=I: Q=J \n"
+"300 GOSUB 800 \n"
+"310 IF R<>1 THEN CONT \n"
+"320 A=I*I-J*J \n"
+"330 B=2*I*J \n"
+"340 C=I*I+J*J \n"
+"350 PRINT \"Primitive triple\",A ,B, C \n"
+"360 PRINT \"Circumference=\",A+B+C \n"
+"370 S=K/(A+B+C)\n"
+"380 PRINT \"Scale with\",S \n"
+"390 PRINT \"Solution \",A*S, B*S, C*S \n"
+"400 F=1 \n"
+"420 NEXT \n"
+"430 NEXT \n"
+"440 REM \"All solutions found\"\n"
+"450 IF F=0 THEN PRINT \"No solution\"\n"
+"460 GOTO 130 \n"
+"800 REM \"Find GCD\"\n"
+"810 IF R=Q THEN RETURN \n"
+"820 IF R>Q THEN R=R-Q \n"
+"830 IF Q>R THEN Q=Q-R \n"
+"840 GOTO 810 \n"
+"\f"
+};
+const char buildin_pgm2_name[] PROGMEM = "*euler9.bas";
+const char buildin_pgm3[] PROGMEM = {
+"10 REM \"Calculates the Fibonacci numbers\"\n"
+"20 REM \"And the Golden Ratio on an Integer BASIC\"\n"
+"200 REM \"Main program\"\n"
+"210 N=19\n"
+"220 DIM A(N)\n"
+"230 A(1)=1\n"
+"240 A(2)=1\n"
+"250 FOR I=3 TO N\n"
+"260 IF A(I)>16000 THEN BREAK\n"
+"270 A(I)=A(I-1)+A(I-2)\n"
+"280 Q=A(I): D=A(I-1)\n"
+"290 PRINT #4;I,Q,D;\n"
+"300 GOSUB 500\n"
+"310 NEXT\n"
+"320 END\n"
+"500 REM \"Print a decimal ratio of a fraction\"\n"
+"520 Z=INT(Q/D)\n"
+"530 PRINT \" \";Z;\".\";\n"
+"540 FOR J=1 TO 10\n"
+"550 Z=Q%D\n"
+"560 Q=Z*10\n"
+"570 Z=INT(Q/D)\n"
+"580 PRINT Z;\n"
+"590 NEXT\n"
+"600 PRINT \" \"\n"
+"610 RETURN\n"
+"\f"
+};
+const char buildin_pgm3_name[] PROGMEM = "*fibo.bas";
+const char buildin_pgm4[] PROGMEM = {
+"100 REM \"Calculate the first N prime numbers\"\n"
+"110 REM \"and output them!\"\n"
+"200 CLR \n"
+"210 INPUT \"How many primes (0=stop)? \", N \n"
+"220 IF N=0 THEN 500\n"
+"230 DIM P(N): P(1)=2: P(2)=3: I=2 \n"
+"240 IF I=N THEN 360\n"
+"250 K=P(I)\n"
+"260 K=K+2 \n"
+"270 L=SQR(K)\n"
+"280 J=1 \n"
+"290 D=P(J)\n"
+"310 M=K%D \n"
+"320 IF M=0 THEN 260\n"
+"330 IF D<L THEN J=J+1: GOTO 290 \n"
+"340 I=I+1: P(I)=K \n"
+"350 GOTO 240 \n"
+"360 PRINT \"The first\",N ,\"primes are:\"\n"
+"370 FOR J=1 TO N \n"
+"380 PRINT #4,J ,P(J)\n"
+"390 NEXT \n"
+"400 GOTO 200\n"
+"500 END\n"
+"\f"
+};
+const char buildin_pgm4_name[] PROGMEM = "*primes.bas";
+const char buildin_pgm5[] PROGMEM = {
+"10 REM \"Calculate Factorial and Stirlings function\"\n"
+"20 REM \"\"\n"
+"100 REM \"Factorial\"\n"
+"110 L=20 \n"
+"120 DIM F(L)\n"
+"130 F(1)=1\n"
+"140 FOR I=2 TO L\n"
+"150 F(I)=F(I-1)*I \n"
+"160 NEXT \n"
+"200 REM \"Stirling\"\n"
+"210 P1=4*ATAN(1)\n"
+"220 DEF FNS(N)=SQR(2*P1*N)*EXP(N*(LOG(N)-1))\n"
+"300 REM \"Print table\"\n"
+"305 PRINT \"N\";: TAB(4)    \n"
+"310 PRINT \"FACT(N)\";: TAB(6)\n"
+"315 PRINT \"STIR(N)\";: TAB(6)\n"
+"320 PRINT \"Accuracy (%)\"\n"
+"330 FOR I=1 TO L\n"
+"340 PRINT #4, I, #12, F(I), FNS(I), (F(I)-FNS(I))/F(I)*100\n"
+"350 NEXT\n"
+"400 END\n"
+"\f"
+};
+const char buildin_pgm5_name[] PROGMEM = "*stir.bas";
+const char buildin_pgm6[] PROGMEM = {
+"10 REM \"TIC TAC TOE from 101 BASIC games\"\n"
+"20 REM \"by David Ahl.\"\n"
+"30 REM \"Ported to Stefan's BASIC in 2021\"\n"
+"40 REM \"The machine goes first\"\n"
+"100 PRINT \"Welcome to tictactoe\"\n"
+"110 PRINT \"The game board is numbered:\"\n"
+"120 PRINT\n"
+"130 PRINT \"1  2  3\"\n"
+"140 PRINT \"8  9  4\"\n"
+"150 PRINT \"7  6  5\"\n"
+"160 PRINT\n"
+"200 REM \"Main Program\"\n"
+"210 PRINT \"Staring a new game\"\n"
+"230 A=9\n"
+"240 M=A\n"
+"250 GOSUB 800 \n"
+"260 P=M\n"
+"270 B=P%8+1\n"
+"280 M=B\n"
+"290 GOSUB 800 \n"
+"300 Q=M\n"
+"310 IF Q=(B+3)%8+1 GOTO 360\n"
+"320 C=(B+3)%8+1\n"
+"330 M=C\n"
+"340 GOSUB 900 \n"
+"350 GOTO 640 \n"
+"360 C=(B+1)%8+1\n"
+"370 M=C\n"
+"380 GOSUB 800 \n"
+"390 R=M\n"
+"400 IF R=(C+3)%8+1 GOTO 450\n"
+"410 D=(C+3)%8+1\n"
+"420 M=D\n"
+"430 GOSUB 900\n"
+"440 GOTO 640 \n"
+"450 IF P%2<>0 GOTO 500\n"
+"460 D=(C+6)%8+1\n"
+"470 M=D\n"
+"480 GOSUB 900\n"
+"490 GOTO 640 \n"
+"500 D=(C+2)%8+1\n"
+"510 M=D\n"
+"520 GOSUB 800 \n"
+"530 S=M\n"
+"540 IF S=(D+3)%8+1 GOTO 590\n"
+"550 E=(D+3)%8+1\n"
+"560 M=E\n"
+"570 GOSUB 900\n"
+"580 REM \"Game is a draw\"\n"
+"590 E=(D+5)%8+1\n"
+"600 M=E\n"
+"610 GOSUB 900\n"
+"620 PRINT \"The game is a draw.\"\n"
+"630 GOTO 200\n"
+"640 PRINT \"and wins!  ********\"\n"
+"650 GOTO 200\n"
+"800 REM \"Subroutine to ask user for the move\"\n"
+"810 GOSUB 900\n"
+"820 INPUT \"Your move? \", M\n"
+"830 RETURN\n"
+"900 REM \"Subroutine to display move\"\n"
+"910 PRINT \"Computer moves:\",M\n"
+"920 RETURN\n"
+"\f"
+};
+const char buildin_pgm6_name[] PROGMEM = "*tictac.bas";
+const char* const buildin_programs[] PROGMEM = {
+buildin_pgm1,
+buildin_pgm2,
+buildin_pgm3,
+buildin_pgm4,
+buildin_pgm5,
+buildin_pgm6,
+0
+};
+const char* const buildin_program_names[] PROGMEM = {
+buildin_pgm1_name,
+buildin_pgm2_name,
+buildin_pgm3_name,
+buildin_pgm4_name,
+buildin_pgm5_name,
+buildin_pgm6_name,
+0
+};

data/Basic2/IoTBasic/buildin/buildin.h

@@ -0,0 +1,41 @@
+/* 
+ *  This is the demo code for the buildin programs.
+ *  
+ *  Format of the buildin program store: 
+ *  
+ *  programs are one long string terminated by FF \f.
+ *  lines are terminated by newline. 
+ *  
+ *  Programs can have any name, * as a prefix is used to 
+ *  distinguish them from other programs. This is not yet
+ *  implemented.
+ */
+
+const char buildin_pgm1[] PROGMEM = { 
+	"10 print \"hello world\"\n"
+	"20 end\n"
+	"\f"
+};
+
+const char buildin_pgm1_name[] PROGMEM = "*hello.bas";
+
+const char buildin_pgm2[] PROGMEM = { 
+	"10 PI=22000/7\n"
+	"20 PRINT 'PI=',INT(PI)\n"
+	"30 END\n"
+	"\f"
+};
+
+const char buildin_pgm2_name[] PROGMEM = "*pi.bas";
+
+const char* const buildin_programs[] PROGMEM = { 
+	buildin_pgm1,
+	buildin_pgm2,
+	0 
+}; 
+
+const char* const buildin_program_names[] PROGMEM = { 
+	buildin_pgm1_name,
+	buildin_pgm2_name,
+	0 
+};

data/Basic2/IoTBasic/hardware.h

@@ -0,0 +1,1091 @@
+/*
+ * Stefan's basic interpreter.  
+ *
+ * Playing around with frugal programming. See the licence file on 
+ * https://github.com/slviajero/tinybasic for copyright/left.
+ *   (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)
+ *
+ * Author: Stefan Lenz, [email protected]
+ * 
+ * Architectures and the definitions from the Arduino IDE. 
+ * 
+ * Arduino hardware settings , set here what you need or
+ * use one of the predefined configurations below.
+ * 
+ * If HARDWAREHEURISTICS is set, some of the settings below 
+ * are activated automatically for some platforms. If you want
+ * to control ALL settings below manually, undef HARDWAREHEURISTICS 
+ *
+ * Input/output methods ARUINOPICOSERIAL, ARDUINOPS2
+ *  ARDUINOUSBKBD, ARDUINOZX81KBD, ARDUINOI2CKBD, GIGAUSBKBD
+ *	ARDUINOPRT, DISPLAYCANSCROLL, ARDUINOLCDI2C,
+ *	ARDUINOTFT, ARDUINONOKIA51, ARDUINOILI9488,
+ *  ARDUINOSSD1306, ARDUINOMCUFRIEND
+ * Storage ARDUINOEEPROM, ARDUINOSD, ESPSPIFFS, RP2040LITTLEFS
+ * storage ARDUINOEFS, SM32SDIO, ESP32FAT, ESPSDMMC
+ * sensors ARDUINOWIRE, ARDUINOSIMPLEWIRE, ARDUINOSENSORS
+ * network ARDUINORF24, ARDUNIOMQTT 
+ * memory ARDUINOSPIRAM
+ * real time clocks ARDUINORTC, ARDUINORTCEMULATION
+ * 
+ * Secial features
+ *  ARDUINOPGMEEPROM: makes the EEPROM primary program store
+ *  HASMSTAB: counts characters, prerequisite for MSTAB in languages
+ *  BUILDIN: include buildin programs 
+ *  
+ * Instead of setting all this manually, you can use one of the 
+ * predefined hardware models. They are stored in board and are sources
+ * here later in the code to override some of the defaults. Custom configurations
+ * coming with BASIC are: 
+ * 
+ *  dummy.h: 
+ *      do nothing.
+ *  avrlcd.h:
+ *      a AVR system with a LCD shield
+ *  avrmcufriend.h:
+ *      a AVR system with a parallel TFT 
+ *  wemosshield.h: 
+ *      a ESP8266 UNO lookalike with a modified datalogger shield
+ *      great hardware for small BASIC based IoT projects.
+ *  megashield.h: 
+ *      an Arduino Mega with Ethernet Shield optional keyboard 
+ *      and i2c display
+ *  megatft.h: 
+ *  duetft.h:
+ *      TFT 7inch screen systems, standalone
+ *  nanoboard.h:
+ *      Arduino Nano Every board with PS2 keyboard and sensor 
+ *      kit.
+ *  megaboard.h:
+ *      A board for the MEGA with 64 kB RAM, SD Card, and real time
+ *      clock.
+ *  unoboard.h:
+ *      A board for an UNO with 64kB memory and EEPROM disk
+ *      fits into an UNO flash only with integer
+ *  esp01board.h:
+ *      ESP01 based board as a sensor / MQTT interface
+ * rp2040board.h:
+ *      A ILI9488 hardware design based on an Arduino connect RP2040.
+ * rp2040board2.h:
+ *      like the one above but based on the Pi Pico core
+ * esp32board.h:
+ *      same like above with an ESP32 core
+ * mkboard.h:
+ *      a digital signage and low energy board
+ * tdeck.h: 
+ *      the LILYGO T-Deck - not yet finished
+ * ttgovga.h:
+ *      the TTGO VGA 1.4 board with VGA output
+ */
+#define PREDEFINEDBOARD "boards/dummy.h"
+
+/* undef this if you want to overide all defaults, then use the settings below */
+#define HARDWAREHEURISTICS
+
+/* 
+ * These are the individual settings. Logic: 
+ * PREDEFINEDBOARD is set, and some of the settings below are
+ * activated automatically.
+ * HARDWAREHEURISTICS is set, some of the settings below are
+ * activated automatically depending on the hardware.
+ * HARDWAREHEURISTICS is not set, all settings below are
+ * have to be set manually.
+ * 
+ * Important: HARDWAREHEURISTICS is processed last in the code
+ * so it can override all settings below.
+ * 
+ * In one sentence:
+ * First PREDEFINEDBOARD, then manual settings, then HARDWAREHEURISTICS.
+ */
+/*
+#undef ARDUINOPICOSERIAL 
+#undef ARDUINOPS2
+#undef ARDUINOUSBKBD
+#undef ARDUINOZX81KBD
+#undef ARDUINOI2CKBD
+#undef GIGAUSBKBD
+#undef ARDUINOPRT
+#undef DISPLAYCANSCROLL
+#undef ARDUINOLCDI2C
+#undef ARDUINONOKIA51
+#undef ARDUINOILI9488
+#undef ARDUINOSSD1306
+#undef ARDUINOMCUFRIEND
+#undef ARDUINOEDP47
+#undef ARDUINOGRAPHDUMMY
+#undef LCDSHIELD
+#undef ARDUINOTFT
+#undef ARDUINOVGA
+#undef TFTESPI
+#undef ARDUINOEEPROM
+#undef ARDUINOI2CEEPROM
+#undef ARDUINOEFS
+#undef ARDUINOSD
+#undef ESPSDMMC
+#undef ESPSPIFFS
+#undef ESP32FAT
+#undef RP2040LITTLEFS
+#undef STM32SDIO
+#undef GIGAUSBFS
+#undef ARDUINORTC
+#undef ARDUINORTCEMULATION
+#undef ARDUINOTONEEMULATION
+#undef ARDUINOWIRE
+#undef ARDUINOSIMPLEWIRE
+#undef ARDUINOWIRESLAVE
+#undef ARDUINORF24
+#undef ARDUINOETH
+#undef ARDUINOMQTT 
+#undef ARDUINOSENSORS
+#undef ARDUINOSPIRAM 
+#undef STANDALONE
+#undef STANDALONESECONDSERIAL
+*/
+// #define ALTSERIAL Serial
+
+/* we debug the runtime library and where the logging goes */
+#define RTDEBUG 1
+#define RTDEBUGSTREAM 1
+
+/* the memory size, set to 0 means determine automatically 
+ leaving it undefined means zero. setting it larger than 16 bit
+ make the address_t 32bit */
+
+#define MEMSIZE 0
+
+/* experimental features, don't use unless you know the code */
+/* 
+ * this setting uses the EEPROM as program storage 
+ * The idea is to create a virtual memory layout starting from 0 with the EEPROM
+ * from elength() and then adding the BASIC RAM to it. himem and top need to be 
+ * handled carefully. 
+ */
+#undef ARDUINOPGMEEPROM
+
+/* IO control, emulate real tab by counting characters, on by default
+  but overriden for very small boards - see hardware heuristics  */
+#define HASMSTAB
+
+/* VT52 settings, on by default but override further down for very 
+  small boards, check the hardware heuristics section if you need VT52
+  on small AVR boards */
+#define HASVT52
+#undef VT52WIRING 
+
+/* 
+ * Experimental BUILDIN feature, implemented as a filesystem. 
+ * Buildin BASIC programs are stored in the flash memory of the Arduino.
+ * They appear as files in the filesystem.
+ */
+#undef HASBUILDIN
+/* this is the demo module */
+#define BUILDINMODULE "buildin/buildin-games.h"
+/* a small tutorial */
+// #define BUILDINMODULE "buildin/buildin-tutorial.h"
+/* test program for Arduinos */
+// #define BUILDINMODULE "buildin/buildin-arduinotest.h"
+/* a games module */
+// #define BUILDINMODULE "buildin/buildin-games.h"
+
+/* interrupts for the EVENT command, this is needed to use Arduino interrupts */
+#define ARDUINOINTERRUPTS
+
+/* 
+ * handle the break condition in the background. 
+ * Off by default but needed for some keyboards. 
+ * On an UNO 170 bytes overhead if on and 5% 
+ * performance loss. If any system runs background 
+ * tasks anyway, better to switch it on.
+ */
+#undef BREAKINBACKGROUND
+
+/* 
+ * This code measures the fast ticker frequency in microseconds 
+ * It counts the number of tokens drawn plus statements executed.
+ */
+#undef FASTTICKERPROFILE
+
+/* the default EEPROM dummy size */
+#define EEPROMSIZE 1024
+
+/* 
+ * PIN settings and I2C addresses for various hardware configurations
+ *	used a few heuristics and then the hardware definitions above 
+ *
+ *	#define SDPIN sets the SD CS pin - can be left as a default for most HW configs
+ *   	TTGO needs it as default definitions in the board file are broken
+ *	#define PS2DATAPIN, PS2IRQPIN sets PS2 pin
+ */
+
+/* PS2 Keyboard pins for AVR - use one interrupt pin 2 and one date pin 
+    5 not 4 because 4 conflicts with SDPIN of the standard SD shield */
+
+#define PS2DATAPIN 3
+#define PS2IRQPIN  2
+
+/* 
+ *  Pin settings for the ZX81 Keyboard
+ *  first the 8 rows, then the 5 columns or the keyboard
+ * 
+ * MEGAs have many pins and default is to use the odd pins on the side
+ * UNOs, NANOs, and others use the lower pins by default avoiding the 
+ * pin 13 which is LED and doesn't work with standard schematics 
+ */
+#ifdef ARDUINO_AVR_MEGA2560
+#define ZX81PINS 37, 35, 33, 31, 29, 27, 25, 23, 47, 45, 43, 41, 39
+#else
+#define ZX81PINS 7, 8, 9, 10, 11, 12, A0, A1, 2, 3, 4, 5, 6
+#endif
+
+/* Ethernet - 10 is the default */
+/* #define ETHPIN 10 */
+
+/* The Pretzelboard definitions for Software Serial, conflicts with SPI */
+#define SOFTSERIALRX 11
+#define SOFTSERIALTX 12
+
+/* near field pin settings for CE and CSN*/
+#define RF24CEPIN 8
+#define RF24CSNPIN 9
+
+/* use standard I2C pins almost always */
+#undef SDA_PIN
+#undef SCL_PIN
+
+/*
+ *	BREAKCHAR is the character stopping the program on Ardunios
+ *  BREAKPIN can be set, it is a pin that needs to go to low to stop a BASIC program
+ *    This should be done in hardware*.h
+ *  BREAKSIGNAL can also be set, should be done in hardware*.h
+ */
+#define BREAKCHAR '#'
+
+/* set this is you want pin 4 on low interrupting the interpreter */
+/* #define BREAKPIN 4 */
+#undef BREAKPIN
+
+/* the primary serial stream aka serial aka sream 1 */
+#ifndef ALTSERIAL
+#define SERIALPORT Serial
+#else 
+#define SERIALPORT ALTSERIAL
+#endif
+
+/* the secondary serial port aka prt aka stream 4 */
+#ifndef PRTSERIAL
+#define PRTSERIAL Serial1
+#endif
+
+/* 
+ *  this is soft SPI for SD cards on MEGAs using 
+ *  pins 10-13, a patched SD library is needed 
+ *  for this: https://github.com/slviajero/SoftSD
+ *  only needed for MEGA boards with an UNO shield
+ */
+#define SOFTWARE_SPI_FOR_SD
+
+/* 
+ *  list of default i2c addresses
+ *
+ * some clock modules do have their EEPROM at 0x57. 
+ * 0x050 this is the default lowest adress of standard EEPROMs
+ * Configurable range is between 0x50 and 0x57 for modules with jumpers. 
+ * Some clock modules do have their EEPROM at 0x57. 
+ * 
+ * Clock default for the size is 4096. Define your EFS EEPROM and I2C EEPROM
+ * size here. One parameter set is for EFS and one parameter set is for 
+ * plain serial EEPROMs.
+ * 
+ * RTCs are often at 0x68 
+ */
+#define EFSEEPROMADDR 0x050
+/* #define EFSEEPROMSIZE 32768 */
+
+#define RTCI2CADDR 0x068
+
+/* the size of the plain I2C EEPROM, typically a clock */
+/* #define I2CEEPROMADDR 0x057 */
+/* #define I2CEEPROMSIZE 4096 */
+/* definition for an external EEPROM */
+#define I2CEEPROMADDR 0x050
+
+/* is the I2C EEPROM buffered, left open here for the board file to decided - defaults to unbuffered */
+/* #define ARDUINOI2CEEPROM_BUFFERED */
+
+/* use the direct i2c code and bypass the Wire library on AVR 
+ * default off here, board file and heuristics to decide, this 
+ * is currently only implemented on ARDUINO_ARCH_AVR and tested on UNO 
+ */
+#undef ARDUINODIRECTI2C
+
+/*
+ * Sensor library code - configure your sensors here, will go to a 
+* separate file in the future
+ */
+#ifdef ARDUINOSENSORS
+#undef ARDUINODHT
+#define DHTTYPE DHT22
+#define DHTPIN 2
+#define ARDUINOSHT
+#define ARDUINOMQ2
+#define MQ2PIN A0
+#undef ARDUINOLMS6
+#undef ARDUINOAHT
+#undef ARDUINOBMP280
+#undef ARDUINOBME280
+#endif
+
+
+#if defined(ARDUINOSHT) || defined(ARDUINOLMS6) || defined(ARDUINOAHT) || defined(ARDUINOBMP280) || defined(ARDUINOBME280)
+#define ARDUINOSIMPLEWIRE
+#endif
+
+/*
+ * Keyboard configuation code, currently only GERMAN and US are supported
+ * This is used for PS2, FABGL and USB. USB very raw.
+ * ZX81 is not supported with different languages, I only have a UK one.
+ */
+
+#define ARDUINOKBDLANG_GERMAN
+//#define ARDUINOKBDLANG_US 
+
+/*
+ * The heuristics. These are things that normally would make sense on a 
+ * board.
+ */
+
+/* 
+ *  Buffer sizes depending on what we are doing.
+ */
+
+ #if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_LGT8F)
+ /* the small memory model with shallow stacks and small buffers */
+ #define BUFSIZE     80
+ #define STACKSIZE   15
+ #define GOSUBDEPTH  4
+ #define FORDEPTH    4
+ #define LINECACHESIZE 4
+ #else 
+ /* the for larger microcontrollers */
+ #define BUFSIZE     128
+ #define STACKSIZE   64
+ #define GOSUBDEPTH  8
+ #define FORDEPTH    8
+ #define LINECACHESIZE 16
+ #endif
+ 
+#ifdef HARDWAREHEURISTICS
+/* UNOS are very common. Small memory, we put the program into EEPROM and make everything small */
+#if defined(ARDUINO_AVR_UNO) || defined(ARDUINO_AVR_NANO) 
+#define ARDUINOEEPROM
+#define ARDUINOPICOSERIAL
+#define ARDUINOPGMEEPROM
+#define ARDUINODIRECTI2C
+#undef  ARDUINOI2CEEPROM_BUFFERED
+#undef  LINECACHESIZE
+#undef  HASMSTAB
+#define MEMSIZE 512
+#endif
+/* der Pro */
+#if defined(ARDUINO_AVR_PRO)
+#define ARDUINOEEPROM
+#define ARDUINOPGMEEPROM
+#undef  LINECACHESIZE
+#undef  HASMSTAB
+#undef  HASVT52
+#define MEMSIZE 768
+#endif
+/* on a DUEMILA we allocate just as little main memory as possible, currenly not working because sketch too big 
+ * needs to be checked */
+#if defined(ARDUINO_AVR_DUEMILANOVE)
+#define ARDUINOEEPROM
+#define ARDUINOPICOSERIAL
+#define ARDUINOPGMEEPROM
+#undef  LINECACHESIZE
+#undef  HASMSTAB
+#define MEMSIZE 128
+#undef  HASVT52
+#endif
+/* tested for LTQF32 Mini EVB - very low memory as core needs a lot */
+#if defined(ARDUINO_ARCH_LGT8F)
+#define ARDUINOEEPROM
+#define ARDUINOPICOSERIAL
+#undef LINECACHESIZE
+#undef HASMSTAB
+#define MEMSIZE 256
+#define ARDUINOPGMEEPROM
+#undef HASVT52
+#endif
+/* all AVR 8 bit boards have an EEPROM (most probably) */
+#if defined(ARDUINO_ARCH_AVR)
+#define ARDUINOEEPROM
+#endif
+/* megaAVR boards have an EEPROM */
+#if defined(ARDUINO_ARCH_MEGAAVR)
+#define ARDUINOEEPROM
+#endif
+/* LEONARDO boards */
+#if defined(ARDUINO_AVR_LEONARDO)
+/* to be done */ 
+#endif
+/* all ESPs best are compiled with ESPSPIFFS predefined */
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+#define ESPSPIFFS
+#endif
+/* all ESPs best have EEPROM emulation */
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+#define ARDUINOEEPROM
+#define ESPSPIFFS
+#endif
+/* all RP2040 boards best are compiled with RP2040LITTLEFS predefined */
+#if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_MBED_RP2040)
+#define RP2040LITTLEFS
+#endif
+/* use the EEPROM dummy of the NRESESA boards */
+#if defined(ARDUINO_ARCH_RENESAS)
+#define ARDUINOEEPROM
+#endif
+/* for XMC there is an EEPROM emulation, which needs: https://github.com/slviajero/XMCEEPROMLib */
+#if defined(ARDUINO_ARCH_XMC)
+#define ARDUINOEEPROM
+#endif
+/* the China Nano clones. Super fast but with very small flash. */ 
+#if defined(ARDUINO_ARCH_LGT8F)
+#undef HASMSTAB
+#endif
+#endif
+
+/*
+ * Now source the the hardware models if this is set.
+ */
+#ifdef PREDEFINEDBOARD
+#include PREDEFINEDBOARD
+#endif
+
+/*
+ * Here, dependencies are handled. Some settings require others to be set
+ * first. 
+ * 
+ * Examples:
+ *  Many filesystems and displays need SPI.
+ *  Some components need Wire. 
+ *  Some platforms do not have tone, so we need to emulate it.
+ */
+
+/* 
+ *  DUE has no tone, we switch to emulation mode automatically.
+ */
+#ifdef ARDUINO_SAM_DUE
+#define ARDUINOTONEEMULATION
+#endif
+
+/*
+ * Some settings, defaults, and dependencies
+ * 
+ * HASWIRE is set to start wire. Some libraries do this again.
+ * 
+ * Handling Wire and SPI is tricky as some of the libraries 
+ * also include and start SPI and Wire code. 
+ * 
+ * HASIMPLEWIRE avoids the overhead of importing the entire 
+ * filesystem code. It only activates plain Wire and provides
+ * the WIRE command in basic.
+ */
+
+/*
+ * Safety net for ARDUINODIRECTI2C, architectures that are 
+ * not AVR 8 bit and do not have TWDR are not supported.
+ */
+#if !defined(ARDUINO_ARCH_AVR) || !defined(TWDR)
+#undef ARDUINODIRECTI2C
+#endif
+
+/* a clock needs wire */
+#ifdef ARDUINORTC
+#define HASSIMPLEWIRE
+#endif
+
+/* a display needs wire */
+#if defined(ARDUINOLCDI2C) || defined(ARDUINOSSD1306) 
+#define HASSIMPLEWIRE
+#endif
+
+/* EEPROM storage needs wire */
+#if defined(ARDUINOEFS)
+#define HASSIMPLEWIRE
+#endif
+
+/* external EEPROMs also need wire */
+#if defined(ARDUINOI2CEEPROM)
+#define HASSIMPLEWIRE
+#endif
+
+/* external EEPROM buffered needs full wire support, because EFS not ported */
+#if defined(ARDUINOI2CEEPROM) && defined(ARDUINOI2CEEPROM_BUFFERED)
+#define HASWIRE
+#endif
+
+/* plain Wire support also needs wire ;-) */
+#if defined(ARDUINOWIRE) || defined(ARDUINOWIRESLAVE)
+#define HASWIRE
+#endif
+
+/* and I2C Keyboard needs wire */
+#if defined(ARDUINOI2CKBD)
+#define HASSIMPLEWIRE
+#endif
+
+/* the BASIC command/function WIRE */
+#if defined (ARDUINOSIMPLEWIRE)
+#define HASSIMPLEWIRE
+#endif
+
+/* radio needs SPI */
+#if defined(ARDUINORF24)
+#define ARDUINOSPI
+#endif
+
+/* a filesystem needs SPI */
+#if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(ESP32FAT)
+#define ARDUINOSPI
+#endif
+
+/* networking may need SPI */
+#if defined(ARDUINOMQTT)
+#define ARDUINOSPI
+#endif
+
+/* the NOKIA and ILI9488 display needs SPI */
+#if defined(ARDUINONOKIA51) || defined(ARDUINOILI9488) || defined(TFTESPI)
+#define ARDUINOSPI
+#endif
+
+/* the RAM chips */
+#if defined(ARDUINOSPIRAM)
+#define ARDUINOSPI
+#endif
+
+/* Networking and keyboards need the background task capability */
+#if defined(ARDUINOMQTT) || defined(ARDUINOETH) || defined(ARDUINOUSBKBD) || defined(ARDUINOZX81KBD) || defined(ARDUINOI2CKBD) || defined(GIGAUSBKBD)
+#define BASICBGTASK
+#endif
+
+/* the ESP8266 needs to run the background task calls for the scheduler */
+#if defined(ARDUINO_ARCH_ESP8266)
+#define BASICBGTASK
+#endif
+
+/* Break in background needs background tasks as well */
+#if defined(BREAKINBACKGROUND)
+#define BASICBGTASK
+#endif
+
+/* picoserial is not a available on many platforms */
+#ifdef ARDUINOPICOSERIAL
+#ifndef UCSR0A
+#undef ARDUINOPICOSERIAL
+#endif
+#endif
+
+/* 
+ *  incompatibilities and library stuff
+ */
+/* these platforms have no EEPROM and no emulation built-in */
+#if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_MBED_GIGA)
+#undef ARDUINOEEPROM
+#endif
+
+/*
+ * SD filesystems with the standard SD driver
+ * for MEGA 256 a soft SPI solution is needed 
+ * if standard shields are used, this is a patched
+ * SD library https://github.com/slviajero/SoftSD
+ */
+#ifdef ARDUINOSD
+#define FILESYSTEMDRIVER
+#endif
+
+/*
+ * ESPSPIFFS tested on ESP8266 and ESP32
+ * supports formating in BASIC
+ */ 
+#ifdef ESPSPIFFS
+#define FILESYSTEMDRIVER
+#endif
+
+/*
+ * ESP32FAT tested on ESP32
+ * supports formating in BASIC
+ */ 
+#ifdef ESP32FAT
+#define FILESYSTEMDRIVER
+#endif
+
+/*
+ * RP2040 internal filesystem 
+ * This is test code from https://github.com/slviajero/littlefs
+ * and the main branch is actively developed
+ */
+#ifdef RP2040LITTLEFS
+#define FILESYSTEMDRIVER
+#endif
+
+/*
+ * STM32 SDIO driver for he SD card slot of the STM32F4 boards (and others)
+ */
+#ifdef STM32SDIO 
+#define FILESYSTEMDRIVER
+#endif
+
+/* 
+ *  The USB filesystem of the GIGA board
+ */
+#ifdef GIGAUSBFS
+#define FILESYSTEMDRIVER
+#define NEEDSUSB
+#endif
+
+/*
+ * external flash file systems override internal filesystems
+ * currently BASIC can only have one filesystem
+ */ 
+#ifdef ARDUINOSD
+#undef ESPSPIFFS
+#undef ESP32FAT
+#undef RP2040LITTLEFS
+#undef GIAGUSBFS
+#endif
+
+/*
+ * support for external EEPROMs as filesystem
+ * overriding all other filessystems. This is a minimalistic
+ * filesystem meant for very small systems with not enough 
+ * memory for real filesystems
+ * https://github.com/slviajero/EepromFS
+ */ 
+#ifdef ARDUINOEFS
+#undef ESPSPIFFS
+#undef ESP32FAT
+#undef RP2040LITTLEFS
+#undef ARDUINOSD
+#undef STM32SDIO
+#undef GIGAUSBFS
+#define FILESYSTEMDRIVER
+#endif
+
+/*
+ * The build in file system for read only programs, only 
+ * if there is no other file system present
+ */
+#if defined(HASBUILDIN)
+#define FILESYSTEMDRIVER
+#include BUILDINMODULE
+#endif
+
+/*
+ * Software SPI only on Mega2560
+ */
+#ifndef ARDUINO_AVR_MEGA2560
+#undef SOFTWARE_SPI_FOR_SD
+#endif
+
+/*
+ * I used these two articles 
+ * https://randomnerdtutorials.com/esp8266-deep-sleep-with-arduino-ide/
+ * https://randomnerdtutorials.com/esp32-deep-sleep-arduino-ide-wake-up-sources/
+ * for this very simple implementation - needs to be improved (pass data from sleep
+ * state to sleep state via EEPROM)
+ */
+/* this is done only here now to make sure HASCLOCK is set properly */ 
+
+#if defined(ARDUINO_ARCH_SAMD) 
+#define HASBUILTINRTC
+#endif
+
+/* STM32duino have the same structure */
+#if defined(ARDUINO_ARCH_STM32)
+#define HASBUILTINRTC
+#endif
+
+/* the NRENESA board have a buildin RTC as well */
+#if defined(ARDUINO_ARCH_RENESAS)
+#define HASBUILTINRTC
+#endif
+
+/* 
+ * global variables for a standard LCD shield. 
+ * Includes the standard Arduino LiquidCrystal library
+ */
+#ifdef LCDSHIELD 
+#define DISPLAYDRIVER
+#define HASKEYPAD
+#undef DISPLAYHASCOLOR
+#undef DISPLAYHASGRAPH
+#endif
+ 
+/* 
+ * A LCD display connnected via I2C, uses the standard 
+ * Arduino I2C display library.
+ */ 
+#ifdef ARDUINOLCDI2C
+#define DISPLAYDRIVER
+#undef DISPLAYHASCOLOR
+#undef DISPLAYHASGRAPH
+#endif
+
+/* 
+ * A Nokia 5110 with ug8lib2 - can scroll quite well
+ * https://github.com/olikraus/u8g2/wiki/u8g2reference
+ * This is a buffered display it has a dspupdate() function 
+ * it also needs to call dspgraphupdate() after each graphic 
+ * operation
+ *
+ * default PIN settings here are for ESP8266, using the standard 
+ * SPI SS for 15 for CS/CE, and 0 for DC, 2 for reset
+ *
+ */ 
+#ifdef ARDUINONOKIA51
+#define DISPLAYDRIVER
+#define DISPLAYPAGEMODE
+#undef DISPLAYHASCOLOR /* display driver not color aware for this display */
+#define DISPLAYHASGRAPH
+#endif
+
+/*
+ * 4.7 inch epaper displays are derived from the NOKIA51 code, no grayscales 
+ * at the moment. Forcing the font into rectangles and hoping this works.
+ * 
+ * Epapers bypass the display driver here and use a graphics based display 
+ * mode instead
+ */
+#ifdef ARDUINOEDP47
+#define GRAPHDISPLAYDRIVER
+#define DISPLAYPAGEMODE
+#undef DISPLAYHASCOLOR /* display driver not color aware for this display */
+#define DISPLAYHASGRAPH
+#endif
+ 
+
+/* 
+ * Small SSD1306 OLED displays with I2C interface
+ * This is a buffered display it has a dspupdate() function 
+ * it also needs to call dspgraphupdate() after each graphic 
+ * operation
+ */ 
+#ifdef ARDUINOSSD1306
+#define DISPLAYDRIVER
+#define DISPLAYPAGEMODE
+#undef DISLAYHASCOLOR /* display driver not color aware for this display */
+#define DISPLAYHASGRAPH
+#endif
+
+/* 
+ * A ILI9488 with Jarett Burkets version of Adafruit GFX and patches
+ * by Stefan Lenz
+ * currently only slow software scrolling implemented in BASIC
+ * 
+ * https://github.com/slviajero/ILI9488
+ * 
+ * we use 9, 8, 7 as CS, CE, RST by default and A7 for the led brightness control
+ */ 
+ 
+#ifdef ARDUINOILI9488
+#define DISPLAYDRIVER
+#define DISPLAYHASCOLOR
+#define DISPLAYHASGRAPH
+#endif
+
+/* 
+ * A MCUFRIEND parallel port display for the various tft shields 
+ * This implementation is mainly for Arduino MEGA
+ * 
+ * currently only slow software scrolling implemented in BASIC
+ * 
+ */ 
+
+#ifdef ARDUINOMCUFRIEND
+#define DISPLAYDRIVER
+#define DISPLAYHASCOLOR
+#define DISPLAYHASGRAPH
+#endif
+
+/*
+ * The driver for the TFT_eSPI graphics of the T-Deck from Lilygo
+ * currently not finished 
+ */
+
+#ifdef TFTESPI
+#define DISPLAYDRIVER
+#define DISPLAYHASCOLOR
+#define DISPLAYHASGRAPH
+#endif
+
+/* 
+ * A no operations graphics dummy  
+ * Tests the BASIC side of the graphics code without triggering 
+ * any output
+ */ 
+#ifdef ARDUINOGRAPHDUMMY
+#define DISPLAYDRIVER
+#undef DISPLAYHASCOLOR
+#define DISPLAYHASGRAPH
+#endif
+
+/*
+ * SD1963 TFT display code with UTFT.
+ * Tested witth SD1963 800*480 board. 
+ *	it is mainly intended for a MEGA or DUE as a all in one system
+ *	this is for a MEGA shield and the CTE DUE shield, for the due 
+ *	you need to read the comment in Arduino/libraries/UTFT/hardware/arm
+ *	HW_ARM_defines.h -> uncomment the DUE shield
+ * See also 
+  * https://github.com/slviajero/tinybasic/wiki/Projects:-4.-A-standalone-computer-with-a-TFT-screen-based-on-a-DUE
+ */
+#ifdef ARDUINOTFT
+#define DISPLAYDRIVER
+#define DISPLAYHASCOLOR 
+#define DISPLAYHASGRAPH
+#endif
+
+/* 
+ * Keyboard code for either the Fablib Terminal class or 
+ * PS2Keyboard - please note that you need the ESP patched 
+ * version here as mentioned above
+ * 
+ * sets HASKEYBOARD to inform basic about this capability
+ * 
+ * keyboards can implement 
+ * 	kbdbegin()
+ * they need to provide
+ * 	kbdavailable(), kbdread(), kbdcheckch()
+ * the later is for interrupting running BASIC code
+ */
+#if defined(ARDUINO_TTGO_T7_V14_Mini32) && defined(ARDUINOVGA)
+#define PS2FABLIB
+#define HASKEYBOARD
+#define DISPLAYHASCOLOR
+#define DISPLAYHASGRAPH
+#endif 
+
+#if defined(ARDUINO) && defined(ARDUINOPS2)
+#define PS2KEYBOARD
+#define HASKEYBOARD
+#endif 
+
+#if defined(ARDUINO) && defined(ARDUINOUSBKBD)
+#define HASKEYBOARD
+#define USBKEYBOARD
+#endif
+
+#if defined(ARDUINOZX81KBD)
+#define HASKEYBOARD
+#define ZX81KEYBOARD
+#endif
+
+/* BREAKINBACKGROUND is needed here to avoid slowdown, probably also for the other keyboards */
+#if defined(ARDUINOI2CKBD)
+#define HASKEYBOARD
+#define I2CKEYBOARD
+#define BREAKINBACKGROUND
+#endif
+
+/* set the HASKEYBOARD feature to tell BASIC about it */
+#if defined(GIGAUSBKBD)
+#define HASKEYBOARD
+#define GIGAUSBKEYBOARD
+#endif
+
+/* 
+ * Arduino Real Time clock. The interface here offers the values as number_t 
+ * combining all values. 
+ * 
+ * The code does not use an RTC library any more all the rtc support is 
+ * builtin now. 
+ * 
+ * A clock must activate the macro #define HASCLOCK to make the clock 
+ * available in BASIC.
+ * 
+ * The following software models are supported
+ *  - Built-in clocks of STM32 and MKR and NRESAS and XIAO are supported by default 
+ *      as RTCZero type code
+ *  - Built-in clocks of ESP32 are supported by default with a time structure type code
+ *  - Built-in clocks of GIGA the same as ESP32
+ *  - I2C clocks can be activated: DS1307, DS3231, and DS3232
+ *  - A Real Time Clock emulation is possible using millis()
+ * 
+ * rtcget accesses the internal registers of the clock. 
+ * Registers 0-6 are bcd transformed to return 
+ * seconds, minutes, hours, day of week, day, month, year
+ * 
+ * On I2C clocks registers 7-255 are returned as memory cells
+ */
+
+ #if defined(ARDUINORTC) || defined(HASBUILTINRTC) || defined(ARDUINO_ARCH_ESP32) || defined(ARDUINORTCEMULATION) || defined(ARDUINO_ARCH_MBED_GIGA)
+ #define HASCLOCK
+ #endif
+
+/* 
+ * External EEPROM is handled through an EFS filesystem object  
+ * see https://github.com/slviajero/EepromFS 
+ * for details. Here the most common parameters are set as a default.
+*/
+#ifdef ARDUINOEFS
+#undef ARDUINOI2CEEPROM
+#endif
+
+/* 
+ *  Tell BASIC we have a second serial port
+ */
+#ifdef ARDUINOPRT
+#define HASSERIAL1
+#endif
+
+/* 
+ *  Tell BASIC we have a radio adapter
+ */
+#ifdef ARDUINORF24
+#define HASRF24
+#endif
+
+/* 
+ *  Tell BASIC we have MQTT and make sure one low level
+ *  interface is available
+ */
+#ifdef ARDUINOMQTT
+#define HASMQTT
+#ifndef ARDUINOETH
+#define ARDUINOWIFI
+#endif
+#endif
+
+/* 
+ *  handling the PROGMEM macros 
+ */
+
+ /*
+ * if the PROGMEM macro is define we compile on the Arduino IDE
+ *  we undef all hardware settings otherwise a little odd
+ */
+#ifdef ARDUINO_ARCH_MBED
+#define PROGMEM
+#endif
+
+#ifdef PROGMEM
+#define ARDUINOPROGMEM
+#else
+#undef ARDUINOPROGMEM
+#define PROGMEM
+#endif
+
+/* on XMC we circumvent progmem */
+#ifdef ARDUINO_ARCH_XMC
+#undef ARDUINOPROGMEM
+#define PROGMEM
+#endif
+
+
+/* the code to address EEPROMs directly */
+/* only AVR controllers are tested with this, don't use elsewhere, there are multiple bugs */
+#if defined(ARDUINOPGMEEPROM) & ! ( defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_LGT8F) )
+#undef ARDUINOPGMEEPROM
+#endif
+
+#ifdef ARDUINOPGMEEPROM
+#define USEMEMINTERFACE
+#define EEPROMMEMINTERFACE
+#else 
+#undef EEPROMMEMINTERFACE
+#endif
+
+/* the SPI RAM interface */
+#ifdef ARDUINOSPIRAM
+#define USEMEMINTERFACE
+#define SPIRAMINTERFACE
+#endif
+
+/* 
+ * to handle strings in situations with a memory interface two more buffers are 
+ * needed they store intermediate results of string operations. The buffersize 
+ * limits the maximum string length indepents of how big strings are set. 
+ * 
+ * default is 128, on an MEGA 512 is possible
+ */
+#ifdef ARDUINO_AVR_MEGA2560
+#define SPIRAMSBSIZE 512
+#else
+#define SPIRAMSBSIZE 128
+#endif
+
+
+/*
+ * Does the platform has command line args and do we want to use them 
+ * Arduinos don't have them
+ */
+#undef HASARGS
+
+/*
+ * How restrictive are we on function recursive calls to protect the stack
+ * On 8 bit Arduinos this needs to be limited strictly
+ */
+#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR) || defined(ARDUINO_ARCH_LGT8F) || defined(ARDUINO_AVR_PRO)
+#define FNLIMIT 4
+#elif defined(ARDUINO_ARCH_ESP8266)
+#define FNLIMIT 64
+#elif defined(ARDUINO_ARCH_ESP32)
+#define FNLIMIT 128
+#elif defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_MBED_RP2040)
+#define FNLIMIT 128
+#elif defined(ARDUINO_ARCH_SAM) && defined(ARDUINO_ARCH_SAMD)
+#define FNLIMIT 64
+#elif defined(ARDUINO_ARCH_XMC)
+#define FNLIMIT 64
+#elif defined(ARDUINO_ARCH_SMT32)
+#define FNLIMIT 128
+#elif defined(ARDUINO_ARCH_RENESAS)
+#define FNLIMIT 32
+#else
+#define FNLIMIT 128
+#endif
+
+/* 
+ *  here the runtime environment makes a good guess which 
+ *  language can be supported by the boards. This is tricky
+ *  it may not always work. 
+ *  
+ *  MEGAAVR does BASICFULL but this leaves little room for hardware drivers
+ *  LEONARDO currently broken, to much flash allocated.
+ */
+#if defined(ARDUINO_ARCH_AVR)
+#if defined(ARDUINO_AVR_DUEMILANOVE)
+#define BASICPALOALTO
+#endif
+#if defined(ARDUINO_AVR_UNO) || defined(ARDUINO_AVR_NANO) || defined(ARDUINO_AVR_PRO)
+#define BASICSIMPLE
+#endif
+#if defined(ARDUINO_AVR_LEONARDO)
+#define BASICSMALL
+#endif
+#if defined(ARDUINO_AVR_MEGA2560)
+#define BASICFULL
+#endif
+#elif defined(ARDUINO_ARCH_LGT8F)
+#define BASICSIMPLE
+#elif defined(ARDUINO_ARCH_MEGAAVR)
+#define BASICFULL
+#elif defined(ARDUINO_ARCH_ESP8266)
+#define BASICFULL
+#elif defined(ARDUINO_ARCH_ESP32)
+#define BASICFULL
+#elif defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_MBED_RP2040)
+#define BASICFULL
+#elif defined(ARDUINO_ARCH_SAM) && defined(ARDUINO_ARCH_SAMD)
+#define BASICFULL
+#elif defined(ARDUINO_ARCH_XMC)
+#define BASICFULL
+#elif defined(ARDUINO_ARCH_SMT32)
+#define BASICFULL
+#elif defined(ARDUINO_ARCH_RENESAS)
+#define BASICFULL
+#else
+#define BASICFULL
+#endif

data/Basic2/IoTBasic/language.h

@@ -0,0 +1,464 @@
+/*
+ *
+ *	$Id: language.h,v 1.1 2024/02/25 04:43:16 stefan Exp stefan $ 
+ *
+ *	Stefan's IoT BASIC interpreter 
+ *
+ * 	See the licence file on 
+ *	https://github.com/slviajero/tinybasic for copyright/left.
+ *    (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)
+ *
+ *	Author: Stefan Lenz, [email protected]
+ *
+ *	This is the language definition file. Edit this to set the language 
+ * 	capabilities.
+ * 
+ * MEMSIZE was moved to hardware.h now as it is a hardware setting.
+ * 
+ */
+
+/*
+ *	DEBUG switches on compiled debug mode. Consider using runtime 
+ * 		debug with SET 0,x before using this.
+ */
+#define DEBUG 0
+
+/*
+ * Interpreter feature sets, choose one of the predefines or undefine all predefines and set the 
+ * features in custom settings
+ *
+ * BASICFULL: full language set, use this with flash >32kB - ESPs, MKRs, Mega2560, RP2040, UNO R4
+ * BASICINTEGER: integer BASIC with full language, use this with flash >32kB
+ * BASICSIMPLE: integer BASIC with reduced language set, 32kB capable - for UNOs with a lot of device drivers
+ * BASICSIMPLEWITHFLOAT: a small floating point BASIC, 32kB capable, for UNOs - good for UNOs with the need of float
+ * BASICTINYWITHFLOAT: a floating point tinybasic, if you have 32kB and need complex device drivers
+ * BASICMINIMAL: minimal language, just Palo Alto plus Arduino I/O, works on 168 with 1kB RAM and 16kB flash
+ * 
+ * The board will try to find the best language model for it's size and capabilities. Relies on the 
+ * information hardware.h produces. It set one of the language models: 
+ * 
+ * BASICFULL, BASICSIMPLE, BASICMINIMAL.
+ * 
+ * Setting NOLANGUAGEHEURISTICS and then one of the models below will override this 
+ * selection.
+ */
+#define LANGUAGEHEURISTICS
+
+#ifndef LANGUAGEHEURISTICS
+#undef  BASICFULL
+#undef	BASICINTEGER
+#undef	BASICSIMPLE
+#undef	BASICMINIMAL
+#undef  BASICPALOALTO
+#undef	BASICSIMPLEWITHFLOAT
+#undef	BASICTINYWITHFLOAT
+#endif
+
+/*
+ * Custom settings undef all the the language sets above when you are using this. Not all language
+ * features work in all combinations.
+ * 
+ * HASAPPLE1: Apple 1 BASIC compatibility. This is the base for all other features.
+ *  In this version the interpreter has a heap, a string pool and one dimensional arrays.
+ * HASARDUINOIO: Arduino I/O functions, including millis() timer.
+ * HASFILEIO: file I/O functions, including open, close, read, write, remove, rename.
+ * HASTONE: tone() and noTone() functions for sound output mapped to the PLAY command.
+ * HASPULSE: pulseIn() function for measuring pulse lengths. Pulse output. Both mapped to the PULSE command.
+ * HASSTEFANSEXT: Stefan's BASIC extensions, including ELSE, PUT, GET, advanced FOR loops, SQR and POW.
+ * HASERRORMSG: error messages for syntax and runtime errors.
+ * HASVT52: VT52 terminal emulation for text output -> moved to hardware.h
+ * HASFLOAT: floating point support.
+ * HASGRAPH: graphics support, including line, circle, rectangle, fill, color.
+ * HASDARTMOUTH: Dartmouth BASIC compatibility: single line DEF FN, ON, READ, DATA.
+ * HASDARKARTS: Dark Arts BASIC is MALLOC, FIND, CLR for individual variables and EVAL for self modifying code.
+ * HASIOT: IoT functions, Wire access, Sensor functions, MQTT. Needs strings and heap. STR, VAL, INSTR are 
+ *  part of this. MQTT support only on Arduino-
+ * HASMULTIDIM: two dimensional arrays and one dimensional string arrays.
+ * HASTIMER: timer functions, AFTER and EVERY for periodic execution of programs.
+ * HASEVENTS: event handling, EVENT command. 
+ * HASERRORHANDLING: error handling with ERROR GOTO.
+ * HASSTRUCT: structured language elements, WHILE WEND, REPEAT UNTIL, SWITCH CASE. Multi line IF THEN ELSE 
+ * 	with the DO DEND construct.
+ * HASMSSTRINGS: MS Basic compatible strings, RIGHT$, LEFT$, MID$, ASC, CHR$, and string addition with +.
+ * 	Compatibility to MS BASICs is limited as this BASIC has only inplace string operations-
+ * HASMULTILINEFUNCTIONS: multi line functions, DEF FN, FEND.
+ * HASEDITOR: line editor for the console.
+ * HASTINYBASICINPUT: Tiny BASIC compatible input using the expression parser. Expressions and variables 
+ * 	are valid number input with it. Default now but can have odd side effects.
+ * HASLONGNAMES: long variable names, up to 16 characters. Name length is set by MAXNAME in basic.h and
+ * 	can be any value <128 bytes. Names are still only uppercase and all names will be uppercased by lexer.
+ * HASHELP: show the commands of the interpreter. Will be extended to a help system.
+ * HASFULLINSTR: the full C64 style INSTR command. Without this flag INSTR only accepts
+ *	a single character as argument. This is much faster and leaner on an Arduino. 
+ * 	This macro is activated when HASMSSTRINGS is set. 
+ * HASLOOPOPT: optimizes the FOR loops for speed. This is a trade off between speed and 
+ *  memory. It is activated by default. Speeup is about 10% on a Mac. On platforms
+ *  with low memory bandwidth it is much more.
+ * HASNUMSYSTEM: constants can be hex, octal, binary or decimal. This is not activated by 
+ *  default. Currently only implemented in VAL() and STR().
+ * HASBITWISE: has bitwise operations >>, << and the function BIT -> removed and default now.
+ * 
+ * If you want to set everything manually, set NOLANGUAGEHEURISTICS above
+ */
+
+#ifndef LANGUAGEHEURISTICS
+#define HASAPPLE1
+#define HASARDUINOIO
+#define HASFILEIO
+#define HASTONE
+#define HASPULSE
+#define HASSTEFANSEXT
+#define HASERRORMSG
+#define HASFLOAT
+#define HASGRAPH
+#define HASDARTMOUTH
+#define HASDARKARTS
+#define HASIOT
+#define HASMULTIDIM
+#define HASTIMER
+#define HASEVENTS
+#define HASERRORHANDLING
+#define HASSTRUCT
+#define HASMSSTRINGS
+#define HASMULTILINEFUNCTIONS
+#define HASEDITOR
+#define HASTINYBASICINPUT
+#define HASLONGNAMES 
+#define HASHELP
+#define HASFULLINSTR
+#define HASLOOPOPT
+#define HASNUMSYSTEM
+#endif
+
+
+/*
+ *
+ * Odd stuff - these things change the behaviour of BASIC in some aspects.
+ * They can be used to make the interpreter compatible with other dialects.
+ * 
+ * 	POWERRIGHTTOLEFT: normally the ^ operator works from left to right 
+ *		which means 2^3^2 = (2^3)^2 = 8^2 = 64. Setting this flag would 
+ *		change the behaviour to 2^3^2 = 2^(3^2) = 512
+ *  MSARRAYLIMITS: in BASIC arrays start at 1 and DIM A(10) creates 10 
+ *      elements. With MSARRAYLIMITS defined, arrays start at 0 and have 
+ *      n+1 elements. This can be changed at any time with SET 21,0 or 1.
+ *  SUPPRESSSUBSTRINGS: switch off substring logic by default, makes only sense with 
+ *      HASMSSTRINGS activated. With this, the syntax of strings and string 
+ *      arrays is comaptible to MS strings (only used to preset the variable now).
+ * 		SET 20 can change this at runtime. 
+ *  USELONGJUMP: use the longjmp feature of C. This greatly simplifies 
+ *      error handling at the cost of portability to some MCU platforms
+ *      currently only experimental. It costs memory for the jump buffer. 
+ *      Don't use it on very small systems. LONGJUMP must be set to 0 or 1 as 
+ *      it is used in boolean expression in the code
+ *  BOOLEANMODE: switch the behaviour of BASICs boolean operators. Default (-1)
+ *      is to cast all numbers to signed 16bit and then do bitwise arithemtic.
+ *      In this mode false is 0 and -1 is true. (1) is C style boolean arithemtic.
+ *      In this mode true is 1 and false is 0. AND and OR still do bitwise operations
+ *      but NOT is C not. SET 19,1 or -1 can change this at runtime.
+ *  HAS64BIT: 64 bit floating point support on platforms that have a 64 bit double. 
+ *      Counterexample: AVR 8bit does not have 64 bit floating point.
+ * HAS32BITINT: 32 bit integer support on 8 bit platforms.
+ * HASPOWER: the POWER operator ^ is available in addition to the POW function.
+ * HASUSRCALL: the USR and CALL functions. On small systems they need a lot 
+ *      of flash and can be disabled.
+ */
+
+#undef POWERRIGHTTOLEFT
+#undef MSARRAYLIMITS
+#undef SUPPRESSSUBSTRINGS
+#define USELONGJUMP 0
+#define BOOLEANMODE -1
+#undef  HAS64BIT
+#undef  HAS32BITINT
+#define HASPOWER 
+#define HASUSRCALL
+
+/* Palo Alto plus Arduino functions */
+#ifdef BASICMINIMAL
+#undef HASAPPLE1
+#define HASARDUINOIO
+#undef HASFILEIO
+#undef HASTONE
+#undef HASPULSE
+#undef HASSTEFANSEXT
+#undef HASERRORMSG
+#undef HASFLOAT
+#undef HASGRAPH
+#undef HASDARTMOUTH
+#undef HASDARKARTS
+#undef HASIOT
+#undef HASMULTIDIM
+#undef HASTIMER
+#undef HASEVENTS
+#undef HASERRORHANDLING
+#undef HASSTRUCT
+#undef HASMSSTRINGS
+#undef HASMULTILINEFUNCTIONS
+#undef HASEDITOR
+#define HASTINYBASICINPUT
+#undef HASLONGNAMES 
+#undef HASHELP
+#undef HASFULLINSTR
+#undef HASLOOPOPT
+#undef HASNUMSYSTEM
+#undef HASPOWER
+#undef HASUSRCALL
+#endif
+
+/* the original Palo Alto Tinybasic, this is the real minimum */
+#ifdef BASICPALOALTO
+#undef HASAPPLE1
+#undef HASARDUINOIO
+#undef HASFILEIO
+#undef HASTONE
+#undef HASPULSE
+#undef HASSTEFANSEXT
+#undef HASERRORMSG
+#undef HASFLOAT
+#undef HASGRAPH
+#undef HASDARTMOUTH
+#undef HASDARKARTS
+#undef HASIOT
+#undef HASMULTIDIM
+#undef HASTIMER
+#undef HASEVENTS
+#undef HASERRORHANDLING
+#undef HASSTRUCT
+#undef HASMSSTRINGS
+#undef HASMULTILINEFUNCTIONS
+#undef HASEDITOR
+#define HASTINYBASICINPUT
+#undef HASLONGNAMES 
+#undef HASHELP
+#undef HASLOOPOPT
+#undef HASNUMSYSTEM
+#undef HASBITWISE
+#undef HASFULLINSTR
+#undef HASLOOPOPT
+#undef HASNUMSYSTEM
+#undef HASPOWER
+#undef HASUSRCALL
+#endif
+
+/* all features minus float and tone */
+#ifdef  BASICINTEGER
+#define HASAPPLE1
+#define HASARDUINOIO
+#define HASFILEIO
+#define HASTONE
+#define HASPULSE
+#define HASSTEFANSEXT
+#define HASERRORMSG
+#undef  HASFLOAT
+#define HASGRAPH
+#define HASDARTMOUTH
+#define HASDARKARTS
+#define HASIOT
+#define HASMULTIDIM
+#define HASTIMER
+#define HASEVENTS
+#define HASERRORHANDLING
+#define HASSTRUCT
+#define HASMSSTRINGS
+#define HASMULTILINEFUNCTIONS
+#define HASEDITOR
+#define HASTINYBASICINPUT
+#define HASLONGNAMES 
+#define HASHELP
+#define HASFULLINSTR
+#define HASLOOPOPT
+#define HASNUMSYSTEM
+#endif
+
+/* a simple integer basic for small systems mainly the UNO */
+#ifdef  BASICSIMPLE
+#define HASAPPLE1
+#define HASARDUINOIO
+#define HASFILEIO
+#define HASTONE
+#define HASPULSE
+#define HASSTEFANSEXT
+#define HASERRORMSG
+#undef  HASFLOAT
+#undef  HASGRAPH
+#define HASDARTMOUTH
+#undef  HASDARKARTS
+#define HASIOT
+#undef  HASMULTIDIM
+#define HASTIMER
+#define HASEVENTS
+#define HASERRORHANDLING
+#undef 	HASSTRUCT
+#undef  HASMSSTRINGS
+#undef HASMULTILINEFUNCTIONS
+#undef HASEDITOR
+#define HASTINYBASICINPUT
+#undef HASLONGNAMES 
+#undef HASHELP
+#undef HASFULLINSTR
+#undef HASLOOPOPT
+#undef HASNUMSYSTEM
+#undef HASPOWER
+#undef HASUSRCALL
+#endif
+
+/* a small integer BASIC for 32kB systems with big cores */
+#ifdef  BASICSMALL
+#define HASAPPLE1
+#define HASARDUINOIO
+#undef  HASFILEIO
+#undef  HASTONE
+#undef  HASPULSE
+#define HASSTEFANSEXT
+#define HASERRORMSG
+#undef  HASFLOAT
+#undef  HASGRAPH
+#undef  HASDARTMOUTH
+#undef  HASDARKARTS
+#define HASIOT
+#undef  HASMULTIDIM
+#define HASTIMER
+#define HASEVENTS
+#define HASERRORHANDLING
+#undef  HASSTRUCT
+#undef HASMSSTRINGS
+#undef HASMULTILINEFUNCTIONS
+#undef HASEDITOR
+#define HASTINYBASICINPUT
+#undef HASLONGNAMES 
+#undef HASHELP
+#undef HASFULLINSTR
+#undef HASLOOPOPT
+#undef HASNUMSYSTEM
+#undef HASPOWER
+#undef HASUSRCALL
+#endif
+
+
+/* all features activated */
+#ifdef BASICFULL
+#define HASAPPLE1
+#define HASARDUINOIO
+#define HASFILEIO
+#define HASTONE
+#define HASPULSE
+#define HASSTEFANSEXT
+#define HASERRORMSG
+#define HASFLOAT
+#define HASGRAPH
+#define HASDARTMOUTH
+#define HASDARKARTS
+#define HASIOT
+#define HASMULTIDIM
+#define HASTIMER
+#define HASEVENTS
+#define HASERRORHANDLING
+#define HASSTRUCT
+#define HASMSSTRINGS
+#define HASMULTILINEFUNCTIONS
+#define HASEDITOR
+#define HASTINYBASICINPUT
+#define HASLONGNAMES 
+#define HASHELP
+#define HASFULLINSTR
+#define HASLOOPOPT
+#define HASNUMSYSTEM
+#endif
+
+/* a simple BASIC with float support */
+#ifdef BASICSIMPLEWITHFLOAT
+#define HASAPPLE1
+#define HASARDUINOIO
+#undef HASFILEIO
+#undef HASTONE
+#undef HASPULSE
+#define HASSTEFANSEXT
+#define HASERRORMSG
+#define HASFLOAT
+#undef HASGRAPH
+#define HASDARTMOUTH
+#undef HASDARKARTS
+#undef HASIOT
+#undef HASMULTIDIM
+#undef HASTIMER
+#undef HASEVENTS
+#undef HASERRORHANDLING
+#undef HASSTRUCT
+#undef HASMSSTRINGS
+#undef HASMULTILINEFUNCTIONS
+#undef HASEDITOR
+#define HASTINYBASICINPUT
+#undef HASLONGNAMES 
+#undef HASHELP
+#undef HASFULLINSTR
+#undef HASLOOPOPT
+#undef HASNUMSYSTEM
+#undef HASPOWER
+#undef HASUSRCALL
+#endif
+
+/* a Tinybasic with float support */
+#ifdef BASICTINYWITHFLOAT
+#define HASAPPLE1
+#define HASARDUINOIO
+#undef HASFILEIO
+#undef HASTONE
+#undef HASPULSE
+#define HASSTEFANSEXT
+#define HASERRORMSG
+#define HASFLOAT
+#undef HASGRAPH
+#undef HASDARTMOUTH
+#undef HASDARKARTS
+#undef HASIOT
+#undef HASMULTIDIM
+#undef HASTIMER
+#undef HASEVENTS
+#undef HASERRORHANDLING
+#undef HASSTRUCT
+#undef HASMSSTRINGS
+#undef HASMULTILINEFUNCTIONS
+#undef HASEDITOR
+#define HASTINYBASICINPUT
+#undef HASLONGNAMES 
+#undef HASHELP
+#undef HASFULLINSTR
+#undef HASLOOPOPT
+#undef HASNUMSYSTEM
+#undef HASPOWER
+#undef HASUSRCALL
+#endif
+
+/* 
+ *	Language feature dependencies
+ * 
+ * Dartmouth and darkarts needs the heap which is in Apple 1
+ * IoT needs strings and the heap, also Apple 1
+ * 
+ * String arrays need multi dimensional capabilities
+ *
+ * The structured language set needs ELSE from STEFANSEXT
+ *
+ */
+#if defined(HASMULTILINEFUNCTIONS)
+#define HASDARTMOUTH
+#endif
+
+#if defined(HASDARTMOUTH) || defined(HASDARKARTS) || defined(HASIOT) || defined(HASMSSTRINGS)
+#define HASAPPLE1
+#endif
+
+#if defined(HASSTRUCT)
+#define HASSTEFANSEXT
+#endif
+
+/* MS strings also bring the full INSTR */
+#if defined(HASMSSTRINGS)
+#define HASFULLINSTR
+#endif
+
+/* dependencies on the hardware */
+#if !defined(DISPLAYHASGRAPH) 
+#undef HASGRAPH
+#endif

data/Basic2/IoTBasic/runtime.h

@@ -0,0 +1,1205 @@
+/*
+ * Stefan's basic interpreter. 
+ *
+ * Prototypes for the runtime environment of the BASIC interpreter.
+ *
+ * Needs to be included by runtime.c or runtime.cpp and basic.c as 
+ * it describes the interface between the BASIC interpreter and the
+ * runtime environment.
+ * 
+ * Most configurable parameters are in hardware.h.
+ *
+ * Author: Stefan Lenz, [email protected]
+ * 
+ */
+
+#if !defined(__RUNTIMEH__)
+#define __RUNTIMEH__ 
+
+/* 
+ * The system type identifiers
+ * 
+ * SYSTYPE_UNKNOWN: unknown system, typically an unknown Arduino
+ * SYSTYPE_AVR: an AVR based Arduino, like the UNO, NANO, MEGA, PRO
+ * SYSTYPE_ESP8266: an ESP8266 based Arduino, like the Wemos D1, very common and generic
+ * SYSTYPE_ESP32: an ESP32 based Arduino, like the Wemos Lolin32, very common and generic
+ * SYSTYPE_RP2040: a Raspberry PI Pico, the first RP2040 based Arduino
+ * SYSTYPE_SAM: a SAM based Arduino, like the DUE
+ * SYSTYPE_XMC: an XMC based Arduino, like the Infineon XMC1100
+ * SYSTYPE_SMT32: an STM32 based Arduino, like the Blue Pill
+ * SYSTYPE_NRENESA: a Renesas based Arduino, like the R4 Wifi and Minimal
+ * SYSTYPE_GIGA: Arduino GIGA board 
+ * SYSTYPE_POSIX: a POSIX system, like Linux, MacOS
+ * SYSTYPE_MSDOS: a DOS system, like FreeDOS
+ * SYSTYPE_MINGW: a Windows system with MinGW
+ * SYSTYPE_RASPPI: a Raspberry PI system
+ * 
+ * Number ranges from 0-31 are reserved for Arduino systems
+ * Number ranges from 32-63 are reserved for POSIX systems
+ */
+
+#define SYSTYPE_UNKNOWN	0
+#define SYSTYPE_AVR 	1
+#define SYSTYPE_ESP8266 2
+#define SYSTYPE_ESP32	3
+#define SYSTYPE_RP2040  4
+#define SYSTYPE_SAM     5
+#define SYSTYPE_XMC		6
+#define SYSTYPE_SMT32	7
+#define SYSTYPE_NRENESA 8
+#define SYSTYPE_GIGA    9
+#define SYSTYPE_POSIX	32
+#define SYSTYPE_MSDOS	33
+#define SYSTYPE_MINGW   34
+#define SYSTYPE_RASPPI  35
+
+/* 
+ * Input and output channels.
+ * 
+ * The channels are used to identify the I/O devices in the
+ * runtime environment. 
+ * 
+ * NULL is the memory channel outputting to a buffer.
+ * SERIAL is the standard serial channel and the default device. 
+ * DSP is the display channel.
+ * GRAPH is the additional graphics display channel.
+ * PRT is the second serial channel used for printing and communication
+ *   with external devices.
+ * WIRE is the I2C channel.
+ * RADIO is the RF24 channel.
+ * MQTT is the MQTT channel.
+ * FILE is the file system channel.
+ */
+
+#define ONULL 0
+#define OSERIAL 1
+#define ODSP 2
+#define OGRAPH 3
+#define OPRT 4
+#define OWIRE 7
+#define ORADIO 8
+#define OMQTT  9
+#define OFILE 16
+
+#define INULL 0
+#define ISERIAL 1
+#define IKEYBOARD 2
+#define IGRAPH 3  
+#define ISERIAL1 4
+#define IWIRE 7
+#define IRADIO 8
+#define IMQTT  9
+#define IFILE 16
+
+/* 
+ * Global variables of the runtime env, visible to BASIC. 
+ * These are the variables that BASIC provides to the runtime  
+ * environment. They are used all over the BASIC code. Some 
+ * could be encapsulated as function calls calls.
+ *
+ * Variables to control the io device channels. 
+ *
+ * id: the current input device
+ * od: the current output device
+ * idd: the default input device in interactive mode
+ * odd: the default output device in interactive mode
+ * ioer: the io error   
+ */
+extern int8_t id; 
+extern int8_t od; 
+extern int8_t idd;
+extern int8_t odd;
+extern int8_t ioer;
+
+/* 
+ * Io control flags.
+ *
+ * These flags are used to control the I/O devices.
+ * kbdrepeat: the keyboard repeat flag for the keypad of a shield
+ *  only used by SET and defined in the keypad code
+ * blockmode: the blockmode flag, switch a channel to blockmode
+ * sendcr: the sendcr flag, send a carriage return after a newline if true
+ */
+
+extern uint8_t kbdrepeat;
+extern uint8_t blockmode;
+extern uint8_t sendcr;
+
+/* breaks, signaly back that the breakcondition has been detected */
+extern char breakcondition;
+
+/* counts the outputed characters on streams 0-4, used to emulate a real tab */
+extern uint8_t charcount[5]; /* devices 0-4 support tabing */
+
+/* the memory buffer comes from BASIC in this version, it is the input buffer for lines */
+extern char ibuffer[BUFSIZE];
+
+/* only needed in POSIX worlds */
+extern uint8_t breaksignal; 
+extern uint8_t vt52active;
+
+/* the string buffer the interpreter needs, here to be known by BASIC */
+extern char spistrbuf1[SPIRAMSBSIZE], spistrbuf2[SPIRAMSBSIZE];
+
+/* 
+ * the mqtt variable the interpreter needs.
+ * The following parameters are configured here:
+ * 
+ * MQTTLENGTH: the length of the mqtt topic, restricted to 32 by default.
+ * MQTTBLENGTH: the length of the mqtt buffer, 128 by default.
+ * MQTTNAMELENGTH: the length of the autogenerated mqtt name, 12 by default. 
+ * The mqtt name is used to identify the device in the mqtt network.
+ * 
+ * mqtt_otopic: the outgoing topic
+ * mqtt_itopic: the incoming topic
+ * mqttname: the name of the device in the mqtt network
+*/
+
+#define MQTTLENGTH 32
+#define MQTTBLENGTH 128
+#define MQTTNAMELENGTH 12
+
+extern char mqtt_otopic[MQTTLENGTH];
+extern char mqtt_itopic[MQTTLENGTH];
+extern char mqttname[];
+
+/* a byte in the runtime memory containing the system type */
+extern uint8_t bsystype;
+
+/* 
+ *  Console logger functions for the runtime code. Runtime does not know 
+ *  anything about output deviced. BASIC is to provide this. This 
+ *  is used for debugging and logging.
+ */
+
+ extern void consolelog(char*);
+ extern void consolelognum(int);
+ 
+/*
+ * Statup function. They start the runtime environment.
+ * 
+ * The functions timeinit(), wiringbegin(), signalon()
+ * are always empty on Arduino, they are only used in 
+ * the POSIX branch of the code.
+ * 
+ * timeinit() initializes the time functions.
+ * wiringbegin() initializes the wiring functions, this is needed on 
+ *   Raspberry PI.
+ * signalon() initializes the signal handling, this is needed on
+ *   Unix like systems and Windows. 
+ * 
+ * BASIC calls these functions once to start the timing, wiring, and 
+ * signal handling.
+ */
+
+ void timeinit();	
+ void wiringbegin();	
+ void signalon();
+
+/* 
+ * Start the SPI bus. Called once on start. Needed on Arduino. 
+ * Empty in the POSIX branch of the code.
+ * 
+ * Some libraries also try to start the SPI which may lead to on override of 
+ * the PIN settings if the library code is not clean - currenty no conflict known.
+ * for the libraries used here. Old SD card libraries have problems as they always 
+ * start the SPI bus with default settings and cannot get the settings from the
+ * SPI.begin() call. In these cases patching of the SD library is needed.
+ */
+
+ void spibegin();
+
+/*
+ * Memory allocation functions.
+ * 
+ * BASIC calls freememorysize() to detemine how much memory can be allocated 
+ * savely on the heap.
+ * BASIC calls restartsystem() for a complete reboot. 
+ * freeRam() is the actual free heap. Used by freememorysize() and in USR()
+ * 
+ * Arduino data from https://docs.arduino.cc/learn/programming/memory-guide
+ */
+
+ long freememorysize(); /* determine how much actually to allocate */
+ void restartsystem(); /* cold start of the MCU */
+ long freeRam();	/* try to find the free heap after alocating all globals */
+ 
+ /* Test function for real time clock interrupt, currently not useable. 
+     Kept for the future. */ 
+ void rtcsqw();
+ void aftersleepinterrupt(void);
+ void activatesleep(long);
+ 
+/* 
+ * The main IO interface. This is how BASIC uses I/O functions.
+ *
+ * ioinit(): called at setup to initialize what ever io is needed
+ * iostat(): check which io devices are available
+ * iodefaults(): called at setup and while changing to interactive mode 
+ *       to set the default io devices
+ * cheof(): checks for end of file condition on the current input stream
+ * inch(): gets one character from the current input stream and waits for it
+ * checkch(): checks for one character on the current input stream, non blocking
+ * availch(): checks for available characters on the current input stream
+ * inb(): reads a block of characters from the current input stream
+ * ins(): reads an entire line from the current input stream, usually by consins()
+ * outch(): prints one ascii character to the current output stream
+ * outs(): prints a string of characters to the current output stream
+ */
+
+ void ioinit();
+ int iostat(int);
+ void iodefaults();
+ int cheof(int);
+ char inch();
+ char checkch();
+ uint16_t availch();
+ uint16_t inb(char*, int16_t);
+ uint16_t ins(char*, uint16_t);
+ void outch(char);
+ void outs(char*, uint16_t);
+
+/* 
+ *  Timeing functions and background tasks. 
+ *  
+ *  byield() must be called after every statement and in all 
+ *  waiting loops for I/O. BASIC gives back the unneeded 
+ *  CPU cycles by calling byield().
+ *  
+ *  byield() allows three levels of background tasks. 
+ *
+ *  BASICBGTASK controls if time for background tasks is 
+ *  needed, usually set by hardware features
+ *
+ *  YIELDINTERVAL by default is 32, generating a 32 ms call
+ *    to the network loop function. This is the frequency 
+ *    yieldfunction() is called.
+ *
+ *  LONGYIELDINTERVAL by default is 1000, generating a one second
+ *    call to maintenance functions. This is the frequency 
+ *    longyieldfunction() is called.
+ *    
+ *  fastticker() is called in every byield for fast I/O control.
+ *    It is currently only used for the tone emulation.
+ *    
+ *  byield() calls back bloop() in the BASIC interpreter for user 
+ *    defined background tasks in an Arduino style loop() function.
+ * 
+ *  bdelay() is a delay function using byield() to allow for
+ *   background tasks to run even when the main code does a delay.
+ *
+ *  The yield mechanism is needed for ESP8266 yields, network client 
+ *  loops and other timing related functions.
+ * 
+ *  yieldschedule() is a function that calls the buildin scheduler 
+ *   of some platforms. Currently it is only used in ESP8266. The 
+ *   core on this boards does not tolerate that the loop() function
+ *   does not return and crashes the system. This can be prevented 
+ *   by calling yieldschedule() often enough.  
+ */
+
+#define LONGYIELDINTERVAL 1000
+#define YIELDINTERVAL 32
+
+void byield(); 
+void bdelay(uint32_t); 
+void fastticker(); 
+void yieldfunction(); 
+void longyieldfunction();
+void yieldschedule();
+
+/* 
+ * This function measures the fast ticker frequency in microseconds.
+ * This can be accessed with USR(0, 35) in BASIC.
+ * Activate this only for test  purposes as it slows down the interpreter. 
+ * The value is the shortest timeframe the interpreter can handle. Activated 
+ * if the code is compiled with FASTTICKERPROFILE in hardware.h.
+ */
+
+void fasttickerprofile();
+void clearfasttickerprofile();
+int  avgfastticker();
+
+/* 
+ * EEPROM handling, these function enable the @E array and 
+ * loading and saving to EEPROM with the "!" mechanism
+ * 
+ * The EEPROM code can address EEPROMS up to 64 kB. It returns 
+ * signed byte values which corresponds to the definition of 
+ * mem_t in BASIC. This is needed because running from EEPROM
+ * requires negative token values to be recongized. 
+ * 
+ * ebegin() starts the EEPROM code. Needed for the emulations.
+ * eflush() writes the EEPROM buffer to the EEPROM. Also this is 
+ *    mainly needed in the emulations. 
+ * elength() returns the length of the EEPROM.
+ * eupdate() updates one EEPROM cell with a value. Does not flush. 
+ * eread() reads one EEPROM cell.
+ */ 
+
+void ebegin(); 
+void eflush();
+uint16_t elength();
+void eupdate(uint16_t, int8_t);
+int8_t eread(uint16_t);
+
+/* 
+ *  The wrappers of the arduino io functions.
+ *  
+ *  The normalize the differences of some of the Arduino cores 
+ *  and raspberyy PI wiring implementations.
+ * 
+ *  Pin numbers are the raw numerical pin values in BASIC. 
+ *  The functions are called with this raw pin number and the value.
+ * 
+ * The functions are:
+ * aread(pin): read an analog value from a pin
+ * dread(pin): read a digital value from a pin
+ * awrite(pin, value): write an analog value to a pin
+ * dwrite(pin, value): write a digital value to a pin
+ * pinm(pin, mode): set the mode of a pin, mode is also the raw value from the core
+ * pulsein(pin, value, timeout): read a pulse from a pin, timeout in microseconds
+ * void pulseout(unit, pin, duration, val, repetition, interval): generate a pulse on a pin
+ *    unit is the timeunit in microsecind and the duration is the pulse length in this unit.
+ *    This is needed for system were the number_t is only 16 bit. This way longer pulses can 
+ *    be generated.
+ * void playtone(pin, frequency, duration, volume): generate a tone on a pin. 
+ *   frequency is the frequency in Hz, duration the duration in ms, volume the volume in percent.
+ *   The tone is generated in the background, the function returns immediately.
+ * tonetoggle(): toggle the tone generation, needed for the tone emulation, this is called 
+ *  by byield() to generate the tone.
+ */ 
+
+uint16_t aread(uint8_t);
+uint8_t dread(uint8_t);
+void awrite(uint8_t, uint16_t);
+void dwrite(uint8_t, uint8_t);
+void pinm(uint8_t, uint8_t);
+uint32_t pulsein(uint8_t, uint8_t, uint32_t);
+void pulseout(uint16_t, uint8_t, uint16_t, uint16_t, uint16_t, uint16_t);
+void playtone(uint8_t, uint16_t, uint16_t, uint8_t);
+void tonetoggle(); /* internal function of the tone emulation, called by byield */
+
+/*
+ * The break pin code. This is a pin that can be used to break the execution of the
+ * BASIC code. This is used as an alternative to the BREAK key in the terminal.
+ * 
+ * brakepinbegin() initializes the break pin, usually a button connected to a pin.
+ * getbreakpin() returns the state of the break pin. This is called in statement() to 
+ * check if the break condition is met and then change the interpreter state at the end
+ * of the statement.
+ */
+
+void breakpinbegin();
+uint8_t getbreakpin();
+
+/* 
+ * The hardware port register access functions.
+ * They can be used to directly access hardware ports. Typically they 
+ * call port macros like PORTB on the Arduino AVR platform. They are very 
+ * fast and can be used to implement fast I/O functions but they are hardware
+ * dependent and not portable. Currently only AVR UNO and MEGA are implemented.
+ * 
+ * The calling mechanism in BASIC is the special array @P()for read and write.
+ */
+
+void portwrite(uint8_t, int);
+int portread(uint8_t);
+void ddrwrite(uint8_t, int);
+int ddrread(uint8_t);
+int pinread(uint8_t);
+
+/*
+ * Prototypes for the interrupt interface. This uses the standard Arduino
+ * interrupt functions. 
+ */
+
+uint8_t pintointerrupt(uint8_t);
+void attachinterrupt(uint8_t, void (*f)(), uint8_t);
+void detachinterrupt(uint8_t);
+
+/* some have PinStatus and some don't */
+#if !(defined(ARDUINO_ARCH_MBED_RP2040) || defined(ARDUINO_ARCH_MBED_NANO) || \
+     defined(ARDUINO_ARCH_RENESAS) || defined(ARDUINO_ARCH_MBED_GIGA) || \
+     defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_MEGAAVR)) || defined(ARDUINO_SEEED_XIAO_M0)
+typedef int PinStatus;
+#endif
+
+/*
+ * IO channel 0 - the buffer I/O device.
+ *
+ * This is a stream to write to the input buffer from BASIC. 
+ */
+
+ void bufferbegin();
+ uint8_t bufferstat(uint8_t);
+ void bufferwrite(char);
+ char bufferread();
+ char buffercheckch();
+ uint16_t bufferavailable();
+ uint16_t bufferins(char*, uint16_t);
+ void bufferouts(char*, uint16_t);
+ 
+
+/*
+  * IO channel 1 - the serial I/O device.
+  * 
+  * Primary serial code uses the Serial object or Picoserial on 
+  * Arduino. On POSIX systems it uses the standard input/output.
+  * 
+  * Functions are: 
+  * 
+  * serialbegin(): start the serial port
+  * serialread(): read a character from the serial port, this is blocking 
+  *  for the standard Serial object and non blocking for Picoserial.
+  *  Picoserial is not character oriented. It read one entire line. 
+  * serialstat(s): check the status of the serial port
+  * serialwrite(c): write a character to the serial port
+  * serialcheckch(): check if a character is available without blocking
+  * serialavailable(): check if characters are available
+  * serialflush(): flush the serial port
+  * serialins(s, l): read a line from the serial port
+  */
+ 
+ void serialbegin();
+ char serialread();
+ uint8_t serialstat(uint8_t); /* state information on the serial port */
+ void serialwrite(char); /* write to a serial stream */
+ char serialcheckch(); /* check on a character, needed for breaking */
+ uint16_t serialavailable(); /* avail method, needed for AVAIL() */ 
+ void serialflush(); /* flush serial */
+ uint16_t serialins(char*, uint16_t); /* read a line from serial */
+ 
+ /*
+  * reading from the console with inch or the picoserial callback.
+  * consins() is used for all devices that have a character oriented
+  * input and creates entire lines from it.
+  */
+
+ uint16_t consins(char *, uint16_t);
+
+/* 
+ * On Arduino Serial is a big object that needs a lot of memory 
+ * on the smaller boards. Picoserial is smaller. It is mainly 
+ * for the small 8bit AVR boards. It uses the UART macros directly.
+ * 
+ * The picoseria has an own interrupt function. This is used to fill 
+ * the input buffer directly on read. Write is standard like in 
+ * the serial code. Currently picoserial is only implemented for
+ * AVR UNO, NANO and MEGA. 
+ *  
+ * As echoing is done in the interrupt routine, the code cannot be 
+ * used to receive keystrokes from serial and then display the echo
+ * directly to a display. To do this the write command in picogetchar
+ * would have to be replaced with a outch() that then redirects to the 
+ * display driver. This would be very tricky from the timing point of 
+ * view if the display driver code is slow. 
+ * 
+ * The code for the UART control is mostly taken from PicoSerial
+ * https://github.com/gitcnd/PicoSerial, originally written by Chris Drake
+ * and published under GPL3.0 just like this code.
+ * 
+ * Functions for the picoserial code are:
+ * 
+ * picobegin(baud): start the picoserial port with the baud rate baud
+ * picowrite(c): write a character to the picoserial port
+ * picoins(s, l): read a line from the picoserial port
+ * 
+ */
+
+ void picobegin(uint32_t);
+ void picowrite(char);
+ uint16_t picoins(char *, uint16_t);
+ 
+ /* 
+  *  picogetchar: this is the interrupt service routine.  It 
+  *  recieves a character and feeds it into a buffer and echos it
+  *  back. The logic here is that the ins() code sets the buffer 
+  *  to the input buffer. Only then the routine starts writing to the 
+  *  buffer. Once a newline is received, the length information is set 
+  *  and picoa is also set to 1 indicating an available string, this stops
+  *  recevieing bytes until the input is processed by the calling code.
+  */
+ void picogetchar(char);
+
+/*
+ * IO channel 2 - the display I/O device. 
+ *
+ * DISPLAY driver code section. The display driver is a generic text and graphics
+ * output device. Characters are buffered in a display buffer if DISPLAYCANSCROLL 
+ * is defined. These displays can scroll. Scrolling is handled by the display driver.
+ * It is soft scroll, meaning that the display buffer is scrolled and the display is
+ * updated. This is slow for large displays. Hardware scrolling is not yet implemented.
+ * 
+ * The display driver is used by the terminal code to output text and
+ * graphics. It is needed because there is no standard terminal emulation on Arduino
+ * systems. It tries to be so generic that everything from small 16*2 LCDs to large
+ * TFT displays can be used. It contains a VT52 state engine to process control
+ * sequences.
+ * 
+ * The hardware dependent part of the display driver has to implement the following
+ * functions:
+ *
+ * Text display functions:
+ * 
+ * dsp_rows, dsp_columns: size of the display
+ * dspbegin(): start the display - can be empty
+ * dspprintchar(c, col, row): print a character at a given position
+ *      logic here that col is the x coordinate and row the y coordinate
+ *      for text and graphics the display coordinate system has its origin
+ *      in the upper left corner
+ * dspclear(): clear the display
+ * dspupdate(): update the display, this function is needed for displays that
+ *      have a buffer and can update the display after a series of prints. 
+ *      Examples are epaper displays and LCD displays like the Nokia. Writing 
+ *      directly to them is slow. 
+ * dspsetcursor(c): switch the cursor on or off, typically used for text 
+ *      displays with blinking cursors.
+ * dspsetfgcolor(c): set the foreground color of the display.
+ * dspsetbgcolor(c): set the background color of the display.
+ *      c is a VGA color. 4bit VGA colors are used for text displays. 
+ *      Graphics is 24 bit color rgb and 8 bit VGA color.
+ * dspsetreverse(c): set the reverse mode of the display, currently unused.
+ * dspident(): return the display type, currently unused.
+ * 
+ * For displays with color, the macro DISPLAYHASCOLOR has to be defined.
+ * The text display buffer then contains one byte for the character and 
+ * one byte for color and font. 
+ *
+ * All displays which have these functions can be used with the 
+ * generic display driver below. For minimal functionality only
+ * dspprintchar() and dspclear() are needed. The screen dimensions
+ * have to be set in dsp_rows and dsp_columns.
+ * 
+ * Graphics displays need to implement the functions 
+ * 
+ * rgbcolor(r, g, b): set the color for graphics. The color
+ *     is 24 bit rgb. This function needs to convert the byte 
+ *     values to the native color of the display.
+ * vgacolor(c): set the color for text. The color is a 256 VGA  
+ *    color for most displays. This function needs to convert this
+ *    one byte value to the native color of the display.
+ * These two functions are called by the BASIC COLOR command.
+ * 
+ * plot(x, y): plot a pixel at x, y
+ * line(x1, y1, x2, y2): draw a line from x1, y1 to x2, y2
+ * rect(x1, y1, x2, y2): draw a rectangle from x1, y1 to x2, y2
+ * frect(x1, y1, x2, y2): draw a filled rectangle from x1, y1 to x2, y2
+ * circle(x, y, r): draw a circle with center x, y and radius r
+ * fcircle(x, y, r): draw a filled circle with center x, y and radius r
+ * 
+ * 
+ * Color is currently either 24 bit or 8 bit 16 VGA color. BW and displays
+ * only have 0 and 1 as colors. Text is buffered in 4 bit VGA color (see below).
+ */
+
+ /* Generate a 4 bit vga color from a given rgb color, to be checked */
+uint8_t rgbtovga(uint8_t, uint8_t, uint8_t);
+
+
+/* Text functions */
+void dspbegin(); 
+void dspprintchar(char, uint8_t, uint8_t);
+void dspclear();
+void dspupdate();
+void dspsetcursor(uint8_t);
+void dspsavepen();
+void dsprestorepen();
+void dspsetfgcolor(uint8_t);
+void dspsetbgcolor(uint8_t);
+void dspsetreverse(uint8_t);
+uint8_t dspident();
+
+/* Graphics functions */
+void rgbcolor(uint8_t, uint8_t, uint8_t);
+void vgacolor(uint8_t);
+void plot(int, int);
+void line(int, int, int, int);
+void rect(int, int, int, int);
+void frect(int, int, int, int);
+void circle(int, int, int);
+void fcircle(int, int, int);
+
+/* to whom the bell tolls - implement this to you own liking, reacts to ASCII 7 */
+void dspbell(); 
+
+/*
+ * The public functions of the display driver are the following:
+ *
+ * dspouts(s, l): print a string of length l to the display. This 
+ *      function is only used for output on certain graphics displays
+ *      These displays expect an entire string to be printed at once.
+ *      Currently this is only implemented for epaper displays.
+ * dspwrite(c): print a character to the display. This function is 
+ *      the main output method for text displays. It prints a character
+ *      at the current cursor position and updates the cursor position.
+ *      For vt52 capable displays, the character goes through the vt52
+ *      state engine and it processed there. 
+ * dspstat(s): check the status of the display. It returns 1 if the 
+ *      display is present and 0 if it is not. 
+ * dspactive(): check if the display is the current output device.
+ *      This function is used to control scrolling in the LIST command.
+ * dspwaitonscroll(): this function waits for character input if the 
+ *      display wants to scroll.  This is used in the LIST command to
+ *       wait for a keypress before scrolling the display. It returns the 
+ *      character that was pressed. This can also be used to end the output
+ *      of the LIST command.
+ * dspsetupdatemode(m): set the update mode of the display. Valid update
+ *     modes are 0, 1, 2. 0 is character mode, 1 is line mode, 2 is page mode.
+ *     In character mode, the display is updated after every character. In line
+ *     mode, the display is updated after every line. In page mode, the display
+ *     is updated after an ETX character. This function is only used for displays
+ *     that implement the dspupdate() function.
+ * dspgetupdatemode(): get the current update mode of the display.
+ * dspgraphupdate(): update the display after a series of graphics commands. While
+ *     dspsetupdatemode() and dspgetupdatemode() control the update from the text buffer,
+ *     dspgraphupdate() controls the update from the graphics buffer. See for example 
+ *     the Nokia display as an example. This function must be called after graphics 
+ *     operations to update the display. Typically this is done in the graphics functions
+ *     like line(), rect(), circle(), etc.
+ * dspsetcursorx(x): set the x coordinate of the cursor
+ * dspsetcursory(y): set the y coordinate of the cursor
+ * dspgetcursorx(): get the x coordinate of the cursor
+ * dspgetcursory(): get the y coordinate of the cursor
+ */
+
+void dspouts(char*, uint16_t);
+void dspwrite(char);
+uint8_t dspstat(uint8_t);
+uint8_t dspactive();
+char dspwaitonscroll();
+void dspsetupdatemode(uint8_t);
+uint8_t dspgetupdatemode(); 
+void dspgraphupdate();
+void dspsetcursorx(uint8_t);
+void dspsetcursory(uint8_t);
+uint8_t dspgetcursorx();
+uint8_t dspgetcursory();
+
+/* 
+ * These are the buffer control functions for the display driver.
+ * 
+ * Color handling: 
+ * 
+ * Non scrolling displays simply use the pen color of the display
+ * stored in dspfgcolor() to paint the information on the screen.
+ * 
+ * For scrolling displays we store the color information of every
+ * character in the display buffer to enable scrolling with color. 
+ * To limit the storage requirements, this code translates the color 
+ * to a 4 bit VGA color. This means that if BASIC uses 24 bit colors, 
+ * the color may change at scroll
+ *
+ * For color displays the buffer is a 16 bit object. The lower 8 bits 
+ * plus the sign are the character, higher 7 the color and font.
+ * For monochrome just the character is stored in an 8 bit object.
+ * 
+ * The type dspbuffer_t is defined according to the display type.
+ * 
+ * The following functions are used to control the display buffer:
+ * 
+ * dspget(): get a character from the display buffer in form of a linear
+ *    address. This is only used for the special array @D() in BASIC.
+ *    It allows direct access to the display buffer.
+ * dspgetrc(r, c): get a character from the display buffer at row r and column c.
+ *    This is used for the print function of the vt52 terminal. An entire display 
+ *    can be sent to the printer device OPRT
+ * dspgetc(c): get a character from the current line at column c. Also this is 
+ *   used for the print function of the VT52 terminal. This only sents the 
+ *   current line to the printer device OPRT.
+ * For both functions the actual print code is in the VT52 object.
+ * These three functions are somewhat redundant.
+ * 
+ * dspsetxy(c, x, y): set a character at x, y in the display buffer and on the 
+ *   display. This function is needed for various control sequences of the VT52 
+ *   terminal.
+ * dspset(c, v): set a character at a linear address in the display buffer. Also u
+ *   used for the @D() array in BASIC.
+ * 
+ * dspsetscrollmode(m, l): set the scroll mode. m is the mode and l is the number
+ *    of lines to be scrolled. Mode 0 means that dspwaitonscroll() does not 
+ *    wait for keyboard input. Mode 1 is wait for input. 
+ * dspbufferclear(): clears the input buffer. 
+ * dspscroll(l, t): do the actual scrolling. l is the number of lines to be scrolled.
+ *    t is the topmost line included in the scroll. O by default.
+ * dspreversescroll(l): reverse scroll from line l downward.
+ */
+
+#ifdef DISPLAYHASCOLOR
+typedef short dspbuffer_t;
+#else
+typedef char dspbuffer_t;
+#endif
+
+dspbuffer_t dspget(uint16_t);
+dspbuffer_t dspgetrc(uint8_t, uint8_t);
+dspbuffer_t dspgetc(uint8_t);
+
+void dspsetxy(dspbuffer_t, uint8_t, uint8_t); 
+void dspset(uint16_t, dspbuffer_t);
+void dspsetscrollmode(uint8_t, uint8_t);
+
+void dspbufferclear(); 
+void dspscroll(uint8_t, uint8_t); 
+void dspreversescroll(uint8_t); 
+
+/*
+ * A VT52 state engine is implemented and works for buffered and 
+ * unbuffered displays. Only buffered displays have the full VT52
+ * feature set including most of the GEMDOS extensions described here:
+ * https://en.wikipedia.org/wiki/VT52
+ * 
+ * The VT52 state engine processes sequences of the form <ESC> char.
+ * 
+ * In addition to this, it also gives back certain return values. 
+ * The can be read by vt52read() and vt52avail().
+ * vt52push() is used to push characters into the VT52 buffer.
+ * vt52number() is used to convert a character into the VT52 number format.
+ * vt52graphcommand() is a VT52 extension to display graphics on the screen.
+ */
+
+char vt52read(); 
+uint8_t vt52avail(); 
+void vt52push(char); 
+uint8_t vt52number(char); 
+void vt52graphcommand(uint8_t);
+
+/* 
+ * this is a special part of the vt52 code with this, the terminal 
+ * can control the digital and analog pins.
+ * 
+ * It is meant for situations where the terminal is controlled by a (powerful)
+ * device with no or very few I/O pins. It can use the pins of the Arduino through  
+ * the terminal. 
+ * 
+ * This works as long as everything stays within the terminals timescale.
+ * On a 9600 baud interface, the character processing time is 1ms, everything 
+ * slower than approximately 10ms can be done through the serial line.
+ */
+
+void vt52wiringcommand(uint8_t);
+
+/* the vt52 state engine */
+void dspvt52(char*);
+
+/* 
+ * Code for the VGA system of Fabgl. This is a full VT52 terminal. The 
+ * display driver is not used for this. 
+ */
+
+void vgabegin(); 
+int vgastat(uint8_t); 
+void vgascale(int*, int*); 
+void vgawrite(char); 
+void vgaend();
+
+/* 
+ * IO channel 2 (input) - the keyboard I/O device.
+ *
+ * Keyboard code for either the Fablib Terminal class,  
+ * PS2Keyboard or other keyboards. 
+ * 
+ * PS2Keyboard: please note that you need the patched 
+ * version here as mentioned above.
+ * 
+ * Keyboards implement kbdbegin() which is called at startup
+ * and kbdstat() which is called to check if the keyboard is
+ * available.
+ * 
+ * Keyboards need to provide the following functions:
+ * 
+ * kbdavailable(): check if a character is available
+ * kbdread(): read a character from the keyboard
+ * kbdcheckch(): check if a character is available without blocking
+ * kbdins(): read a line from the keyboard
+ * 
+ * kbdcheckch() is for interrupting running BASIC code with a 
+ * BREAKCHAR character from the keyboard. If this functions is 
+ * not implemented, the BREAKCHAR character is ignored.
+ * 
+ * kbdins() is usually using consins() to read a line from the
+ * keyboard repeatedly calling kbdread() until a newline is
+ * received. A keyboard can also bring its on kbdins() function.
+ */
+
+void kbdbegin();
+uint8_t kbdstat(uint8_t);
+uint8_t kbdavailable();
+char kbdread();
+char kbdcheckch();
+uint16_t kbdins(char*, uint16_t);
+
+/* IO channel 3 - reserved for future use */
+
+ /*
+  * IO channel 4 - the second serial I/O device.
+  * 
+  * This is the (mostly) the Serial1 object 
+  * on Arduino. On POSIX systems this opens a serial port like /dev/ttyUSB1.
+  * This &4 in BASIC.
+  * 
+  * Functions are:
+  * 
+  * prtbegin(): start the serial port
+  * prtopen(name, baud): open the serial port with the baud rate baud. Only 
+  *  neded in POSIX to open the port.
+  * prtclose(): close the serial port
+  * prtstat(s): check the status of the serial port
+  * prtwrite(c): write a character to the serial port
+  * prtread(): read a character from the serial port
+  * prtcheckch(): check if a character is available without blocking
+  * prtavailable(): check if characters are available
+  * prtset(baud): set the baud rate of the serial port
+  * prtins(s, l): read a line from the serial port
+  */
+ 
+  void prtbegin();
+  char prtopen(char*, uint16_t); 
+  void prtclose();
+  uint8_t prtstat(uint8_t);
+  void prtwrite(char);
+  char prtread();
+  char prtcheckch();
+  uint16_t prtavailable();
+  void prtset(uint32_t);
+  uint16_t prtins(char*, uint16_t);
+
+/* 
+ * IO channel 7 - I2C through the Wire library.
+ *
+ * The wire code, direct access to wire communication.
+ *
+ * In master mode wire_slaveid is the I2C address bound 
+ * to channel &7 and wire_myid is 0.
+ * 
+ * In slave mode wire_myid is the devices slave address
+ * and wire_slaveid is 0.
+ * 
+ * The maximum number of bytes the Wire library can handle
+ * is 32. This is given by the Wire library.
+ * 
+ * Wire is handled through the following functions:
+ * 
+ * wirebegin(): start the wire system. 
+ * wireslavebegin(id): start the wire system as a slave with the id.
+ * wirestat(s): check if the wire system is available.
+ * wireavailable(): check if characters are available in slave mode.
+ * wireonreceive(h): set the event handler for received data on a slave.
+ * wireonrequest(): set the event handler for request on a slave.
+ * wireopen(id, slaveid): open the wire system as a master with id to 
+ *   the slave id.
+ * wireread(): read a character from the wire system.
+ * wirewrite(c): write a character to the wire system.
+ * wireins(l, s): read a line l from the wire system max length is s.
+ * wireouts(l, s): write a line l to the wire system max length is s.
+ * They are available in BASIC as the WIRE
+ * command. 
+ */ 
+
+ void wirebegin();
+ void wireslavebegin(uint8_t);
+ uint8_t wirestat(uint8_t);
+ uint16_t wireavailable(); 
+ void wireonreceive(int);
+ void wireonrequest(); 
+ void wireopen(uint8_t, uint8_t);
+ char wireread(); 
+ void wirewrite(char c);
+ uint16_t wireins(char*, uint8_t);
+ void wireouts(char*, uint8_t);
+
+/* new byte wire interface for direct access */
+void wirestart(uint8_t, uint8_t);
+void wirewritebyte(uint8_t);
+uint8_t wirestop();
+int16_t wirereadbyte();
+
+/* 
+ * IO channel 8 - the RF24 radio I/O device.
+ *
+ * Read from the radio interface, radio is always block 
+ * oriented. This function is called from ins for an entire 
+ * line.
+ * 
+ * In blockmode the entire message is returned in the 
+ * receiving string while in line mode the length of the 
+ * string is adapted. Blockmode can be used to transfer
+ * binary data.
+ * 
+ * The radio code is rather obsolet and not used a lot.
+ * 
+ * On RF24 we always read from pipe 1 and use pipe 0 for writing, 
+ * the filename is the pipe address, by default the radio 
+ * goes to reading mode after open and is only stopped for 
+ * write.
+ */
+
+ uint8_t radiostat(uint8_t); 
+ uint64_t pipeaddr(const char*); 
+ uint16_t radioins(char*, uint8_t); 
+ void radioouts(char *, uint8_t); 
+ uint16_t radioavailable(); 
+ char radioread();
+ void iradioopen(const char *);
+ void oradioopen(const char *);
+ void radioset(uint8_t);
+
+/*
+ * IO channel 9 - the network I/O device.
+ *
+ * Only MQTT is implemented at the moment. Other protocols
+ * will be channel 10-15. 
+ *
+ * Underlying networks can be the Wifi classes of the ESP, MKR, and
+ * STM32 cores. The network code is based on the PubSubClient library.
+ * Ethernet is supported with the standard Ethernet library on Arduino.
+ * 
+ * On POSIX systems networking is currently not supported.
+ *
+ * No encryptionis implemented in MQTT. Only unencrypted servers can be used.
+ * 
+ * Buffers are defined above in the mqtt section.
+ * 
+ * MQTTLENGTH: the length of the mqtt topic, restricted to 32 by default.
+ * MQTTBLENGTH: the length of the mqtt buffer, 128 by default.
+ * MQTTNAMELENGTH: the length of the autogenerated mqtt name, 12 by default.
+ *
+ * wifisettings.h is the generic network definition file all network settings 
+ * are compiled into the code. BASIC cannot change them at runtime.
+ * 
+ * Low level network functions are:
+ * 
+ * netbegin(): start the network
+ * netstop(): stop the network
+ * netreconnect(): reconnect the network
+ * netconnected(): check if the network is connected
+ * 
+ * BASIC uses these function to control the network and reconnect if
+ * the connection is lost.
+ */
+
+ void netbegin();
+ void netstop();
+ void netreconnect();
+ uint8_t netconnected();
+ 
+ /*
+  * The mqtt prototypes used by BASIC are:
+  * 
+  * mqttbegin(): start the mqtt client
+  * mqttsetname(): set the name of the mqtt client. The name is autogenerated.
+  * mqttstat(s): check the status of the mqtt client
+  * mqttreconnect(): reconnect the mqtt client
+  * mqttstate(): get the state of the mqtt client (redunant to mqttstat())
+  * mqttsubscribe(t): subscribe to a topic
+  * mqttunsubscribe(): unsubscribe from a topic
+  * mqttsettopic(t): set the topic of the mqtt client
+  * mqttouts(s, l): send a string of length l to the mqtt server
+  * mqttwrite(c): send a character to the mqtt server.
+  * These two functions work buffered. The write to the MQTT output buffer. Only
+  * when the buffer is full or a newline is received, the buffer is sent to the
+  * server.
+  * mqttread(): read a character from the mqtt input buffer.
+  * mqttins(s, l): read a line from the mqtt input buffer.
+  * mqttavailable(): check if characters are available in the mqtt input buffer. 
+  * mqttcheckch(): get the next character from the mqtt input buffer without advancing.
+  */
+
+ void mqttbegin();
+ void mqttsetname();
+ uint8_t mqttstat(uint8_t);
+ uint8_t mqttreconnect();
+ uint8_t mqttstate();
+ void mqttsubscribe(const char*);
+ void mqttunsubscribe();
+ void mqttsettopic(const char*);
+ void mqttouts(const char*, uint16_t);
+ void mqttwrite(const char);
+ char mqttread();
+ uint16_t mqttins(char*, uint16_t);
+ uint16_t mqttavailable();
+ char mqttcheckch();
+ 
+ /*
+  * The callback function of the pubsub client. This is called when a
+  * message is received from the mqtt server. 
+  * 
+  * The Arduino type byte is used here because it is used this way in Pubsub.
+  */
+ void mqttcallback(char*, byte*, unsigned int);
+ 
+/* 
+ * IO channel 16 - the file system I/O device.
+ *
+ * The file system driver - all methods needed to support BASIC fs access. 
+ * 
+ * Different filesystems need different prefixes and fs objects, these 
+ * filesystems use the stream API in the Arduino world.
+ * 
+ *  The functions to access the filesystem are:
+ * 
+ * fsbegin(): start the filesystem
+ * fsstat(s): check the status of the filesystem
+ * mkfilename(s): make a filename from a string
+ * rmrootfsprefix(s): remove the prefix from a filename
+ * 
+ * Different filesystems have different prefixes. In BASIC we 
+ * only show a flat file system with no path names and prefixes.
+ * 
+ * Supported filesystems are:
+ * 
+ * SPIFF - the internal flash file system of the ESP32 and ESP8266
+ * SD - the SD card file system (no formatting)
+ * EFS - the file system EFS for I2C EEPROMs
+ * LittleFS - the LittleFS file system on RP2040
+ * USB devices on Arduino GIGA boards
+ * Posix and Windows file systems on POSIX systems
+ */
+
+ void fsbegin(); 
+ uint8_t fsstat(uint8_t);
+ char* mkfilename(const char*);
+ const char* rmrootfsprefix(const char*); 
+ 
+ /*
+  *	File I/O function on an Arduino:
+  * 
+  *  filewrite(c): write a character to a file
+  *  fileread(): read a character from a file
+  *  fileavailable(): check if a character is available in the file
+  *  ifileopen(s): open a file for input
+  *  ifileclose(): close a file for input
+  *  ofileopen(s, m): open a file for output with mode m
+  *  ofileclose(): close a file for output 
+  * 
+  * The wrapper and BASIC currently only support one file for read 
+  * and one file for write.
+  */
+ 
+ void filewrite(char);
+ char fileread();
+ int fileavailable(); /* is int because some of the fs do this */
+ uint8_t ifileopen(const char*);
+ void ifileclose();
+ uint8_t ofileopen(const char*, const char*);
+ void ofileclose();
+ 
+ /*
+  * Directory handling for the catalog function these methods are
+  * needed for a walkthtrough of one directory. 
+  * 
+  * The logic is:
+  *
+  * rootopen()
+  * while rootnextfile()
+  * 	if rootisfile() print rootfilename() rootfilesize()
+  *	rootfileclose()
+  * rootclose()
+  * 
+  * rootopen(): opens the root directory
+  * rootnextfile(): gets the next file in the directory
+  * rootisfile(): checks if the file is a file or something else
+  * rootfilename(): gets the name of the file
+  * rootfilesize(): gets the size of the file
+  * rootfileclose(): closes the root file
+  */
+
+ void rootopen();
+ uint8_t rootnextfile(); 
+ uint8_t rootisfile();
+ const char* rootfilename();
+ uint32_t rootfilesize();
+ void rootfileclose(); 
+ void rootclose();
+ 
+ /* delete a file, needed in the DELETE command of BASIC */
+ void removefile(const char*);
+ 
+ /*
+  * Formatting for fdisk of the internal filesystems. This 
+  * is not implemented for all filesystems.
+  */
+ void formatdisk(uint8_t);
+
+/* 
+ * The Real Time clock. The interface here offers the values as number_t 
+ * combining all values. 
+ * 
+ * On Arduino, he code does not use an RTC library any more all the 
+ * RTC support is builtin now for standard I2C clocks. 
+ * 
+ * A clock must activate the macro #define HASCLOCK to make the clock 
+ * available in BASIC.
+ * 
+ * Four software models are supported in runtime.cpp for Arduino:
+ *  - Built-in clocks of STM32, MKR, and ESP32 are supported by default.
+ *  - I2C clocks can be activated: DS1307, DS3231, and DS3232 
+ *  - A Real Time Clock emulation using millis()
+ * 
+ * On POSIX the standard time functions are used and mapped to this API.
+ * 
+ * rtcget(r) accesses the internal registers of the clock. 
+ * r==0 is the seconds, r==1 the minutes, r==2 the hours, r==3 the 
+ * day of week, r==4 the day, r==5 the month, r==6 the year.
+ * The day of the week feature is not supported by all clocks.
+ * rtcset(r, v) sets the internal registers of the clock.
+ * 
+ * On I2C clocks with NVRAM the  registers 7-255 are accessed as 
+ * memory cells through these functions.
+ * 
+ * rtcbegin() is called at startup to initialize the clock, normally 
+ * a dummy function.
+ *
+ * rtctimetoutime() converts the clock time to a unix time number.
+ * rtcutimetotime() converts the unix time number to a clock time.
+ * Both are private functions of the clock emulation.
+ * 
+ * Code in these two functions is taken from the German Wikipedia
+ * article on Unix time. https://de.wikipedia.org/wiki/Unixzeit
+ */
+
+void rtcbegin();
+uint16_t rtcget(uint8_t); 
+void rtcset(uint8_t, uint16_t);
+void rtctimetoutime();
+void rtcutimetotime();
+
+/* 
+ *	Arduino Sensor library code 
+ *		The sensorread() is a generic function called by 
+ *		SENSOR basic function and command. The first argument
+ *		is the sensor and the second argument the value.
+ *		sensorread(n, 0) checks if the sensorstatus.
+ */
+void sensorbegin();
+float sensorread(uint8_t, uint8_t);
+
+/*
+ * Experimental code to drive SPI SRAM 
+ *
+ * Currently only the 23LCV512 is implemented, assuming a 64kB SRAM.
+ * Part of code is taken in part from the SRAMsimple library.
+ * 
+ * Two buffers are implemented: 
+ * 
+ * - a ro buffer used by memread, this buffer is mainly reading the token 
+ *  stream at runtime. 
+ * - a rw buffer used by memread2 and memwrite2, this buffer is mainly accessing
+ *  the heap at runtime. In interactive mode this is also the interface to read 
+ *  and write program code to memory. 
+ * 
+ */
+
+/* the RAM begin method sets the RAM to sequential mode */
+uint16_t spirambegin();
+int8_t spiramrawread(uint16_t);
+void spiram_bufferread(uint16_t, int8_t*, uint16_t);
+void spiram_bufferwrite(uint16_t, int8_t*, uint16_t);
+int8_t spiram_robufferread(uint16_t);
+void spiram_rwbufferflush(); /* flush the buffer */
+int8_t spiram_rwbufferread(uint16_t);
+void spiram_rwbufferwrite(uint16_t, int8_t); /* the buffered file write */
+void spiramrawwrite(uint16_t, int8_t); /* the simple unbuffered byte write, with a cast to signed char */
+
+// defined RUNTIMEH
+#endif

data/Basic2/IoTBasic/src/FlashStorage_SAMD/FlashAsEEPROM_SAMD.h

@@ -0,0 +1,49 @@
+/******************************************************************************************************************************************
+  FlashAsEEPROM_SAMD.h
+  For SAMD21/SAMD51 using Flash emulated-EEPROM
+
+  The FlashStorage_SAMD library aims to provide a convenient way to store and retrieve user's data using the non-volatile flash memory
+  of SAMD21/SAMD51. It now supports writing and reading the whole object, not just byte-and-byte.
+
+  Based on and modified from Cristian Maglie's FlashStorage (https://github.com/cmaglie/FlashStorage)
+
+  Built by Khoi Hoang https://github.com/khoih-prog/FlashStorage_SAMD
+  Licensed under LGPLv3 license
+  
+  Orginally written by Cristian Maglie
+  
+  Copyright (c) 2015 Arduino LLC.  All right reserved.
+  Copyright (c) 2020 Khoi Hoang.
+  
+  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License 
+  as published bythe Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public License along with this library. 
+  If not, see (https://www.gnu.org/licenses/)
+  
+  Version: 1.3.2
+
+  Version Modified By   Date        Comments
+  ------- -----------  ----------   -----------
+  1.0.0   K Hoang      28/03/2020  Initial coding to add support to SAMD51 besides SAMD21
+  1.1.0   K Hoang      26/01/2021  Add supports to put() and get() for writing and reading the whole object. Fix bug.
+  1.2.0   K Hoang      18/08/2021  Optimize code. Add debug option
+  1.2.1   K Hoang      10/10/2021  Update `platform.ini` and `library.json`
+  1.3.0   K Hoang      25/01/2022  Fix `multiple-definitions` linker error. Add support to many more boards.
+  1.3.1   K Hoang      25/01/2022  Reduce number of library files
+  1.3.2   K Hoang      26/01/2022  Make compatible with old libraries and codes
+ ******************************************************************************************************************************************/
+
+// The .hpp contains only definitions, and can be included as many times as necessary, without `Multiple Definitions` Linker Error
+// The .h contains implementations, and can be included only in main(), .ino with setup() to avoid `Multiple Definitions` Linker Error
+
+#pragma once
+
+#ifndef FlashAsEEPROM_SAMD_h
+#define FlashAsEEPROM_SAMD_h
+
+#include <FlashStorage_SAMD.hpp>
+#include <FlashStorage_SAMD_Impl.h>
+
+#endif    //#ifndef FlashAsEEPROM_SAMD_h