diff --git "a/data/Basic2/IoTBasic/runtime.cpp" "b/data/Basic2/IoTBasic/runtime.cpp"
new file mode 100644--- /dev/null
+++ "b/data/Basic2/IoTBasic/runtime.cpp"
@@ -0,0 +1,6239 @@
+/*
+ * Stefan's basic interpreter - Arduino runtime environment runtime.cpp.
+ * 
+ * This is the Arduino runtime environment for BASIC. It maps the functions 
+ * needed for the various subsystems to the MCU specific implementations. 
+ *
+ * Author: Stefan Lenz, sl001@serverfabrik.de
+ *
+ * Configure the hardware settings and parameters in hardware.h.
+ */
+
+#include "Arduino.h"
+#include "hardware.h"
+#include "runtime.h"
+
+/* If the BASIC interpreter provides a loop function it will superseed this one */
+void __attribute__((weak)) bloop() {};
+
+/*
+ * Defining the bssystype variable which informs BASIC about the platform at runtime.
+ * bssystype is not used by the interpreter, but can be used by BASIC programs to
+ * determine the platform they are running on.
+ */
+
+#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR)
+uint8_t bsystype = SYSTYPE_AVR;
+#elif defined(ARDUINO_ARCH_ESP8266)
+uint8_t bsystype = SYSTYPE_ESP8266;
+#elif defined(ARDUINO_ARCH_ESP32)
+uint8_t bsystype = SYSTYPE_ESP32;
+#elif defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_MBED_RP2040)
+uint8_t bsystype = SYSTYPE_RP2040;
+#elif defined(ARDUINO_ARCH_SAM) && defined(ARDUINO_ARCH_SAMD)
+uint8_t bsystype = SYSTYPE_SAM;
+#elif defined(ARDUINO_ARCH_XMC)
+uint8_t bsystype = SYSTYPE_XMC;
+#elif defined(ARDUINO_ARCH_SMT32)
+uint8_t bsystype = SYSTYPE_SMT32;
+#elif defined(ARDUINO_ARCH_RENESAS)
+uint8_t bsystype = SYSTYPE_NRENESA;
+#elif defined(ARDUINO_ARCH_MBED_GIGA)
+uint8_t bsystype = SYSTYPE_GIGA;
+#else
+uint8_t bsystype = SYSTYPE_UNKNOWN;
+#endif
+
+/* 
+ *  Global variables of the runtime env.
+ * 
+ * id: the active input stream
+ * od: the active output stream
+ * idd: the default input stream in interactive mode
+ * odd: the default output stream in interactive mode
+ * ioer: the io error variable, always or-ed with ert in BASIC
+ */
+
+int8_t id; 
+int8_t od;  
+int8_t idd = ISERIAL;
+int8_t odd = OSERIAL; 
+int8_t ioer = 0; 
+
+/*
+ * MS Basic and many terminals have a real TAB function advanceing to 
+ * the next tab stop. This is emulated by counting the characters on 
+ * the output streams 0-4. The feature is activated with the HASMSTAB.
+ * The code cannot processes composed characters like Germin Umlauts
+ * correctly.
+ */
+
+#ifdef HASMSTAB
+uint8_t charcount[5]; 
+#endif
+
+/* 
+ * The pointer to the buffer used for the &0 device.
+ * The BASIC input buffer is used. With this feature, a line can be printed
+ * to the buffer and then accessed as a string @$ in BASIC. In systems where
+ * CHR() is not available, this can be used to convert a number to a string.
+ */
+
+char* nullbuffer = ibuffer;
+uint16_t nullbufsize = BUFSIZE; 
+uint8_t bufferstat(uint8_t ch) { return 1; }
+
+/* 
+ * External libraries of the runtime environment for the peripherals.
+ * When the runtime environment is brocken down to modules this will 
+ * got into the modules. Summerized here for the sake of clarity.
+ */
+
+/*
+ * OS specific headers.
+ */
+
+/*
+ * ESPy stuff, pgmspace has changed location in some ESP32 cores.
+ */
+
+ #ifdef ARDUINOPROGMEM
+ #ifdef ARDUINO_ARCH_ESP32
+ #include <pgmspace.h>
+ #else
+ #include <avr/pgmspace.h>
+ #endif
+ #endif
+
+/*
+ * MBED OS type includes summarized here - tested for GIGA boards. 
+*/
+
+#ifdef ARDUINO_ARCH_MBED_GIGA
+#include "mbed.h"
+#include <mbed_mktime.h>
+#endif
+
+/*
+ * EEPROM code. Some of the boards bring their own EEPROM classes.
+ * 
+ * These are: 
+ * - AVR boards of all kinds
+ * - ESP8266 and ESP32
+ * - the LGT8F boards with the newer cores
+ * 
+ * For XMC my homebrew is now part of the interpreter.
+ * See https://github.com/slviajero/XMCEEPROMLib
+ * For more information on this or if you want to use it on other platforms.
+ * 
+ * For SAMD the FlashStorage library is used. It was orginally written by
+ * Cristian Maglie. I use the version of Khoi Huang from
+ * https://github.com/khoih-prog/FlashStorage_SAMD
+ * This is now bundled with the interpreter. The emulation buffers the
+ * entire EEPROM in RAM, so 2k should be ok but not more. If the 
+ * dual buffer strategy of EepromFS or XMC would be used, larger 
+ * EEPROMs could be emulated - this is work to be done. 
+ * 
+ * RP2040 standard cores and the DUE do not have an EEPROM emulation.
+ * This is trapped in hardware.h (EEPROM is disabled).
+ */
+
+#ifdef ARDUINOEEPROM
+#if defined(ARDUINO_ARCH_XMC)
+#include "src/XMCEEPROMLib/XMCEEPROMLib.h"
+#elif defined(ARDUINO_ARCH_SAMD)
+#define EEPROM_EMULATION_SIZE 2048
+#include "src/FlashStorage_SAMD/FlashStorage_SAMD.h"
+#else
+#include <EEPROM.h>
+#endif
+#endif
+
+/* Standard SPI coming with the board is used */
+
+#ifdef ARDUINOSPI
+#include <SPI.h>
+#endif
+
+/* 
+ * Standard wire - triggered by the HASWIRE or HASSIMPLEWIR macro.
+ * These macros are set in the hardware.h file depending on the subsystems.
+ * 
+ * If ARDUINODIRECTI2C is set the the Wire library is bypassed. This saves 
+ * 200 bytes of RAM and 1kB of program space on an AVR 8bit. It 
+ * also removed the blocking of Wire if the slave does not respond.
+ * 
+ * In this case Wire.h should not be included in the sketch because
+ * it allocates the buffers and the Wire object. 
+ */
+
+#if defined(HASWIRE)
+#include <Wire.h>
+#endif 
+
+#if defined(HASSIMPLEWIRE) && !defined(ARDUINODIRECTI2C)
+#include <Wire.h>
+#endif
+
+/* 
+ * IO channel 2 - Keyboards 
+ *
+ * This is Paul Stoffregen's PS2Keyboard library for PS2 keyboards
+ * patched for use with non AVR boards. Please download the patched
+ * version from github: https://github.com/slviajero/PS2Keyboard
+ */
+
+ #ifdef ARDUINOPS2
+ #include <PS2Keyboard.h>
+ #endif
+ 
+ /*
+  * The USB keyboard code of the Arduino DUE. Keymapping and timing
+  * need improvement. Currently not a priority. 
+  */
+ 
+ #ifdef ARDUINOUSBKBD
+ #include <KeyboardController.h>
+ #endif
+ 
+ /*
+  * The ZX81 keyboard code - tested on AVR MEGA256. Please download
+  * the library from github: https://github.com/slviajero/ZX81Keyboard
+  */
+ 
+ #ifdef ARDUINOZX81KBD
+ #include <ZX81Keyboard.h>
+ #endif
+ 
+ /*
+  * This is for the USB keyboard code on a GIGA board
+  * https://docs.arduino.cc/tutorials/giga-r1-wifi/giga-usb/#usb-host-keyboard
+  * like the DUE keyboard, this code is not recommended.
+  */
+ 
+ #ifdef GIGAUSBKBD
+ #include "USBHostGiga.h"
+ #endif
+
+/* 
+ * IO channel 2 - Displays
+ *
+ * The display library for the parallel LCD, this is a standard 
+ * Arduino library.
+ */
+
+#ifdef LCDSHIELD 
+#include <LiquidCrystal.h>
+#endif
+
+/*
+ * I2C LCD displays, this library works almost universally despite 
+ * a nasty warning message it sometimes gives. 
+ */
+
+#ifdef ARDUINOLCDI2C
+#include <LiquidCrystal_I2C.h>
+#endif
+
+/*
+ * This is the monochrome library of Oli Kraus used for Nokia and 
+ * SSD1306 displays.
+ * https://github.com/olikraus/u8g2/wiki/u8g2reference
+ * 
+ * It can harware scroll, but this is not yet implemented.
+ */
+
+#if defined(ARDUINONOKIA51) || defined(ARDUINOSSD1306)
+#include <U8g2lib.h>
+#endif
+
+/*
+ * This is the (old) ILI9488 library originally created by Jarett Burket
+ * for SPI control if the very common ILI9488 displays.
+ * I created a fork as the original is no longer maintained (last commits 
+ * from 2017). Patches in my version allow use from RP2040.
+ * https://github.com/slviajero/ILI9488
+ * 
+ * It can hardware scroll (not yet used). 
+ */
+
+#ifdef ARDUINOILI9488
+#include <Adafruit_GFX.h>
+#include <ILI9488.h>
+#endif
+
+/*
+ * This is the MCUFRIED library originally for parallel TFTs
+ * https://github.com/prenticedavid/MCUFRIEND_kbv
+ * 
+ * For R4 boards, use my patched version
+ * https://github.com/slviajero/MCUFRIEND_kbv
+ * 
+ * The original library is board hardware depended as it tries
+ * to make use of the port macros. This makes it fast but 
+ * it cannot used on non supported boards.
+ * 
+ * This library can drive the TFT from any board as it has a
+ * generic section using the Arduino GPIOs. This is slower but 
+ * works. For R4 it uses the port macros.
+ */
+
+#ifdef ARDUINOMCUFRIEND
+#include <Adafruit_GFX.h>
+#include <MCUFRIEND_kbv.h>
+#endif
+
+/*
+ * For TFT we use the UTFT library
+ * http://www.rinkydinkelectronics.com/library.php?id=51
+ * Please note the License, it is not GPL but NON COMMERCIAL 
+ * Creative Commons. 
+ */
+
+#ifdef ARDUINOTFT
+#include <memorysaver.h>
+#include <UTFT.h>
+#endif
+
+/*
+ * Lilygo EDP47 displays, 4.7 inch epapers using the respective library 
+ * from Lilygo https://github.com/Xinyuan-LilyGO/LilyGo-EPD47
+ */
+
+#ifdef ARDUINOEDP47
+#include "epd_driver.h"
+#include "font/firasans.h"
+#endif
+
+/*
+ * VGA is only implemented on one platform - TTGO VGA 1.4
+ * Needs https://github.com/slviajero/FabGL
+ * 
+ * There is a side effect to the network code. The Wifi library
+ * has to be sourced before FabGL. Reason is unknown.
+ */
+
+ #if defined(ARDUINOVGA) && defined(ARDUINO_TTGO_T7_V14_Mini32)
+ #include <WiFi.h> 
+ #include <fabgl.h> 
+ #endif
+ 
+/* 
+ * IO channel 9 - Networking.
+ *
+ * Currently the standard Ethernet shield, ESP Wifi 
+ * MKW Wifi, RP2040 Wifi, R4 Wifi and GIGA is supported. 
+ * All of them  with the standard library.
+ *
+ * In addition to this Pubsub is used
+ * https://github.com/slviajero/pubsubclient
+ * for MQTT. This is the standard library for MQTT on Arduino.
+ * 
+ * The ARDUINOMQTT macro is set in hardware.h while 
+ * the ARDUINOWIFI is just generated by hardware.h if
+ * Ethernet is not set but MQTT is set. We assume that 
+ * mostly it is Wifi we are dealing with.
+ */
+
+ /* the network transport layer, either Ethernet or Wifi */
+#ifdef ARDUINOETH
+#include <Ethernet.h>
+#else
+#ifdef ARDUINOWIFI
+#if defined(ARDUINO_ARCH_ESP8266)
+#include <ESP8266WiFi.h>
+#elif defined(ARDUINO_ARCH_ESP32)
+#include <WiFi.h>
+#elif defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_SAMD)
+#include <WiFiNINA.h>
+#elif defined(ARDUINO_UNOR4_WIFI)
+#include <WiFiS3.h>
+#elif defined(ARDUINO_ARCH_MBED_GIGA)
+#include <WiFi.h>
+#endif
+#endif
+#endif
+
+/* the protocall */
+#if defined(ARDUINOMQTT)
+#include <PubSubClient.h>
+#endif
+
+/*
+ * IO channel 16 - the various filesystems.
+ * 
+ * SD filesystems with the standard SD driver.
+ *
+ * For MEGA 256 a soft SPI solution is needed 
+ * if standard shields are used, this done in is a 
+ * patched SD library https://github.com/slviajero/SoftSD
+ */
+
+#ifdef ARDUINOSD
+#define FILESYSTEMDRIVER
+#if defined(SOFTWARE_SPI_FOR_SD)
+#include <SoftSD.h>
+#else
+#include <SD.h>
+#endif
+#endif
+
+/*
+ * ESPSPIFFS tested on ESP8266 and ESP32 supports formating in BASIC.
+ * This is standard on all ESP boards and autoconfigured.
+ */ 
+
+#ifdef ESPSPIFFS
+#define FILESYSTEMDRIVER
+#ifdef ARDUINO_ARCH_ESP8266
+#include <FS.h>
+#endif
+#ifdef ARDUINO_ARCH_ESP32
+#include <FS.h>
+#include <SPIFFS.h>
+#endif
+#endif
+
+
+/*
+ * ESP32FAT tested on ESP32 supports formating in BASIC. Only tested 
+ * on the T-Deck. Partition at upload must be ffat. This is available
+ * on ESP32S3 but not on older boards.
+ */ 
+
+#ifdef ESP32FAT
+#define FILESYSTEMDRIVER
+#ifdef ARDUINO_ARCH_ESP32
+#include <FS.h>
+#include <FFat.h>
+#endif
+#endif
+
+/* 
+ *  ESPSDMMC code
+ */
+ 
+#ifdef ESPSDMMC
+#include "FS.h"
+#include "SD_MMC.h"
+#endif
+
+/* 
+ *  ESPSDMMC code, this is an SD card solution with direct access 
+ *  only available on ES32 and ESP32-S3
+ *  
+ *  https://github.com/espressif/arduino-esp32/tree/master/libraries/SD_MMC
+ *  
+ *  Needed for the ESP32 CAM
+ *  
+ */
+
+/*
+ * The USB filesystem for the GIGA board.
+ * USB device has to be connected at boot time. No remount is possible.
+ */
+
+#ifdef GIGAUSBFS
+#include <DigitalOut.h>
+#include <FATFileSystem.h>
+#include <Arduino_USBHostMbed5.h>
+#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
+#define LFS_MBED_RP2040_VERSION_MIN_TARGET      "LittleFS_Mbed_RP2040 v1.1.0"
+#define LFS_MBED_RP2040_VERSION_MIN             1001000
+#define _LFS_LOGLEVEL_          1
+#define RP2040_FS_SIZE_KB       1024
+#define FORCE_REFORMAT          false
+#include <LittleFS_Mbed_RP2040.h>
+#endif
+
+/*
+ * STM32 SDIO driver for he SD card slot of the STM32F4 boards (and others).
+ */
+
+#ifdef STM32SDIO 
+#define FILESYSTEMDRIVER
+#include <STM32SD.h> 
+#ifndef SD_DETECT_PIN
+#define SD_DETECT_PIN SD_DETECT_NONE
+#endif
+#endif
+
+/*
+ * External flash file systems on an SD override internal filesystems
+ * (currently BASIC can only have one filesystem).
+ */ 
+
+#if defined(ARDUINOSD) ||defined(ESPSDMMC)
+#undef ESPSPIFFS
+#undef RP2040LITTLEFS
+#undef ESP32FAT
+#undef GIGAUSBFS
+#define FILESYSTEMDRIVER
+#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 EFS object is used for filesystems and raw EEPROM access. */
+
+#if (defined(ARDUINOI2CEEPROM) && defined(ARDUINOI2CEEPROM_BUFFERED)) || defined(ARDUINOEFS)
+#include <EepromFS.h
+#endif
+
+/*
+ * Software SPI only on Mega2560. This only used for the SD shield typically 
+ * but not necessarily with a TFT display. 
+ */
+
+ #ifndef ARDUINO_AVR_MEGA2560
+ #undef SOFTWARE_SPI_FOR_SD
+ #endif
+
+/*
+ * TFT_eSPI is a library for the T-Deck from Lilygo.
+ * 
+ * #include "utilities.h" provided by Lilygo is coded directly into hardware.h
+ * For some reason this has to be included after FS and FFat. Not yet fully 
+ * understood why.
+ */
+
+ #ifdef TFTESPI
+ #include <TFT_eSPI.h>
+ #endif
+
+/*
+ * Global variables of the runtime environment.
+ */
+
+/* If there is an unbuffered I2C EEPROM, use an autodetect mechanism. */
+#if defined(ARDUINOI2CEEPROM) 
+unsigned int i2ceepromsize = 0;
+#endif
+
+/* 
+ * Arduino default serial baudrate and serial flags for the 
+ * two supported serial interfaces. Serial is always active and 
+ * connected to channel &1 with 9600 baud. 
+ * 
+ * Channel 4 (ARDUINOPRT) can be either in character or block 
+ * mode. Blockmode is set as default here. This means that all 
+ * available characters are always loaded to a string -> inb(). 
+ * This is typically needed if you want to receive AT commands from
+ * a modem or a GPS device.
+ * 
+ * Serial baudrate of the second channel is changeable in the BASIC
+ * program.
+ */
+
+const uint16_t serial_baudrate = 9600;
+uint8_t sendcr = 0;
+
+#ifdef ARDUINOPRT
+uint32_t serial1_baudrate = 9600; 
+uint8_t blockmode = 1;
+#else 
+const int serial1_baudrate = 0;
+uint8_t blockmode = 0;
+#endif
+
+/* 
+ * Implementation of the global IO function. These are the 
+ * functions that are called from the BASIC interpreter. To access 
+ * a device. 
+ * 
+ * ioinit(): called at setup to initialize what ever io is needed.
+ * outch(): prints one ascii character to the output channel od.
+ * inch(): gets one character (and waits for it) from the input channel id.
+ * checkch(): checks for one character (non blocking) on the input channel id.
+ * ins(): reads an entire line (uses inch except for pioserial) from the input channel id.
+ * availch(): checks for available characters on the input channel id.
+ * inb(): reads a block of characters from the input channel id.
+ * outs(): prints a string of characters to the output channel od.
+ *
+ */
+void ioinit() {
+
+/* a standalone system runs from keyboard and display, i.e channel 2 */
+#ifdef STANDALONE
+  idd = IKEYBOARD;
+  odd = ODSP;
+#endif
+
+/* run standalone on second serial, set the right parameters, this is 
+   needed for a few boars where the first serial port is not usable 
+   for BASIC */
+#ifdef STANDALONESECONDSERIAL
+  idd = ISERIAL1;
+  odd = OPRT;
+  blockmode = 0;
+  sendcr = 0;
+#endif
+
+/* 
+ * Signal handling - by default SIGINT which is ^C is always caught and 
+ * leads to program stop. Side effect: the interpreter cannot be stopped 
+ * with ^C, it has to be left with CALL 0, works on Linux, Mac and MINGW
+ * but not on DOSBOX MSDOS as DOSBOS does not handle CTRL BREAK correctly 
+ * DOS can be interrupted with the CONIO mechanism using BREAKCHAR. 
+ * Here on Arduino signalon() is currentl unused. 
+ */ 
+
+  signalon();
+
+/* This is only for RASPBERRY - wiring has to be started explicitly. */
+  wiringbegin();
+
+/* Start all serial protocolls, ttl channels, SPI and Wire. */
+  serialbegin();
+
+/* start the second serial port */
+#ifdef ARDUINOPRT
+  prtbegin();
+#endif
+
+/* start SPI (before displays and filesystems)*/
+#ifdef ARDUINOSPI
+  spibegin();
+#endif
+
+/* start wire */
+#if defined(HASWIRE) || defined(HASSIMPLEWIRE)
+  wirebegin();
+#endif
+
+/* Filesystems */
+  fsbegin();
+
+/* networks */
+#ifdef ARDUINOMQTT
+  netbegin();  
+  mqttbegin();
+#endif
+
+/* the keyboards */
+#if defined(HASKEYBOARD) || defined(HASKEYPAD)
+  kbdbegin();
+#endif
+
+/* the displays */
+#if defined(DISPLAYDRIVER) || defined(GRAPHDISPLAYDRIVER)
+  dspbegin();
+#endif
+
+/* fablib code (and framebuffer on POSIX) do not use the graphics driver startup 
+    they use vgabegin(), we also do not use the display driver */
+#if defined(ARDUINOVGA)
+  vgabegin();  
+#endif
+
+/* sensor startup */
+#ifdef ARDUINOSENSORS
+  sensorbegin();
+#endif
+
+/* clocks and time */
+#if defined(HASCLOCK)
+  rtcbegin();
+#endif
+
+/* the eeprom dummy needs a begin method */
+  ebegin();
+
+/* activate the iodefaults */
+  iodefaults();
+
+}
+
+
+/* The status of the io streams just on/off on that why (0) for all the stat function */
+int iostat(int channel) {
+  switch(channel) {
+/* channel 0, the buffer */
+  case ONULL:
+    return bufferstat(0);
+    break;
+/* channel 1, the serial port */
+  case ISERIAL:
+    return serialstat(0);
+    break;
+/* channel 2, the display */
+  case ODSP:
+    return dspstat(0);
+    break;
+/* channel 4, the second serial device */
+#ifdef ARDUINOPRT
+  case ISERIAL1:
+    return prtstat(0);
+    break;
+#endif
+/* channel 7 wire */
+#if defined(HASWIRE)
+  case IWIRE:
+    return wirestat(0);
+    break;
+#endif
+/* channel 8 radio adaptors */
+#ifdef HASRF24
+  case IRADIO:
+    return radiostat(0);
+    break;
+#endif
+/* channel 9 mqtt */
+#ifdef ARDUINOMQTT
+  case IMQTT:
+    return mqttstat(0);
+    break;
+#endif
+/* channel 16 file system */
+#ifdef FILESYSTEMDRIVER
+  case IFILE:
+    return fsstat(0);
+    break;
+#endif
+  }
+  return 0;
+}
+
+/* set the iodefaults at startup and in runtime status change to interactive */
+void iodefaults() {
+  od=odd;
+  id=idd;
+}
+
+
+/* char is sometimes signed and sometimes not */
+int cheof(int c) { if ((c == -1) || (c == 255)) return 1; else return 0; }
+
+/* the generic inch code reading one character from a stream, blocking! */
+char inch() {
+  switch(id) {
+  case ONULL:
+    return bufferread();
+  case ISERIAL:
+    return serialread();   
+#ifdef ARDUINOPRT
+  case ISERIAL1:
+    return prtread();
+#endif
+#if defined(HASKEYBOARD) || defined(HASKEYPAD) || defined(HASVT52)        
+  case IKEYBOARD:
+#if defined(HASVT52) /* if the display has a message, read it, it acts as a keyboard */
+    if (vt52avail()) return vt52read(); 
+#endif
+#if defined(HASKEYBOARD) || defined(HASKEYPAD)  
+    return kbdread();
+#endif
+#endif
+#if defined(HASWIRE)
+  case IWIRE:
+    return wireread();
+#endif
+#ifdef HASRF24
+  case IRADIO:
+    return radioread();
+#endif
+#ifdef ARDUINOMQTT
+   case IMQTT:
+    return mqttread();
+#endif
+#ifdef FILESYSTEMDRIVER
+  case IFILE:
+    return fileread();
+#endif      
+  }
+  return 0;
+}
+
+/* 
+ * checking on a character in the stream, this is normally only used 
+ * for interrupting a program, for many streams this is just mapped 
+ * to avail. This is currently inconsistent.
+ */
+char checkch(){
+  switch (id) {
+  case ONULL:
+    return buffercheckch();
+  case ISERIAL:
+    return serialcheckch();
+#ifdef FILESYSTEMDRIVER
+  case IFILE:
+    return fileavailable();
+#endif
+#ifdef HASRF24
+  case IRADIO:
+    return radioavailable();
+#endif
+#ifdef ARDUINOMQTT
+  case IMQTT:
+    return mqttcheckch();
+#endif   
+#ifdef HASWIRE 
+  case IWIRE:
+    return 0;
+#endif
+#ifdef ARDUINOPRT
+  case ISERIAL1:
+    return prtcheckch(); 
+#endif
+  case IKEYBOARD:
+#if defined(HASKEYBOARD)  || defined(HASKEYPAD)
+    return kbdcheckch(); /* here no display read as this is only for break and scroll control */
+#endif
+    break;
+  }
+  return 0;
+}
+
+/* character availability */
+uint16_t availch(){
+  switch (id) {
+  case ONULL:
+    return bufferavailable();
+  case ISERIAL:
+    return serialavailable(); 
+#ifdef FILESYSTEMDRIVER
+  case IFILE:
+    return fileavailable();
+#endif
+#ifdef HASRF24
+  case IRADIO:
+    return radioavailable();
+#endif        
+#ifdef ARDUINOMQTT
+  case IMQTT:
+    return mqttavailable();
+#endif        
+#if defined(HASWIRE)
+  case IWIRE:
+    return wireavailable();
+#endif
+#ifdef ARDUINOPRT
+  case ISERIAL1:
+    return prtavailable();
+#endif
+  case IKEYBOARD:
+#if defined(HASKEYBOARD) || defined(HASKEYPAD) || defined(HASVT52)
+#if defined(HASVT52)  /* if the display has a message, read it */
+    if (vt52avail()) return vt52avail();
+#endif
+#if defined(HASKEYBOARD) || defined(HASKEYPAD) 
+    return kbdavailable();
+#endif
+#endif
+    break;
+  }
+  return 0;
+}
+
+/* 
+ *  The block mode reader for esp and sensor modules 
+ *  on a serial interface, it tries to read as many 
+ *  characters as possible into a buffer. 
+ * 
+ *  blockmode = 1 reads once availch() bytes
+ *  blockmode > 1 implements a timeout mechanism and tries 
+ *    to read until blockmode milliseconds have expired
+ *    this is needed for esps and other sensors without
+ *    flow control and volatile timing to receive more 
+ *    then 64 bytes.
+ * 
+ * The function only exists if ARDUINOPRT is defined to 
+ * activate the second serial port.
+ */
+ 
+uint16_t inb(char *b, uint16_t nb) {
+  long m;
+  uint16_t z;
+  int16_t i = 0; // check this 
+
+  if (blockmode == 1) {
+    i=availch();
+    if (i>nb-1) i=nb-1;
+    b[0]=(unsigned char)i;
+    z=i;
+    b[i+1]=0;
+    b++;
+    while (i--) {*b++=inch();}  
+  } else if (blockmode > 1) {
+    m=millis();
+    while (i < nb-1) {
+      if (availch()) b[++i]=inch();
+      if (millis() > m+blockmode) break;
+    }
+    b[0]=(unsigned char)i;
+    z=i;
+    b[i+1]=0;
+  } else {
+    b[0]=0;
+    z=0;
+    b[1]=0;
+  } 
+  return z;
+}
+
+/*
+ * Reading one line from the console with inch(). 
+ * consins() is used for all channels where individual
+ * characters are read. Others which provide entire strings
+ * are handled by their respective string methods.
+ * (Example: picoserial, radio, wire)
+ */
+uint16_t consins(char *b, uint16_t nb) {
+  char c;
+  uint16_t z;
+ 
+  z=1;
+  while(z < nb) {
+      c=inch();
+      if (id == ISERIAL || id == IKEYBOARD) {
+        outch(c); /* this is local echo */
+      }
+      if (c == '\r') c=inch(); /* skip carriage return */
+      if (c == '\n' || c == -1 || c == 255) { /* terminal character is either newline or EOF */
+        break;
+      } else if (c == 127 || c == 8) { /* backspace or delete */
+        if (z>1) z--;
+      } else {
+        b[z++]=c;
+      } 
+  }
+  b[z]=0;
+  z--;
+  b[0]=z; /* cast to signed char is not good */
+  return z;
+}
+
+/* 
+ * ins() is the generic reader into a string, by default 
+ * it works in line mode and ends reading after newline.
+ *
+ * The first element of the buffer is the lower byte of the length.
+ *
+ * For streams providing entire strings as an input the 
+ * respective string method is called.
+ *
+ * All other streams are read using consins() for character by character
+ * input until a terminal character is reached. For almost all channel
+ * this is done in a *ins() method. The advantage is that one can plug in 
+ * line oriented input here.
+ */
+uint16_t ins(char *b, uint16_t nb) {
+  switch(id) {
+  case ONULL:
+    return bufferins(b, nb);
+  case ISERIAL:
+    return serialins(b, nb);
+#if defined(HASKEYBOARD) || defined(HASKEYPAD)
+  case IKEYBOARD:
+    return kbdins(b, nb);
+#endif
+#ifdef ARDUINOPRT
+  case ISERIAL1:
+    return prtins(b, nb);
+ #endif   
+#if defined(HASWIRE)
+  case IWIRE:
+    return wireins(b, nb);
+#endif
+#ifdef HASRF24
+  case IRADIO:
+    return radioins(b, nb);
+#endif
+#ifdef ARDUINOMQTT
+  case IMQTT:
+    return mqttins(b, nb);  
+#endif
+#ifdef FILESYSTEMDRIVER
+  case IFILE:
+    return consins(b, nb);
+#endif
+  default:
+    b[0]=0; b[1]=0;
+    return 0;
+  }  
+}
+
+/*
+ * outch() outputs one character to a stream.
+ * some block oriented i/o like in radio not implemented here.
+ * Exception is mqtt where we buffer in the code for the PRINT command.
+ * 
+ * If BASIC needs a MS style tab command, then count characters on stream 
+ * 0-4 this does not work for control characters. 
+ */
+void outch(char c) {
+
+#ifdef HASMSTAB
+  if (od <= OPRT) {
+    if (c > 31) charcount[od]+=1;
+    if (c == 10) charcount[od]=0;
+  }
+#endif
+
+  switch(od) {
+  case ONULL:
+    bufferwrite(c);
+    break;
+  case OSERIAL:
+    serialwrite(c);
+    break;
+#ifdef ARDUINOPRT
+  case OPRT:
+    prtwrite(c);
+    break;
+#endif    
+#ifdef FILESYSTEMDRIVER
+  case OFILE:
+    filewrite(c);
+    break;
+#endif
+#ifdef ARDUINOVGA
+  case ODSP: 
+    vgawrite(c);
+    break;
+#elif defined(DISPLAYDRIVER) || defined(GRAPHDISPLAYDRIVER)
+  case ODSP: 
+    dspwrite(c);
+    break;
+#endif
+#ifdef ARDUINOMQTT
+  case OMQTT:
+    mqttwrite(c); /* buffering for the PRINT command */
+    break;
+#endif
+  default:
+    break;
+  }
+  byield(); /* yield after every character for ESP8266 */
+}
+
+/*
+ *  outs() outputs a string of length x at index ir - basic style
+ *  default is a character by character operation, block 
+ *  oriented write needs special functions
+ */
+void outs(char *b, uint16_t l){
+  uint16_t i;
+
+  switch (od) {
+#ifdef HASRF24
+    case ORADIO:
+      radioouts(b, l);
+      break;
+#endif
+#if (defined(HASWIRE))
+    case OWIRE:
+      wireouts(b, l);
+      break;
+#endif
+#ifdef ARDUINOMQTT
+    case OMQTT:
+      mqttouts(b, l);
+      break;
+#endif
+#ifdef GRAPHDISPLAYDRIVER
+    case ODSP:
+      dspouts(b, l);
+      break;
+#endif
+    default:
+      for(i=0; i<l; i++) outch(b[i]);
+  }
+  byield(); /* triggers yield after each character output for ESP8266 stability */
+}
+
+/*  handling time - part of the Arduino core - only needed on POSIX OSes */
+void timeinit() {}
+
+/* starting wiring is only needed on raspberry */
+void wiringbegin() {}
+
+/* POSIX signals - not needed here */
+void signalon() {}
+
+/*
+ * helper functions OS, heuristic on how much memory is 
+ * available in BASIC
+ * Arduino information from
+ * data from https://docs.arduino.cc/learn/programming/memory-guide
+ */
+#if defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_ARCH_XMC) || defined(ARDUINO_ARCH_STM32) || defined(ARDUINO_ARCH_RENESAS)
+extern "C" char* sbrk(int incr);
+long freeRam() {
+  char top;
+  return &top - reinterpret_cast<char*>(sbrk(0));
+}
+#elif defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR) || defined(ARDUINO_ARCH_LGT8F) 
+long freeRam() {
+  extern int __heap_start,*__brkval;
+  int v;
+  return (int)&v - (__brkval == 0  
+     ? (int)&__heap_start : (int) __brkval); 
+}
+#elif defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266)
+long freeRam() {
+  return ESP.getFreeHeap();
+}
+#else
+long freeRam() {
+  return 0; 
+}
+#endif
+
+/*
+ * Heuristic Wifi systems reserve 4k by default, small 8 bit AVR try to guess sizes conservatively
+ * RP2040 cannot measure, we set to 16 bit full address space
+ */
+long freememorysize() {
+#if defined(ARDUINO_ARCH_RENESAS)
+  return freeRam() - 2000;
+#endif
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_STM32) 
+  return freeRam() - 4000;
+#endif
+#if defined(ARDUINO_ARCH_ESP32) 
+#if defined(ARDUINO_TTGO_T7_V14_Mini32)
+  return freeRam() - 4000; 
+#else
+  return freeRam() - 4000;
+#endif
+#endif
+#if defined(ARDUINO_ARCH_XMC) 
+  return freeRam() - 2000;
+#endif
+#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR) || defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_ARCH_LGT8F) 
+  int overhead=256;
+#ifdef ARDUINO_ARCH_LGT8F
+  overhead+=0;
+#endif
+#ifdef ARDUINO_AVR_MEGA2560
+  overhead+=96;
+#endif
+#if (defined(ARDUINOWIRE) || defined(ARDUINOSIMPLEWIRE)) && !defined(ARDUINODIRECTI2C)
+  overhead+=200;
+#endif
+#ifdef ARDUINORF24
+  overhead+=128;
+#endif
+#if defined(ARDUINOSD)
+  overhead+=512;
+#endif
+#ifdef ARDUINOZX81KBD
+  overhead+=64;
+#endif
+#ifdef ARDUINOETH
+  overhead+=256;
+#endif
+  return freeRam() - overhead;
+#endif
+#if defined(ARDUINO_NANO_RP2040_CONNECT) || defined(ARDUINO_RASPBERRY_PI_PICO) || defined(ARDUINO_ARCH_MBED_GIGA)
+  return 65536;
+#endif
+  return 0;
+}
+
+/* 
+ * the sleep and restart functions - only implemented for some controllers
+ */
+#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR)
+void(* callzero)() = 0;
+#endif
+
+void restartsystem() {
+  eflush(); /* if there is a I2C eeprom dummy, flush the buffer */
+#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266)
+  ESP.restart();
+#endif
+#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR)
+  callzero();
+#endif
+#if defined(ARDUINO_ARCH_LGT8F)
+#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)
+ */
+#if defined(ARDUINO_ARCH_SAMD) 
+#include "RTCZero.h"
+#include "ArduinoLowPower.h"
+RTCZero rtc;
+#endif
+
+/* STM32duino have the same structure */
+#if defined(ARDUINO_ARCH_STM32)
+#include "STM32RTC.h"
+#include "STM32LowPower.h"
+STM32RTC& rtc = STM32RTC::getInstance();
+#endif
+
+/* the NRENESA board have a buildin RTC as well */
+#if defined(ARDUINO_ARCH_RENESAS)
+#include "RTC.h"
+RTCTime rtc;
+#endif
+
+/* for ESP32 we also include the time stuctures and offer a POSIX style clock*/
+#if defined(ARDUINO_ARCH_ESP32)
+#include "time.h"
+#include <sys/time.h>
+#endif
+
+
+/* this is unfinished, don't use */ 
+void rtcsqw();
+
+#define LOWPOWERINTPIN 2
+void aftersleepinterrupt(void) { }
+
+void activatesleep(long t) {
+  eflush(); /* if there is a I2C eeprom dummy, flush the buffer */
+#if defined(ARDUINO_ARCH_ESP8266)
+  ESP.deepSleep(t*1000);
+#endif
+#if defined(ARDUINO_ARCH_ESP32)
+  esp_sleep_enable_timer_wakeup(t*1000);
+  esp_deep_sleep_start();
+#endif
+#if defined(ARDUINO_ARCH_SAMD)
+  LowPower.sleep((int) t);
+#endif
+#if defined(ARDUINO_AVR_ATmega644)
+/* unfinished, don't use, just test code
+  rtcsqw();
+  pinMode(LOWPOWERINTPIN, INPUT_PULLUP);
+  attachInterrupt(digitalPinToInterrupt(LOWPOWERINTPIN), aftersleepinterrupt, CHANGE);
+  sleepMode(SLEEP_POWER_SAVE);
+  sleep();
+  detachInterrupt(digitalPinToInterrupt(LOWPOWERINTPIN));
+  noSleep();
+*/
+#endif
+}
+
+/* 
+ * Start the SPI bus - this is a little mean as 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.
+ * 
+ * The startup on the T-Deck seems to be tricky and require precautions.
+ * The startup sequence used here is from the HelloWorld example of the
+ * TFT_eSPI library.
+ */
+void spibegin() {
+#ifdef ARDUINOSPI
+#ifdef ARDUINO_TTGO_T7_V14_Mini32
+/* this fixes the wrong board definition in the ESP32 core for this board */
+  SPI.begin(14, 2, 12, 13);
+#else 
+#ifdef TFTESPI
+  //! The board peripheral power control pin needs to be set to HIGH when using the peripheral
+  pinMode(BOARD_POWERON, OUTPUT);
+  digitalWrite(BOARD_POWERON, HIGH);
+
+  //! Set CS on all SPI buses to high level during initialization
+  pinMode(BOARD_SDCARD_CS, OUTPUT);
+  pinMode(RADIO_CS_PIN, OUTPUT);
+  pinMode(BOARD_TFT_CS, OUTPUT);
+
+  digitalWrite(BOARD_SDCARD_CS, HIGH);
+  digitalWrite(RADIO_CS_PIN, HIGH);
+  digitalWrite(BOARD_TFT_CS, HIGH);
+
+  pinMode(BOARD_SPI_MISO, INPUT_PULLUP);
+  SPI.begin(BOARD_SPI_SCK, BOARD_SPI_MISO, BOARD_SPI_MOSI);
+#else
+  SPI.begin();
+#endif
+#endif
+#endif
+}
+
+/*
+ * DISPLAY driver code section, the hardware models define a set of 
+ * of functions and definitions needed for the display driver. 
+ * 
+ * See runtime.h for the definitions of the display driver functions.
+ */
+
+ /* generate a 4 bit vga color from a given rgb color */
+uint8_t rgbtovga(uint8_t r, uint8_t g, uint8_t b) {
+  short vga;
+  if (r>191 || g>191 || b>191) vga=8; else vga=0;
+  vga=vga+r/128+g/128*2+b/128*4;
+  return vga;
+}
+
+/* 
+ * global variables for a standard LCD shield. 
+ * Includes the standard Arduino LiquidCrystal library
+ */
+#ifdef LCDSHIELD 
+#define DISPLAYDRIVER
+#undef DISPLAYHASCOLOR
+#undef DISPLAYHASGRAPH
+/* LCD shield pins to Arduino
+ *  RS, EN, d4, d5, d6, d7; 
+ * backlight on pin 10;
+ */
+
+ 
+#ifndef LCDSHIELDPINS 
+#ifdef ARDUINO_ESP8266_WEMOS_D1R1
+#define LCDSHIELDPINS 0,2,4,14,12,13
+#define LCD3VOLTS
+#else
+#define LCDSHIELDPINS 8,9,4,5,6,7
+#endif
+#endif
+const int dsp_rows=2;
+const int dsp_columns=16;
+LiquidCrystal lcd(LCDSHIELDPINS);
+void dspbegin() { lcd.begin(dsp_columns, dsp_rows); dspsetscrollmode(1, 1);  }
+void dspprintchar(char c, uint8_t col, uint8_t row) { lcd.setCursor(col, row); if (c) lcd.write(c);}
+void dspclear() { lcd.clear(); }
+void dspupdate() {}
+void dspsetcursor(uint8_t c) { if (c) lcd.blink(); else lcd.noBlink(); }
+void dspsetfgcolor(uint8_t c) {}
+void dspsetbgcolor(uint8_t c) {}
+void dspsetreverse(uint8_t c) {}
+uint8_t dspident() {return 0; }
+#define HASKEYPAD
+/* elementary keypad reader left=1, right=2, up=3, down=4, select=<lf> */
+char keypadread(){
+	int a=analogRead(A0);
+#ifndef LCD3VOLTS
+	if (a >= 850) return 0;
+	else if (a>=600 && a<850) return 10;
+	else if (a>=400 && a<600) return '1'; 
+	else if (a>=200 && a<400) return '3';
+	else if (a>=60  && a<200) return '4';
+	else return '2';
+#else
+  if (a >= 1000) return 0;
+  else if (a>=900 && a<1000) return 10;
+  else if (a>=700 && a<900) return '1'; 
+  else if (a>=400 && a<700) return '3';
+  else if (a>=100  && a<400) return '4';
+  else return '2';
+#endif
+}
+/* repeat mode of the keypad - off means block, on means return immediately */
+uint8_t kbdrepeat=0;
+#endif
+
+/* 
+ * A LCD display connnected via I2C, uses the standard 
+ * Arduino I2C display library.
+ */ 
+#ifdef ARDUINOLCDI2C
+#define DISPLAYDRIVER
+#undef DISPLAYHASCOLOR
+#undef DISPLAYHASGRAPH
+const int dsp_rows=4;
+const int dsp_columns=20;
+LiquidCrystal_I2C lcd(0x27, dsp_columns, dsp_rows);
+void dspbegin() { lcd.init(); lcd.backlight(); dspsetscrollmode(1, 1); }
+void dspprintchar(char c, uint8_t col, uint8_t row) { lcd.setCursor(col, row); if (c) lcd.write(c); }
+void dspclear() { lcd.clear(); }
+void dspupdate() {}
+void dspsetcursor(uint8_t c) { if (c) lcd.blink(); else lcd.noBlink(); }
+void dspsetfgcolor(uint8_t c) {}
+void dspsetbgcolor(uint8_t c) {}
+void dspsetreverse(uint8_t c) {}
+uint8_t dspident() {return 0; }
+#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
+#ifndef NOKIA_CS
+#define NOKIA_CS 15
+#endif
+#ifndef NOKIA_DC
+#define NOKIA_DC 0
+#endif
+#ifndef NOKIA_RST
+#define NOKIA_RST 2
+#endif
+U8G2_PCD8544_84X48_F_4W_HW_SPI u8g2(U8G2_R0, NOKIA_CS, NOKIA_DC, NOKIA_RST); 
+const int dsp_rows=6;
+const int dsp_columns=10;
+typedef uint8_t dspcolor_t;
+dspcolor_t dspfgcolor = 1;
+dspcolor_t dspbgcolor = 0;
+char dspfontsize = 8;
+void dspbegin() { u8g2.begin(); u8g2.setFont(u8g2_font_amstrad_cpc_extended_8r); }
+void dspprintchar(char c, uint8_t col, uint8_t row) { char b[] = { 0, 0 }; b[0]=c; if (c) u8g2.drawStr(col*dspfontsize+2, (row+1)*dspfontsize, b); }
+void dspclear() { u8g2.clearBuffer(); u8g2.sendBuffer(); dspfgcolor=1; }
+void dspupdate() { u8g2.sendBuffer(); }
+void dspsetcursor(uint8_t c) {}
+void dspsetfgcolor(uint8_t c) {}
+void dspsetbgcolor(uint8_t c) {}
+void dspsetreverse(uint8_t c) {}
+uint8_t dspident() {return 0;}
+void rgbcolor(uint8_t r, uint8_t g, uint8_t b) {}
+void vgacolor(uint8_t c) { dspfgcolor=c%3; u8g2.setDrawColor(dspfgcolor); }
+void plot(int x, int y) { u8g2.setDrawColor(dspfgcolor); u8g2.drawPixel(x, y); dspgraphupdate(); }
+void line(int x0, int y0, int x1, int y1)   { u8g2.drawLine(x0, y0, x1, y1);  dspgraphupdate(); }
+void rect(int x0, int y0, int x1, int y1)   { u8g2.drawFrame(x0, y0, x1-x0, y1-y0);  dspgraphupdate(); }
+void frect(int x0, int y0, int x1, int y1)  { u8g2.drawBox(x0, y0, x1-x0, y1-y0);  dspgraphupdate(); }
+void circle(int x0, int y0, int r) { u8g2.drawCircle(x0, y0, r); dspgraphupdate(); }
+void fcircle(int x0, int y0, int r) { u8g2.drawDisc(x0, y0, r); dspgraphupdate(); }
+#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
+const int dsp_width=960;
+const int dsp_height=540;
+const int dsp_rows=0;
+const int dsp_columns=0;
+typedef uint8_t dspcolor_t;
+dspcolor_t dspfgcolor = 1;
+dspcolor_t dspbgcolor = 0;
+char dspfontsize = 24;
+int dspgraphcursor_x = 0;
+int dspgraphcursor_y = dspfontsize;
+void dspbegin() { epd_init(); dspclear(); }
+void dspprintstring(char* s) { 
+  epd_poweron();
+  writeln((GFXfont *)&FiraSans, s, &dspgraphcursor_x, &dspgraphcursor_y, NULL);
+  epd_poweroff();
+}
+void dspclear() { epd_poweron();  epd_clear(); epd_poweroff(); dspfgcolor=1; }
+void dspupdate() { }
+void dspsetcursor(uint8_t c) {}
+void dspsetfgcolor(uint8_t c) {}
+void dspsetbgcolor(uint8_t c) {}
+void dspsetreverse(uint8_t c) {}
+uint8_t dspident() {return 0;}
+void rgbcolor(uint8_t r, uint_8 g, uint8_t b) {}
+void vgacolor(uint8_t c) { dspfgcolor=c%3; }
+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) {  }
+#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
+#define SSD1306WIDTH 32
+#define SSD1306HEIGHT 128
+/* constructors may look like this, last argument is the reset pin
+ * //U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE);
+ * //U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0,  SCL, SDA, U8X8_PIN_NONE);  
+ */
+#if SSD1306WIDTH == 32
+/* U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE); 
+ * use hardware I2C instead of software. Tested (only) on ESP32C3 and ESP8266 so far.
+ */
+U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0);
+#endif
+#if SSD1306WIDTH == 64
+/* the Heltec board has an internal software I2C on pins 4=SDA and 15=SCL */
+#ifdef ARDUINO_heltec_wifi_lora_32_V2
+U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, 15, 4, 16); 
+#else 
+/* use hardware I2C instead of software. Tested (only) on ESP32C3 and ESP8266 so far.
+ */
+U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0); 
+#endif
+#endif
+const char dspfontsize = 8;
+const int dsp_rows=SSD1306WIDTH/dspfontsize;
+const int dsp_columns=SSD1306HEIGHT/dspfontsize;
+typedef uint8_t dspcolor_t;
+dspcolor_t dspfgcolor = 1;
+dspcolor_t dspbgcolor = 0;
+void dspbegin() { u8g2.begin(); u8g2.setFont(u8g2_font_amstrad_cpc_extended_8r); }
+void dspprintchar(char c, uint8_t col, uint8_t row) { char b[] = { 0, 0 }; b[0]=c; if (c) u8g2.drawStr(col*dspfontsize+2, (row+1)*dspfontsize, b); }
+void dspclear() { u8g2.clearBuffer(); u8g2.sendBuffer(); dspfgcolor=1; }
+void dspupdate() { u8g2.sendBuffer(); }
+void dspsetcursor(uint8_t c) {}
+void dspsetfgcolor(uint8_t c) {}
+void dspsetbgcolor(uint8_t c) {}
+void dspsetreverse(uint8_t c) {}
+uint8_t dspident() {return 0;}
+void rgbcolor(uint8_t r, uint8_t g, uint8_t b) {}
+void vgacolor(uint8_t c) { dspfgcolor=c%3; u8g2.setDrawColor(dspfgcolor); }
+void plot(int x, int y) { u8g2.setDrawColor(dspfgcolor); u8g2.drawPixel(x, y); dspgraphupdate(); }
+void line(int x0, int y0, int x1, int y1)   { u8g2.drawLine(x0, y0, x1, y1); dspgraphupdate(); }
+void rect(int x0, int y0, int x1, int y1)   { u8g2.drawFrame(x0, y0, x1-x0, y1-y0);  dspgraphupdate(); }
+void frect(int x0, int y0, int x1, int y1)  { u8g2.drawBox(x0, y0, x1-x0, y1-y0);  dspgraphupdate(); }
+void circle(int x0, int y0, int r) { u8g2.drawCircle(x0, y0, r); dspgraphupdate(); }
+void fcircle(int x0, int y0, int r) { u8g2.drawDisc(x0, y0, r); dspgraphupdate(); }
+#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
+#ifndef ILI_CS
+#define ILI_CS  9
+#endif
+#ifndef ILI_DC
+#define ILI_DC  8
+#endif
+#ifndef ILI_RST
+#define ILI_RST 7
+#endif
+#ifndef ILI_LED
+#define ILI_LED A3
+#endif
+ILI9488 tft = ILI9488(ILI_CS, ILI_DC, ILI_RST);
+/* ILI in landscape */
+const int dsp_rows=20;
+const int dsp_columns=30;
+char dspfontsize = 16;
+typedef uint16_t dspcolor_t;
+const uint16_t dspdefaultfgcolor = 0xFFFF;
+const uint8_t dspdefaultfgvgacolor = 0x0F;
+dspcolor_t dspfgcolor = dspdefaultfgcolor;
+dspcolor_t dspbgcolor = 0;
+dspcolor_t dsptmpcolor = 0;
+uint8_t dspfgvgacolor = dspdefaultfgvgacolor;
+uint8_t dsptmpvgacolor = 0;
+void dspbegin() { 
+  tft.begin(); 
+  tft.setRotation(3); /* ILI in landscape, SD slot up */
+  tft.setTextColor(dspfgcolor);
+  tft.setTextSize(2);
+  tft.fillScreen(dspbgcolor); 
+  pinMode(ILI_LED, OUTPUT);
+  analogWrite(ILI_LED, 255);
+  dspsetscrollmode(1, 4);
+}
+void dspprintchar(char c, uint8_t col, uint8_t row) {  if (c) tft.drawChar(col*dspfontsize, row*dspfontsize, c, dspfgcolor, dspbgcolor, 2); }
+void dspclear() { 
+  tft.fillScreen(dspbgcolor); 
+  dspfgcolor = dspdefaultfgcolor; 
+  dspfgvgacolor = dspdefaultfgvgacolor; 
+}
+void dspupdate() {}
+void dspsetcursor(uint8_t c) {}
+void dspsavepen() { dsptmpcolor=dspfgcolor; dsptmpvgacolor=dspfgvgacolor; }
+void dsprestorepen() { dspfgcolor=dsptmpcolor; dspfgvgacolor=dsptmpvgacolor; }
+void dspsetfgcolor(uint8_t c) { vgacolor(c); }
+void dspsetbgcolor(uint8_t c) { }
+void dspsetreverse(uint8_t c) {}
+uint8_t dspident() {return 0; }
+void rgbcolor(uint8_t r, uint8_t g, uint8_t b) { dspfgvgacolor=rgbtovga(r, g, b); dspfgcolor=tft.color565(r, g, b);}
+void vgacolor(uint8_t c) {  
+  short base=128;
+  dspfgvgacolor=c;
+  if (c==8) { dspfgcolor=tft.color565(64, 64, 64); return; }
+  if (c>8) base=255;
+  dspfgcolor=tft.color565(base*(c&1), base*((c&2)/2), base*((c&4)/4)); 
+}
+void plot(int x, int y) { tft.drawPixel(x, y, dspfgcolor); }
+void line(int x0, int y0, int x1, int y1)   { tft.drawLine(x0, y0, x1, y1, dspfgcolor); }
+void rect(int x0, int y0, int x1, int y1)   { tft.drawRect(x0, y0, x1, y1, dspfgcolor);}
+void frect(int x0, int y0, int x1, int y1)  { tft.fillRect(x0, y0, x1, y1, dspfgcolor); }
+void circle(int x0, int y0, int r) { tft.drawCircle(x0, y0, r, dspfgcolor); }
+void fcircle(int x0, int y0, int r) { tft.fillCircle(x0, y0, r, dspfgcolor); }
+#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
+#ifndef LCD_CS
+#define LCD_CS  A3
+#endif
+#ifndef LCD_CD
+#define LCD_CD  A2
+#endif
+#ifndef LCD_WR
+#define LCD_WR  A1
+#endif
+#ifndef LCD_RD
+#define LCD_RD  A0
+#endif
+#ifndef LCD_RESET
+#define LCD_RESET A4
+#endif
+MCUFRIEND_kbv tft;
+/* ILI in landscape */
+const int dsp_rows=20;
+const int dsp_columns=30;
+char dspfontsize = 16;
+typedef uint16_t dspcolor_t;
+const uint16_t dspdefaultfgcolor = 0xFFFF;
+const uint8_t dspdefaultfgvgacolor = 0x0F;
+dspcolor_t dspfgcolor = dspdefaultfgcolor;
+dspcolor_t dspbgcolor = 0;
+dspcolor_t dsptmpcolor = 0;
+uint8_t dspfgvgacolor = dspdefaultfgvgacolor;
+uint8_t dsptmpvgacolor = 0;
+void dspbegin() { 
+  uint16_t ID = tft.readID();
+  if (ID == 0xD3D3) ID = 0x9481; /* write-only shield - taken from the MCDFRIEND demo */
+  tft.begin(ID); 
+  tft.setRotation(1); /* ILI in landscape, 3: SD slot on right the side */
+  tft.setTextColor(dspfgcolor);
+  tft.setTextSize(2);
+  tft.fillScreen(dspbgcolor); 
+  dspsetscrollmode(1, 4); /* scrolling is on, scroll 4 lines at once */
+ }
+void dspprintchar(char c, uint8_t col, uint8_t row) {  if (c) tft.drawChar(col*dspfontsize, row*dspfontsize, c, dspfgcolor, dspbgcolor, 2); }
+void dspclear() { 
+  tft.fillScreen(dspbgcolor); 
+  dspfgcolor = dspdefaultfgcolor; 
+  dspfgvgacolor = dspdefaultfgvgacolor; 
+}
+void dspupdate() {}
+void dspsetcursor(uint8_t c) {}
+void dspsavepen() { dsptmpcolor=dspfgcolor; dsptmpvgacolor=dspfgvgacolor; }
+void dsprestorepen() { dspfgcolor=dsptmpcolor; dspfgvgacolor=dsptmpvgacolor; }
+void dspsetfgcolor(uint8_t c) { vgacolor(c); }
+void dspsetbgcolor(uint8_t c) { }
+void dspsetreverse(uint8_t c) {}
+uint8_t dspident() {return 0; }
+void rgbcolor(uint8_t r, uint8_t g, uint8_t b) { dspfgvgacolor=rgbtovga(r, g, b); dspfgcolor=tft.color565(r, g, b);}
+void vgacolor(uint8_t c) {  
+  short base=128;
+  dspfgvgacolor=c;
+  if (c==8) { dspfgcolor=tft.color565(64, 64, 64); return; }
+  if (c>8) base=255;
+  dspfgcolor=tft.color565(base*(c&1), base*((c&2)/2), base*((c&4)/4)); 
+}
+void plot(int x, int y) { tft.drawPixel(x, y, dspfgcolor); }
+void line(int x0, int y0, int x1, int y1)   { tft.drawLine(x0, y0, x1, y1, dspfgcolor); }
+void rect(int x0, int y0, int x1, int y1)   { tft.drawRect(x0, y0, x1, y1, dspfgcolor);}
+void frect(int x0, int y0, int x1, int y1)  { tft.fillRect(x0, y0, x1, y1, dspfgcolor); }
+void circle(int x0, int y0, int r) { tft.drawCircle(x0, y0, r, dspfgcolor); }
+void fcircle(int x0, int y0, int r) { tft.fillCircle(x0, y0, r, dspfgcolor); }
+#endif
+
+#ifdef TFTESPI
+#define DISPLAYDRIVER
+#define DISPLAYHASCOLOR
+#define DISPLAYHASGRAPH
+/* 
+ * first draft od the code taken from the hello world demo 
+ * of Lilygo. This code only works on the 2.0.14 version of the ESP32 core.
+ * Physical display dimensions is 320x240. We use the 12pf font for a first 
+ * test. With this font we can display 26 columns and 20 rows. This is set 
+ * statically in the code at the moment. 
+ */
+/* constants for 16 bit fonts */
+const int dsp_rows=15;
+const int dsp_columns=20;
+char dspfontsize = 16;
+const char dspfontsizeindex = 2;
+/* constants for 8 bit fonts */
+/*
+const int dsp_rows=30;
+const int dsp_columns=40;
+char dspfontsize = 8;
+const char dspfontsizeindex = 1;
+*/
+/* unchanged from the ILI code */
+typedef uint16_t dspcolor_t;
+const uint16_t dspdefaultfgcolor = 0xFFFF;
+const uint8_t dspdefaultfgvgacolor = 0x0F;
+dspcolor_t dspfgcolor = dspdefaultfgcolor;
+dspcolor_t dspbgcolor = 0;
+dspcolor_t dsptmpcolor = 0;
+uint8_t dspfgvgacolor = dspdefaultfgvgacolor;
+uint8_t dsptmpvgacolor = 0;
+/* this is new for TFT_eSPI*/
+TFT_eSPI tft;
+/* change the brightness, taken from HelloWorld as well */
+void tftespisetBrightness(uint8_t value)
+{
+    static uint8_t level = 0;
+    static uint8_t steps = 16;
+    if (value == 0) {
+        digitalWrite(BOARD_BL_PIN, 0);
+        delay(3);
+        level = 0;
+        return;
+    }
+    if (level == 0) {
+        digitalWrite(BOARD_BL_PIN, 1);
+        level = steps;
+        delayMicroseconds(30);
+    }
+    int from = steps - level;
+    int to = steps - value;
+    int num = (steps + to - from) % steps;
+    for (int i = 0; i < num; i++) {
+        digitalWrite(BOARD_BL_PIN, 0);
+        digitalWrite(BOARD_BL_PIN, 1);
+    }
+    level = value;
+}
+void dspbegin() { 
+  tft.begin(); 
+  tft.setRotation(1);
+  tft.setTextDatum(6); /* upper left*/
+  tft.setTextColor(dspfgcolor);
+  tft.fillScreen(dspbgcolor); 
+  dspsetscrollmode(1, 4); /* scrolling is on, scroll 4 lines at once */
+  pinMode(BOARD_BL_PIN, OUTPUT);
+  tftespisetBrightness(16); /* maximum brightness */
+}
+void dspprintchar(char c, uint8_t col, uint8_t row) {  
+  if (c) tft.drawChar(col*dspfontsize, row*dspfontsize, c, dspfgcolor, dspbgcolor, dspfontsizeindex);  
+}
+void dspclear() { 
+  tft.fillScreen(dspbgcolor); 
+  dspfgcolor = dspdefaultfgcolor; 
+  dspfgvgacolor = dspdefaultfgvgacolor; 
+}
+void dspupdate() {}
+void dspsetcursor(uint8_t c) {}
+void dspsavepen() { dsptmpcolor=dspfgcolor; dsptmpvgacolor=dspfgvgacolor; }
+void dsprestorepen() { dspfgcolor=dsptmpcolor; dspfgvgacolor=dsptmpvgacolor; }
+void dspsetfgcolor(uint8_t c) { vgacolor(c); }
+void dspsetbgcolor(uint8_t c) { }
+void dspsetreverse(uint8_t c) {}
+uint8_t dspident() {return 0; }
+void rgbcolor(uint8_t r, uint8_t g, uint8_t b) { dspfgvgacolor=rgbtovga(r, g, b); dspfgcolor=tft.color565(r, g, b);}
+void vgacolor(uint8_t c) {  
+  short base=128;
+  dspfgvgacolor=c;
+  if (c==8) { dspfgcolor=tft.color565(64, 64, 64); return; }
+  if (c>8) base=255;
+  dspfgcolor=tft.color565(base*(c&1), base*((c&2)/2), base*((c&4)/4)); 
+}
+void plot(int x, int y) { tft.drawPixel(x, y, dspfgcolor); }
+void line(int x0, int y0, int x1, int y1)   { tft.drawLine(x0, y0, x1, y1, dspfgcolor); }
+void rect(int x0, int y0, int x1, int y1)   { tft.drawRect(x0, y0, x1, y1, dspfgcolor);}
+void frect(int x0, int y0, int x1, int y1)  { tft.fillRect(x0, y0, x1, y1, dspfgcolor); }
+void circle(int x0, int y0, int r) { tft.drawCircle(x0, y0, r, dspfgcolor); }
+void fcircle(int x0, int y0, int r) { tft.fillCircle(x0, y0, r, dspfgcolor); }
+#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
+const int dsp_rows=20;
+const int dsp_columns=30;
+const uint16_t dspdefaultfgcolor = 1;
+char dspfontsize = 16;
+typedef uint16_t dspcolor_t;
+dspcolor_t dspfgcolor = 0xFFFF;
+dspcolor_t dspbgcolor = 0x0000;
+void dspbegin() { dspsetscrollmode(1, 4); }
+void dspprintchar(char c, uint8_t col, uint8_t row) {}
+void dspclear() {}
+void dspupdate() {}
+void dspsetcursor(uint8_t c) {}
+void dspsetfgcolor(uint8_t c) {}
+void dspsetbgcolor(uint8_t c) {}
+void dspsetreverse(uint8_t c) {}
+uint8_t dspident() {return 0; }
+void rgbcolor(uint8_t r, uint8_t g, uint8_t b) { dspfgcolor=0; }
+void vgacolor(uint8_t c) {  
+  short base=128;
+  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)); 
+}
+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) {}
+#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
+extern uint8_t SmallFont[];
+extern uint8_t BigFont[];
+#ifdef ARDUINO_SAM_DUE
+UTFT tft(CTE70,25,26,27,28);
+#else 
+UTFT tft(CTE70,38,39,40,41);
+#endif
+const int dsp_rows=30;
+const int dsp_columns=50;
+char dspfontsize = 16;
+const uint32_t dspdefaultfgcolor = 0x00FFFFFF;
+const uint8_t dspdefaultfgvgacolor = 0x0F;
+typedef uint32_t dspcolor_t;
+dspcolor_t dspfgcolor = dspdefaultfgcolor;
+dspcolor_t dspbgcolor = 0;
+dspcolor_t dsptmpcolor = 0;
+uint8_t dspfgvgacolor = dspdefaultfgvgacolor;
+uint8_t dsptmpvgacolor = 0;
+void dspbegin() { tft.InitLCD(); tft.setFont(BigFont); tft.clrScr(); dspsetscrollmode(1, 4); }
+void dspprintchar(char c, uint8_t col, uint8_t row) { if (c) tft.printChar(c, col*dspfontsize, row*dspfontsize); }
+void dspclear() { 
+  tft.clrScr();  
+  dspfgcolor = dspdefaultfgcolor; 
+  dspfgvgacolor = dspdefaultfgvgacolor; 
+  vgacolor(dspfgvgacolor);
+}
+void rgbcolor(uint8_t r, uint8_t g, uint8_t b) { 
+  tft.setColor(r,g,b); 
+  dspfgcolor=(r << 16) + (g << 8) + b;
+  dspfgvgacolor=rgbtovga(r, g, b);
+}
+void vgacolor(uint8_t c) {
+  short base=128;
+  dspfgvgacolor=c;
+  if (c==8) { tft.setColor(64, 64, 64); return; }
+  if (c>8) base=255;
+  tft.setColor(base*(c&1), base*((c&2)/2), base*((c&4)/4));  
+}
+void dspupdate() {}
+void dspsetcursor(uint8_t c) {}
+void dspsavepen() { dsptmpcolor=dspfgcolor; dsptmpvgacolor=dspfgvgacolor; }
+void dsprestorepen() { dspfgcolor=dsptmpcolor; dspfgvgacolor=dsptmpvgacolor; }
+void dspsetfgcolor(uint8_t c) { vgacolor(c); }
+void dspsetbgcolor(uint8_t c) { }
+void dspsetreverse(uint8_t c) {}
+uint8_t dspident() {return 0;}
+void plot(int x, int y) { tft.drawPixel(x, y); }
+void line(int x0, int y0, int x1, int y1)   { tft.drawLine(x0, y0, x1, y1); }
+void rect(int x0, int y0, int x1, int y1)   { tft.drawRect(x0, y0, x1, y1); }
+void frect(int x0, int y0, int x1, int y1)  { tft.fillRect(x0, y0, x1, y1); }
+void circle(int x0, int y0, int r) { tft.drawCircle(x0, y0, r); }
+void fcircle(int x0, int y0, int r) { tft.fillCircle(x0, y0, r); }
+#endif
+
+/* 
+ * This is the VGA code for fablib.
+ *
+ * Not all modes and possibilities explored. It leaves enough memory for the 
+ * interpreter. Networking is not possible an a TTGO T7 V1.4. 
+ * 
+ * This code overrides the display driver logic as fabgl brings an own 
+ * terminal emulation.
+ * 
+ * Default settings is a 640*480 VGA screen with 16 colors
+ * and default fonts for the Terminal
+ */
+#if defined(ARDUINOVGA) && defined(ARDUINO_TTGO_T7_V14_Mini32) 
+#ifndef TTGOVGACONTROLLER
+#define TTGOVGACONTROLLER VGA16Controller
+#endif
+#ifndef TTGOVGACOLUMNS
+#define TTGOVGACOLUMNS -1
+#endif
+#ifndef TTGOVGAROWS
+#define TTGOVGAROWS -1
+#endif
+#ifndef TTGOVGARESOLUTION
+#define TTGOVGARESOLUTION VGA_640x480_60Hz
+#endif
+fabgl::TTGOVGACONTROLLER VGAController; /* 16 color object with less memory */
+static fabgl::Terminal Terminal;
+static Canvas cv(&VGAController);
+TerminalController tc(&Terminal);
+Color vga_graph_pen = Color::BrightWhite;
+Color vga_graph_brush = Color::Black;
+Color vga_txt_pen = Color::BrightGreen;
+Color vga_txt_background = Color::Black;
+fabgl::SoundGenerator soundGenerator;
+
+/* this starts the vga controller and the terminal right now */
+void vgabegin() {
+	VGAController.begin(GPIO_NUM_22, GPIO_NUM_21, GPIO_NUM_19, GPIO_NUM_18, GPIO_NUM_5, GPIO_NUM_4, GPIO_NUM_23, GPIO_NUM_15);
+  VGAController.setResolution(TTGOVGARESOLUTION);
+	Terminal.begin(&VGAController, TTGOVGACOLUMNS, TTGOVGAROWS);
+	Terminal.setBackgroundColor(vga_txt_background);
+	Terminal.setForegroundColor(vga_txt_pen);
+ #ifdef TTGOVGAFONT
+  Terminal.loadFont(&fabgl::TTGOVGAFONT);
+ #endif
+  Terminal.connectLocally();
+  Terminal.clear();
+  Terminal.enableCursor(1); 
+  Terminal.setTerminalType(TermType::VT52);
+}
+
+/* for Arduino just a dummy, needed in the POSIX branch of the code */
+void vgaend() {}
+
+/* this is a dummy function, we do not have a status line */
+int vgastat(uint8_t c) {return 0; }
+
+/* scale the screen size to make a circle round, unneeded if the right resulution is set */
+void vgascale(int* x, int* y) {
+	/* *y=*y*10/16; */
+}
+
+void rgbcolor(uint8_t r, uint8_t g, uint8_t b) {
+	short vga;
+	if (r>191 || g>191 || b>191) vga=8; else vga=0;
+	vga=vga+r/128+g/128*2+b/128*4;
+	vga_graph_pen=fabgl::Color(vga);
+}
+
+void vgacolor(uint8_t c) { vga_graph_pen = fabgl::Color(c%16); }
+void plot(int x, int y) { 
+	vgascale(&x, &y);
+	cv.setPenColor(vga_graph_pen);
+	cv.setPixel(x,y);
+	cv.setPenColor(vga_txt_pen);
+}
+
+void line(int x0, int y0, int x1, int y1) {
+	vgascale(&x0, &y0);
+	vgascale(&x1, &y1);
+	cv.setPenColor(vga_graph_pen);
+	cv.setPenWidth(1);
+ 	cv.drawLine(x0, y0, x1, y1);
+ 	cv.setPenColor(vga_txt_pen);
+}
+
+void rect(int x0, int y0, int x1, int y1) { 
+	vgascale(&x0, &y0);
+	vgascale(&x1, &y1);
+	cv.setPenColor(vga_graph_pen);
+	cv.setPenWidth(1);
+	cv.drawRectangle(x0, y0, x1, y1);
+	cv.setPenColor(vga_txt_pen);
+}
+
+void frect(int x0, int y0, int x1, int y1) {  
+	vgascale(&x0, &y0);
+	vgascale(&x1, &y1);
+	cv.setBrushColor(vga_graph_pen);
+	cv.fillRectangle(x0, y0, x1, y1);
+	cv.setBrushColor(vga_txt_background);
+}
+
+void circle(int x0, int y0, int r) {  
+	int rx = r;
+	int ry = r;
+	vgascale(&x0, &y0);
+	vgascale(&rx, &ry);
+	cv.setPenColor(vga_graph_pen);
+	cv.setPenWidth(1);
+	cv.drawEllipse(x0, y0, rx, ry);
+	cv.setPenColor(vga_txt_pen);
+}
+
+void fcircle(int x0, int y0, int r) {  
+	int rx = r;
+	int ry = r;
+	vgascale(&x0, &y0);
+	vgascale(&rx, &ry);
+	cv.setBrushColor(vga_graph_pen);
+	cv.fillEllipse(x0, y0, rx, ry);
+	cv.setBrushColor(vga_txt_background);	
+}
+
+void vgawrite(char c){
+	switch(c) {
+    case 12: /* form feed is clear screen */
+  		Terminal.write(27); Terminal.write('H');
+    	Terminal.write(27); Terminal.write('J');
+      return;
+    case 10: /* this is LF Unix style doing also a CR */
+      Terminal.write(10); Terminal.write(13);
+    	return;
+  	}
+  	Terminal.write(c);
+}
+#else 
+void vgabegin(){}
+int vgastat(uint8_t c) {return 0; }
+void vgawrite(char c){}
+void vgaend() {}
+#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)
+fabgl::PS2Controller PS2Controller;
+char fabgllastchar = 0;
+#else
+#if defined(ARDUINO) && defined(ARDUINOPS2)
+PS2Keyboard keyboard;
+#else 
+#if defined(ARDUINO) && defined(ARDUINOUSBKBD)
+USBHost usb;
+KeyboardController keyboard(usb);
+char usbkey=0;
+#else 
+#if defined(ARDUINOZX81KBD)
+ZX81Keyboard keyboard;
+#else
+#if defined(ARDUINOI2CKBD)
+/* with an I2C keyboard we remeber the last key, this is similar to the USB keyboard */
+char i2ckey=0;
+#else
+#if defined(GIGAUSBKBD)
+Keyboard keyb;
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+
+/*
+ * Experimental, unfinished, rudimentary
+ */
+#if defined(ARDUINOUSBKBD)
+/* not really needed, only here for reference */
+char usbkeymapUS[] = 
+{' ', '"', '!', '#', '$', '%', '&', '\'', '(', ')', '*', '+', 
+ ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', 
+ '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 
+ 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 
+ 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', 
+ '\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 
+ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
+ 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', 0, 0};
+/* map the ASCII codes of the essential keys for BASIC of a
+ *  German keyboard, most notable is < and > which is ö/a
+ */
+char usbkeymapGerman[] = 
+{' ', '!',  '!', '#', '$', '%', '/', '>', ')', '=', '(', '+', 
+ ',', '-', '.', '-', '0', '1', '2', '3', '4', '5', '6', '7', 
+ '8', '9', ':', '<', ';', '=', ':', '_', '"', 'A', 'B', 'C', 
+ 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 
+ 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Z', 'Y', '[', 
+ '#', '+', '&', '?', '@', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 
+ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
+ 't', 'u', 'v', 'w', 'x', 'z', 'y', '{', '\'', '*', 0, 0};
+
+/*
+ * he weak functions from the keyboard controller class implemented
+ */
+void keyPressed() {}
+void keyReleased() {
+  switch (keyboard.getOemKey()) {
+    case 40:
+      usbkey=10;
+      break;
+    case 42:
+    case 76:
+      usbkey=127;
+      break;
+    case 41:
+      usbkey=27;
+      break;
+    default:
+      usbkey=keyboard.getKey(); 
+#if ARDUINOKBDLANG_GERMAN
+      if (usbkey>31 && usbkey<128) usbkey=usbkeymapGerman[usbkey-32]; 
+#else 
+      if (usbkey>31 && usbkey<128) usbkey=usbkeymapUS[usbkey-32]; 
+#endif
+  }
+}
+#endif
+
+/* 
+ * keyboard controller code 
+ */
+
+#ifdef ZX81KEYBOARD
+const byte zx81pins[] = {ZX81PINS}; 
+#endif
+
+/* 
+ *  A helper function for the I2C keyboard code. We get one character 
+ *  from the board. A -1 is an I2C error condition for a non reply of 
+ *  the keyboard. 
+ */
+#ifdef ARDUINOI2CKBD
+char i2ckbdgetkey() {
+  char c=0;
+  Wire.requestFrom(I2CKBDADDR, 1);
+    if (Wire.available()) {
+      c=Wire.read();
+      if (c == -1) { ioer=1; c=0; }
+    }
+    return c;
+}
+#endif
+
+/* start the keyboard */
+void kbdbegin() {
+#ifdef PS2KEYBOARD
+#ifdef ARDUINOKBDLANG_GERMAN
+	keyboard.begin(PS2DATAPIN, PS2IRQPIN, PS2Keymap_German);
+#else
+  keyboard.begin(PS2DATAPIN, PS2IRQPIN, PS2Keymap_US);
+#endif
+#else
+#ifdef PS2FABLIB
+	PS2Controller.begin(PS2Preset::KeyboardPort0);
+#ifdef ARDUINOKBDLANG_GERMAN
+  PS2Controller.keyboard()->setLayout(&fabgl::GermanLayout);
+#else
+  PS2Controller.keyboard()->setLayout(&fabgl::USLayout);
+#endif
+#else 
+#ifdef USBKEYBOARD
+/* nothing to be done here */
+#else
+#ifdef ZX81KEYBOARD
+  keyboard.begin(zx81pins);
+#else
+#ifdef ARDUINOI2CKBD
+/* this is from the T-Deck examples, time needed for the keyboard to start */
+  delay(500);
+#else 
+#ifdef GIGAUSBKBD
+  pinMode(PA_15, OUTPUT); /* no digitalWrite in original example file */
+  keyb.begin();
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+}
+
+uint8_t kbdstat(uint8_t c) {return 0; }
+
+uint16_t kbdins(char* b, uint16_t nb) { return consins(b, nb); }
+
+uint8_t kbdavailable(){
+#ifdef PS2KEYBOARD
+	return keyboard.available(); 
+#else
+#ifdef PS2FABLIB
+  if (fabgllastchar) return Terminal.available()+1; else return Terminal.available();
+#else 
+#ifdef USBKEYBOARD
+/* if we already have a key, tell the caller we have one */
+  if (usbkey) return 1; 
+/* if not, look it up */
+  if (usbkey) return 1; else return 0;
+#else
+#ifdef ZX81KEYBOARD
+  return keyboard.available();
+#else
+#ifdef ARDUINOI2CKBD
+/* do we have a key stored, then return it */
+  if (i2ckey) {
+    return 1; 
+  } else {
+    i2ckey=i2ckbdgetkey(); 
+    if (i2ckey != 0) return 1;
+  }
+#else
+#if defined(GIGAUSBKBD)
+  return keyb.available();
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+#ifdef HASKEYPAD
+/* a poor man's debouncer, unstable state returns 0 */
+  char c=keypadread();
+  if (c != 0) {
+    bdelay(2); 
+    if (c == keypadread()) return 1;
+  }
+#endif	
+	return 0;
+}
+
+char kbdread() {
+  char c = 0;
+/* wait for the keystrike in a tight loop, yielding a lot */
+  while(!kbdavailable()) byield();
+#ifdef PS2KEYBOARD  
+	c=keyboard.read();
+#endif
+#ifdef PS2FABLIB
+  if (fabgllastchar) { c=fabgllastchar; fabgllastchar=0; }
+  else c=Terminal.read();
+#else 
+#ifdef USBKEYBOARD
+/* if we have read a key before, return it else look it up */
+  c=usbkey; 
+  usbkey=0; 
+#else
+#ifdef ZX81KEYBOARD
+  c=keyboard.read();
+#else
+#ifdef ARDUINOI2CKBD
+/* a key is stored from a previous kbdavailable() */
+ if (i2ckey) {
+    c=i2ckey;
+    i2ckey=0;
+  } else {
+/* if not look for a key, no need to store it */
+    c=i2ckbdgetkey();
+  }
+#else
+#if defined(GIGAUSBKBD)
+/* sometimes 0s are returned even with avail > 0 */
+      auto _key = keyb.read();
+      c=keyb.getAscii(_key);
+#endif
+#endif
+#endif
+#endif
+#endif
+#ifdef HASKEYPAD
+  if (c == 0) { /* we have no character from a real keyboard, ask the keypad */
+	  c=keypadread();
+/* if the keypad is in non repeat mode, block */
+	  if (!kbdrepeat) while(kbdavailable()) byield();
+  }
+#endif	
+	if (c == 13) c=10;
+	return c;
+}
+
+char kbdcheckch() {
+#ifdef PS2KEYBOARD
+/*
+ * only works with the patched library https://github.com/slviajero/PS2Keyboard
+ */
+#ifdef PS2KEYBOARD_HASPEEK
+ return keyboard.peek();
+#else 
+/*
+ * for the original library  https://github.com/PaulStoffregen/PS2Keyboard 
+ * GET does not work properly with it as there is no peek functionality which is needed
+ * for non blocking IO and the ability to stop programs
+ */
+  if (kbdavailable()) return kbdread(); else return 0;
+#endif
+#else
+#ifdef PS2FABLIB
+  if (fabgllastchar) return fabgllastchar;
+	if (kbdavailable()) { fabgllastchar=Terminal.read(); return fabgllastchar; }
+#else 
+#ifdef USBKEYBOARD
+  return usbkey;
+#else 
+#ifdef ZX81KEYBOARD
+  return keyboard.lastKey; /* dont peek here as checkch called in a fast loop in statement(), peek done in byield*/
+#else 
+#ifdef ARDUINOI2CKBD
+  if (!i2ckey) {
+    i2ckey=i2ckbdgetkey();
+  }
+  return i2ckey;
+#else
+#if defined(GIGAUSBKBD)
+    auto _key = keyb.peek();
+    return keyb.getAscii(_key);
+#endif
+#endif
+#endif
+#endif
+#endif
+#endif
+#ifdef HASKEYPAD
+	return keypadread();
+#endif	
+	return 0;
+}
+
+/*
+ * Display driver code - documentation is in the header file
+ */
+
+#ifdef DISPLAYDRIVER
+
+/* the cursor position */
+uint8_t dspmycol = 0;
+uint8_t dspmyrow = 0;
+
+/* the escape state of the vt52 terminal */
+uint8_t dspesc = 0;
+
+/* which update mode do we have */
+uint8_t dspupdatemode = 0;
+
+/* how do we handle wrap 0 is wrap, 1 is no wrap */
+uint8_t dspwrap = 0; 
+
+/* the print mode */
+uint8_t dspprintmode = 0;
+
+/* the scroll control variables */
+uint8_t dspscrollmode = 0;
+uint8_t dsp_scroll_rows = 1;
+
+uint8_t dspstat(uint8_t c) { return 1; }
+
+void dspsetcursorx(uint8_t c) {
+  if (c>=0 && c<dsp_columns) dspmycol=c;
+  dspprintchar(0, dspmycol, dspmyrow); /* needed to really position the cursor if there is a hardware cursor */
+}
+
+void dspsetcursory(uint8_t r) {
+  if (r>=0 && r<dsp_rows) dspmyrow=r;
+    dspprintchar(0, dspmycol, dspmyrow); /* needed to really position the cursor if there is a hardware cursor */
+}
+
+uint8_t dspgetcursorx() { return dspmycol; }
+
+uint8_t dspgetcursory() { return dspmyrow; }
+
+uint8_t dspactive() {
+	return od == ODSP;
+}
+
+/* to whom the bell tolls - implement this to you own liking */
+void dspbell() {}
+
+/*
+ * Control the update modes for page update displays
+ * like Epaper, Nokia 5110 and SSD1306
+ * dspgraphupdate is the helper for the graphics functions.
+ */
+
+void dspsetupdatemode(uint8_t c) {
+  dspupdatemode=c;
+}
+
+uint8_t dspgetupdatemode() {
+  return dspupdatemode;
+}
+
+void dspgraphupdate() {
+  if (dspupdatemode == 0) dspupdate();
+}
+
+/* scrollable displays need a character buffer */
+#ifdef DISPLAYCANSCROLL
+
+#ifndef DISPLAYHASCOLOR
+const uint16_t dspfgvgacolor = 0;
+#endif
+
+dspbuffer_t dspbuffer[dsp_rows][dsp_columns];
+
+/* buffer access functions */
+
+/* needed for @D() */
+dspbuffer_t dspget(uint16_t i) {
+  if (i>=0 && i<=dsp_columns*dsp_rows-1) return dspbuffer[i/dsp_columns][i%dsp_columns]; else return 0;
+}
+
+/* print line and screen helpers */
+dspbuffer_t dspgetrc(uint8_t r, uint8_t c) { return dspbuffer[r][c]; }
+dspbuffer_t dspgetc(uint8_t c) { return dspbuffer[dspmyrow][c]; }
+
+/* this functions prints a character and updates the display buffer */
+void dspsetxy(dspbuffer_t ch, uint8_t c, uint8_t r) {
+  if (r>=0 && c>=0 && r<dsp_rows && c<dsp_columns) {
+    dspbuffer[r][c]=(dspbuffer_t)ch | (dspfgvgacolor << 8);
+    if (ch != 0) dspprintchar(ch, c, r); else dspprintchar(' ', c, r);
+  }
+}
+
+/* needed for @D() access */
+void dspset(uint16_t i, dspbuffer_t ch) {
+  uint8_t c=i%dsp_columns;
+  uint8_t r=i/dsp_columns;
+  dspsetxy(ch, c, r);
+}
+
+/* 0 normal scroll, 1 enable waitonscroll function */
+void dspsetscrollmode(uint8_t c, uint8_t l) {
+	dspscrollmode = c;
+	dsp_scroll_rows = l;
+}
+
+/* clear the buffer */
+void dspbufferclear() {
+	uint8_t r,c;
+	for (r=0; r<dsp_rows; r++)
+		for (c=0; c<dsp_columns; c++)
+      dspbuffer[r][c]=0;
+  dspmyrow=0;
+  dspmycol=0;
+}
+
+#ifdef DISPLAYHASCOLOR
+/* separates characters and color/font */
+const uint16_t charmask = 0x80FF;
+#endif
+
+/* do the scroll */
+void dspscroll(uint8_t scroll_rows, uint8_t scroll_top=0){
+	uint8_t r,c;
+  dspbuffer_t a,b;
+  
+/* scroll data up and redraw the display */
+  for (r=scroll_top; r<dsp_rows-scroll_rows; r++) { 
+    for (c=0; c<dsp_columns; c++) {
+			a=dspbuffer[r][c];
+			b=dspbuffer[r+scroll_rows][c];
+			if ( a != b ) {
+  			if (b != 0) { 
+#ifdef DISPLAYHASCOLOR
+            dspsavepen();
+            dspsetfgcolor((b >> 8) & 15);
+            dspprintchar(b & charmask, c, r); 
+            dsprestorepen();
+#else
+  			    dspprintchar(b, c, r); 
+#endif     
+  			} else {
+  			  dspprintchar(' ', c, r);
+  			}
+      }      
+			dspbuffer[r][c]=b;
+		} 
+	}
+
+/* delete the characters in the remaining lines */
+	for (r=dsp_rows-scroll_rows; r<dsp_rows; r++) {
+		for (c=0; c<dsp_columns; c++) {
+			if (dspbuffer[r][c] != 0 && ( dspbuffer[r][c]) != 32) dspprintchar(' ', c, r); 
+			dspbuffer[r][c]=0;     
+    }
+	}
+  
+/* set the cursor to the first free line	*/ 
+  dspmycol=0;
+	dspmyrow=dsp_rows-scroll_rows;
+}
+
+/* do the reverse scroll only one line implemented */
+void dspreversescroll(uint8_t line){
+  uint8_t r,c;
+  dspbuffer_t a,b;
+  
+/* scroll data up and redraw the display */
+  for (r=dsp_rows; r>line; r--) { 
+    for (c=0; c<dsp_columns; c++) {
+      a=dspbuffer[r][c];
+      b=dspbuffer[r-1][c];
+      if ( a != b ) {
+        if (b != 0) { 
+#ifdef DISPLAYHASCOLOR
+            dspsavepen();
+            dspsetfgcolor((b >> 8) & 15);
+            dspprintchar(b & charmask, c, r); 
+            dsprestorepen();
+#else
+            dspprintchar(b, c, r); 
+#endif 
+        } else {
+          dspprintchar(' ', c, r);
+        }
+      }      
+      dspbuffer[r][c]=b;
+    } 
+  }
+
+/* delete the characters in the remaining line */
+  for (c=0; c<dsp_columns; c++) {
+    if (dspbuffer[line][c] != 0 && dspbuffer[line][c] != 32) dspprintchar(' ', c, r); 
+    dspbuffer[line][c]=0;     
+  }
+ 
+/* set the cursor to the free line  */ 
+  dspmyrow=line;
+}
+
+/* again a break in API, using inch here */
+char dspwaitonscroll() {
+  char c;
+
+	if ( dspscrollmode == 1 ) {
+		if (dspmyrow == dsp_rows-1) {
+      c=inch();
+      if (c == ' ') dspwrite(12);
+		  return c;
+		}
+	}
+	return 0;
+}
+#else 
+
+/* code for low memory simple display access */
+
+/* buffer access functions - stubs for displays without buffer */
+dspbuffer_t dspget(uint16_t i) { return 0; }
+dspbuffer_t dspgetrc(uint8_t r, uint8_t c) { return 0; }
+dspbuffer_t dspgetc(uint8_t c) { return 0; }
+
+void dspsetxy(dspbuffer_t ch, uint8_t c, uint8_t r) {
+  if (ch != 0) dspprintchar(ch, c, r); else dspprintchar(' ', c, r);
+}
+
+void dspset(uint16_t i, dspbuffer_t ch) {
+  uint8_t c=i%dsp_columns;
+  uint8_t r=i/dsp_columns;
+  dspsetxy(ch, c, r);
+}
+
+/* unbuffered display, the only thing we can do is go home */
+void dspbufferclear() {
+  dspmyrow=0;
+  dspmycol=0;
+}
+
+/* no scroll no wait */
+char dspwaitonscroll() { return 0; }
+
+/* a stub for dspwrite */
+void dspscroll(uint8_t scroll_rows, uint8_t scroll_top=0){
+  dspmyrow=dsp_rows-1;
+}
+
+/* no scroll without buffer */
+void dspsetscrollmode(uint8_t c, uint8_t l) {}
+void dspreversescroll(uint8_t a){}
+#endif
+
+/* the generic write function for displays with and without buffers */
+void dspwrite(char c){
+int8_t dspmycolt;
+
+/* on escape call the vt52 state engine, it modifies the character */
+#ifdef HASVT52
+  if (dspesc) { 
+    dspvt52(&c); 
+  }
+#endif
+
+/* do we print? */
+#ifdef ARDUINOPRT
+  if (dspprintmode) {
+    prtwrite(c);
+    if (sendcr && c == 10) prtwrite(13); /* some printers want cr */
+    if (dspprintmode == 2) return; /* do not print in mode 2 */
+  }
+#endif 
+  
+/* the buildin control characters for all displays */
+  switch(c) {
+    case 0:
+      return;
+    case 7: // the function dspbell() is not implemented.
+      dspbell();
+      return;
+    case 9: // tab moves on 8 positions
+      dspmycolt = dspmycol/8;
+      if ((dspmycolt+1)*8<dsp_columns-1) dspmycol=(dspmycolt+1)*8;
+      return;
+    case 10: // this is LF Unix style doing also a CR
+      dspmyrow++;
+      if (dspmyrow >= dsp_rows) dspscroll(dsp_scroll_rows);  
+      dspmycol=0;
+      if (dspupdatemode == 1) dspupdate();
+      return;
+    case 11: // vertical tab - converted to line feed without carriage return
+      if (dspmyrow < dsp_rows-1) dspmyrow++;
+      return; 
+    case 12: // form feed is clear screen plus home
+      dspbufferclear();
+      dspclear();
+      return;
+    case 13: // classical carriage return, no form feed 
+      dspmycol=0;
+      return;
+    case 27: // escape - initiate vtxxx mode
+      dspesc=1;
+      return;
+    case 28: // cursor back - this is what terminal applications send for cursor back
+      if (dspmycol > 0) dspmycol--;
+      return;
+    case 29: // cursor forward - this is what terminal applications send for cursor back
+      if (dspmycol < dsp_columns-1) dspmycol++;
+      return;
+    case 8:   // back space is delete the moment
+    case 127: // delete
+      if (dspmycol > 0) {
+        dspmycol--;
+        dspsetxy(0, dspmycol, dspmyrow);
+      }
+      return;
+    case 2: // we abuse start of text as a home sequence, may also be needed for Epaper later
+      dspmycol=dspmyrow=0;
+      return;
+    case 3: //  ETX = Update display for buffered display like Epaper 
+      dspupdate();
+      return;
+    default: // eliminate all non printables - problematic for LCD special character
+      if (c<32) return;
+      break;
+  }
+  
+  dspsetxy(c, dspmycol, dspmyrow);
+  dspmycol++;
+  if (dspmycol == dsp_columns) {
+    if (!dspwrap) { /* we simply ignore the cursor */
+      dspmycol=0;
+      dspmyrow=(dspmyrow + 1);
+    }
+    if (dspmyrow >= dsp_rows) dspscroll(dsp_scroll_rows); 
+  }
+  if (dspupdatemode == 0) dspupdate();
+}
+
+/* 
+ * This is the minimalistic VT52 state engine. It is an interface to 
+ * process single byte control sequences of the form <ESC> char 
+ */
+ 
+#ifdef HASVT52
+/* the state variable */
+char vt52s = 0;
+
+/* the graphics mode mode - unused so far */
+uint8_t vt52graph = 0;
+
+/* the secondary cursor */
+uint8_t vt52mycol = 0;
+uint8_t vt52myrow = 0;
+
+/* temp variables for column and row , do them here and not in the case: guess why */
+uint8_t vt52tmpr;
+uint8_t vt52tmpc;
+
+/* an output buffer for the vt52 terminal */
+const uint8_t vt52buffersize = 4; 
+char vt52outbuffer[vt52buffersize] = { 0, 0, 0, 0 };
+uint8_t vt52bi = 0;
+uint8_t vt52bj = 0;
+
+/* the reader from the buffer */
+char vt52read() {
+  if (vt52bi<=vt52bj) { vt52bi = 0; vt52bj = 0; } /* empty, reset */
+  if (vt52bi>vt52bj) return vt52outbuffer[vt52bj++];
+  return 0;
+}
+
+/* the avail from the buffer */
+uint8_t vt52avail() { if (vt52bi > vt52bj) return vt52bi-vt52bj; else return 0; }
+
+/* putting something into the buffer */
+void vt52push(char c) {
+  if (vt52bi < vt52buffersize) vt52outbuffer[vt52bi++]=c; 
+}
+
+/* clear the buffer */
+void vt52clear() {
+  vt52bi=0;
+}
+
+/* something little */
+uint8_t vt52number(char c) {
+  uint8_t b=c;
+  if (b>31) return b-32; else return 0;
+}
+
+/*
+ * The VT52 data registers for the graphics and wiring extension.
+ * x,y are 14 bit and z is 7bit. Data is transferred in VT52 style
+ * -> numerical value plus 32 to map the data to printable characters
+ * Access is done through the the ESC x, ESC y and ESC z sequences:
+ * ESC x #1 #2 
+ * sets the xregister to (#1-32)+(#2-32)*128
+ */
+
+#if defined(DISPLAYHASGRAPH) || defined(VT52WIRING)
+#define VT52HASREGISTERS
+/* the three register variables */
+uint16_t vt52regx = 0;
+uint16_t vt52regy = 0;
+uint8_t  vt52regz = 0;
+
+/* one argument cache for two byte arguments */
+uint8_t vt52arg = 0;
+#endif
+
+/* 
+ * graphics code in VT52, if you want to control graphics from the character stream 
+ * The ESC g <ch> sequence sends a graphics command as the second byte after the g
+ * 
+ * Valid values for g are
+ *  s: set the graphics cursor
+ *  p: plot a point
+ *  l: draw a line
+ *  L: draw a line and move the cursor to the endpoint
+ *  r: draw a rectangle
+ *  R: draw a filled rectangle
+ *  c: draw a circle
+ *  C: draw a filled circle
+ * 
+ */
+#ifdef DISPLAYHASGRAPH
+/* the grahics cursor of VT52 */
+uint16_t vt52graphx = 0;
+uint16_t vt52graphy = 0;
+
+/* execute one graphics command */
+void vt52graphcommand(uint8_t c) {
+  switch(c) {
+    case 's': /* set the cursor */
+      vt52graphx=vt52regx;
+      vt52graphy=vt52regy;
+      break;
+    case 'p': /* plot a point at the cursor */
+      plot(vt52graphx, vt52graphy);
+      break;
+    case 'l': /* plot a line */
+      line(vt52graphx, vt52graphy, vt52regx, vt52regy);
+      break;
+    case 'L': /* plot a line and update the cursor, needed for drawing shapes */
+      line(vt52graphx, vt52graphy, vt52regx, vt52regy);
+      vt52graphx=vt52regx;
+      vt52graphy=vt52regy;
+      break;
+    case 'r': /* plot a rectangle */
+      rect(vt52graphx, vt52graphy, vt52regx, vt52regy);
+      break;
+    case 'c': /* plot a circle */
+      circle(vt52graphx, vt52graphy, vt52regx);
+      break;
+    case 'R': /* plot a filled rectangle */
+      frect(vt52graphx, vt52graphy, vt52regx, vt52regy);
+      break;
+    case 'C': /* plot a filled circle */
+      fcircle(vt52graphx, vt52graphy, vt52regx);
+      break;
+  }  
+}
+#endif
+
+/* 
+ * This is an odd part of the vt52 code with this, the terminal 
+ * can control the digital and analog pins.
+ */
+
+#ifdef VT52WIRING
+#define VT52HASREGISTERS
+  void vt52wiringcommand(uint8_t c) {
+    switch(c) { 
+      case 'p': /* pinMode z */
+        pinMode(vt52regz, vt52regx);
+        break;
+      case 'l': /* digital write low pin z*/
+        digitalWrite(vt52regz, LOW);
+        break;
+      case 'h': /* digital write high pin z*/
+        digitalWrite(vt52regz, HIGH);
+        break;
+      case 'r': /* digital read from pin z */
+        vt52push(digitalRead(vt52regz)+32);
+        break;      
+      case 'a': /* analog write pin z to value x */
+        analogWrite(vt52regz, vt52regx);
+        break;
+      case 'A': /* analog read from pin z */
+        break;
+      case 't': /* tone at pin z, frequency x, duration y */
+        tone(vt52regz, vt52regx, vt52regy);
+        break;
+    }  
+  }
+#endif
+
+
+/* the actual vt52 state engine */
+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;
+#ifdef VT52HASREGISTERS
+    case 'x':
+      if (dspesc == 2) { 
+        vt52arg=vt52number(*c);
+        dspesc=1; 
+        *c=0;
+        return;
+      }
+      if (dspesc == 1) { 
+        vt52regx=vt52arg+vt52number(*c)*128;
+        *c=0; 
+      }
+      vt52s=0; 
+      break;
+    case 'y':
+      if (dspesc == 2) { 
+        vt52arg=vt52number(*c);
+        dspesc=1; 
+        *c=0;
+        return;
+      }
+      if (dspesc == 1) { 
+        vt52regy=vt52arg+vt52number(*c)*127;
+        *c=0; 
+      }
+      vt52s=0; 
+      break;
+    case 'z':
+      vt52regz=vt52number(*c);
+      *c=0;
+      vt52s=0;
+      break;
+#endif
+#ifdef DISPLAYHASGRAPH
+    case 'g':
+      vt52graphcommand(*c);
+      *c=0;
+      vt52s=0;
+      break;      
+#endif
+#ifdef VT52WIRING
+    case 'a':
+      vt52wiringcommand(*c);
+      *c=0;
+      vt52s=0;
+      break; 
+#endif
+  }
+ 
+/* commands of the terminal in text mode */
+  
+  switch (*c) {
+    case 'v': /* GEMDOS / TOS extension enable wrap */
+      dspwrap=0;
+      break;
+    case 'w': /* GEMDOS / TOS extension disable wrap */
+      dspwrap=1;
+      break;
+    case '^': /* Printer extensions - print on */
+      dspprintmode=1;
+      break;
+    case '_': /* Printer extensions - print off */
+      dspprintmode=0;
+      break;
+    case 'W': /* Printer extensions - print without display on */
+      dspprintmode=2;
+      break;
+    case 'X': /* Printer extensions - print without display off */
+      dspprintmode=0;
+      break;
+    case 'V': /* Printer extensions - print cursor line */
+#if defined(ARDUINOPRT) && defined(DISPLAYCANSCROLL)
+      for (uint8_t i=0; i<dsp_columns; i++) prtwrite(dspgetc(i));
+#endif
+      break;
+    case ']': /* Printer extension - print screen */
+#if defined(ARDUINOPRT) && defined(DISPLAYCANSCROLL)
+      for (uint8_t j=0; j<dsp_rows; j++)
+        for (uint8_t i=0; i<dsp_columns; i++) prtwrite(dspgetrc(j, i));
+#endif
+      break;
+    case 'F': /* enter graphics mode */
+      vt52graph=1;
+      break;
+    case 'G': /* exit graphics mode */
+      vt52graph=0;
+      break;
+    case 'Z': // Ident 
+      vt52clear();
+      vt52push(27);
+      vt52push('/');
+#ifndef ARDUINOPRT
+      vt52push('K');
+#else
+      vt52push('L');
+#endif
+      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
+      dspsetcursor(1);
+      break;
+    case 'f': // GEMDOS / TOS extension disable cursor 
+      dspsetcursor(0);
+      break;
+    case 'p': // GEMDOS / TOS extension reverse video 
+      dspsetreverse(1);
+      break;
+    case 'q': // GEMDOS / TOS extension normal video 
+      dspsetreverse(0);
+      break;
+    case 'A': // cursor up
+      if (dspmyrow>0) dspmyrow--;
+      break;
+    case 'B': // cursor down 
+      if (dspmyrow < dsp_rows-1) dspmyrow++;
+      break;
+    case 'C': // cursor right 
+      if (dspmycol < dsp_columns-1) dspmycol++;
+      break; 
+    case 'D': // cursor left 
+      if (dspmycol>0) dspmycol--;
+      break;
+    case 'E': // GEMDOS / TOS extension clear screen 
+      dspbufferclear();
+      dspclear();
+      break;
+    case 'H': // cursor home 
+      dspmyrow=dspmycol=0;
+      break;  
+    case 'Y': // Set cursor position 
+      vt52s='Y';
+      dspesc=2;
+      *c=0;
+      return;
+    case 'J': // clear to end of screen 
+      for (int i=dspmycol+dsp_columns*dspmyrow; i<dsp_columns*dsp_rows; i++) dspset(i, 0);
+      break;
+    case 'd': // GEMDOS / TOS extension clear to start of screen 
+      for (int i=0; i<dspmycol+dsp_columns*dspmyrow; i++) dspset(i, 0);
+      break;
+    case 'K': // clear to the end of line
+      for (uint8_t i=dspmycol; i<dsp_columns; i++) dspsetxy(0, i, dspmyrow);
+      break;
+    case 'l': // GEMDOS / TOS extension clear line 
+      for (uint8_t i=0; i<dsp_columns; i++) dspsetxy(0, i, dspmyrow);
+      break;
+    case 'o': // GEMDOS / TOS extension clear to start of line
+      for (uint8_t i=0; i<=dspmycol; i++) dspsetxy(0, i, dspmyrow);
+      break;
+    case 'k': // GEMDOS / TOS extension restore cursor
+      dspmycol=vt52mycol;
+      dspmyrow=vt52myrow;
+      break;
+    case 'j': // GEMDOS / TOS extension save cursor
+      vt52mycol=dspmycol;
+      vt52myrow=dspmyrow;
+      break;
+    case 'I': // reverse line feed
+      if (dspmyrow>0) dspmyrow--; else dspreversescroll(0);
+      break;
+    case 'L': // Insert line
+      dspreversescroll(dspmyrow);
+      break;
+    case 'M': 
+      vt52tmpr = dspmyrow;
+      vt52tmpc = dspmycol;
+      dspscroll(1, dspmyrow);
+      dspmyrow=vt52tmpr;
+      dspmycol=vt52tmpc;
+      break;
+#ifdef VT52HASREGISTERS
+    case 'x': // set the x register 
+    case 'y': // set the y register 
+      vt52s=*c;
+      dspesc=2;
+      *c=0;
+      return;
+    case 'z': // set the z register
+      vt52s=*c;
+      dspesc=1;
+      *c=0;
+      return;
+      break;
+#endif   
+#ifdef DISPLAYHASGRAPH 
+    case 'g': // execute a graphics command 
+      vt52s=*c;
+      dspesc=1;
+      *c=0;
+      return;
+      break;
+#endif
+#ifdef VT52WIRING
+    case 'a': // execute a wiring command
+      vt52s=*c;
+      dspesc=1;
+      *c=0;
+      return;
+      break;
+#endif
+  }
+  dspesc=0;
+  *c=0;
+}
+#endif
+
+#else
+#ifdef GRAPHDISPLAYDRIVER
+/* a super simple display driver for graphics only systems, only handles drawing 
+  and graphics cursor stuff, experimental for epapers */
+#undef HASVT52
+#define GBUFFERSIZE 80
+static char gbuffer[GBUFFERSIZE];
+void dspouts(char* s, uint16_t l) {
+  int i;
+  for (i=0; i<l-1 && i<GBUFFERSIZE-1; i++) gbuffer[i]=s[i];
+  gbuffer[i]=0;
+  dspprintstring(gbuffer);
+}
+/* single character handling is triggered by PUT, it controls cursor movement */
+void dspwrite(char c) {
+  switch(c) {
+    case 0:
+      return;
+    case 10: // this is LF Unix style doing also a CR
+      dspgraphcursor_x=0;
+    case 11: // vertical tab - converted to line feed without carriage return
+      dspgraphcursor_y+=dspfontsize;
+      return; 
+    case 12: // form feed is clear screen plus home
+      dspclear();
+    case 2: // we abuse start of text as a home sequence, may also be needed for Epaper later
+      dspgraphcursor_x=0;
+      dspgraphcursor_y=dspfontsize;
+      return;
+    case 13: // classical carriage return, no form feed, we stay in the same line
+      dspgraphcursor_x=0;
+      return;
+    default: // eliminate all non printables
+      if (c<32) return;
+      break;
+  }
+  dspouts(&c, 1);
+}
+int dspstat(char c) { return 1; }
+int dspgetcursorx() { return dspgraphcursor_x; }
+int dspgetcursory() { return dspgraphcursor_y; }
+void dspsetcursorx(int v) { dspgraphcursor_x = v; }
+void dspsetcursory(int v) { dspgraphcursor_y = v; } 
+char dspwaitonscroll() { return 0; };
+uint8_t dspactive() {return 1; }
+void dspsetupdatemode(uint8_t c) {}
+#else
+/* stubs for systems without a display driver, BASIC uses these functions */
+const int dsp_rows=0;
+const int dsp_columns=0;
+void dspsetupdatemode(uint8_t c) {}
+void dspwrite(char c){};
+void dspbegin() {};
+uint8_t dspstat(uint8_t c) {return 0; }
+char dspwaitonscroll() { return 0; };
+uint8_t dspactive() {return 0; }
+void dspsetscrollmode(uint8_t c, uint8_t l) {}
+void dspscroll(uint8_t a, uint8_t b){}
+char vt52read() { return 0; }
+uint8_t vt52avail() { return 0; }
+#endif
+#endif
+
+/* 
+ * Real time clock access for the system. See runtime.h for the
+ * configuration of the clock access. 
+ */
+
+#if defined(ARDUINORTC)
+/*
+ * I2C clocks DS1307, DS3231, and DS3232 using Wire directly
+ * no buffering of values, access directly to the clock registers
+ */
+
+/* No begin method needed */
+void rtcbegin() {}
+
+/* get the time from the registers */
+uint16_t rtcget(uint8_t i) {
+  
+    /* set the address of the read */
+    wirestart(RTCI2CADDR, 0);
+    wirewritebyte(i);
+    wirestop();
+
+    /* now read */
+    wirestart(RTCI2CADDR, 1);
+    uint8_t v=wirereadbyte();
+    
+    switch (i) {
+    case 0: 
+    case 1:
+      return (v & 0b00001111)+((v >> 4) & 0b00000111) * 10;      
+    case 2:
+      return (v & 0b00001111)+((v >> 4) & 0b00000011) * 10 ; /* only 24 hour support */
+    case 3:
+      return (v & 0b00001111);
+    case 4:
+      return (v & 0b00001111) + ((v >> 4) & 0b00000011) * 10;
+    case 5:
+      return (v & 0b00001111) + ((v >> 4) & 0b00000001) * 10;
+    case 6:
+      return (v & 0b00001111) + (v >> 4) * 10;
+    default:
+      return v;
+   }
+}
+
+/* set the registers */
+void rtcset(uint8_t i, uint16_t v) { 
+  uint8_t b;
+
+  /* to bcd if we deal with a clock byte (0-6) */
+  if (i<7) b=(v%10 + ((v/10) << 4)); else b=v;
+   
+  switch (i) {
+    case 0: 
+    case 1:  
+      b = b & 0b01111111; 
+      break; 
+    case 2:
+    case 4:
+      b = b & 0b00111111; /* only 24 hour support */
+      break;
+    case 3:
+      b = b & 0b00000111;
+      break;
+    case 5:
+      b = b & 0b00011111;
+   }
+
+/* send the address and then the byte */
+    wirestart(RTCI2CADDR, 0);
+    wirewritebyte(i);
+    wirewritebyte(b);
+    wirestop();
+
+}
+#elif defined(HASBUILTINRTC) 
+/*
+ * Built-in clocks of STM32 and MKR are based on the RTCZero interface
+ * an rtc object is created after loading the libraries
+ * for NRENESAs the interface is slightly different
+ */
+#ifndef ARDUINO_ARCH_RENESAS
+/* begin method */
+void rtcbegin() {
+  rtc.begin(); /* 24 hours mode */ 
+}
+
+/* get the time */
+uint16_t rtcget(uint8_t i) { 
+    switch (i) {
+    case 0: 
+      return rtc.getSeconds();
+    case 1:
+      return rtc.getMinutes();      
+    case 2:
+      return rtc.getHours();
+    case 3:
+      // return rtc.getWeekDay();
+      return 0;
+    case 4:
+      return rtc.getDay();
+    case 5:
+      return rtc.getMonth();
+    case 6:
+      return rtc.getYear();
+    default:
+      return 0;
+   }
+}
+
+/* set the time */
+void rtcset(uint8_t i, uint16_t v) { 
+  switch (i) {
+    case 0: 
+      rtc.setSeconds(v);
+      break;
+    case 1: 
+      rtc.setMinutes(v);
+      break;    
+    case 2:
+      rtc.setHours(v);
+      break;
+    case 3:
+      // rtc.setWeekDay(v);
+      break;
+    case 4:
+      rtc.setDay(v);
+      break;
+    case 5:
+      rtc.setMonth(v);
+      break;
+    case 6:
+      rtc.setYear(v);
+      break;
+    default:
+      return; 
+   }
+}
+#else 
+/* NRENESA code, interface different to my great ennui! */
+/* begin method */
+void rtcbegin() {
+  RTC.begin(); /* 24 hours mode */ 
+}
+
+/* get the time */
+uint16_t rtcget(uint8_t i) { 
+    RTC.getTime(rtc);
+    switch (i) {
+    case 0: 
+      return rtc.getSeconds();
+    case 1:
+      return rtc.getMinutes();      
+    case 2:
+      return rtc.getHour();
+    case 3:
+      return static_cast<int>(rtc.getDayOfWeek());
+    case 4:
+      return rtc.getDayOfMonth();
+    case 5:
+      return Month2int(rtc.getMonth());
+    case 6:
+      return rtc.getYear();
+    default:
+      return 0;
+   }
+}
+
+/* set the time */
+void rtcset(uint8_t i, uint16_t v) { 
+  RTC.getTime(rtc);
+  switch (i) {
+    case 0: 
+      rtc.setSecond(v);
+      break;
+    case 1: 
+      rtc.setMinute(v);
+      break;    
+    case 2:
+      rtc.setHour(v);
+      break;
+    case 3:
+      rtc.setDayOfWeek(static_cast<DayOfWeek>(v));
+      break;
+    case 4:
+      rtc.setDayOfMonth(v);
+      break;
+    case 5:
+      rtc.setMonthOfYear(static_cast<Month>(v-1));
+      break;
+    case 6:
+      rtc.setYear(v);
+      break;
+    default:
+      return; 
+   }
+   RTC.setTime(rtc);
+}
+#endif
+#elif defined(ARDUINORTCEMULATION)
+/* 
+ * A millis() based real time clock emulation. It creates a 32bit Unix time 
+ * variable and adds millis()/1000 
+ */
+
+/* the begin method - standard interface to BASIC*/
+void rtcbegin() {}
+
+/* the current unix time - initialized to the begin of the epoch */
+long rtcutime = 0; 
+
+/* the offset of millis()/1000 when we last set the clock */
+long rtcutimeoffset = 0;
+
+/* the current unix date - initialized to the begin of the epoch */
+struct { uint8_t second; uint8_t minute; uint8_t hour; uint8_t weekday; uint8_t day; uint8_t month; uint16_t year; } 
+  rtctime = { 0, 0, 0, 4, 1, 1, 1970 };
+
+/* the number of days per month */
+const int rtcmonthdays[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
+
+
+/* convert the time to a unix time number from https://de.wikipedia.org/wiki/Unixzeit  */
+void rtctimetoutime() {
+  int leapyear = ((rtctime.year-1)-1968)/4 - ((rtctime.year-1)-1900)/100 + ((rtctime.year-1)-1600)/400;
+  long epochdays = (rtctime.year-1970)*365 + leapyear + rtcmonthdays[rtctime.month-1] + rtctime.day - 1;
+  if ((rtctime.month > 2) && (rtctime.year%4 == 0 && (rtctime.year%100 != 0 || rtctime.year%400 == 0))) epochdays+=1;
+  rtcutime = rtctime.second + 60*(rtctime.minute + 60*(rtctime.hour + 24*epochdays));
+}
+
+/* convert the unix time to time and date from https://de.wikipedia.org/wiki/Unixzeit */
+void rtcutimetotime() {
+  const unsigned long int secondsperday   =  86400ul; /*  24* 60 * 60 */
+  const unsigned long int daysperyear     =    365ul; /* no leap year */
+  const unsigned long int daysinfoury     =   1461ul; /*   4*365 +   1 */
+  const unsigned long int daysinhundredy  =  36524ul; /* 100*365 +  25 - 1 */
+  const unsigned long int daysinfourhundredy = 146097ul; /* 400*365 + 100 - 4 + 1 */
+  const unsigned long int daynumberzero      = 719468ul; /* day number of March, 1 1970 */
+  
+  unsigned long int daynumber = daynumberzero + rtcutime/secondsperday;
+  unsigned long int secondssincemidnight = rtcutime%secondsperday;
+  unsigned long int temp;
+
+  /* the weekday is based in the daynumber since March, 1, 1970 a SUNDAY */
+  rtctime.weekday = daynumber % 7;
+
+  /* leap years of the Gregorian calendar */
+  temp = 4 * (daynumber + daysinhundredy + 1) / daysinfourhundredy - 1;
+  rtctime.year = 100 * temp;
+  daynumber -= daysinhundredy * temp + temp / 4;
+
+  /* leap years of the Julian calendar */
+  temp = 4 * (daynumber + daysperyear + 1) / daysinfoury - 1;
+  rtctime.year += temp;
+  daynumber -= daysperyear * temp + temp / 4;
+
+  /* calculate day and month, reference March 1 */
+  rtctime.month = (5 * daynumber + 2) / 153;
+  rtctime.day = daynumber - (rtctime.month * 153 + 2) / 5 + 1;
+
+  /* recalulate to a normal year */
+  rtctime.month += 3;
+  if (rtctime.month > 12) {
+    rtctime.month -= 12;
+    rtctime.year++;
+  }
+
+  /* calculate hours, months, seconds */
+    rtctime.hour  = secondssincemidnight / 3600;
+    rtctime.minute = secondssincemidnight % 3600 / 60;
+    rtctime.second = secondssincemidnight % 60;
+}
+
+/* get the time elements -> standard interface to BASIC */
+uint16_t rtcget(uint8_t i) { 
+/* add to the last time we set the clock and subtract the offset*/
+  rtcutime = millis()/1000 + rtcutimeoffset;
+/* calulate the time data */
+  rtcutimetotime();
+
+  switch (i) {
+    case 0: 
+      return rtctime.second;
+    case 1:
+      return rtctime.minute;      
+    case 2:
+      return rtctime.hour;
+    case 3:
+      return rtctime.weekday;
+    case 4:
+      return rtctime.day;
+    case 5:
+      return rtctime.month;
+    case 6:
+      return rtctime.year;
+    default:
+      return 0;
+   }
+}
+
+/* set the time elements -> standard interface to BASIC */
+void rtcset(uint8_t i, uint16_t v) {
+/* how much time has elapsed since we last set the clock */
+  rtcutime = millis()/1000 + rtcutimeoffset;
+
+/* generate the time structure */
+  rtcutimetotime();
+
+/* set the clock */
+  switch (i) {
+    case 0: 
+      if (v>=0 && v<60) rtctime.second=v;
+      break;
+    case 1:
+      if (v>=0 && v<60) rtctime.minute=v;
+      break;     
+    case 2:
+      if (v>=0 && v<24) rtctime.hour=v;
+      break;
+    case 3:
+      if (v>=0 && v<7) rtctime.weekday=v;
+      break;
+    case 4:
+      if (v>0 && v<32) rtctime.day=v;
+      break;
+    case 5:
+      if (v>0 && v<13) rtctime.month=v;
+      break;
+    case 6:
+      if (v>=1970 && v<2100) rtctime.year=v;
+      break;
+    default:
+      return;
+   }
+
+ /* recalulate the right offset by first finding the second value of the new date*/
+  rtctimetoutime();
+  
+/* remember when we set the clock */
+  rtcutimeoffset = rtcutime - millis()/1000;  
+}
+#elif defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_MBED_GIGA)
+/* 
+ * On ESP32 we use the builtin clock, this is a generic Unix time mechanism equivalent
+ * to the code in hardware-posix.h. The code works also for the GIGA which is surprising!
+ */
+
+/* no begin needed */
+void rtcbegin() {}
+
+/* get the time */
+uint16_t rtcget(uint8_t i) { 
+  struct tm rtctime;
+  time_t now;
+  time(&now);
+  localtime_r(&now, &rtctime);
+
+  switch (i) {
+    case 0: 
+      return rtctime.tm_sec;
+    case 1:
+      return rtctime.tm_min;      
+    case 2:
+      return rtctime.tm_hour;
+    case 3:
+      return rtctime.tm_wday;
+    case 4:
+      return rtctime.tm_mday;
+    case 5:
+      return rtctime.tm_mon+1;
+    case 6:
+      if (rtctime.tm_year > 100) return rtctime.tm_year-100; else return rtctime.tm_year;
+    default:
+      return 0;
+  }
+
+  return 0; 
+}
+
+/* set the time */
+void rtcset(uint8_t i, uint16_t v) { 
+  struct tm rtctime;
+  struct timeval tv;
+
+  /* get the time stucture from the system */
+  time_t now;
+  time(&now);
+  localtime_r(&now, &rtctime);
+
+  /* change what needs to be changed */
+  switch (i) {
+    case 0: 
+      rtctime.tm_sec = v%60;
+      break;
+    case 1:
+      rtctime.tm_min = v%60; 
+      break;     
+    case 2:
+      rtctime.tm_hour = v%24;
+      break;
+    case 3:
+      rtctime.tm_wday = v%7;
+      break;
+    case 4:
+      rtctime.tm_mday = v;
+      break;
+    case 5:
+      rtctime.tm_mon = v-1;
+      break;
+    case 6:
+      if (v > 1900) v=v-1900; /* get years to the right value */
+      if (v < 50) v=v+100; 
+      rtctime.tm_year = v;
+      break;
+  }
+
+  /* calculate the seconds and put it back*/
+  time_t epocht = mktime(&rtctime);
+  if (epocht > 2082758399){
+    tv.tv_sec = epocht - 2082758399;  
+  } else {
+    tv.tv_sec = epocht;  
+  }
+  tv.tv_usec = 0;
+  settimeofday(&tv, NULL);
+}
+#else
+/* no clock at all, no operations */
+void rtcbegin() {}
+uint16_t rtcget(uint8_t i) { return 0; }
+void rtcset(uint8_t i, uint16_t v) { }
+#endif
+
+/* 
+ * External EEPROM as a filesystem 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.
+ * The EFS library is now part of the interpreter runtime.
+ */
+
+#ifdef ARDUINOEFS
+#undef ARDUINOI2CEEPROM
+#ifndef EFSEEPROMADDR
+#define EFSEEPROMADDR 0x50
+#endif
+#ifdef EFSEEPROMSIZE
+EepromFS EFS(EFSEEPROMADDR, EFSEEPROMSIZE);
+#else
+EepromFS EFS(EFSEEPROMADDR);
+#endif
+#endif
+
+/* 
+ * External EEPROM is also handled through an EFS filesystem object 
+ * in raw mode. This handles buffering with a minium of ram. 
+*/
+
+#if defined(ARDUINOI2CEEPROM) && defined(ARDUINOI2CEEPROM_BUFFERED)
+#ifndef I2CEEPROMADDR
+#define I2CEEPROMADDR 0x50
+#endif
+#ifdef I2CEEPROMSIZE
+EepromFS EFSRAW(I2CEEPROMADDR, I2CEEPROMSIZE);
+#else
+EepromFS EFSRAW(I2CEEPROMADDR);
+#endif
+#endif
+
+/*
+ * definitions for ESP Wifi and MQTT, super experimental.
+ * As networking is only used for MQTT at the moment, 
+ * mqtt, Wifi and Ethernet comes all in one. 
+ *
+ * No encryption/authetication is implemented in MQTT. 
+ * Only public, open servers can be used.
+ *
+ * MQTT topics can only be 32 bytes long.
+ * Buffered incoming and outgoing messages can be 128 bytes
+ * per default.
+ *
+ * wifisettings.h is the generic network definition file
+ * all network settings are compiled into the code 
+ * BASIC cannot change them at runtime.
+ */
+#ifdef ARDUINOMQTT
+#include "wifisettings.h"
+#ifdef ARDUINOETH
+EthernetClient bethclient;
+PubSubClient bmqtt(bethclient);
+#else
+WiFiClient bwifi;
+PubSubClient bmqtt(bwifi);
+#endif
+
+/* the buffers of the outgoing and incoming MQTT topic, they are char!! */ 
+char mqtt_otopic[MQTTLENGTH];
+char mqtt_itopic[MQTTLENGTH];
+
+/* 
+ * the buffers for MQTT messages, input and output goes 
+ * through these static buffers. 
+ */
+
+volatile char mqtt_buffer[MQTTBLENGTH];
+volatile uint16_t mqtt_messagelength;
+volatile char mqtt_obuffer[MQTTBLENGTH];
+volatile uint16_t mqtt_charsforsend;
+
+/* the name of the client, generated pseudo randomly to avoind 
+		naming conflicts */
+char mqttname[MQTTNAMELENGTH] = "iotbasicxxx";
+void mqttsetname() {
+	uint32_t m = millis();
+	mqttname[8]=(char)(65+m%26);
+	m=m/26;
+	mqttname[9]=(char)(65+m%26);
+	m=m/26;
+	mqttname[10]=(char)(65+m%26);
+}
+
+/* 
+ *	network begin method 
+ *	needs the settings from wifisettings.h
+ * 
+ * Default is right now that Wifi is started at boot
+ * This may change in the future.
+ * 
+ * Ethernet begin has to be reviewed to avoid DHCP 
+ * start timeout if network is not connected
+ */
+void netbegin() {
+#ifdef ARDUINOETH
+#ifdef ETHPIN
+  Ethernet.init(ETHPIN);
+#endif
+  Ethernet.begin(mac);
+#else  
+#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266)
+	WiFi.mode(WIFI_STA);
+	WiFi.begin(ssid, password);
+	WiFi.setAutoReconnect(1);
+#endif
+#if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_UNOR4_WIFI)
+	WiFi.begin(ssid, password);
+#endif
+#if defined(ARDUINO_ARCH_MBED_GIGA)
+  int counter=0;
+  int status=WL_IDLE_STATUS;
+  while (status != WL_CONNECTED && counter++ < 10) {
+    status=WiFi.begin(ssid, password);
+    bdelay(500);  
+  }
+#endif
+#endif
+}
+
+/*
+ * network stop methode, needed sometime to reinit networking
+ * completely or to save power
+ * 
+ */
+void netstop() {
+#ifdef ARDUINOETH
+/* to be done */
+#else  
+#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266)
+  WiFi.mode(WIFI_OFF);
+#endif
+#if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_UNOR4_WIFI) || defined(ARDUINO_ARCH_MBED_GIGA)
+  WiFi.end();
+#endif
+#endif
+}
+
+/*
+ * network reconnect methode
+ * 
+ */
+void netreconnect() {
+#ifdef ARDUINOETH
+/* */
+#else 
+#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266)
+  WiFi.reconnect(); 
+  bdelay(1000); 
+#elif defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_UNOR4_WIFI) || defined(ARDUINO_ARCH_MBED_GIGA)
+/* on these platforms there is no reconnect method, we simply stop and start again */
+  netstop();
+  netbegin();
+#endif  
+#endif
+}
+
+/*
+ * network connected method
+ * on ESP Wifi try to reconnect, the delay is odd 
+ * This is a partial reconnect, BASIC needs to handle 
+ * repeated reconnects
+ */
+uint8_t netconnected() {
+#ifdef ARDUINOETH
+  return bethclient.connected();
+#else
+	return WiFi.status() == WL_CONNECTED;
+#endif
+}
+
+/*
+ * mqtt callback function, using the byte type here
+ * because payload can be binary - interface to BASIC 
+ * strings need to be done
+ *
+ * mqtt event handling in BASIC can be triggered here
+ * we leave the types Arduino style
+ */
+void mqttcallback(char* t, byte* p, unsigned int l) {
+	short i;
+	mqtt_messagelength=l;
+	for(i=0; i<l; i++) mqtt_buffer[i]=(char)p[i];
+}
+
+/*
+ * starting mqtt 
+ * set the server, register the callback and purge all topics
+ */
+void mqttbegin() {
+	bmqtt.setServer(mqtt_server, mqtt_port);
+	bmqtt.setCallback(mqttcallback);
+	*mqtt_itopic=0;
+	*mqtt_otopic=0;
+	mqtt_charsforsend=0;
+}
+
+/* the interface to the usr function */
+uint8_t mqttstat(uint8_t c) {
+#if defined(ARDUINOMQTT)
+  if (c == 0) return 1;
+  if (c == 1) return mqttstate();
+#endif
+  return 0; 
+}
+
+/*
+ * reconnecting mqtt - exponential backoff here 
+ * exponental backoff reconnect in 10 ms * 2^n intervals
+ * no randomization 
+ */
+uint8_t mqttreconnect() {
+	uint16_t timer=10;
+	uint8_t reconnect=0;
+
+/* all good and nothing to be done, we are connected */
+	if (bmqtt.connected()) return 1;
+
+/* try to reconnect the network */
+  if (!netconnected()) { netreconnect(); bdelay(5000); }
+  if (!netconnected()) return 0;
+	
+/* create a new random name right now */
+	mqttsetname();
+
+/* try to reconnect assuming that the network is connected */
+	while (!bmqtt.connected() && timer < 400) {
+    if (*mqtt_user == 0) {
+      bmqtt.connect(mqttname);
+    } else {
+      bmqtt.connect(mqttname, mqtt_user, mqtt_passwd);
+    }
+		bmqtt.connect(mqttname);
+		bdelay(timer);
+		timer=timer*2;
+    reconnect=1;
+	}
+
+/* after reconnect resubscribe if there is a valid topic */
+	if (*mqtt_itopic && bmqtt.connected() && reconnect) bmqtt.subscribe(mqtt_itopic);
+ 
+	return bmqtt.connected();
+}
+
+/* mqtt state information */
+uint8_t mqttstate() {
+	return bmqtt.state();
+}
+
+/* subscribing to a topic  */
+void mqttsubscribe(const char* t) {
+	uint16_t i;
+
+	for (i=0; i<MQTTLENGTH; i++) {
+		if ((mqtt_itopic[i]=t[i]) == 0 ) break;
+	}
+	if (!mqttreconnect()) {ioer=1; return;};
+	if (!bmqtt.subscribe(mqtt_itopic)) ioer=1;
+}
+
+void mqttunsubscribe() {
+	if (!mqttreconnect()) {ioer=1; return;};
+	if (!bmqtt.unsubscribe(mqtt_itopic)) ioer=1;
+	*mqtt_itopic=0;
+}
+
+/*
+ * set the topic we pushlish, coming from OPEN
+ * BASIC can do only one topic.
+ * 
+ */
+void mqttsettopic(const char *t) {
+	uint16_t i;
+
+	for (i=0; i<MQTTLENGTH; i++) {
+		if ((mqtt_otopic[i]=t[i]) == 0 ) break;
+	}
+}
+
+/* 
+ *	print a mqtt message 
+ *  we buffer until we reach either cr or until the buffer is full
+ *	this is needed to do things like PRINT A,B,C as one message
+ */
+void mqttouts(const char *m, uint16_t l) {
+	uint16_t i=0;
+
+	while(mqtt_charsforsend < MQTTBLENGTH && i<l) mqtt_obuffer[mqtt_charsforsend++]=m[i++];
+	if (mqtt_obuffer[mqtt_charsforsend-1] == '\n' || mqtt_charsforsend > MQTTBLENGTH) {
+		if (!mqttreconnect()) {ioer=1; return;};
+		if (!bmqtt.publish(mqtt_otopic, (uint8_t*) mqtt_obuffer, (unsigned int) mqtt_charsforsend-1, false)) ioer=1;
+		mqtt_charsforsend=0;
+	}
+} 
+
+/* the write command is simple */
+void mqttwrite(const char c) { mqttouts(&c, 1); }
+
+/* return the messagelength as avail */
+uint16_t mqttavailable() {
+    return mqtt_messagelength;
+}
+
+/* checkch is just a dummy */
+char mqttcheckch() {
+    if (mqtt_messagelength>0) return mqtt_buffer[0]; else return 0;
+}
+
+/* 
+ * ins copies the buffer into a basic string 
+ *  - behold the jabberwock - length gynmastics 
+ */
+uint16_t mqttins(char *b, uint16_t nb) {
+  uint16_t z;
+  
+	for (z=0; z<nb && z<mqtt_messagelength; z++) b[z+1]=mqtt_buffer[z];
+ 	b[0]=z;
+ 	mqtt_messagelength=0;
+ 	*mqtt_buffer=0;
+  return z;
+}
+
+/* just one character to emulate basic get */
+char mqttread() {
+	char ch=0;
+	uint16_t i;
+
+	if (mqtt_messagelength>0) {
+		ch=mqtt_buffer[0];
+		for (i=0; i<mqtt_messagelength-1; i++) mqtt_buffer[i]=mqtt_buffer[i+1];
+    mqtt_messagelength--;
+	}
+	
+	return ch;
+}
+
+#else 
+void netbegin() {}
+uint8_t netconnected() { return 0; }
+void mqttbegin() {}
+uint8_t mqttstate() {return 0;}
+void mqttsubscribe(char *t) {}
+void mqttsettopic(char *t) {}
+void mqttouts(char *m, uint16_t l) {}
+uint16_t mqttins(char *b, uint16_t nb) { return 0; };
+char mqttread() {return 0;};
+#endif
+
+/* 
+ *	EEPROM handling, these function enable the @E array and 
+ *	loading and saving to EEPROM with the "!" mechanism
+ */ 
+void ebegin(){
+/* this is the EEPROM dummy */
+#if (defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32) ) && defined(ARDUINOEEPROM)
+  EEPROM.begin(EEPROMSIZE);
+#endif
+#if (defined(ARDUINO_ARCH_STM32)) && defined(ARDUINOEEPROM)
+  eeprom_buffer_fill();
+#endif
+#if (defined(ARDUINO_ARCH_XMC)) && defined(ARDUINOEEPROM)
+  EEPROM.begin();
+#endif
+#if (defined(ARDUINO_ARCH_SAMD)) && defined(ARDUINOEEPROM)
+/* no begin method needed */
+#endif
+#if (defined(ARDUINO_ARCH_MBED_NANO)) && defined(ARDUINOEEPROM)
+  EEPROM.begin();
+#endif
+/* an unbuffered EEPROM, typically used to store a program */
+#if defined(ARDUINOI2CEEPROM) && !defined(ARDUINOI2CEEPROM_BUFFERED)
+/* 
+ * we test the size with a heuristic, but beware, EEPROM addressing
+ * is circular. We only consider the two most common sizes, 4096 and 32768.
+ * This is tricky.
+ */
+
+#ifndef I2CEEPROMSIZE
+  int c4=eread(4094);
+  int c32=eread(32766);
+  eupdate(4094, 42);
+  eupdate(32766, 84);
+  if (ioer !=0 ) return;
+  if (eread(32766) == 84 && eread(4094) == 42) i2ceepromsize = 32767; else i2ceepromsize = 4096;
+  eupdate(4094, c4);
+  eupdate(32766, c32);  
+#else
+  i2ceepromsize = I2CEEPROMSIZE;
+#endif
+#endif
+/* there also can be a raw EFS object */
+#if defined(ARDUINOI2CEEPROM) && defined(ARDUINOI2CEEPROM_BUFFERED)
+  EFSRAW.begin();
+#ifndef I2CEEPROMSIZE
+  i2ceepromsize = EFSRAW.esize();
+#else
+  i2ceepromsize = I2CEEPROMSIZE;
+#endif
+#endif
+} 
+
+void eflush(){
+/* code for the EEPROM dummy */
+#if (defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32) || \
+    defined(ARDUINO_ARCH_XMC) || defined(ARDUINO_ARCH_SAMD)) \
+    && defined(ARDUINOEEPROM) 
+  EEPROM.commit();
+#endif 
+#if (defined(ARDUINO_ARCH_STM32)) && defined(ARDUINOEEPROM) 
+  eeprom_buffer_flush();
+#endif
+/* flushing the I2C EEPROM */
+#if defined(ARDUINOI2CEEPROM) && defined(ARDUINOI2CEEPROM_BUFFERED)
+  EFSRAW.rawflush();
+#endif
+}
+
+#if defined(ARDUINOEEPROM) && !defined(ARDUINOI2CEEPROM)
+uint16_t elength() { 
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+  return EEPROMSIZE;
+#endif
+#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR) || defined(ARDUINO_ARCH_XMC) || \
+    defined(ARDUINO_ARCH_STM32) || defined(ARDUINO_ARCH_RENESAS) || defined(ARDUINO_ARCH_SAMD)
+  return EEPROM.length(); 
+#endif
+#ifdef ARDUINO_ARCH_LGT8F 
+  return EEPROM.length();
+#endif
+  return 0;
+}
+
+void eupdate(uint16_t a, int8_t c) { 
+#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)|| defined(AARDUINO_ARCH_LGT8F) || \
+    defined(ARDUINO_ARCH_XMC) || defined(ARDUINO_ARCH_SAMD)
+  EEPROM.write(a, c);
+#else
+#if defined(ARDUINO_ARCH_STM32)
+  eeprom_buffered_write_byte(a, c);
+#else
+  EEPROM.update(a, c); 
+#endif
+#endif
+}
+
+int8_t eread(uint16_t a) { 
+#ifdef ARDUINO_ARCH_STM32
+  return (int8_t) eeprom_buffered_read_byte(a); 
+#else
+  return (int8_t) EEPROM.read(a); 
+#endif
+}
+#else 
+#if defined(ARDUINOI2CEEPROM)
+uint16_t elength() { 
+  return i2ceepromsize;
+}
+
+void eupdate(uint16_t a, int8_t c) { 
+#if defined(ARDUINOI2CEEPROM_BUFFERED)
+  EFSRAW.rawwrite(a, c);
+#else
+/* go directly into the EEPROM */
+  if (eread(a) != c) {
+  /* set the address and send the byte*/
+
+/*
+    Wire.beginTransmission(I2CEEPROMADDR);
+    Wire.write((int)a/256);
+    Wire.write((int)a%256);
+    Wire.write((int)c);
+    ioer=Wire.endTransmission();
+*/
+    wirestart(I2CEEPROMADDR, 0);
+    wirewritebyte((int)a/256);
+    wirewritebyte((int)a%256);
+    wirewritebyte((int)c);
+    ioer=wirestop();
+
+  /* wait the max time */
+    bdelay(5);
+  }
+#endif
+}
+
+int8_t eread(uint16_t a) { 
+#ifdef ARDUINOI2CEEPROM_BUFFERED
+  return (int8_t) EFSRAW.rawread(a); 
+#else
+/* read directly from the EEPROM */
+
+/* set the address */
+  wirestart(I2CEEPROMADDR, 0);
+  wirewritebyte((int)a/256);
+  wirewritebyte((int)a%256);
+  ioer=wirestop();
+  
+/* read a byte */
+  if (ioer == 0) {
+    wirestart(I2CEEPROMADDR, 1);
+    return wirereadbyte();
+  } else return 0;
+ 
+#endif
+}
+#else
+/* no EEPROM present */
+uint16_t elength() { return 0; }
+void eupdate(uint16_t a, int8_t c) { return; }
+int8_t eread(uint16_t a) { return 0; }
+#endif
+#endif
+
+/*
+ * A set of function to directly accessing IO ports. This is 
+ * hardware dependend and needs to be implemented for each
+ * platform.
+ *  
+ * Unfinished code right now, test code for the UNO.
+ */
+#if defined(ARDUINO_AVR_UNO) || defined(ARDUINO_AVR_DUEMILANOVE) || defined(ARDUINO_AVR_NANO)
+void portwrite(uint8_t p, int v) { 
+  switch (p) {
+    case 0: PORTB = v; break;
+    case 1: PORTC = v; break;
+    case 2: PORTD = v; break; 
+    default: break;
+  }
+}
+int portread(uint8_t p) { 
+  switch (p) {
+    case 0: return PORTB; break;
+    case 1: return PORTC; break;
+    case 2: return PORTD; break; 
+    default: return 0;
+  }
+}
+void ddrwrite(uint8_t p, int v) { 
+  switch (p) {
+    case 0: DDRB = v; break;
+    case 1: DDRC = v; break;
+    case 2: DDRD = v; break; 
+    default: break;
+  }
+}
+int ddrread(uint8_t p) { 
+  switch (p) {
+    case 0: return DDRB; break;
+    case 1: return DDRC; break;
+    case 2: return DDRD; break; 
+    default: return 0;
+  }
+}
+int pinread(uint8_t p) { 
+  switch (p) {
+    case 0: return PINB; break;
+    case 1: return PINC; break;
+    case 2: return PIND; break; 
+    default: return 0;
+  }
+}
+#else
+void portwrite(uint8_t p, int v) {}
+int portread(uint8_t p) { return 0; }
+void ddrwrite(uint8_t p, int v) {}
+int ddrread(uint8_t p) { return 0; }
+int pinread(uint8_t p) { return 0; }
+#endif
+
+/* 
+ *	the wrappers of the arduino io functions
+ *  awrite requires ESP32 2.0.2 core, else disable awrite() 
+ */ 
+
+uint16_t aread(uint8_t p) { return analogRead(p); }
+uint8_t dread(uint8_t p) { return digitalRead(p); }
+void awrite(uint8_t p, uint16_t v){ analogWrite(p, v); }
+void dwrite(uint8_t p, uint8_t v){ if (v) digitalWrite(p, HIGH); else digitalWrite(p, LOW); }
+
+/* we normalize the pinMode as ESP32, ESP8266, and other boards behave rather
+ *  differently. Following Arduino conventions we map 0 always to INPUT  
+ *  and 1 always to OUTPUT, all the other numbers are passed through to the HAL 
+ *  layer of the platform.
+ *  Example: OUTPUT on ESP32 is 3 and 1 is assigned to INPUT.
+ *  XMC also needs special treatment here.
+ *  uint8_t is here for a reason.
+ */
+void pinm(uint8_t p, uint8_t m){
+  if (m == 0) m=INPUT; 
+  else if (m == 1) m=OUTPUT;
+  pinMode(p,m);
+}
+
+/* wrapper around pulsein */
+uint32_t pulsein(uint8_t pin, uint8_t val, uint32_t t) { 
+  return pulseIn(pin, val, t);
+}
+
+/* write a pulse in microsecond range */
+void pulseout(uint16_t unit, uint8_t pin, uint16_t duration, uint16_t val, uint16_t repetition, uint16_t interval) { 
+  
+  pinMode(pin, OUTPUT);
+  while (repetition--) {
+    digitalWrite(pin, val);
+    delayMicroseconds(duration*unit);
+    digitalWrite(pin, !val);
+    delayMicroseconds(interval*unit);
+  }
+}
+
+/* the BREAKPIN mechanism */
+#if defined(BREAKPIN) && defined(INPUT_PULLUP)
+void breakpinbegin() { pinm(BREAKPIN, INPUT_PULLUP); }
+uint8_t getbreakpin() { return dread(BREAKPIN); } 
+#else 
+/* there is no pins hence no breakpin */
+void breakpinbegin() {}
+uint8_t getbreakpin() { return 1; } /* we return 1 because the breakpin is defined INPUT_PULLUP */
+#endif
+
+
+/*
+ * A tone emulation based on the byield loop. The maximum frequency depends 
+ * on the byield call speed. 10-20 kHz is possible. Will be unreliable if 
+ * the loop functions need a lot of CPU cycles.
+ */
+#if defined(ARDUINOTONEEMULATION)
+uint8_t tone_enabled;
+uint8_t tone_pinstate = 0;
+uint32_t tone_intervall;
+uint32_t tone_micros;
+uint16_t tone_duration;
+uint32_t tone_start;
+uint8_t tone_pin;
+
+void playtone(uint8_t pin, uint16_t frequency, uint16_t duration, uint8_t volume) {
+
+/* the pin we are using is reset every time this is called*/
+  tone_pin=pin;
+  pinMode(tone_pin, OUTPUT);
+  digitalWrite(tone_pin, LOW);
+  tone_pinstate=0;
+
+/* duration 0 is a long tone */
+  if (duration == 0) duration=32767;
+
+/* frequency 0 stops playing */ 
+  if (frequency == 0) {
+    tone_enabled=0;
+    return;
+  }
+
+/* calculate the toggle intervall in micros and remember where we are */
+  tone_intervall=1000000/frequency/2;
+  tone_micros=micros();
+
+/* set the duration and remember where we are*/
+  tone_duration=duration;
+  tone_start=millis();
+
+/* start the play */
+  tone_enabled=1;
+}
+
+void tonetoggle() {
+
+/* is this active? */
+  if (!tone_enabled) return;
+
+/* check if we are done playing */
+  if (millis() > tone_duration+tone_start) {
+    tone_enabled=0;
+    digitalWrite(tone_pin, LOW);
+    tone_pinstate=0;
+    return;
+  }
+
+/* if not, check if the intervall is over */
+  if (micros() > tone_intervall+tone_micros) {
+    tone_micros=micros();
+    tone_pinstate=!tone_pinstate;
+    digitalWrite(tone_pin, tone_pinstate);
+  }
+}
+#elif defined(ARDUINO_TTGO_T7_V14_Mini32) && defined(PS2FABLIB)
+/* fabGL soundgenerator code of suggestes by testerrossa
+ * pin numbers below 128 are real arduino pins while 
+ * pin numvers from 128 onwards are sound generator capabilities
+ * this is different from the original code
+ * 
+ * Sound generator capabilities are numbered as follows
+ * 128: Sine wave 
+ * 129: Symmetric square wave 
+ * 130: Sawtooth
+ * 131: Triangle
+ * 132: VIC noise
+ * 133: noise
+ *
+ * 256-511: square wave with variable duty cycle
+ * 
+ */
+void playtone(uint8_t pin, uint16_t frequency, uint16_t duration, uint8_t volume) {
+
+/* frequency 0 is off */
+  if (frequency == 0) {
+    soundGenerator.play(false);
+    soundGenerator.clear();
+    return;
+  } 
+
+/* duration 0 is a long tone */
+  if (duration == 0) duration=60000;
+  
+  if (pin == 128) soundGenerator.playSound(SineWaveformGenerator(), frequency, duration, volume); 
+  if (pin == 129) soundGenerator.playSound(SquareWaveformGenerator(), frequency, duration, volume);
+  if (pin == 130) soundGenerator.playSound(SawtoothWaveformGenerator(), frequency, duration, volume);
+  if (pin == 131) soundGenerator.playSound(TriangleWaveformGenerator(), frequency, duration, volume); 
+  if (pin == 132) soundGenerator.playSound(VICNoiseGenerator(), frequency, duration, volume);
+  if (pin == 133) soundGenerator.playSound(NoiseWaveformGenerator(), frequency, duration, volume);
+  if (pin >= 255 && pin < 512 ) {
+      pin=pin-255;
+      SquareWaveformGenerator sqw;
+      sqw.setDutyCycle(pin);
+      soundGenerator.playSound(sqw, frequency, duration, volume); 
+  }
+}
+#else 
+/* playtone is just a wrapper around tone and noTone */
+void playtone(uint8_t pin, uint16_t frequency, uint16_t duration, uint8_t volume) {
+  if (frequency == 0) {
+    noTone(pin);
+  } else if (duration == 0) {
+    tone(pin, frequency);
+  } else {
+    tone(pin, frequency, duration);
+  }
+}
+#endif
+
+/* 
+ *	The byield function is called after every statement
+ *	it allows two 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. 
+ *
+ * 	LONGYIELDINTERVAL by default is 1000, generating a one second
+ *		call to maintenance functions. 
+ */
+
+uint32_t lastyield=0;
+uint32_t lastlongyield=0;
+int countfasttick = 0;
+
+void byield() { 
+
+/* the fast ticker for all fast timing functions */
+  fastticker();
+
+/* the loop function for non BASIC stuff */
+  bloop();
+
+#if defined(BASICBGTASK)
+/* what time is it, call millis only once */
+  long m=millis();
+
+/* yield all 32 milliseconds */
+
+  if (m-lastyield > YIELDINTERVAL-1) {
+    yieldfunction();
+    lastyield=m;
+  }
+
+/* yield every second */
+  if (m-lastlongyield > LONGYIELDINTERVAL-1) {
+    longyieldfunction();
+    lastlongyield=m;
+  }
+ #endif
+ 
+ /* call the background task scheduler on some platforms implemented in hardware-* */
+
+}
+
+/* delay must be implemented to use byield() while waiting */
+void bdelay(uint32_t t) { 
+  unsigned long i;
+  if (t>0) {
+    i=millis();
+    while (millis() < i+t) byield();
+  } 
+}
+
+/* 
+ * This code measures the fast ticker frequency in microseconds 
+ * It leaves the data in variable F. Activate this only for test 
+ * purposes.
+ */
+
+#ifdef FASTTICKERPROFILE
+int avgfastticker() {
+  return countfasttick;
+}
+
+void clearfasttickerprofile() {
+  countfasttick=0;
+}
+#endif
+
+
+/* fastticker is the hook for all fast timing functions */
+void fastticker() {
+/* fastticker profiling test code */
+#if defined(FASTTICKERPROFILE)
+  countfasttick++;
+#endif
+/* toggle the tone pin */
+#ifdef ARDUINOTONEEMULATION
+  tonetoggle();
+#endif
+}
+
+/* everything that needs to be done often - 32 ms */
+void yieldfunction() {
+#ifdef ARDUINOMQTT
+  bmqtt.loop();
+#endif
+#ifdef ARDUINOUSBKBD
+  usb.Task();
+#endif
+#ifdef ARDUINOZX81KBD
+  (void) keyboard.peek(); /* scan once and set lastkey properly every 32 ms */
+#endif
+/* delay(0) is only needed on ESP8266! it calls the scheduler - no bdelay here!! */
+#if defined(ARDUINO_ARCH_ESP8266)
+ delay(0);
+#endif
+}
+
+/* everything that needs to be done not so often - 1 second */
+void longyieldfunction() {
+#ifdef ARDUINOETH
+  Ethernet.maintain();
+#endif 
+#ifdef BREAKINBACKGROUND
+  if (checkch() == BREAKCHAR) breakcondition=1;
+#endif
+}
+
+/* 
+ *	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
+ */
+
+/* typical file name length */
+#define FBUFSIZE 32
+ 
+#if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(ESP32FAT) || defined(STM32SDIO) ||defined(ESPSDMMC)
+File ifile;
+File ofile;
+char tempname[FBUFSIZE]; /* this is needed for the catalog code as these platforms do not give static C strings back */
+#if defined(ARDUINOSD) || defined(STM32SDIO) ||defined(ESPSDMMC)
+File root;
+File file;
+#ifdef ARDUINO_ARCH_ESP32
+const char rootfsprefix[2] = "/";
+#else
+const char rootfsprefix[1] = "";
+#endif
+#endif
+#if defined(ESPSPIFFS) || defined(ESP32FAT)
+const char rootfsprefix[2] = "/";
+#ifdef ARDUINO_ARCH_ESP8266
+Dir root;
+File file;
+#endif
+#ifdef ARDUINO_ARCH_ESP32
+File root;
+File file;
+#endif
+#endif
+#ifdef ARDUINO_ARCH_ESP8266
+/* #define FILE_OWRITE (O_READ | O_WRITE | O_CREAT | O_TRUNC) */
+/* this is the ESP8266 definition for kernel 3.0, 3.1 has fixed this */
+#define FILE_OWRITE (sdfat::O_READ | sdfat::O_WRITE | sdfat::O_CREAT | sdfat::O_TRUNC)
+#else 
+#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_STM32)
+#define FILE_OWRITE FILE_WRITE
+#else 
+#define FILE_OWRITE (O_READ | O_WRITE | O_CREAT | O_TRUNC)
+#endif
+#endif
+#endif
+
+/* using the POSIX API in LittleFS */
+#ifdef RP2040LITTLEFS
+#define FILESYSTEMDRIVER
+FILE* ifile;
+FILE* ofile;
+DIR* root;
+struct dirent* file;
+LittleFS_MBED *myFS;
+const char rootfsprefix[10] = MBED_LITTLEFS_FILE_PREFIX;
+#endif
+
+/* 
+ * the API of the USB filesystem on GIGA and Portenta. 
+ * Looks like LITTLEFS. Pointers to the objects msd and usb are used and 
+ * allocation is postponed to fsbegin(). This was done to try to get the code 
+ * restartable, but it doesn't really work. Still, using the pointers
+ * is cleaner and more C++ish.
+ */
+#ifdef GIGAUSBFS
+#define FILESYSTEMDRIVER
+USBHostMSD* msdp;
+mbed::FATFileSystem* usbp;
+FILE* ifile;
+FILE* ofile;
+DIR* root;
+struct dirent *file;
+const char rootfsprefix[10] = "/usb/";
+#endif
+
+/* use EEPROM as filesystem */
+#ifdef ARDUINOEFS
+byte ifile;
+byte ofile;
+byte file;
+#endif
+
+/* the buildin file system for ro access */
+#ifdef HASBUILDIN
+char* buildin_ifile = 0;
+uint16_t buildin_ifilepointer = 0;
+char* buildin_file = 0;
+char* buildin_pgm = 0;
+uint8_t buildin_rootactive = 0;
+uint16_t buildin_rootpointer = 0;
+char buildin_tempname[FBUFSIZE]; /* this is needed for the catalog code as strings need to be copied from progmem */
+#endif
+
+
+/* these filesystems may have a path prefixes, we treat STM32SDIO like an SD here */
+#if defined(RP2040LITTLEFS) || defined(ESPSPIFFS) || defined(ESP32FAT) || defined(ARDUINOSD) || defined(GIGAUSBFS) || defined(ESPSDMMC)
+char tmpfilename[10+FBUFSIZE];
+
+/* add the prefix to the filename */
+char* mkfilename(const char* filename) {
+	uint8_t i,j;
+	for(i=0; i<10 && rootfsprefix[i]!=0; i++) tmpfilename[i]=rootfsprefix[i];
+	tmpfilename[i++]='/';
+	for(j=0; j<FBUFSIZE && filename[j]!=0; j++) tmpfilename[i++]=filename[j];
+	tmpfilename[i]=0;
+	return tmpfilename;
+}
+
+/* remove the prefix from the filename */
+const char* rmrootfsprefix(const char* filename) {
+	uint8_t i=0;
+	while (filename[i] == rootfsprefix[i] && rootfsprefix[i] !=0 && filename[i] !=0 ) i++;
+	if (filename[i]=='/') i++;
+	return &filename[i];
+}
+#endif
+
+/* 
+ *	filesystem starter for SPIFFS and SD on ESP, ESP32 and Arduino plus LittleFS
+ *  and then also GIGAUSBFS
+ *	the verbose option needs to be checked .
+ *  
+ *  Also here the driver for the buildin file system.
+ * 
+ * if SDPIN is empty it is the standard SS pin of the platfrom
+ * 
+ */
+
+uint8_t fsstart;
+ 
+void fsbegin() {
+#ifdef ARDUINOSD 
+#ifndef SDPIN
+#define SDPIN
+#endif
+  if (SD.begin(SDPIN)) fsstart=1; else fsstart=0;	
+#endif
+#ifdef STM32SDIO
+  static int fsbegins = 0;
+  while (fsbegins<100) { 
+    if (SD.begin(SD_DETECT_PIN)) { fsstart=1; break; } else fsstart=0;
+    bdelay(20); 
+    fsbegins++;
+  } 
+#endif
+#if defined(ESPSPIFFS) && defined(ARDUINO_ARCH_ESP8266) 
+ 	if (SPIFFS.begin()) fsstart=1; else fsstart=0;
+#endif
+#if defined(ESPSPIFFS) && defined(ARDUINO_ARCH_ESP32) 
+ 	if (SPIFFS.begin()) fsstart=1; else fsstart=0;
+#endif
+#if defined(ESP32FAT) && defined(ARDUINO_ARCH_ESP32)
+  if (FFat.begin()) fsstart=1; else fsstart=0;
+#endif
+#if defined(ESPSDMMC) && defined(ARDUINO_ARCH_ESP32)
+  if (SD_MMC.begin()) fsstart=1; else fsstart=0;
+#endif
+#ifdef RP2040LITTLEFS
+	myFS = new LittleFS_MBED();
+	if (myFS->init()) fsstart=1; else fsstart=0;
+#endif
+#ifdef GIGAUSBFS
+  static int fsbegins = 0;
+  int usbfsstat;
+  if (RTDEBUG) consolelog("Starting USB file system.\n");
+/* power up the USB A port */
+  pinMode(PA_15, OUTPUT);
+  if (RTDEBUG) consolelog("Power down USB port.\n");
+  digitalWrite(PA_15, LOW); 
+  bdelay(100);
+  if (RTDEBUG) consolelog("Power up USB port.\n");
+  digitalWrite(PA_15, HIGH);
+  bdelay(100);
+
+/* delete old objects */
+  if (msdp) delete msdp;
+  if (usbp) delete usbp;
+
+ /* create the msdp and the filesystem object */ 
+  msdp=new USBHostMSD();
+  usbp=new mbed::FATFileSystem("usb"); 
+
+/* connect and mount */
+  while(!msdp->connect() && fsbegins++ < 10) { bdelay(500); }
+  if (msdp->connected()) {
+    if (RTDEBUG) { consolelog("msd connected\n"); } 
+    usbfsstat=usbp->mount(msdp);
+    if (RTDEBUG) {
+      consolelog("USB mount status is "); 
+      consolelognum(usbfsstat);
+      consolelog("\n");
+    }
+    fsstart=!usbfsstat;
+  } else {
+    if (RTDEBUG) { consolelog("msd not connected\n"); } 
+    fsstart=0;
+  }
+  
+  if (RTDEBUG) { consolelog("fsstart is: "); consolelognum(fsstart); 
+      consolelog("\n"); }
+#endif
+#ifdef ARDUINOEFS
+	uint8_t s=EFS.begin();
+	if (s>0) {
+		fsstart=s;
+	} else {
+		if (EFS.format(32)) fsstart=32; else fsstart=0;;
+	}
+#endif
+#ifdef HASBUILDIN
+/* hopefully nothing to be done */
+#endif
+}
+
+/* 
+ *  Maps information of the start of the filesystem to 
+ *  the USR(16,x) call. USR(16,0) checks if a filesystem is 
+ *  present and USR(16,1) checks if the filesystem has been mounted.
+ */
+uint8_t fsstat(uint8_t c) { 
+#if defined(FILESYSTEMDRIVER)
+  if (c == 0) return 1;
+  if (c == 1) return fsstart;
+#endif
+  return 0;
+}
+
+/*
+ *	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 defined(ARDUINOSD) || defined(ESPSPIFFS)||defined(ESP32FAT)||defined(STM32SDIO)|| defined(ESPSDMMC)
+	if (ofile) { ofile.write(c); return; }
+#endif
+#if defined(RP2040LITTLEFS) || defined(GIGAUSBFS)
+	if (ofile) { fputc(c, ofile); return; }
+#endif
+#if defined(ARDUINOEFS)
+	if (ofile) { 
+    if (!EFS.fputc(c, ofile)) ioer=-1; 
+    return;
+  }
+#endif
+/* if there is no open ofile, set the ioerror flag to notify BASIC about it */
+  ioer=1;
+}
+
+char fileread() {
+	char c;
+
+/* the buildin file is active, we handle this first, else we allow for another FS */
+#if defined(HASBUILDIN)
+  if (buildin_ifile != 0) { 
+    c=pgm_read_byte(buildin_ifile+buildin_ifilepointer);
+    if (c != '\f') buildin_ifilepointer++; else { ioer=-1; c=255; }
+    return c;
+  }
+#endif
+#if defined(ARDUINOSD) || defined(ESPSPIFFS)||defined(ESP32FAT)||defined(STM32SDIO) || defined(ESPSDMMC)
+	if (ifile) c=ifile.read(); else { ioer=1; return 0; }
+	if (c == -1 || c == 255) ioer=-1;
+	return c;
+#endif
+#if defined(RP2040LITTLEFS)||defined(GIGAUSBFS)
+	if (ifile) c=fgetc(ifile); else { ioer=1; return 0; }
+	if (c == -1 || c == 255) ioer=-1;
+	return c;
+#endif
+#ifdef ARDUINOEFS
+	if (ifile) c=EFS.fgetc(ifile); else { ioer=1; return 0; }
+	if (c == -1|| c == 255) ioer=-1;
+	return c;
+#endif
+	return 0;
+}
+
+int fileavailable(){
+/* for the buildin file \f is the end of file, return true is it has not been reached */
+#if defined(HASBUILDIN)
+  char c;
+  if (buildin_ifile != 0) { 
+    c=pgm_read_byte(buildin_ifile+buildin_ifilepointer);
+    if (c != '\f') return 1; else return 0;
+  }
+#endif
+#if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(ESP32FAT) || defined(STM32SDIO) || defined(ESPSDMMC)
+	return ifile.available();
+#endif
+#if defined(RP2040LITTLEFS) || defined(GIGAUSBFS)
+	return !feof(ifile);
+#endif
+#ifdef ARDUINOEFS
+	return EFS.available(ifile);
+#endif
+	return 0;
+}
+
+uint8_t ifileopen(const char* filename){
+/* we first try to open a file on the builin file system, then of the other ones */
+#if defined(HASBUILDIN)
+  byte i, file;
+  char* name;
+
+/* opening a new file */
+  buildin_ifilepointer=0;
+  buildin_ifile=0;
+
+  file=0;
+  while(1) {
+
+/* find a name in progmem, 0 if no more name */
+    name=(char*)pgm_read_ptr(&buildin_program_names[file]);    
+    if (name == 0) break;
+
+/* compare the name with the filename */  
+    for(i=0;i<32;i++) {
+    char c=pgm_read_byte(&name[i]);
+
+/* we are at the end of the name, if filename is also ending, we got it */
+      if (c == 0 && filename[i] == 0) {
+        buildin_ifile=(char*)pgm_read_ptr(&buildin_programs[file]);
+        return (buildin_ifile != 0);
+      }
+
+/* a character mismatch means we need to go to the next name */
+      if (c != filename[i]) {
+          file++;
+          break;  
+      }
+    }
+  }
+#endif
+/*
+ * All filesystems that are not buildin are checked for correct open
+ * This is needed for GIGA as the USB host tends to block.
+ */
+  if (!fsstart) return 0;
+
+#if defined(ARDUINOSD)
+	ifile=SD.open(mkfilename(filename), FILE_READ);
+	return ifile != 0;
+#endif
+#ifdef ESPSDMMC
+  ifile=SD_MMC.open(mkfilename(filename), FILE_READ);
+  return ifile != 0;
+#endif
+#if defined(STM32SDIO)
+  ifile=SD.open(filename);
+  return ifile != 0;
+#endif
+#ifdef ESPSPIFFS
+	ifile=SPIFFS.open(mkfilename(filename), "r");
+	return ifile != 0;
+#endif
+#ifdef ESP32FAT
+  ifile=FFat.open(mkfilename(filename), "r"); 
+  return ifile != 0;
+#endif
+#if defined(RP2040LITTLEFS) || defined(GIGAUSBFS)
+	ifile=fopen(mkfilename(filename), "r");
+	return ifile != 0;
+#endif
+#ifdef ARDUINOEFS
+	ifile=EFS.fopen(filename, "r");
+	return ifile != 0;
+#endif
+	return 0;
+}
+void ifileclose(){
+#if defined(HASBUILDIN)
+  if (buildin_ifile) {
+    buildin_ifile=0;
+    buildin_ifilepointer=0;   
+  }
+#endif
+#if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(ESP32FAT) || defined(STM32SDIO) || defined(ESPSDMMC)
+	if (ifile) ifile.close();
+#endif	
+#if defined(RP2040LITTLEFS) || defined(GIGAUSBFS)
+	if (ifile) fclose(ifile);
+#endif
+#ifdef ARDUINOEFS
+	if (ifile) EFS.fclose(ifile);	
+#endif
+
+}
+
+uint8_t ofileopen(const char* filename, const char* m){
+
+/*
+ * All filesystems that are not buildin are checked for correct open
+ * This is needed for GIGA as the USB host tends to block.
+ */
+  if (!fsstart) return 0;
+    
+#if defined(ARDUINOSD) 
+	if (*m == 'w') ofile=SD.open(mkfilename(filename), FILE_OWRITE);
+/* ESP32 has FILE_APPEND defined */
+#ifdef FILE_APPEND
+  if (*m == 'a') ofile=SD.open(mkfilename(filename), FILE_APPEND);
+#else
+	if (*m == 'a') ofile=SD.open(mkfilename(filename), FILE_WRITE);
+#endif
+	return ofile != 0;
+#endif
+#if defined(ESPSDMMC) 
+  if (*m == 'w') ofile=SD_MMC.open(mkfilename(filename), FILE_OWRITE);
+/* ESP32 has FILE_APPEND defined */
+#ifdef FILE_APPEND
+  if (*m == 'a') ofile=SD_MMC.open(mkfilename(filename), FILE_APPEND);
+#else
+  if (*m == 'a') ofile=SD_MMC.open(mkfilename(filename), FILE_WRITE);
+#endif
+  return ofile != 0;
+#endif
+#if  defined(STM32SDIO)
+  if (*m == 'w') ofile=SD.open(filename, FILE_OWRITE);
+/* ESP32 has FILE_APPEND defined */
+#ifdef FILE_APPEND
+  if (*m == 'a') ofile=SD.open(filename, FILE_APPEND);
+#else
+  if (*m == 'a') ofile=SD.open(filename, FILE_WRITE);
+#endif
+  return ofile != 0;
+#endif
+#ifdef ESPSPIFFS
+	ofile=SPIFFS.open(mkfilename(filename), m);
+	return ofile != 0;
+#endif
+#ifdef ESP32FAT
+  ofile=FFat.open(mkfilename(filename), m);
+  return ofile != 0;
+#endif
+#if defined(RP2040LITTLEFS) || defined(GIGAUSBFS)
+	ofile=fopen(mkfilename(filename), m);
+	return ofile != 0; 
+#endif
+#ifdef ARDUINOEFS
+	ofile=EFS.fopen(filename, m);
+	return ofile != 0; 
+#endif
+/* if no other filesystem has satisfied the write open BUILDIN reports the error */
+#if defined(HASBUILDIN)
+  ioer=-1;
+  return 0;
+#endif
+	return 0;
+}
+
+void ofileclose(){
+#if defined(ARDUINOSD) || defined(ESPSPIFFS)||defined(ESP32FAT)|| defined(STM32SDIO) || defined(ESPSDMMC)
+  if (ofile) ofile.close();
+#endif
+#if defined(RP2040LITTLEFS) || defined(GIGAUSBFS)
+	if (ofile) fclose(ofile); 
+#endif
+#ifdef ARDUINOEFS
+	if (ofile) EFS.fclose(ofile); 
+#endif	
+}
+
+/*
+ * 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()
+ */
+void rootopen() {
+/* we first open the buildin and remember we are processing it, if there is another root, we also open it */
+#ifdef HASBUILDIN
+  buildin_rootpointer=0;
+  buildin_rootactive=1;
+#endif
+/*
+ * All filesystems that are not buildin are checked for correct open
+ * This is needed for GIGA as the USB host tends to block.
+ */
+  if (!fsstart) return;
+  
+#if defined(ARDUINOSD) || defined(STM32SDIO)
+	root=SD.open("/");
+#endif
+#if defined(ESPSDMMC)
+  root=SD_MMC.open("/");
+#endif
+#ifdef ESPSPIFFS
+#ifdef ARDUINO_ARCH_ESP8266
+	root=SPIFFS.openDir("/");
+#endif
+#ifdef ARDUINO_ARCH_ESP32
+	root=SPIFFS.open("/");
+#endif
+#endif
+#ifdef ESP32FAT
+  root=FFat.open("/");
+#endif
+#if defined(RP2040LITTLEFS) || defined(GIGAUSBFS)
+	root=opendir(rootfsprefix);
+#endif
+#ifdef ARDUINOEFS
+	EFS.dirp=0;
+#endif
+}
+
+uint8_t rootnextfile() {
+/* we first iterate through the buildins, then fall through to the other filesystems */
+#ifdef HASBUILDIN
+  if (buildin_rootactive) {
+    buildin_file=(char*)pgm_read_ptr(&buildin_program_names[buildin_rootpointer]);
+    if (buildin_file != 0) {
+      buildin_pgm=(char*)pgm_read_ptr(&buildin_programs[buildin_rootpointer]);
+      buildin_rootpointer++;
+      return 1;
+    } else {
+      buildin_rootactive=0;
+    }
+  }
+#endif
+/*
+ * All filesystems that are not buildin are checked for correct open
+ * This is needed for GIGA as the USB host tends to block.
+ */
+  if (!fsstart) return 0;
+  
+#if defined(ARDUINOSD) || defined(STM32SDIO)||defined(ESPSDMMC)
+	file=root.openNextFile();
+	return (file != 0);
+#endif
+#ifdef ESPSPIFFS
+#ifdef ARDUINO_ARCH_ESP8266
+  	if (root.next()) {
+    	file=root.openFile("r");
+    	return 1;
+  	} else {
+    	return 0;
+	}
+#endif
+#ifdef ARDUINO_ARCH_ESP32
+	file=root.openNextFile();
+	return (file != 0);
+#endif
+#endif
+#ifdef ESP32FAT
+#ifdef ARDUINO_ARCH_ESP32
+  file=root.openNextFile();
+  return (file != 0);
+#endif
+#endif
+#if defined(RP2040LITTLEFS) || defined(GIGAUSBFS)
+	file = readdir(root);
+	return (file != 0);
+#endif
+#ifdef ARDUINOEFS
+	file = EFS.readdir();
+	return (file != 0);
+#endif
+  return 0;
+}
+
+uint8_t rootisfile() {
+#ifdef HASBUILDIN
+  if (buildin_rootactive) return 1;
+#endif
+#if defined(ARDUINOSD) || defined(STM32SDIO) || defined(ESPSDMMC)
+	return (!file.isDirectory());
+#endif
+
+#ifdef ESPSPIFFS
+#ifdef ARDUINO_ARCH_ESP8266
+	return 1;
+#endif
+#ifdef ARDUINO_ARCH_ESP32
+	return (!file.isDirectory());
+#endif
+#endif
+#ifdef ESP32FAT
+#ifdef ARDUINO_ARCH_ESP32
+  return (!file.isDirectory());
+#endif
+#endif
+#if defined(RP2040LITTLEFS)||defined(GIGAUSBFS)
+	return (file->d_type == DT_REG);
+#endif
+#ifdef ARDUINOEFS
+	return 1;
+#endif	
+	return 0;
+}
+
+const char* rootfilename() {
+#ifdef HASBUILDIN
+  if (buildin_rootactive) {
+    for(int i=0; i<FBUFSIZE; i++) {
+      buildin_tempname[i]=(char)pgm_read_byte(&buildin_file[i]);
+      if (buildin_tempname[i] == 0) return buildin_tempname;
+    }
+  }
+#endif
+#if defined(ARDUINOSD) || defined(ESPSDMMC)
+  return rmrootfsprefix(file.name());
+#endif
+#if defined(STM32SDIO)
+  return (char*) file.name();
+#endif
+#ifdef ESPSPIFFS
+#ifdef ARDUINO_ARCH_ESP8266
+  int i=0;
+	String s=root.fileName();
+ 	for (i=0; i<s.length(); i++) tempname[i]=s[i];
+ 	tempname[i]=0;
+	return rmrootfsprefix(tempname);
+#endif
+#ifdef ARDUINO_ARCH_ESP32
+	return rmrootfsprefix(file.name());
+#endif
+#endif
+#ifdef ESP32FAT
+#ifdef ARDUINO_ARCH_ESP32
+  return rmrootfsprefix(file.name());
+#endif
+#endif
+#if defined(RP2040LITTLEFS)||defined(GIGAUSBFS)
+	return (file->d_name);
+#endif
+#ifdef ARDUINOEFS
+	return EFS.filename(file);
+#endif
+	return 0; 
+}
+
+uint32_t rootfilesize() {
+#ifdef HASBUILDIN
+  int i=0;
+  if (buildin_rootactive && buildin_pgm) {
+    for (;;i++) {
+      char ch=pgm_read_byte(&buildin_pgm[i]);
+      if (ch == 0) return i;
+    }
+  }
+#endif
+#if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(ESP32FAT) || defined(STM32SDIO) || defined(ESPSDMMC)
+  return file.size();
+#endif  
+#if defined(RP2040LITTLEFS)||defined(GIGAUSBFS)
+/* to be done */
+#endif
+#ifdef ARDUINOEFS
+	return EFS.filesize(file);
+#endif
+  return 0;
+}
+
+void rootfileclose() {
+#if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(ESP32FAT) || defined(STM32SDIO) || defined(ESPSDMMC)
+  file.close();
+#endif 
+#if defined(RP2040LITTLEFS) || defined(GIGAUSBFS)
+/* nothing to be done here as we work on dirents */
+#endif
+#ifdef ARDUINOEFS
+#endif
+}
+
+void rootclose(){
+#ifdef HASBUILDIN
+  buildin_rootactive=0;
+#endif
+#if defined(ARDUINOSD) || defined(STM32SDIO) || defined(ESPSDMMC)
+  root.close();
+#endif
+#ifdef ESPSPIFFS
+#ifdef ARDUINO_ARCH_ESP8266
+  return;
+#endif
+#ifdef ARDUINO_ARCH_ESP32
+  root.close();
+#endif
+#endif
+#ifdef ESP32FAT
+#ifdef ARDUINO_ARCH_ESP32
+  root.close();
+#endif
+#endif
+#ifdef RP2040LITTLEFS
+#endif
+#ifdef GIGAUSBFS
+  if (root) (void) closedir(root);
+#endif
+#ifdef ARDUINOEFS
+#endif
+}
+
+/*
+ * remove method for files
+ */
+void removefile(const char *filename) {
+#if defined(ARDUINOSD)	
+	SD.remove(mkfilename(filename));
+	return;
+#endif
+#if defined(ESPSDMMC)
+  SD_MMC.remove(mkfilename(filename));
+  return;
+#endif
+#if defined(STM32SDIO)  
+  SD.remove(filename);
+  return;
+#endif
+#ifdef ESPSPIFFS
+	SPIFFS.remove(mkfilename(filename));
+	return;
+#endif
+#ifdef ESP32FAT
+  FFat.remove(mkfilename(filename));
+  return;
+#endif
+#if defined(RP2040LITTLEFS) || defined(GIGAUSBFS)
+	remove(mkfilename(filename));
+	return;
+#endif
+#ifdef ARDUINOEFS
+	EFS.remove(filename);
+	return;
+#endif
+}
+
+/*
+ * formatting for fdisk of the internal filesystems
+ */
+void formatdisk(uint8_t i) {
+#if defined(ARDUINOSD) || defined(STM32SDIO)||defined(GIGAUSBFS) || defined(ESPSDMMC)
+  return;
+	return;
+#endif
+#ifdef ESPSPIFFS
+	if (SPIFFS.format()) { SPIFFS.begin(); fsstart=1; } else { fsstart=0; }
+#endif
+#ifdef ESP32FAT
+  FFat.end();
+  if (FFat.format()) { FFat.begin(); fsstart=1; } else { fsstart=0; }
+#endif
+#ifdef RP2040LITTLEFS
+  fs.reformat(&bd); /* bd: this comes from the header */
+	return;
+#endif
+#ifdef ARDUINOEFS
+	if (i>0) {
+		if (EFS.format(i)) { EFS.begin(); fsstart=1; } else { fsstart=0; }
+	} else ioer=1;
+	return;
+#endif
+}
+
+/* 
+ *  The buffer code, a simple buffer to store output and 
+ *  input data. It can be used as a device in BASIC using the 
+ *  modifier &0. 
+ */
+
+/* use the input buffer variable from BASIC here, it is extern to runtime */
+void bufferbegin() {}
+
+/* write to the buffer, works only until 127 
+  uses vt52 style commands to handle the buffer content*/
+void bufferwrite(char c) {
+  if (!nullbuffer) return;
+  switch (c) {
+  case 12: /* clear screen */
+    //nullbuffer[nullbuffer[0]+1]=0;
+    nullbuffer[0]=0;
+    nullbuffer[1]=0;
+    break;
+  case 10: 
+  case 13: /* cr and lf ignored */
+    break;
+  case 8: /* backspace */
+    if (nullbuffer[0]>0) nullbuffer[0]--;
+    break;
+  default:
+    if (nullbuffer[0] < nullbufsize-1 && nullbuffer[0] < 127) {
+      nullbuffer[++nullbuffer[0]]=c;
+      nullbuffer[nullbuffer[0]+1]=0; /* null terminate */
+    }    
+    break;
+  }
+}
+
+/* read not needed right now */
+char bufferread() { return 0; }
+uint16_t bufferavailable() { return 0; }
+char buffercheckch() { return 0; }
+void bufferflush() { }
+uint16_t bufferins(char *b, uint16_t nb) { return 0; }
+
+/*
+ *	Primary serial code uses the Serial object or Picoserial
+ *
+ *	The picoseria an own interrupt function. This is used to fill 
+ *  the input buffer directly on read. Write is standard like in 
+ *  the serial code.
+ *  
+ * 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
+ * 
+ */
+#ifdef ARDUINOPICOSERIAL
+volatile char picochar;
+volatile uint8_t picoa = 0;
+volatile char* picob = NULL;
+int16_t picobsize = 0;
+volatile int16_t picoi = 1;
+volatile uint16_t picoz; /* ugly */
+
+/* this is mostly taken from PicoSerial */
+const uint16_t MIN_2X_BAUD = F_CPU/(4*(2*0XFFF + 1)) + 1;
+
+/* the begin code */
+void picobegin(uint32_t baud) {
+    uint16_t baud_setting;
+    cli();               
+    if ((F_CPU != 16000000UL || baud != 57600) && baud > MIN_2X_BAUD) {
+      UCSR0A = 1 << U2X0;
+      baud_setting = (F_CPU / 4 / baud - 1) / 2;
+    } else {
+      UCSR0A = 0;
+      baud_setting = (F_CPU / 8 / baud - 1) / 2;
+    }
+/* assign the baud_setting */
+    UBRR0H = baud_setting >> 8;
+    UBRR0L = baud_setting;
+/* enable transmit and receive */
+    UCSR0B |= (1 << TXEN0) | (1 << RXEN0) | (1 << RXCIE0);
+    sei();                   
+}
+
+/* the write code, sending bytes directly to the UART */
+void picowrite(char b) {
+    while (((1 << UDRIE0) & UCSR0B) || !(UCSR0A & (1 << UDRE0))) {}
+    UDR0 = b;
+}
+
+/* 
+ *  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 c){
+	if (picob && (!picoa)) {
+    picochar=c;
+		if (picochar != '\n' && picochar != '\r' && picoi<picobsize-1) {
+      if (c == 127 || c == 8) {
+        if (picoi>1) picoi--; else return;
+      } else 
+			  picob[picoi++]=picochar;
+      picowrite(picochar);
+		} else {
+			picoa = 1;
+			picob[picoi]=0;
+			picob[0]=picoi;
+			picoz=picoi;
+			picoi=1;
+		}
+		picochar=0; /* every buffered byte is deleted */
+	} else {
+    	if (c != 10) picochar=c;
+	}
+}
+
+/* the ins code of picoserial, called like this in consins */
+uint16_t picoins(char *b, uint16_t nb) {
+  picob=b;
+  picobsize=nb;
+  picoa=0;
+/* once picoa is set, the interrupt routine records characters 
+ *  until a cr and then resets picoa to 0 */
+  while (!picoa) byield();
+  outch(10);
+  return picoz;
+ }
+
+/* on an UART interrupt, the getchar function is called */
+#ifdef USART_RX_vect
+ISR(USART_RX_vect) {
+  char c=UDR0;
+  picogetchar(c);
+}
+#else
+/* for MEGAs and other with many UARTs */
+  ISR(USART0_RX_vect) {
+  char c=UDR0;
+  picogetchar(c);
+}
+#endif
+#endif
+
+/* 
+ * blocking serial single char read for Serial
+ * unblocking for Picoserial because it is not 
+ * character oriented -> blocking is handled in 
+ * consins instead.
+ */
+char serialread() {
+#ifdef ARDUINOPICOSERIAL
+	char c;
+	c=picochar;
+	picochar=0;
+	return c;	
+#else
+	while (!SERIALPORT.available()) byield();
+  return SERIALPORT.read();
+#endif
+}
+
+/*
+ *  serial begin code with a one second delay after start
+ *	this is not needed any more 
+ */
+void serialbegin() {
+#ifdef ARDUINOPICOSERIAL
+	picobegin(serial_baudrate); 
+#else
+	SERIALPORT.begin(serial_baudrate);
+#endif
+	bdelay(1000);
+}
+
+/* state information on the serial port */
+uint8_t serialstat(uint8_t c) {
+  if (c == 0) return 1;
+  if (c == 1) return serial_baudrate/100;
+  return 0;
+}
+
+/* write to a serial stream */
+void serialwrite(char c) {
+#ifdef ARDUINOPICOSERIAL
+	picowrite(c);
+#else
+/* write never blocks. discard any bytes we can't get rid of */
+  SERIALPORT.write(c);  
+/* if (Serial.availableForWrite()>0) Serial.write(c);	*/
+#endif
+}
+
+/* check on a character, needed for breaking */
+char serialcheckch() {
+#ifdef ARDUINOPICOSERIAL
+	return picochar;
+#else
+	if (SERIALPORT.available()) return SERIALPORT.peek(); else return 0; // should really be -1
+#endif	
+}
+
+/* avail method, needed for AVAIL() */ 
+uint16_t serialavailable() {
+#ifdef ARDUINOPICOSERIAL
+	return picoi;
+#else
+	return SERIALPORT.available();
+#endif	
+}
+
+/* flush serial */
+void serialflush() {
+#ifdef ARDUINOPICOSERIAL
+  return;
+#else
+  while (SERIALPORT.available()) SERIALPORT.read();
+#endif 
+}
+
+/* the serial ins */
+uint16_t serialins(char *b, uint16_t nb) {
+#ifdef ARDUINOPICOSERIAL
+  return picoins(b, nb);
+#else
+  return consins(b, nb);
+#endif  
+}
+
+/* 
+ * Start a secondary serial port for printing and/or networking 
+ * This is either Serial1 on a MEGA or DUE or Nano Every or a SoftwareSerial 
+ * instance
+ */
+#ifdef ARDUINOPRT
+#if !defined(ARDUINO_AVR_MEGA2560) && !defined(ARDUINO_SAM_DUE) && !defined(ARDUINO_AVR_NANO_EVERY) \
+    && !defined(ARDUINO_NANO_RP2040_CONNECT) && !defined(ARDUINO_RASPBERRY_PI_PICO) \
+    && !defined(ARDUINO_SEEED_XIAO_M0) && !defined(ARDUINO_ARCH_RENESAS) &&! defined(ARDUINO_ARCH_MBED)
+#include <SoftwareSerial.h>
+SoftwareSerial PRTSERIAL(SOFTSERIALRX, SOFTSERIALTX);
+#endif
+
+/* second serial port */
+void prtbegin() {
+	PRTSERIAL.begin(serial1_baudrate);
+}
+
+/* the open functions are not needed here */
+char prtopen(char* filename, uint16_t mode) {}
+void prtclose() {}
+
+uint8_t prtstat(uint8_t c) {
+  if (c == 0) return 1;
+  if (c == 1) return serial1_baudrate;
+  return 0;
+}
+
+void prtwrite(char c) {
+	PRTSERIAL.write(c);
+}
+
+char prtread() {
+	while (!PRTSERIAL.available()) byield();
+	return PRTSERIAL.read();
+}
+
+char prtcheckch() {
+	if (PRTSERIAL.available()) return PRTSERIAL.peek(); else return 0;
+}
+
+uint16_t prtavailable() {
+	return PRTSERIAL.available();
+}
+
+void prtset(uint32_t s) {
+  serial1_baudrate=s;
+  prtbegin();
+}
+
+uint16_t prtins(char* b, uint16_t nb) {
+    if (blockmode > 0) return inb(b, nb); else return consins(b, nb);
+}
+#endif
+
+
+/* 
+ * 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
+ * ARDUINOWIREBUFFER is the maximum length of meesages the 
+ * underlying library can process. This is 32 for the Wire
+ * library
+ */ 
+
+/* this is always here, if Wire is needed by a subsysem, full wire always loads the Arduino wire library */
+#if defined(HASWIRE)
+/* default begin is as a master 
+ * This doesn't work properly on the ESP32C3 platform
+ * See  https://github.com/espressif/arduino-esp32/issues/6376 
+ * for more details
+ */
+void wirebegin() {
+#ifndef SDA_PIN   
+  Wire.begin();
+#else
+  Wire.begin(SDA_PIN, SCL_PIN);
+#endif
+}
+#endif
+
+/* this is code needed for the OPEN/CLOSE and wireslave mechanisms */
+#if defined(HASWIRE)
+uint8_t wire_slaveid = 0;
+uint8_t wire_myid = 0;
+#define ARDUINOWIREBUFFER 32
+#ifdef ARDUINOWIRESLAVE
+char wirereceivebuffer[ARDUINOWIREBUFFER];
+short wirereceivechars = 0;
+char wirerequestbuffer[ARDUINOWIREBUFFER];
+short wirerequestchars = 0;
+#endif
+
+void wireslavebegin(uint8_t s) {
+#ifndef SDA_PIN
+  Wire.begin(s);
+#else
+  Wire.begin(SDA_PIN, SCL_PIN, s);
+#endif
+}
+
+/* wire status - just checks if wire is compiled */
+uint8_t wirestat(uint8_t c) {
+  switch (c) {
+    case 0: 
+      return 1;
+#ifdef ARDUINOWIRESLAVE
+    case 1:
+      return wirerequestchars;
+#endif    
+    default:
+      return 0;
+  }
+}
+
+/* available characters - test code ecapsulation prep for slave*/
+uint16_t wireavailable() {
+/* as a master we return 1, as a slave the received chars*/
+  if (wire_myid == 0) return 1;
+#ifdef ARDUINOWIRESLAVE
+  else return wirereceivechars; 
+#else
+  else return 0;
+#endif
+}
+
+#ifdef ARDUINOWIRESLAVE
+/* event handler for receive */
+void wireonreceive(int h) {
+  wirereceivechars=h;
+  if (h>ARDUINOWIREBUFFER) h=ARDUINOWIREBUFFER;
+  for (int i=0; i<h; i++) wirereceivebuffer[i]=Wire.read();
+}
+
+/* event handler for request, deliver the message and forget the buffer */ 
+void wireonrequest() {
+  Wire.write(wirerequestbuffer, wirerequestchars);
+  wirerequestchars=0;
+}
+#endif
+
+/*
+ *	as a master open sets the slave id for the communication
+ *	no extra begin while we stay master
+ */
+void wireopen(uint8_t s, uint8_t m) {
+	if (m == 0) {
+		wire_slaveid=s;
+/* we have been a slave and become master, restart wire*/
+    if (wire_myid != 0) {
+      wirebegin();
+      wire_myid=0;    
+    }
+	} else if ( m == 1 ) { 
+		wire_myid=s;
+		wire_slaveid=0;
+#ifdef ARDUINOWIRESLAVE
+		wireslavebegin(wire_myid);
+    Wire.onReceive(&wireonreceive);
+    Wire.onRequest(&wireonrequest);
+#endif
+	} 
+}
+
+/* input an entire string */
+uint16_t wireins(char *b, uint8_t l) {
+  uint16_t z;
+  if (wire_myid == 0) {
+    z=0;
+    if (l>ARDUINOWIREBUFFER) l=ARDUINOWIREBUFFER;
+    if (!Wire.requestFrom(wire_slaveid, l)) ioer=1;
+    while (Wire.available() && z<l) b[++z]=Wire.read();
+  } else {
+#ifdef ARDUINOWIRESLAVE
+    for (z=0; z<wirereceivechars && z<l; z++) b[z+1]=wirereceivebuffer[z];
+    wirereceivechars=0; /* clear the entire buffer on read, bytewise read not really supported */
+#endif
+  }
+  b[0]=z;
+  return z;
+}
+
+/* just a helper to make GET work, wire is string oriented */
+char wireread() {
+    char wbuffer[2];
+    if (wireins(wbuffer, 1)) return wbuffer[1]; else return 0;
+}
+
+/* send an entire string - truncate radically */
+void wireouts(char *b, uint8_t l) {
+  int16_t z;
+  if (l>ARDUINOWIREBUFFER) l=ARDUINOWIREBUFFER; 
+  if (wire_myid == 0) {
+    Wire.beginTransmission(wire_slaveid); 
+#ifdef ARDUINO_ARCH_ESP32
+    for(z=0; z<l; z++) Wire.write(b[z]);  
+#else
+    Wire.write(b, l);
+#endif
+    ioer=Wire.endTransmission(); 
+  } else {
+#ifdef ARDUINOWIRESLAVE
+    for (int i=0; i<l; i++) wirerequestbuffer[i]=b[i];
+    wirerequestchars=l;
+#endif
+  }
+}
+#endif
+
+/* plain wire without FILE I/O functions */
+#if defined(HASSIMPLEWIRE) || defined(HASWIRE)
+
+/* AVR boards can be handled with a smaller Wire implementation, this 
+   should go into a separate library soon */
+#if defined(ARDUINODIRECTI2C)
+
+/* a few constants */ 
+uint32_t const F_TWI = 100000L;                               
+uint8_t const TWSR_MTX_DATA_ACK = 0x28;
+uint8_t const TWSR_MTX_ADR_ACK = 0x18;
+uint8_t const TWSR_MRX_ADR_ACK = 0x40;
+uint8_t const TWSR_START = 0x08;
+uint8_t const TWSR_REP_START = 0x10;
+uint8_t const I2C_READ = 1;
+uint8_t const I2C_WRITE = 0;
+
+/* counts the bytes to be read, in this implementation not used, kept for later */
+uint8_t wirecount;
+
+/* start the bus and set the frequency in TWBR */
+void wirebegin() {
+  digitalWrite(SDA, HIGH);                                      
+  digitalWrite(SCL, HIGH);
+  TWSR = 0;
+  TWBR = (F_CPU/F_TWI - 16)/2;
+}
+
+/* a generic start function for read and write*/
+void wirestart (uint8_t port, uint8_t n) {
+  
+  /* form the right address*/
+  port=port<<1;
+
+  /* remember the requested bytes and go to read mode if read */
+  if (n) { 
+    wirecount=n;  
+    port |= I2C_READ;
+  }
+  
+  /* start the bus and wait */
+  TWCR = 1<<TWINT | 1<<TWSTA | 1<<TWEN;
+  while (!(TWCR & 1<<TWINT));
+  
+  /* check the status */
+  if ((TWSR & 0xF8) != TWSR_START && (TWSR & 0xF8) != TWSR_REP_START) { ioer=1; return; }
+  
+  /* send the address and direction */
+  TWDR = port;
+  TWCR = 1<<TWINT | 1<<TWEN;
+  while (!(TWCR & 1<<TWINT));
+  
+  /* check the status */
+  if (port & I2C_READ) {
+    if ((TWSR & 0xF8) == TWSR_MRX_ADR_ACK) ioer=0; else ioer=1;
+  } else { 
+    if ((TWSR & 0xF8) == TWSR_MTX_ADR_ACK) ioer=0; else ioer=1;
+  }
+}
+
+/* stop, return value just a formality, error handling is done differently*/
+uint8_t wirestop () {
+  TWCR = 1<<TWINT | 1<<TWEN | 1<<TWSTO;
+  while (TWCR & 1<<TWSTO);
+  return ioer;
+}
+
+/* one byte write */
+void wirewritebyte(uint8_t b) {
+  TWDR = b;
+  TWCR = 1<<TWINT | 1<<TWEN;
+  while (!(TWCR & 1<<TWINT));
+  if (!((TWSR & 0xF8) == TWSR_MTX_DATA_ACK)) ioer=1;
+}
+
+/* one byte read without stopping the bus */
+int16_t wirereadbyte () {
+  if (wirecount != 0) wirecount--;
+  TWCR = 1<<TWINT | 1<<TWEN | ((wirecount == 0) ? 0 : (1<<TWEA));
+  while (!(TWCR & 1<<TWINT));
+  return TWDR;
+}
+#else /* not ARDUINODIRECTI2C this uses the standard Wire objects but provide the same API */
+
+/* start the Wire object*/
+void wirebegin() {
+#ifndef SDA_PIN   
+  Wire.begin();
+#else
+  Wire.begin(SDA_PIN, SCL_PIN);
+#endif
+}
+
+/* initiate communication for read or write */
+void wirestart(uint8_t port, uint8_t n) { 
+  if (n) {
+    if (!Wire.requestFrom(port, n)) ioer=1;
+  } else {
+    Wire.beginTransmission(port); 
+  }
+}
+
+/* stop is only explicitly used on write */
+uint8_t wirestop() { return Wire.endTransmission(); }
+void wirewritebyte(uint8_t data) { Wire.write(data); }
+int16_t wirereadbyte() { return Wire.read(); }
+#endif
+#endif
+
+/* 
+ *	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.
+ */
+
+#ifdef ARDUINORF24
+/*
+ * definitions for the nearfield module, still very experimental
+ * We use the standard RF24 nearfield library 
+ */
+const char rf24_ce = RF24CEPIN; 
+const char rf24_csn = RF24CSNPIN; 
+#include <nRF24L01.h>
+#include <RF24.h>
+rf24_pa_dbm_e rf24_pa = RF24_PA_MAX;
+RF24 radio(rf24_ce, rf24_csn);
+
+/* radio status */
+uint8_t radiostat(uint8_t c) {
+  if (c == 0) return 1;
+  if (c == 1) return radio.isChipConnected();
+  return 0; 
+}
+
+/* generate a uint64_t pipe address from the filename string for RF24 */
+uint64_t pipeaddr(const char *f){
+	uint64_t t = 0;
+	t=(uint8_t)f[0];
+	for(short i=1; i<=4; i++) t=t*256+(uint8_t)f[i];
+	return t;
+} 
+
+
+/* read an entire string */
+uint16_t radioins(char *b, uint8_t nb) {
+    uint16_t z;
+    
+    if (radio.available()) {
+    	radio.read(b+1, nb);
+    	if (!blockmode) {
+        for (z=0; z<nb; z++) if (b[z+1]==0) break;		
+    	} else {
+    		z=radio.getPayloadSize();
+      	if (z > nb) z=nb;
+    	}
+      b[0]=z;
+	} else {
+    b[0]=0; 
+    b[1]=0;
+    z=0;
+	}
+  return z;
+}
+
+
+ /* radio is not character oriented, this is only added to make GET work
+    or single byte payloads, radio, like file is treated nonblocking here */   
+char radioread() {
+    char rbuffer[2];
+    if (radioins(rbuffer, 1)) return rbuffer[1]; else return 0;
+}
+
+/* write to radio, no character mode here */
+void radioouts(char *b, uint8_t l) {
+	radio.stopListening();
+	if (!radio.write(b, l)) ioer=1;
+	radio.startListening();
+}
+
+/* radio available */
+uint16_t radioavailable() {
+  return radio.available();
+}
+
+/* 
+ *	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
+ */
+void iradioopen(const char *filename) {
+	if (!radio.begin()) ioer=1;
+	radio.openReadingPipe(1, pipeaddr(filename));
+	radio.startListening();
+}
+
+void oradioopen(const char *filename) {
+	if (!radio.begin()) ioer=1;
+	radio.openWritingPipe(pipeaddr(filename));
+}
+
+void radioset(uint8_t s) {
+  if ((s<0) && (s>3)) {ioer=1; return; } 
+  rf24_pa=(rf24_pa_dbm_e) s;
+  radio.setPALevel(rf24_pa);
+}
+
+#else 
+uint8_t radiostat(uint8_t c) { return 0; }
+uint64_t pipeaddr(const char *f){ return 0; } 
+uint16_t radioins(char *b, uint8_t nb) { b[0]=0; b[1]=0; return 0; }
+void radioouts(char *b, uint8_t l) {}
+uint16_t radioavailable() { return 0; }
+void iradioopen(const char *filename) {}
+void oradioopen(const char *filename) {}
+void radioset(uint8_t s) {}
+#endif
+
+
+/* 
+ *	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.
+ */
+#ifdef ARDUINOSENSORS
+#ifdef ARDUINODHT
+#include "DHT.h"
+DHT dht(DHTPIN, DHTTYPE);
+#endif
+#ifdef ARDUINOSHT
+#include <SHT3x.h>
+SHT3x SHT;
+#endif
+#ifdef ARDUINOMQ2
+#include <MQ2.h>
+MQ2 mq2(MQ2PIN);
+#endif
+#ifdef ARDUINOLMS6
+#include <Arduino_LSM6DSOX.h>
+/* https://www.arduino.cc/en/Reference/Arduino_LSM6DSOX */
+#endif
+#ifdef ARDUINOAHT
+#include <Adafruit_AHTX0.h>
+Adafruit_AHTX0 aht;
+#endif
+#ifdef ARDUINOBMP280
+#include <Adafruit_BMP280.h>
+Adafruit_BMP280 bmp;
+#endif
+#ifdef ARDUINOBME280
+#include <Adafruit_BME280.h>
+Adafruit_BME280 bme;
+/* add your own code here */
+#endif
+
+
+void sensorbegin(){
+#ifdef ARDUINODHT
+dht.begin();
+#endif
+#ifdef ARDUINOSHT
+  SHT.Begin();
+#endif
+#ifdef ARDUINOMQ2
+  mq2.begin();
+#endif
+#ifdef ARDUINOAHT
+  aht.begin();
+#endif
+#ifdef ARDUINOBMP280
+  bmp.begin(); 
+  bmp.setSampling(Adafruit_BMP280::MODE_NORMAL,   /* Operating Mode. */
+                  Adafruit_BMP280::SAMPLING_X2,     /* Temp. oversampling */
+                  Adafruit_BMP280::SAMPLING_X16,    /* Pressure oversampling */
+                  Adafruit_BMP280::FILTER_X16,      /* Filtering. */
+                  Adafruit_BMP280::STANDBY_MS_500); /* Standby time. */
+#endif
+#ifdef ARDUINOBME280
+  bme.begin(); 
+#endif
+}
+
+float sensorread(uint8_t s, uint8_t v) {
+  switch (s) {
+    case 0:
+      return analogRead(A0+v);
+    case 1:
+#ifdef ARDUINODHT
+			switch (v) {
+				case 0:
+					return 1;
+				case 1:
+					return dht.readHumidity();
+				case 2:
+					return dht.readTemperature();
+			}     	
+#endif
+      return 0;
+    case 2:
+#ifdef ARDUINOSHT
+      switch (v) {
+        case 0:
+          return 1;
+        case 1:
+          SHT.UpdateData();
+          return SHT.GetRelHumidity();
+        case 2:
+          SHT.UpdateData();
+          return SHT.GetTemperature();
+      }       
+#endif
+      return 0;
+    case 3:
+#ifdef ARDUINOMQ2
+      switch (v) {
+        case 0:
+          return 1;
+        case 1:
+          (void) mq2.read(false);
+          return mq2.readLPG();;
+        case 2:
+          (void) mq2.read(false);
+          return mq2.readCO();
+        case 3:
+          (void) mq2.read(false);
+          return mq2.readSmoke();
+      }       
+#endif
+      return 0;
+    case 4:
+#ifdef ARDUINOAHT
+      sensors_event_t humidity, temp;
+      switch (v) {
+        case 0:
+          return 1;
+        case 1:
+          aht.getEvent(&humidity, &temp);
+          return temp.temperature;
+        case 2:
+          aht.getEvent(&humidity, &temp);
+          return humidity.relative_humidity;
+      }       
+#endif
+      return 0;
+    case 5:
+#ifdef ARDUINOBMP280  
+      switch (v) {
+        case 0:
+          return 1;
+        case 1:
+          return bmp.readTemperature();
+        case 2:
+          return bmp.readPressure() / 100.0;
+        case 3:
+          return bmp.readAltitude(1013.25);
+      }       
+#endif
+      return 0;
+    case 6:
+#ifdef ARDUINOBME280
+      switch (v) {
+        case 0:
+          return 1;
+        case 1:
+          return bme.readTemperature();
+        case 2:
+          return bme.readPressure() / 100.0;
+        case 3:
+          return bme.readAltitude(1013.25);
+        case 4:
+          return bme.readHumidity();
+      }       
+#endif
+/* add your own sensor code here */
+      return 0;  
+    default:
+      return 0;
+  }
+}
+
+#else
+void sensorbegin() {}
+float sensorread(uint8_t s, uint8_t v) {return 0;};
+#endif
+
+/* 
+ *  event handling wrappers, to keep Arduino specifics out of BASIC
+ */
+
+#ifdef ARDUINOINTERRUPTS
+uint8_t pintointerrupt(uint8_t pin) { return digitalPinToInterrupt(pin); }
+void attachinterrupt(uint8_t interrupt, void (*f)(), uint8_t mode) { attachInterrupt(interrupt, f, (PinStatus) mode); };
+void detachinterrupt(uint8_t pin) { detachInterrupt(digitalPinToInterrupt(pin)); };
+#else 
+uint8_t pintointerrupt(uint8_t pin) { return 0; }
+void attachinterrupt(uint8_t interrupt, void (*f)(), uint8_t mode) {  };
+void detachinterrupt(uint8_t pin) {  };
+#endif
+
+/*
+ * Experimental code to drive SPI SRAM 
+ *
+ * Currently only the 23LCV512 is implemented, assuming a 
+ * 64kB SRAM
+ * The code below 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 
+ * 
+ */
+
+#ifdef ARDUINOSPIRAM
+
+/* 
+ *  we use the standard slave select pin as default 
+ *  RAMPIN
+ */
+#ifndef RAMPIN
+#define RAMPIN SS
+#endif
+
+#define SPIRAMWRMR  1 
+#define SPIRAMRDMR  5
+#define SPIRAMREAD  3     
+#define SPIRAMWRITE 2     
+#define SPIRAMRSTIO 0xFF
+#define SPIRAMSEQ   0x40
+#define SPIRAMBYTE  0x00
+
+/* the RAM begin method sets the RAM to sequential mode */
+uint16_t spirambegin() {
+  pinMode(RAMPIN, OUTPUT);
+  digitalWrite(RAMPIN, LOW);
+  SPI.transfer(SPIRAMRSTIO);
+  SPI.transfer(SPIRAMWRMR);
+  //SPI.transfer(SPIRAMBYTE);
+  SPI.transfer(SPIRAMSEQ);
+  digitalWrite(RAMPIN, HIGH);
+  return 65535;
+}
+
+/* the simple unbuffered byte read, with a cast to signed 8 bit integer */
+int8_t spiramrawread(uint16_t a) {
+  uint8_t c;
+  digitalWrite(RAMPIN, LOW);
+  SPI.transfer(SPIRAMREAD);
+  SPI.transfer((uint8_t)(a >> 8));
+  SPI.transfer((uint8_t)a);
+  c = SPI.transfer(0x00);
+  digitalWrite(RAMPIN, HIGH);
+  return c;
+}
+
+/* one read only buffer for access from the token stream 
+    memread calls this */
+uint16_t spiram_robufferaddr = 0;
+uint8_t spiram_robuffervalid=0;
+const uint8_t spiram_robuffersize = 32;
+int8_t spiram_robuffer[spiram_robuffersize];
+
+/* one rw buffer for access to the heap and all the program editing 
+    memread2 and memwrite2 call this*/
+uint16_t spiram_rwbufferaddr = 0;
+uint8_t spiram_rwbuffervalid=0;
+const uint8_t spiram_rwbuffersize = 32; /* also change the addressmask if you want to play here */
+int8_t spiram_rwbuffer[spiram_rwbuffersize];
+uint8_t spiram_rwbufferclean = 1; 
+
+const uint16_t spiram_addrmask=0xffe0;
+/* const address_t spiram_addrmask=0xffd0; // 64 byte frame */
+
+/* the elementary buffer access functions used almost everywhere */
+
+void spiram_bufferread(uint16_t a, int8_t* b, uint16_t l) {
+  digitalWrite(RAMPIN, LOW);
+  SPI.transfer(SPIRAMREAD);
+  SPI.transfer((uint8_t)(a >> 8));
+  SPI.transfer((uint8_t)a);
+  SPI.transfer(b, l);
+  digitalWrite(RAMPIN, HIGH);
+} 
+
+void spiram_bufferwrite(uint16_t a, int8_t* b, uint16_t l) {
+  digitalWrite(RAMPIN, LOW); 
+  SPI.transfer(SPIRAMWRITE);
+  SPI.transfer((uint8_t)(a >> 8));
+  SPI.transfer((uint8_t)a);
+  SPI.transfer(b, l);
+  digitalWrite(RAMPIN, HIGH);
+}
+
+int8_t spiram_robufferread(uint16_t a) {
+/* we address a byte known to the rw buffer, then get it from there */
+  if (spiram_rwbuffervalid && ((a & spiram_addrmask) == spiram_rwbufferaddr)) {
+    return spiram_rwbuffer[a-spiram_rwbufferaddr];
+  }
+  
+/* page fault, we dont have the byte in the ro buffer, so read from the chip*/
+  if (!spiram_robuffervalid || a >= spiram_robufferaddr + spiram_robuffersize || a < spiram_robufferaddr ) {
+      spiram_bufferread(a, spiram_robuffer, spiram_robuffersize);
+      spiram_robufferaddr=a;
+      spiram_robuffervalid=1;
+  }
+  return spiram_robuffer[a-spiram_robufferaddr];
+}
+
+/* flush the buffer */
+void spiram_rwbufferflush() {
+  if (!spiram_rwbufferclean) {
+    spiram_bufferwrite(spiram_rwbufferaddr, spiram_rwbuffer, spiram_rwbuffersize);
+    spiram_rwbufferclean=1;
+   }
+}
+
+int8_t spiram_rwbufferread(uint16_t a) {
+/* page fault, do read, ignore the ro buffer buffer */
+  uint16_t p=a & spiram_addrmask;
+  if (!spiram_rwbuffervalid || (p != spiram_rwbufferaddr)) {
+/* flush the buffer if needed */
+    spiram_rwbufferflush();
+/* and reload it */
+    spiram_bufferread(p, spiram_rwbuffer, spiram_rwbuffersize);
+    spiram_rwbufferaddr=p; /* we only handle full pages here */
+    spiram_rwbuffervalid=1;
+  }
+  return spiram_rwbuffer[a-spiram_rwbufferaddr];
+}
+
+/* the buffered file write */
+void spiram_rwbufferwrite(uint16_t a, int8_t c) {
+  uint16_t p=a&spiram_addrmask;
+/* correct the two buffers if needed */
+  if (spiram_robuffervalid && a >= spiram_robufferaddr && a < spiram_robufferaddr + spiram_robuffersize) {
+    spiram_robuffer[a-spiram_robufferaddr]=c;
+  }
+/* if we have the frame, write it, mark the buffer dirty and return */
+  if (spiram_rwbuffervalid && p == spiram_rwbufferaddr) {
+    spiram_rwbuffer[a-spiram_rwbufferaddr]=c;
+    spiram_rwbufferclean=0;
+    return;
+  }
+/* if we end up here the write was impossible because we dont have the frame, so flush and then get it */
+  spiram_rwbufferflush();
+  (void) spiram_rwbufferread(a);
+  spiram_rwbuffer[a-spiram_rwbufferaddr]=c;
+  spiram_rwbufferclean=0;
+}
+
+/* the simple unbuffered byte write, with a cast to signed char */
+void spiramrawwrite(uint16_t a, int8_t c) {
+  digitalWrite(RAMPIN, LOW);
+  SPI.transfer(SPIRAMWRITE);
+  SPI.transfer((uint8_t)(a >> 8));
+  SPI.transfer((uint8_t)a);
+  SPI.transfer((uint8_t) c);
+  digitalWrite(RAMPIN, HIGH);
+/* also refresh the ro buffer if in the frame */
+  if (a >= spiram_robufferaddr && a < spiram_robufferaddr + spiram_robuffersize && spiram_robufferaddr > 0) 
+    spiram_robuffer[a-spiram_robufferaddr]=c;
+/* and the rw buffer if needed) */
+  if (a >= spiram_rwbufferaddr && a < spiram_rwbufferaddr + spiram_rwbuffersize && spiram_rwbufferaddr > 0) 
+    spiram_rwbuffer[a-spiram_rwbufferaddr]=c;
+}
+#endif
+
+#if defined(USEMEMINTERFACE)
+/* 
+ * 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
+
+/* the string buffers of the memory interface */
+char spistrbuf1[SPIRAMSBSIZE];
+char spistrbuf2[SPIRAMSBSIZE];
+#endif