Datasets:

introvoyz041
/

tinybasic

	/*
	*
	* $Id: hardware-arduino.h,v 1.8 2023/02/18 20:16:59 stefan Exp stefan $
	*
	* Stefan's basic interpreter
	*
	* Playing around with frugal programming. See the licence file on
	* https://github.com/slviajero/tinybasic for copyright/left.
	* (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007)
	*
	* Author: Stefan Lenz, [email protected]
	*
	* Credits:
	* - XMC contributed by Florian
	*
	* Hardware definition file coming with TinybasicArduino.ino aka basic.c
	*
	* - ARDUINOLCD, ARDUINOTFT and LCDSHIELD active the LCD code,
	* LCDSHIELD automatically defines the right settings for
	* the classical shield modules
	* - ARDUINOPS2 activates the PS2 code. Default pins are 2 and 3.
	* If you use other pins the respective changes have to be made
	* below.
	* - _if_ and PS2 are both activated STANDALONE cause the Arduino
	* to start with keyboard and lcd as standard devices.
	* - ARDUINOEEPROM includes the EEPROM access code
	* - ARDUINOEFS, ARDUINOSD, ESPSPIFFS, RP2040LITTLEFS activate filesystem code
	* - activating Picoserial, Picoserial doesn't work on MEGA
	*
	* Architectures and the definitions from the Arduino IDE
	*
	* ARDUINO_ARCH_SAM: no tone command, dtostrf
	* ARDUINO_ARCH_RP2040: dtostrf (for ARDUINO_NANO_RP2040_CONNECT)
	* ARDUINO_ARCH_SAMD: dtostrf (for ARDUINO_SAMD_MKRWIFI1010, ARDUINO_SEEED_XIAO_M0)
	* ARDUINO_ARCH_ESP8266: SPIFFS, dtostrf (ESP8266)
	* ARDUINO_AVR_MEGA2560, ARDUARDUINO_SAM_DUE: second serial port is Serial1-3 - no software serial
	* ARDUINO_SAM_DUE: hardware heuristics
	* ARDUINO_ARCH_AVR: nothing
	* ARDUINO_ARCH_LGT8F: EEPROM code for flash EEPROM - platform fully supported now, yet no call 0
	* ARDUINO_ARCH_ESP32 and ARDUINO_TTGO_T7_V14_Mini32, no tone, no analogWrite, avr/xyz obsolete
	*
	* The code still contains hardware heuristics from my own projects,
	* will be removed in the future
	*
	*/

	#if defined(ARDUINO) && ! defined(__HARDWAREH__)
	#define __HARDWAREH__

	/*
	* Arduino hardware settings , set here what you need or
	* use one of the predefined configurations below
	*
	* input/output methods USERPICOSERIAL, ARDUINOPS2
	* ARDUINOPRT, DISPLAYCANSCROLL, ARDUINOLCDI2C,
	* ARDUINOTFT, ARDUINONOKIA51, ARDUINOILI9488,
	* ARDUINOSSD1306, ARDUINOMCUFRIEND
	* storage ARDUINOEEPROM, ARDUINOSD, ESPSPIFFS, RP2040LITTLEFS
	* storage ARDUINOEFS, SM32SDIO
	* sensors ARDUINOWIRE, ARDUINOSENSORS
	* network ARDUINORF24, ARDUNIOMQTT
	* memory ARDUINOSPIRAM
	* real time clocks ARDUINORTC, ARDUINORTCEMULATION
	*
	* leave this unset if you use the definitions below
	*/

	#undef USESPICOSERIAL
	#undef ARDUINOPS2
	#undef ARDUINOUSBKBD
	#undef ARDUINOZX81KBD
	#undef ARDUINOPRT
	#undef DISPLAYCANSCROLL
	#undef ARDUINOLCDI2C
	#undef ARDUINONOKIA51
	#undef ARDUINOILI9488
	#undef ARDUINOSSD1306
	#undef ARDUINOMCUFRIEND
	#undef ARDUINOEDP47
	#undef ARDUINOGRAPHDUMMY
	#undef LCDSHIELD
	#undef ARDUINOTFT
	#undef ARDUINOVGA
	#define ARDUINOEEPROM
	#undef ARDUINOI2CEEPROM
	#undef ARDUINOEFS
	#undef ARDUINOSD
	#undef ESPSPIFFS
	#undef RP2040LITTLEFS
	#undef STM32SDIO
	#undef ARDUINORTC
	#undef ARDUINORTCEMULATION
	#undef ARDUINOTONEEMULATION
	#undef ARDUINOWIRE
	#undef ARDUINOWIRESLAVE
	#undef ARDUINORF24
	#undef ARDUINOETH
	#undef ARDUINOMQTT
	#undef ARDUINOSENSORS
	#undef ARDUINOSPIRAM
	#undef STANDALONE
	#undef STANDALONESECONDSERIAL

	/* experimental features, don't use unless you know the code */
	/*
	* this setting uses the EEPROM as program storage
	* The idea is to create a virtual memory layout starting from 0 with the EEPROM
	* from elength() and then adding the BASIC RAM to it. himem and top need to be
	* handled carefully.
	*/
	#undef ARDUINOPGMEEPROM

	/*
	* Predefined hardware configurations, this assumes that all of the
	* above are undef
	*
	* UNOPLAIN:
	* a plain UNO with no peripherals
	* AVRLCD:
	* a AVR system with an LCD shield
	* WEMOSSHIELD:
	* a Wemos D1 with a modified simple datalogger shield
	* optional keyboard and i2c display
	* MEGASHIELD:
	* an Arduino Mega with Ethernet Shield
	* optional keyboard and i2c display
	* TTGOVGA:
	* TTGO VGA1.4 system with PS2 keyboard, standalone
	* MEGATFT, DUETFT
	* TFT 7inch screen systems, standalone
	* NANOBOARD:
	* Arduino Nano Every board with PS2 keyboard and sensor
	* kit
	* MEGABOARD:
	* A board for the MEGA with 64 kB RAM, SD Card, and real time
	* clock
	* UNOBOARD:
	* A board for an UNO with 64kB memory and EEPROM disk
	* fits into an UNO flash only with integer
	* ESP01BOARD:
	* ESP01 based board as a sensor / MQTT interface
	* RP2040BOARD:
	* A ILI9488 hardware design based on an Arduino connect RP2040.
	* RP2040BOARD2:
	* like the one above but based on the Pi Pico core
	* ESP32BOARD:
	* same like above with an ESP32 core
	* MKRBOARD:
	* a digital signage and low energy board
	*/

	#undef UNOPLAIN
	#undef AVRLCD
	#undef WEMOSSHIELD
	#undef MEGASHIELD
	#undef TTGOVGA
	#undef DUETFT
	#undef MEGATFT
	#undef NANOBOARD
	#undef MEGABOARD
	#undef UNOBOARD
	#undef ESP01BOARD
	#undef RP2040BOARD
	#undef RP2040BOARD2
	#undef ESP32BOARD
	#undef MKR1010BOARD

	/*
	* PIN settings and I2C addresses for various hardware configurations
	* used a few heuristics and then the hardware definitions above
	*
	* #define SDPIN sets the SD CS pin - can be left as a default for most HW configs
	* TTGO needs it as default definitions in the board file are broken
	* #define PS2DATAPIN, PS2IRQPIN sets PS2 pin
	*/

	/* PS2 Keyboard pins for AVR - use one interrupt pin 2 and one date pin
	5 not 4 because 4 conflicts with SDPIN of the standard SD shield */
	#define PS2DATAPIN 3
	#define PS2IRQPIN 2

	/* Ethernet - 10 is the default */
	/* #define ETHPIN 10 */

	/* The Pretzelboard definitions for Software Serial, conflicts with SPI */
	#define SOFTSERIALRX 11
	#define SOFTSERIALTX 12

	/* near field pin settings for CE and CSN*/
	#define RF24CEPIN 8
	#define RF24CSNPIN 9

	/* use standard I2C pins almost always */
	#undef SDA_PIN
	#undef SCL_PIN

	/* set this is you want pin 4 on low interrupting the interpreter */
	/* #define BREAKPIN 4 */
	#undef BREAKPIN

	/* the primary serial stream aka serial aka sream 1 */
	#ifndef ALTSERIAL
	#define SERIALPORT Serial
	#endif

	/* the secondary serial port aka prt aka stream 4 */
	#ifndef PRTSERIAL
	#define PRTSERIAL Serial1
	#endif

	/*
	* Pin settings for the ZX81 Keyboard
	* first the 8 rows, then the 5 columns or the keyboard
	*
	* MEGAs have many pins and default is to use the odd pins on the side
	* UNOs, NANOs, and others use the lower pins by default avoiding the
	* pin 13 which is LED and doesn't work with standard schematics
	*/
	#ifdef ARDUINOZX81KBD
	#ifdef ARDUINO_AVR_MEGA2560
	const byte zx81pins[] = {37, 35, 33, 31, 29, 27, 25, 23, 47, 45, 43, 41, 39};
	#else
	const char zx81pins[] = {7, 8, 9, 10, 11, 12, A0, A1, 2, 3, 4, 5, 6 };
	#endif
	#endif

	/*
	* this is soft SPI for SD cards on MEGAs using
	* pins 10-13, a patched SD library is needed
	* for this: https://github.com/slviajero/SoftSD
	* only needed for MEGA boards with an UNO shield
	*/
	#undef SOFTWARE_SPI_FOR_SD

	/*
	* list of default i2c addresses
	*
	* some clock modules do have their EEPROM at 0x57.
	* 0x050 this is the default lowest adress of standard EEPROMs
	* Configurable range is between 0x50 and 0x57 for modules with jumpers.
	* Some clock modules do have their EEPROM at 0x57.
	*
	* Clock default for the size is 4096. Define your EFS EEPROM and I2C EEPROM
	* size here. One parameter set is for EFS and one parameter set is for
	* plain serial EEPROMs.
	*
	* RTCs are often at 0x68
	*/
	#define EFSEEPROMADDR 0x050
	/* #define EFSEEPROMSIZE 32768 */

	#define RTCI2CADDR 0x068

	/* the size of the plain I2C EEPROM, typically a clock */
	#define I2CEEPROMADDR 0x057
	/* #define I2CEEPROMSIZE 4096 */

	/* is the I2C EEPROM buffered */
	#define ARDUINOI2CEEPROM_BUFFERED

	/*
	* Sensor library code - configure your sensors here
	*/
	#ifdef ARDUINOSENSORS
	#undef ARDUINODHT
	#define DHTTYPE DHT22
	#define DHTPIN 2
	#define ARDUINOSHT
	#define ARDUINOMQ2
	#define MQ2PIN A0
	#undef ARDUINOLMS6
	#undef ARDUINOAHT
	#undef ARDUINOBMP280
	#undef ARDUINOBME280
	#endif


	#if defined(ARDUINOSHT) \|\| defined(ARDUINOLMS6) \|\| defined(ARDUINOAHT) \|\| defined(ARDUINOBMP280) \|\| defined(RDUINOBME280)
	#define ARDUINOWIRE
	#endif

	/*
	* The hardware models.
	* These are predefined hardware configurations.
	*/

	/* an AVR based Arduino with nothing else */
	#if defined(UNOPLAIN)
	#define ARDUINOEEPROM
	#endif

	/* an AVR ARDUINO (UNO or MEGA) with the classical LCD shield */
	#if defined(AVRLCD)
	#define ARDUINOEEPROM
	#define DISPLAYCANSCROLL
	#define LCDSHIELD
	#endif

	/*
	* a Wemos ESP8266 with a mdified datalogger shield
	* standalone capable, with Wire and MQTT.
	*/
	#if defined(WEMOSSHIELD)
	#define ARDUINOEEPROM
	#define ARDUINOPS2
	#define DISPLAYCANSCROLL
	#define ARDUINOLCDI2C
	#define ARDUINOSD
	#define ARDUINORTC
	#define ARDUINOWIRE
	#define SDPIN D8
	#define PS2DATAPIN D2
	#define PS2IRQPIN D9
	#define ARDUINOMQTT
	#endif

	/*
	* mega with a Ethernet shield
	* standalone capable, Ethernet is not enabled by default
	*/
	#if defined(MEGASHIELD)
	#define ARDUINOEEPROM
	#define ARDUINOPS2
	#define DISPLAYCANSCROLL
	#define ARDUINOLCDI2C
	#define ARDUINOSD
	#define ARDUINOWIRE
	#define ARDUINOPRT
	#define SDPIN 4
	#endif

	/*
	* VGA system with SD card, based on the TTGO VGA 1.4
	* ESP32
	* standalone by default, with MQTT
	*/
	#if defined(TTGOVGA)
	#define ARDUINOEEPROM
	#define ARDUINOVGA
	#define ARDUINOSD
	/* #define ARDUINOMQTT */
	#define SDPIN 13
	#define STANDALONE
	#endif

	/*
	* MEGA with a TFT shield, standalone by default
	*/
	#if defined(MEGATFT)
	#define ARDUINOEEPROM
	#define ARDUINOPS2
	#define DISPLAYCANSCROLL
	#define ARDUINOTFT
	#define ARDUINOSD
	#define ARDUINOWIRE
	#define ARDUINOPRT
	#define PS2DATAPIN 18
	#define PS2IRQPIN 19
	#define SDPIN 53
	#define STANDALONE
	#endif

	/*
	* DUE with a TFT shield, standalone by default
	*/
	#if defined(DUETFT)
	#undef ARDUINOEEPROM
	#define ARDUINOPS2
	#undef ARDUINOUSBKBD
	#define DISPLAYCANSCROLL
	#define ARDUINOTFT
	#define ARDUINOSD
	#define ARDUINOWIRE
	#define ARDUINOPRT
	#define ARDUINORTC
	#define PS2DATAPIN 9
	#define PS2IRQPIN 8
	#define SDPIN 53
	#define STANDALONE
	#endif

	#if defined(NANOBOARD)
	#undef USESPICOSERIAL
	#define ARDUINOPS2
	#define DISPLAYCANSCROLL
	#define ARDUINOLCDI2C
	#define ARDUINOEEPROM
	#define ARDUINOPRT
	#define ARDUINOEFS
	#define ARDUINORTC
	#define ARDUINOWIRE
	#define EFSEEPROMADDR 0x050 /* use clock EEPROM 0x057, set to 0x050 for external EEPROM */
	#define STANDALONE
	#endif

	/* a UNO shield with memory and EFS EEPROM */
	#if defined(UNOBOARD)
	#define ARDUINOEEPROM
	#define ARDUINOSPIRAM
	#define ARDUINOEFS
	#define ARDUINOWIRE
	#define EFSEEPROMADDR 0x050
	#define EFSEEPROMSIZE 65534
	#endif

	/* a MEGA shield with memory and SD card */
	#if defined(MEGABOARD)
	#undef USESPICOSERIAL
	#define DISPLAYCANSCROLL
	#define ARDUINOLCDI2C
	#define ARDUINOEEPROM
	#define ARDUINOPRT
	#define ARDUINOSD
	#define ARDUINOWIRE
	#define ARDUINORTC
	#define ARDUINOSPIRAM
	#define RAMPIN 53
	#define SDPIN 49
	#endif

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

	/* an RP2040 based board with an ILI9488 display */
	#if defined(RP2040BOARD)
	#undef USESPICOSERIAL
	#define DISPLAYCANSCROLL
	#define ARDUINOILI9488
	#undef ARDUINOEEPROM
	#define ARDUINOI2CEEPROM
	#define ARDUINOPRT
	#define ARDUINOSD
	#undef RP2040LITTLEFS
	#define ARDUINOWIRE
	#define ARDUINORTC
	#define ARDUINOPS2
	#define ARDUINOMQTT
	#undef STANDALONE
	#endif

	/* an RP2040 Raspberry Pi Pico based board with an ILI9488 display */
	#if defined(RP2040BOARD2)
	#undef USESPICOSERIAL
	#define DISPLAYCANSCROLL
	#define ARDUINOILI9488
	#undef ARDUINOEEPROM
	#undef ARDUINOPRT
	#undef ARDUINOSD
	#define RP2040LITTLEFS
	#undef ARDUINOWIRE
	#undef ARDUINORTC
	#undef ARDUINOPS2
	#undef ARDUINOMQTT
	#undef STANDALONE
	#define ILI_LED A2
	#define ILI_CS 15
	#define ILI_RST 14
	#define ILI_DC 13
	#endif


	/* an ESP32 board with an ILI9488 display,
	some SD problems here with some hardware */
	#if defined(ESP32BOARD)
	#define ILI_CS 12
	#define ILI_DC 27
	#define ILI_RST 14
	#define ILI_LED 26
	#undef USESPICOSERIAL
	#define ESPSPIFFS
	#define DISPLAYCANSCROLL
	#define ARDUINOILI9488
	#define ARDUINOEEPROM
	#define ARDUINOMQTT
	#define ARDUINOWIRE
	#endif

	/* a board based on the Arduino MKR 1010 Wifi
	* made for low energy games
	*/
	#if defined(MKR1010BOARD)
	#define ILI_CS 7
	#define ILI_DC 4
	#define ILI_RST 6
	#define ILI_LED A3
	#undef USESPICOSERIAL
	#define DISPLAYCANSCROLL
	#define ARDUINOILI9488
	#define ARDUINOEFS
	#define ARDUINOMQTT
	#define ARDUINOWIRE
	/* careful with the setting, lockout possible easily */
	#undef ARDUINOUSBKBD
	#undef STANDALONE
	#endif

	/*
	* defining the systype variable which informs BASIC about the platform at runtime
	*/

	#if defined(ARDUINO_ARCH_AVR)
	const mem_t bsystype = SYSTYPE_AVR;
	#elif defined(ARDUINO_ARCH_ESP8266)
	const mem_t bsystype = SYSTYPE_ESP8266;
	#elif defined(ARDUINO_ARCH_ESP32)
	const mem_t bsystype = SYSTYPE_ESP32;
	#elif defined(ARDUINO_ARCH_RP2040) \|\| defined(ARDUINO_ARCH_MBED_RP2040)
	const mem_t bsystype = SYSTYPE_RP2040;
	#elif defined(ARDUINO_ARCH_SAM) && defined(ARDUINO_ARCH_SAMD)
	const mem_t bsystype = SYSTYPE_SAM;
	#elif defined(ARDUINO_ARCH_XMC)
	const mem_t bsystype = SYSTYPE_XMC;
	#elif defined(ARDUINO_ARCH_SMT32)
	const mem_t bsystype = SYSTYPE_SMT32;
	#elif defined(ARDUINO_ARCH_RENESAS)
	const mem_t bsystype = SYSTYPE_NRENESA;
	#else
	const mem_t bsystype = SYSTYPE_UNKNOWN;
	#endif

	/*
	* DUE has no tone, we switch to emulation mode automatically
	*/
	#ifdef ARDUINO_SAM_DUE
	#define ARDUINOTONEEMULATION
	#endif

	/*
	* Some settings, defaults, and dependencies
	*
	* HASWIRE is set to start wire. Some libraries do this again.
	*
	* Handling Wire and SPI is tricky as some of the libraries
	* also include and start SPI and Wire code.
	*/

	/* a clock needs wire */
	#ifdef ARDUINORTC
	#define ARDUINOWIRE
	#endif

	/* a display needs wire */
	#if defined(ARDUINOLCDI2C) \|\| defined(ARDUINOSSD1306)
	#define ARDUINOWIRE
	#endif

	/* EEPROM storage needs wire */
	#if defined(ARDUINOEFS)
	#define ARDUINOWIRE
	#endif

	/* external EEPROMs also need wire */
	#if defined(ARDUINOI2CEEPROM)
	#define ARDUINOWIRE
	#endif

	/* plain Wire support also needs wire ;-) */
	#if defined(ARDUINOWIRE)
	#define HASWIRE
	#endif

	/* radio needs SPI */
	#if defined(ARDUINORF24)
	#define ARDUINOSPI
	#endif

	/* a filesystem needs SPI */
	#if defined(ARDUINOSD) \|\| defined(ESPSPIFFS)
	#define ARDUINOSPI
	#endif

	/* networking may need SPI */
	#if defined(ARDUINOMQTT)
	#define ARDUINOSPI
	#endif

	/* the NOKIA and ILI9488 display needs SPI */
	#if defined(ARDUINONOKIA51) \|\| defined(ARDUINOILI9488)
	#define ARDUINOSPI
	#endif

	/* the RAM chips */
	#if defined(ARDUINOSPIRAM)
	#define ARDUINOSPI
	#endif


	/* Networking and keyboards need the background task capability */
	#if defined(ARDUINOMQTT) \|\| defined(ARDUINOETH) \|\| defined(ARDUINOUSBKBD) \|\| defined(ARDUINOZX81KBD)
	#define BASICBGTASK
	#endif

	/* picoserial is not a available on many platforms */
	#ifdef USESPICOSERIAL
	#ifndef UCSR0A
	#undef USESPICOSERIAL
	#endif
	#endif

	/*
	* graphics adapter only when graphics hardware, overriding the
	* language setting
	* this is odd and can be removed later on
	*/
	#if !defined(ARDUINOTFT) && !defined(ARDUINOVGA) && !defined(ARDUINOILI9488) && !defined(ARDUINONOKIA51) && !defined(ARDUINOSSD1306) && !defined(ARDUINOMCUFRIEND) && !defined(ARDUINOGRAPHDUMMY) && !defined(ARDUINOEDP47)
	#undef HASGRAPH
	#endif

	/*
	* incompatibilities and library stuff
	*/
	/* these platforms have no EEPROM and no emulation built-in */
	#if defined(ARDUINO_ARCH_SAM) \|\| defined(ARDUINO_ARCH_SAMD) \|\| defined(ARDUINO_ARCH_RP2040) \|\| defined(ARDUINO_ARCH_MBED_RP2040)
	#undef ARDUINOEEPROM
	#endif

	/*
	* Keyboard library, on AVR systems Paul Stoffregens original
	* PS2 library works.
	* I recommend to use my patched version from
	* https://github.com/slviajero/PS2Keyboard
	* works with ESP, has keyboard.peek()
	*/
	#ifdef ARDUINOPS2
	#include <PS2Keyboard.h>
	#endif

	/*
	* The USB keyboard code - tested only on DUE and the like
	* not really good
	*/
	#ifdef ARDUINOUSBKBD
	#include <KeyboardController.h>
	#endif

	/*
	* The ZX81 keyboard code - tested on AVR MEGA256
	*/
	#ifdef ARDUINOZX81KBD
	#include <ZX81Keyboard.h>
	#endif

	/*
	* ESPy stuff, pgmspace has changed location
	*/
	#ifdef ARDUINOPROGMEM
	#ifdef ARDUINO_ARCH_ESP32
	#include <pgmspace.h>
	#else
	#include <avr/pgmspace.h>
	#endif
	#endif

	/*
	* Fix a few things around XMC, contributed by Florian
	*/
	#if defined(ARDUINO_ARCH_XMC)
	#undef USESPICOSERIAL
	#undef ARDUINOPROGMEM
	#endif

	/*
	* This works for AVR and ESP EEPROM dummy.
	* On XMC you need https://github.com/slviajero/XMCEEPROMLib
	* Throws a compiler error for other platforms.
	*/
	#ifdef ARDUINOEEPROM
	#ifdef ARDUINO_ARCH_XMC
	#include <XMCEEPROMLib.h>
	#else
	#ifdef ARDUINO_ARCH_SAMD
	//#include <FlashStorage_SAMD.h>
	#else
	#include <EEPROM.h>
	#endif
	#endif
	#endif

	/* Standard SPI */
	#ifdef ARDUINOSPI
	#include <SPI.h>
	#endif

	/* Standard wire - triggered by the HASWIRE macro now */
	#ifdef HASWIRE
	#include <Wire.h>
	#endif

	/*
	* the display library includes for LCD
	*/
	#ifdef LCDSHIELD
	#include <LiquidCrystal.h>
	#endif

	/*
	* I2C displays
	*/

	#ifdef ARDUINOLCDI2C
	#include <LiquidCrystal_I2C.h>
	#endif

	/*
	* This is the monochrome library of Oli Kraus
	* 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
	* 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
	*
	*/
	#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


	/*
	* experimental networking code
	* currently the standard Ethernet shield, ESP Wifi
	* MKW Wifi, and RP2040 Wifi is supported. All of them
	* with the standard library.
	*
	* In addition to this Pubsub is used
	* https://github.com/slviajero/pubsubclient
	* for MQTT
	*/
	#ifdef ARDUINOMQTT
	#ifdef ARDUINOETH
	#include <Ethernet.h>
	#else
	#ifdef ARDUINO_ARCH_ESP8266
	#include <ESP8266WiFi.h>
	#endif
	#ifdef ARDUINO_ARCH_ESP32
	#include <WiFi.h>
	#endif
	#if defined(ARDUINO_ARCH_RP2040) \|\| defined(ARDUINO_ARCH_SAMD)
	#include <WiFiNINA.h>
	#endif
	#if defined(ARDUINO_UNOR4_WIFI)
	#include <WiFiS3.h>
	#endif
	#endif
	#include <PubSubClient.h>
	#endif

	/*
	* VGA is only implemented on one platform - TTGO VGA 1.4
	* Needs https://github.com/slviajero/FabGL
	*/
	#if defined(ARDUINOVGA) && defined(ARDUINO_TTGO_T7_V14_Mini32)
	#include <WiFi.h>
	#include <fabgl.h>
	#endif

	/*
	* SD filesystems with the standard SD driver
	* for MEGA 256 a soft SPI solution is needed
	* if standard shields are used, this is a patched
	* SD library https://github.com/slviajero/SoftSD
	*/
	#ifdef ARDUINOSD
	#define FILESYSTEMDRIVER
	#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
	*/
	#ifdef ESPSPIFFS
	#define FILESYSTEMDRIVER
	#ifdef ARDUINO_ARCH_ESP8266
	#include <FS.h>
	#endif
	#ifdef ARDUINO_ARCH_ESP32
	#include <FS.h>
	#include <SPIFFS.h>
	#endif
	#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 override internal filesystems
	* currently BASIC can only have one filesystem
	*/
	#ifdef ARDUINOSD
	#undef ESPSPIFFS
	#undef RP2040LITTLEFS
	#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 RP2040LITTLEFS
	#undef ARDUINOSD
	#undef STM32SDIO
	#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

	/* if there is an unbuffered I2C EEPROM, use an autodetect mechanism */
	#if defined(ARDUINOI2CEEPROM)
	unsigned int i2ceepromsize = 0;
	#endif

	/*
	* Software SPI only on Mega2560
	*/
	#ifndef ARDUINO_AVR_MEGA2560
	#undef SOFTWARE_SPI_FOR_SD
	#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()
	*/
	const int serial_baudrate = 9600;
	mem_t sendcr = 0;

	#ifdef ARDUINOPRT
	int serial1_baudrate = 9600;
	mem_t blockmode = 1;
	#else
	const int serial1_baudrate = 0;
	mem_t blockmode = 0;
	#endif

	/* 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_ESP32) \|\| defined(ARDUINO_ARCH_ESP8266) \|\| defined(ARDUINO_ARCH_SAMD) \|\| defined(ARDUINO_ARCH_STM32)
	return freeRam() - 4000;
	#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=192;
	#ifdef HASFLOAT
	overhead+=96;
	#endif
	#ifdef ARDUINO_AVR_MEGA2560
	overhead+=96;
	#endif
	#ifdef ARDUINOWIRE
	overhead+=128;
	#endif
	#ifdef ARDUINORF24
	overhead+=128;
	#endif
	#if defined(ARDUINOSD)
	overhead+=512;
	#endif
	#ifdef ARDUINOZX81KBD
	overhead+=64;
	#endif
	#ifdef ARDUINOETH
	overhead+=256;
	#endif
	#ifdef HASGRAPH
	overhead+=256; /* a bit on the safe side */
	#endif
	return freeRam() - overhead;
	#endif
	#if defined(ARDUINO_NANO_RP2040_CONNECT) \|\| defined(ARDUINO_RASPBERRY_PI_PICO)
	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)
	#define HASBUILTINRTC
	#include "RTCZero.h"
	#include "ArduinoLowPower.h"
	RTCZero rtc;
	#endif

	/* STM32duino have the same structure */
	#if defined(ARDUINO_ARCH_STM32)
	#define HASBUILTINRTC
	#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)
	#define HASBUILTINRTC
	#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
	*/
	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
	SPI.begin();
	#endif
	#endif
	}

	/*
	* DISPLAY driver code section, the hardware models define a set of
	* of functions and definitions needed for the display driver. These are
	*
	* dsp_rows, dsp_columns: size of the display
	* dspbegin(), dspprintchar(c, col, row), dspclear(), dspupdate()
	*
	* All displays which have this functions can be used with the
	* generic display driver below.
	*
	* Graphics displays need to implement the functions
	*
	* rgbcolor(), vgacolor()
	* plot(), line(), rect(), frect(), circle(), fcircle()
	*
	* Color is currently either 24 bit or 4 bit 16 color vga.
	*
	* Non rgb ready displays on rgbcolor translate to their native color
	* when BASIC requests an rgb color, in this case the nearest 4 bit
	* color of the display is also stored for use in the text DISLAY driver
	* code
	*/

	/* generate a 4 bit vga color from a given rgb color */
	uint8_t rgbtovga(int r, int g, int b) {
	short vga;
	if (r>191 \|\| g>191 \|\| b>191) vga=8; else vga=0;
	vga=vga+r/128+g/1282+b/1284;
	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;
	*/
	const int dsp_rows=2;
	const int dsp_columns=16;
	LiquidCrystal lcd( 8, 9, 4, 5, 6, 7);
	void dspbegin() { lcd.begin(dsp_columns, dsp_rows); dspsetscrollmode(1, 1); }
	void dspprintchar(char c, mem_t col, mem_t row) { lcd.setCursor(col, row); if (c) lcd.write(c);}
	void dspclear() { lcd.clear(); }
	void dspupdate() {}
	void dspsetcursor(mem_t c) { if (c) lcd.blink(); else lcd.noBlink(); }
	void dspsetfgcolor(uint8_t c) {}
	void dspsetbgcolor(uint8_t c) {}
	void dspsetreverse(mem_t c) {}
	mem_t dspident() {return 0; }
	#define HASKEYPAD
	/* elementary keypad reader left=1, right=2, up=3, down=4, select=<lf> */
	short keypadread(){
	int a=analogRead(A0);
	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';
	}
	/* repeat mode of the keypad - off means block, on means return immediately */
	mem_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, mem_t col, mem_t row) { lcd.setCursor(col, row); if (c) lcd.write(c); }
	void dspclear() { lcd.clear(); }
	void dspupdate() {}
	void dspsetcursor(mem_t c) { if (c) lcd.blink(); else lcd.noBlink(); }
	void dspsetfgcolor(uint8_t c) {}
	void dspsetbgcolor(uint8_t c) {}
	void dspsetreverse(mem_t c) {}
	mem_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, mem_t col, mem_t row) { char b[] = { 0, 0 }; b[0]=c; if (c) u8g2.drawStr(coldspfontsize+2, (row+1)dspfontsize, b); }
	void dspclear() { u8g2.clearBuffer(); u8g2.sendBuffer(); dspfgcolor=1; }
	void dspupdate() { u8g2.sendBuffer(); }
	void dspsetcursor(mem_t c) {}
	void dspsetfgcolor(uint8_t c) {}
	void dspsetbgcolor(uint8_t c) {}
	void dspsetreverse(mem_t c) {}
	mem_t dspident() {return 0;}
	void rgbcolor(int r, int g, int b) {}
	void vgacolor(short 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(mem_t c) {}
	void dspsetfgcolor(uint8_t c) {}
	void dspsetbgcolor(uint8_t c) {}
	void dspsetreverse(mem_t c) {}
	mem_t dspident() {return 0;}
	void rgbcolor(int r, int g, int b) {}
	void vgacolor(short 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, mem_t col, mem_t row) { char b[] = { 0, 0 }; b[0]=c; if (c) u8g2.drawStr(coldspfontsize+2, (row+1)dspfontsize, b); }
	void dspclear() { u8g2.clearBuffer(); u8g2.sendBuffer(); dspfgcolor=1; }
	void dspupdate() { u8g2.sendBuffer(); }
	void dspsetcursor(mem_t c) {}
	void dspsetfgcolor(uint8_t c) {}
	void dspsetbgcolor(uint8_t c) {}
	void dspsetreverse(mem_t c) {}
	mem_t dspident() {return 0;}
	void rgbcolor(int r, int g, int b) {}
	void vgacolor(short 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, mem_t col, mem_t row) { if (c) tft.drawChar(coldspfontsize, rowdspfontsize, c, dspfgcolor, dspbgcolor, 2); }
	void dspclear() {
	tft.fillScreen(dspbgcolor);
	dspfgcolor = dspdefaultfgcolor;
	dspfgvgacolor = dspdefaultfgvgacolor;
	}
	void dspupdate() {}
	void dspsetcursor(mem_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(mem_t c) {}
	mem_t dspident() {return 0; }
	void rgbcolor(int r, int g, int b) { dspfgvgacolor=rgbtovga(r, g, b); dspfgcolor=tft.color565(r, g, b);}
	void vgacolor(short 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, x0, x1, y1, dspfgcolor);}
	void frect(int x0, int y0, int x1, int y1) { tft.fillRect(x0, x0, 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, mem_t col, mem_t row) { if (c) tft.drawChar(coldspfontsize, rowdspfontsize, c, dspfgcolor, dspbgcolor, 2); }
	void dspclear() {
	tft.fillScreen(dspbgcolor);
	dspfgcolor = dspdefaultfgcolor;
	dspfgvgacolor = dspdefaultfgvgacolor;
	}
	void dspupdate() {}
	void dspsetcursor(mem_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(mem_t c) {}
	mem_t dspident() {return 0; }
	void rgbcolor(int r, int g, int b) { dspfgvgacolor=rgbtovga(r, g, b); dspfgcolor=tft.color565(r, g, b);}
	void vgacolor(short 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, x0, x1, y1, dspfgcolor);}
	void frect(int x0, int y0, int x1, int y1) { tft.fillRect(x0, x0, 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, mem_t col, mem_t row) {}
	void dspclear() {}
	void dspupdate() {}
	void dspsetcursor(mem_t c) {}
	void dspsetfgcolor(uint8_t c) {}
	void dspsetbgcolor(uint8_t c) {}
	void dspsetreverse(mem_t c) {}
	mem_t dspident() {return 0; }
	void rgbcolor(int r, int g, int b) { dspfgcolor=0; }
	void vgacolor(short 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, mem_t col, mem_t row) { if (c) tft.printChar(c, coldspfontsize, rowdspfontsize); }
	void dspclear() {
	tft.clrScr();
	dspfgcolor = dspdefaultfgcolor;
	dspfgvgacolor = dspdefaultfgvgacolor;
	vgacolor(dspfgvgacolor);
	}
	void rgbcolor(int r, int g, int b) {
	tft.setColor(r,g,b);
	dspfgcolor=((uint8_t)r << 16) + ((uint8_t)g << 8) + b;
	dspfgvgacolor=rgbtovga(r, g, b);
	}
	void vgacolor(short 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(mem_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(mem_t c) {}
	mem_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 - experimental
	* not all modes and possibilities explored, with networking on an ESP
	* VGA16 is advisable. It leaves enough memory for the interpreter and network.
	* this code overrides the display driver logic as fabgl brings an own
	* terminal emulation
	*/
	#if defined(ARDUINOVGA) && defined(ARDUINO_TTGO_T7_V14_Mini32)
	/* static fabgl::VGAController VGAController; */
	fabgl::VGA16Controller 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;
	#ifdef HASTONE
	fabgl::SoundGenerator soundGenerator;
	#endif


	/* 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(VGA_640x200_70Hz);
	Terminal.begin(&VGAController);
	Terminal.setBackgroundColor(vga_txt_background);
	Terminal.setForegroundColor(vga_txt_pen);
	Terminal.connectLocally();
	Terminal.clear();
	Terminal.enableCursor(1);
	Terminal.setTerminalType(TermType::VT52);
	}

	int vgastat(char c) {return 0; }

	/* scale the screen size */
	void vgascale(int* x, int* y) {
	y=y*10/24;
	}

	void rgbcolor(int r, int g, int b) {
	short vga;
	if (r>191 \|\| g>191 \|\| b>191) vga=8; else vga=0;
	vga=vga+r/128+g/1282+b/1284;
	vga_graph_pen=fabgl::Color(vga);
	}

	void vgacolor(short 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(char c) {return 0; }
	void vgawrite(char c){}
	#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
	*/
	#ifdef ARDUINO_TTGO_T7_V14_Mini32
	#define PS2FABLIB
	#define HASKEYBOARD
	fabgl::PS2Controller PS2Controller;
	char fabgllastchar = 0;
	#else
	#if defined(ARDUINO) && defined(ARDUINOPS2)
	#define PS2KEYBOARD
	#define HASKEYBOARD
	PS2Keyboard keyboard;
	#else
	#if defined(ARDUINO) && defined(ARDUINOUSBKBD)
	#define HASKEYBOARD
	#define USBKEYBOARD
	USBHost usb;
	KeyboardController keyboard(usb);
	char usbkey=0;
	#else
	#if defined(ARDUINOZX81KBD)
	#define HASKEYBOARD
	#define ZX81KEYBOARD
	ZX81Keyboard keyboard;
	#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 (usbkey>31 && usbkey<128) usbkey=usbkeymapGerman[usbkey-32];
	}
	}
	#endif

	/*
	* keyboard controller code
	*/

	void kbdbegin() {
	#ifdef PS2KEYBOARD
	keyboard.begin(PS2DATAPIN, PS2IRQPIN, PS2Keymap_German);
	#else
	#ifdef PS2FABLIB
	PS2Controller.begin(PS2Preset::KeyboardPort0);
	PS2Controller.keyboard()->setLayout(&fabgl::GermanLayout);
	#else
	#ifdef USBKEYBOARD
	/* nothing to be done here */
	#else
	#ifdef ZX81KEYBOARD
	keyboard.begin(zx81pins);
	#endif
	#endif
	#endif
	#endif
	}

	int kbdstat(char c) {return 0; }

	char 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();
	#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;
	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();
	#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*/
	#endif
	#endif
	#endif
	#endif
	#ifdef HASKEYPAD
	return keypadread();
	#endif
	return 0;
	}

	/*
	* this is a generic display code
	* it combines the functions of LCD and TFT drivers
	* if this code is active
	*
	* dspprintchar(char c, short col, short row)
	* dspclear()
	* dspbegin()
	* dspupdate()
	* dspsetcursor(mem_t c)
	* dspsetfgcolor(address_t c)
	* void dspsetbgcolor(address_t c)
	* void dspsetreverse(mem_t c)
	* mem_t dspident()
	*
	* have to be defined before in a hardware dependent section.
	* Only dspprintchar and dspclear are needed, all other can be stubs
	*
	* VGA systems don't use the display driver for text based output.
	*
	* The display driver exists as a buffered version that can scroll
	* or an unbuffered version that cannot scroll. Interfaces to hardware
	* scrolling are not yet implemented.
	*
	* A VT52 state engine is implemented and works for buffered and
	* unbuffered displays. Only buffered displays have the full VT52
	* feature set including most of the GEMDOS extensions described here:
	* https://en.wikipedia.org/wiki/VT52
	*
	* dspupdatemode controls the page update behaviour
	* 0: character mode, display each character separately
	* 1: line mode, update the display after each line
	* 2: page mode, update the display after an ETX
	* ignored if the display has no update function
	*
	*/

	#ifdef DISPLAYDRIVER

	/* the cursor position */
	mem_t dspmycol = 0;
	mem_t dspmyrow = 0;

	/* the escape state of the vt52 terminal */
	mem_t dspesc = 0;

	/* which update mode do we have */
	mem_t dspupdatemode = 0;

	/* how do we handle wrap 0 is wrap, 1 is no wrap */
	mem_t dspwrap = 0;

	/* the print mode */
	mem_t dspprintmode = 0;

	/* the scroll control variables */
	mem_t dspscrollmode = 0;
	mem_t dsp_scroll_rows = 1;

	int dspstat(char c) { return 0; }

	void dspsetcursorx(mem_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(mem_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 */
	}

	mem_t dspgetcursorx() { return dspmycol; }

	mem_t dspgetcursory() { return dspmyrow; }

	char 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(char c) {
	dspupdatemode=c;
	}

	char dspgetupdatemode() {
	return dspupdatemode;
	}

	void dspgraphupdate() {
	if (dspupdatemode == 0) dspupdate();
	}

	/* scrollable displays need a character buffer */
	#ifdef DISPLAYCANSCROLL

	/*
	* text color code for the scrolling display
	*
	* non scrolling displays simply use the pen color of the display
	* stored in dspfgcolor to paint the information on the screen
	*
	* for scrolling displays we store the color information of every
	* character in the display buffer to enable scrolling, to limit the
	* storage requirements, this code translates the color to a 4 bit VGA
	* color. This means that if BASIC uses 24 bit colors, the color may
	* change at scroll
	*
	*/

	#ifdef DISPLAYHASCOLOR
	/*
	* the display buffer is int here, lower 8 bits plus the sign
	* are the character, higher 7 the color and font
	*/
	typedef short dspbuffer_t;
	#else

	/* plain monochrome display buffer */
	typedef char dspbuffer_t;
	const uint16_t dspfgvgacolor = 0;
	#endif

	dspbuffer_t dspbuffer[dsp_rows][dsp_columns];

	/* buffer access functions */
	dspbuffer_t dspget(address_t i) {
	if (i>=0 && i<=dsp_columns*dsp_rows-1) return dspbuffer[i/dsp_columns][i%dsp_columns]; else return 0;
	}

	dspbuffer_t dspgetrc(mem_t r, mem_t c) { return dspbuffer[r][c]; }

	dspbuffer_t dspgetc(mem_t c) { return dspbuffer[dspmyrow][c]; }

	/* this functions prints a character and updates the display buffer */
	void dspsetxy(dspbuffer_t ch, mem_t c, mem_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);
	}
	}

	void dspset(address_t i, dspbuffer_t ch) {
	mem_t c=i%dsp_columns;
	mem_t r=i/dsp_columns;
	dspsetxy(ch, c, r);
	}

	/* 0 normal scroll, 1 enable waitonscroll function */
	void dspsetscrollmode(char c, short l) {
	dspscrollmode = c;
	dsp_scroll_rows = l;
	}

	/* clear the buffer */
	void dspbufferclear() {
	mem_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
	const uint16_t charmask = 0x80FF;
	#endif

	/* do the scroll */
	void dspscroll(mem_t scroll_rows, mem_t scroll_top=0){
	mem_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(mem_t line){
	mem_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;
	}

	/* code for low memory simple display access */
	#else
	/* buffer access functions */
	char dspget(address_t i) { return 0; }

	char dspgetrc(mem_t r, mem_t c) { return 0; }

	char dspgetc(mem_t c) { return 0; }

	void dspsetxy(char ch, mem_t c, mem_t r) {
	if (ch != 0) dspprintchar(ch, c, r); else dspprintchar(' ', c, r);
	}

	void dspset(address_t i, char ch) {
	mem_t c=i%dsp_columns;
	mem_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;
	}

	char dspwaitonscroll() { return 0; }

	/* a stub for dspwrite */
	void dspscroll(mem_t scroll_rows, mem_t scroll_top=0){
	dspmyrow=dsp_rows-1;
	}

	void dspsetscrollmode(char c, short l) {}
	void dspreversescroll(mem_t a){}
	#endif

	/* the generic write function for displays with and without buffers */

	void dspwrite(char c){
	mem_t dspmycolt;

	/* on escape call the vt52 state engine */
	#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

	switch(c) {
	case 0:
	return;
	case 7: // bell just a stub
	dspbell();
	return;
	case 9: // tab
	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 */
	mem_t vt52graph = 0;

	/* the secondary cursor */
	mem_t vt52mycol = 0;
	mem_t vt52myrow = 0;

	/* temp variables for column and row , do them here and not in the case: guess why */
	mem_t vt52tmpr;
	mem_t vt52tmpc;

	/* an output buffer for the vt52 terminal */
	const mem_t vt52buffersize = 4;
	char vt52outbuffer[vt52buffersize] = { 0, 0, 0, 0 };
	mem_t vt52bi = 0;
	mem_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 */
	mem_t vt52avail() { return vt52bi-vt52bj; }

	/* 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.
	* it is meant for situations where the terminal is controlled by a (powerful)
	* device with no or very few I/O pins. It can use the pins of the Arduino through
	* the terminal. This works as long as everything stays within the terminals timescale
	* On a 9600 baud interface, the character processing time is 1ms, everything slower
	* than approximately 10ms can be done through the serial line.
	*/

	#ifdef VT52WIRING
	#define VT52HASREGISTERS
	void vt52wiringcommand(uint8_t c) {
	switch(c) {
	case 'p': /* pinMode z */
	pinMode(vt52regz);
	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


	/* 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 (mem_t i=0; i<dsp_columns; i++) prtwrite(dspgetc(i));
	#endif
	break;
	case ']': /* Printer extension - print screen */
	#if defined(ARDUINOPRT) && defined(DISPLAYCANSCROLL)
	for (mem_t j=0; j<dsp_rows; j++)
	for (mem_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_columnsdspmyrow; i<dsp_columnsdsp_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 (mem_t i=dspmycol; i<dsp_columns; i++) dspsetxy(0, i, dspmyrow);
	break;
	case 'l': // GEMDOS / TOS extension clear line
	for (mem_t i=0; i<dsp_columns; i++) dspsetxy(0, i, dspmyrow);
	break;
	case 'o': // GEMDOS / TOS extension clear to start of line
	for (mem_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 VT52REGISTERS
	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':
	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, address_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 0; }
	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; };
	char dspactive() {return 1; }
	void dspsetupdatemode(char 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(char c) {}
	void dspwrite(char c){};
	void dspbegin() {};
	int dspstat(char c) {return 0; }
	char dspwaitonscroll() { return 0; };
	char dspactive() {return 0; }
	void dspsetscrollmode(char c, mem_t l) {}
	void dspscroll(mem_t a, mem_t b){}
	char vt52read() { return 0; }
	mem_t vt52avail() { return 0; }
	#endif
	#endif

	/*
	* Arduino Real Time clock. The interface here offers the values as number_t
	* combining all values.
	*
	* The code does not use an RTC library any more all the rtc support is
	* builtin now.
	*
	* A clock must activate the macro #define HASCLOCK to make the clock
	* available in BASIC.
	*
	* Four software models are supported
	* - Built-in clocks of STM32, MKR, and ESP32 are supported by default
	* - I2C clocks can be activated: DS1307, DS3231, and DS3232
	* - A Real Time Clock emulation is possible using millis()
	*
	* rtcget accesses the internal registers of the clock.
	* Registers 0-6 are bcd transformed to return
	* seconds, minutes, hours, day of week, day, month, year
	*
	* On I2C clocks registers 7-255 are returned as memory cells
	*/

	#ifdef ARDUINORTC
	#define HASCLOCK
	/*
	* 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 */
	short rtcget(short i) {

	/* set the address of the read */
	Wire.beginTransmission(RTCI2CADDR);
	Wire.write(i);
	Wire.endTransmission();

	/* now read */
	Wire.requestFrom(RTCI2CADDR, 1);
	uint8_t v=Wire.read();

	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, short 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 */
	Wire.beginTransmission(RTCI2CADDR);
	Wire.write(i);
	Wire.write(b);
	Wire.endTransmission();
	}
	#else
	#if defined(HASBUILTINRTC)
	#define HASCLOCK
	/*
	* 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 */
	short rtcget(short 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, short 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 */
	short rtcget(short 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, short 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
	#else
	#ifdef ARDUINORTCEMULATION
	#define HASCLOCK
	/*
	* 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; /* 4365 + 1 /
	const unsigned long int daysinhundredy = 36524ul; /* 100365 + 25 - 1 /
	const unsigned long int daysinfourhundredy = 146097ul; /* 400365 + 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 */
	short rtcget(short 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, short 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;
	}
	#else
	#if defined(ARDUINO_ARCH_ESP32)
	#define HASCLOCK
	/*
	* On ESP32 we use the builtin clock, this is a generic Unix time mechanism equivalent
	* to the code in hardware-posix.h
	*/

	/* no begin needed */
	void rtcbegin() {}

	/* get the time */
	short rtcget(short 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, short 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() {}
	short rtcget(short i) { return 0; }
	void rtcset(uint8_t i, short v) { }
	#endif
	#endif
	#endif
	#endif

	/*
	* External EEPROM is handled through an EFS filesystem object
	* see https://github.com/slviajero/EepromFS
	* for details. Here the most common parameters are set as a default.
	*/
	#ifdef ARDUINOEFS
	#undef ARDUINOI2CEEPROM
	#ifndef EFSEEPROMADDR
	#define EFSEEPROMADDR 0x50
	#endif
	#ifdef EFSEEPROMSIZE
	EepromFS EFS(EFSEEPROMADDR, EFSEEPROMSIZE);
	#else
	EepromFS EFS(EFSEEPROMADDR);
	#endif
	#endif

	/*
	* External EEPROM is handled through an EFS filesystem object in raw mode
	* see https://github.com/slviajero/EepromFS
	* for details. Here the most common parameters are set as a default.
	*/

	#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 */
	#define MQTTLENGTH 32
	static char mqtt_otopic[MQTTLENGTH];
	static char mqtt_itopic[MQTTLENGTH];

	/*
	* the buffers for MQTT messages, input and output goes
	* through these static buffers.
	*/
	#define MQTTBLENGTH 128
	volatile char mqtt_buffer[MQTTBLENGTH];
	volatile short mqtt_messagelength;
	volatile char mqtt_obuffer[MQTTBLENGTH];
	volatile short mqtt_charsforsend;

	/* the name of the client, generated pseudo randomly to avoind
	naming conflicts */
	static char mqttname[12] = "iotbasicxxx";
	void mqttsetname() {
	long 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
	#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)
	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)
	WiFi.end();
	WiFi.begin(ssid, password);
	bdelay(1000);
	#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
	*/
	char 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
	*/
	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 */
	int mqttstat(char 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
	*/
	char mqttreconnect() {
	short timer=10;
	char 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) {
	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 */
	int mqttstate() {
	return bmqtt.state();
	}

	/* subscribing to a topic */
	void mqttsubscribe(char *t) {
	short i;

	for (i=0; i<MQTTLENGTH; i++) {
	if ((mqtt_itopic[i]=t[i]) == 0 ) break;
	}
	if (!mqttreconnect()) {ert=1; return;};
	if (!bmqtt.subscribe(mqtt_itopic)) ert=1;
	}

	void mqttunsubscribe() {
	if (!mqttreconnect()) {ert=1; return;};
	if (!bmqtt.unsubscribe(mqtt_itopic)) ert=1;
	*mqtt_itopic=0;
	}

	/*
	* set the topic we pushlish, coming from OPEN
	* BASIC can do only one topic.
	*
	*/
	void mqttsettopic(char *t) {
	short 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(char *m, short l) {
	short 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()) {ert=1; return;};
	if (!bmqtt.publish(mqtt_otopic, (uint8_t*) mqtt_obuffer, (unsigned int) mqtt_charsforsend-1, false)) ert=1;
	mqtt_charsforsend=0;
	}
	}

	/*
	* ins copies the buffer into a basic string
	* - behold the jabberwock - length gynmastics
	* z.a has to be the loop variable and contain the length after this -> intended side effect
	*/
	void mqttins(char *b, short nb) {
	for (z.a=0; z.a<nb && z.a<mqtt_messagelength; z.a++) b[z.a+1]=mqtt_buffer[z.a];
	b[0]=z.a;
	mqtt_messagelength=0;
	*mqtt_buffer=0;
	}

	/* just one character to emulate basic get */
	char mqttinch() {
	char ch=0;
	short 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() {}
	char netconnected() { return 0; }
	void mqttbegin() {}
	int mqttstate() {return 0;}
	void mqttsubscribe(char *t) {}
	void mqttsettopic(char *t) {}
	void mqttouts(char *m, short l) {}
	void mqttins(char *b, short nb) { z.a=0; };
	char mqttinch() {return 0;};
	#endif

	/*
	* EEPROM handling, these function enable the @E array and
	* loading and saving to EEPROM with the "!" mechanism
	*/
	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
	/* 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 (ert !=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(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)
	address_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)
	return EEPROM.length();
	#endif
	#ifdef ARDUINO_ARCH_LGT8F
	return EEPROM.length(); /* on newer LGT8 cores, older ones don't have this, set 512 instead */
	#endif
	return 0;
	}

	void eupdate(address_t a, mem_t c) {
	#if defined(ARDUINO_ARCH_ESP8266) \|\|defined(ARDUINO_ARCH_ESP32)\|\| defined(AARDUINO_ARCH_LGT8F) \|\| defined(ARDUINO_ARCH_XMC)
	EEPROM.write(a, c);
	#else
	#if defined(ARDUINO_ARCH_STM32)
	eeprom_buffered_write_byte(a, c);
	#else
	EEPROM.update(a, c);
	#endif
	#endif
	}

	mem_t eread(address_t a) {
	#ifdef ARDUINO_ARCH_STM32
	return (signed char) eeprom_buffered_read_byte(a);
	#else
	return (signed char) EEPROM.read(a);
	#endif
	}
	#else
	#if defined(ARDUINOI2CEEPROM)
	address_t elength() {
	return i2ceepromsize;
	}

	void eupdate(address_t a, mem_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);
	ert=Wire.endTransmission();
	/* wait the max time */
	bdelay(5);
	}
	#endif
	}

	mem_t eread(address_t a) {
	#ifdef ARDUINOI2CEEPROM_BUFFERED
	return (mem_t) EFSRAW.rawread(a);
	#else
	/* read directly from the EEPROM */

	/* set the address */
	Wire.beginTransmission(I2CEEPROMADDR);
	Wire.write((int)a/256);
	Wire.write((int)a%256);
	ert=Wire.endTransmission();

	/* read a byte */
	if (ert == 0) {
	Wire.requestFrom(I2CEEPROMADDR, 1);
	return (mem_t) Wire.read();
	} else return 0;

	#endif
	}
	#else
	/* no EEPROM present */
	address_t elength() { return 0; }
	void eupdate(address_t a, mem_t c) { return; }
	mem_t eread(address_t a) { return 0; }
	#endif
	#endif

	/*
	* the wrappers of the arduino io functions
	* awrite requires ESP32 2.0.2 core, else disable awrite()
	*/

	void aread(){
	push(analogRead(popaddress()));
	}

	void dread(){
	push(digitalRead(popaddress()));
	}

	void awrite(address_t p, address_t v){
	if (v >= 0 && v<256) analogWrite(p, v);
	else error(EORANGE);
	}

	void dwrite(address_t p, address_t v){
	if (v == 0) digitalWrite(p, LOW);
	else if (v == 1) digitalWrite(p, HIGH);
	else error(EORANGE);
	}

	/* 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.
	*/
	void pinm(address_t p, address_t m){
	uint8_t ml = m;
	uint8_t pl = p;
	switch (ml) {
	case 0:
	pinMode(pl, INPUT);
	break;
	case 1:
	pinMode(pl, OUTPUT);
	break;
	default:
	pinMode(pl, ml);
	break;
	}
	}

	/* read a pulse, units given by bpulseunit - default 10 microseconds */
	void bpulsein() {
	address_t x,y;
	unsigned long t, pt;

	t=((unsigned long) pop())*1000;
	y=popaddress();
	x=popaddress();
	if (er != 0) return;

	pt=pulseIn(x, y, t)/bpulseunit;
	push(pt);
	}

	/* write a pulse in microsecond range */
	void bpulseout(short a) {
	short pin, duration;
	short value = 1;
	short intervall = 0;
	short repetition = 1;
	if (a == 5) { intervall=pop(); repetition=pop(); }
	if (a > 2) value=pop();
	duration=pop();
	pin=pop();

	while (repetition--) {
	digitalWrite(pin, value);
	delayMicroseconds(duration*bpulseunit);
	digitalWrite(pin, !value);
	delayMicroseconds(intervall*bpulseunit);
	}
	}

	void btone(short a) {
	number_t d = 0;
	number_t v = 100;
	if (a == 4) v=pop();
	if (a >= 3) d=pop();
	x=pop();
	y=pop();
	#if defined(ARDUINO_TTGO_T7_V14_Mini32) && defined(HASTONE)
	/* 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
	*
	*/
	if (x == 0) {
	soundGenerator.play(false);
	soundGenerator.clear();
	return;
	}
	if (a == 2) d=60000;
	if (y == 128) soundGenerator.playSound(SineWaveformGenerator(), x, d, v);
	if (y == 129) soundGenerator.playSound(SquareWaveformGenerator(), x, d, v);
	if (y == 130) soundGenerator.playSound(SawtoothWaveformGenerator(), x, d, v);
	if (y == 131) soundGenerator.playSound(TriangleWaveformGenerator(), x, d, v);
	if (y == 132) soundGenerator.playSound(VICNoiseGenerator(), x, d, v);
	if (y == 133) soundGenerator.playSound(NoiseWaveformGenerator(), x, d, v);
	if (y >= 255 && y < 512 ) {
	y=y-255;
	SquareWaveformGenerator sqw;
	sqw.setDutyCycle(y);
	soundGenerator.playSound(sqw, x, d, v);
	}
	return;
	#endif

	#ifndef ARDUINOTONEEMULATION
	if (x == 0) {
	noTone(y);
	} else if (a == 2) {
	tone(y, x);
	} else {
	tone(y, x, d);
	}
	#else
	if (x == 0) {
	playtone(0, 0, 0);
	} else if (a == 2) {
	playtone(y, x, 32767);
	} else {
	playtone(y, x, d);
	}
	#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. YIELDTIME is 2 generating
	* a 2 ms wait after the network loop to allow for buffer
	* clearing after - this is needed on ESP8266
	*
	* LONGYIELDINTERVAL by default is 1000, generating a one second
	* call to maintenance functions.
	*
	* On an ESP8266 byield() is called every 100 microseconds
	* (after each statement) in RUN mode. BASIC DELAY calls
	* this every YIELDTIME ms.
	*/

	/* 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
	/* this was delay(YIELDTIME) originally - removed now */
	}

	/* everything that needs to be done not so often - 1 second */
	void longyieldfunction() {
	#ifdef ARDUINOETH
	Ethernet.maintain();
	#endif
	}

	void yieldschedule() {
	/* delay(0) is only needed on ESP8266! it calls the scheduler - no bdelay here!! */
	#if defined(ARDUINO_ARCH_ESP8266)
	delay(0);
	#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
	*/
	#if defined(ARDUINOSD) \|\| defined(ESPSPIFFS) \|\| defined(STM32SDIO)
	File ifile;
	File ofile;
	char tempname[SBUFSIZE];
	#if defined(ARDUINOSD) \|\| defined(STM32SDIO)
	File root;
	File file;
	#ifdef ARDUINO_ARCH_ESP32
	const char rootfsprefix[2] = "/";
	#else
	const char rootfsprefix[1] = "";
	#endif
	#endif
	#ifdef ESPSPIFFS
	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 (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

	/* use EEPROM as filesystem */
	#ifdef ARDUINOEFS
	byte ifile;
	byte ofile;
	byte file;
	#endif

	/* these filesystems may have a path prefixes, we treat STM32SDIO like an SD here */
	#if defined(RP2040LITTLEFS) \|\| defined(ESPSPIFFS) \|\| defined(ARDUINOSD)
	char tmpfilename[10+SBUFSIZE];

	/* add the prefix to the filename */
	char* mkfilename(const char* filename) {
	short i,j;
	for(i=0; i<10 && rootfsprefix[i]!=0; i++) tmpfilename[i]=rootfsprefix[i];
	tmpfilename[i++]='/';
	for(j=0; j<SBUFSIZE && 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) {
	short 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
	* the verbose option needs to be checked
	*
	* if SDPIN is empty it is the standard SS pin of the platfrom
	*
	*/

	static int fsbegins = -1;

	void fsbegin(char v) {
	#ifdef ARDUINOSD
	#ifndef SDPIN
	#define SDPIN
	#endif
	if (SD.begin(SDPIN) && v) outsc("SDcard ok \n"); else outsc("SDcard not ok \n");
	#endif
	#ifdef STM32SDIO
	int i = 1;
	while (i<100) {
	if (SD.begin(SD_DETECT_PIN)) {fsbegins=i; break; } else fsbegins=0;
	bdelay(20);
	i++;
	}
	#endif
	#if defined(ESPSPIFFS) && defined(ARDUINO_ARCH_ESP8266)
	if (SPIFFS.begin() && v) {
	outsc("SPIFFS ok \n");
	FSInfo fs_info;
	SPIFFS.info(fs_info);
	outsc("File system size "); outnumber(fs_info.totalBytes); outcr();
	outsc("File system used "); outnumber(fs_info.usedBytes); outcr();
	}
	#endif
	#if defined(ESPSPIFFS) && defined(ARDUINO_ARCH_ESP32)
	if (SPIFFS.begin() && v) {
	outsc("SPIFFS ok \n"); outcr();
	}
	#endif
	#ifdef RP2040LITTLEFS
	myFS = new LittleFS_MBED();
	if (myFS->init() && v) outsc("LittleFS ok \n");
	#endif
	#ifdef ARDUINOEFS
	int s=EFS.begin();
	if (s>0 && v) {
	outsc("Mounted EFS with "); outnumber(s); outsc(" slots.\n");
	} else {
	if (EFS.format(32) && v) outsc("EFS: formating 32 slots.\n");
	}
	#endif
	}

	int fsstat(char c) {
	#if defined(FILESYSTEMDRIVER)
	if (c == 0) return 1;
	#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(STM32SDIO)
	if (ofile) ofile.write(c); else ert=1;
	#endif
	#if defined(RP2040LITTLEFS)
	if (ofile) fputc(c, ofile); else ert=1;
	#endif
	#if defined(ARDUINOEFS)
	if (ofile) {
	if (!EFS.fputc(c, ofile)) ert=-1;
	} else ert=1;
	#endif
	}

	char fileread(){
	char c;
	#if defined(ARDUINOSD) \|\| defined(ESPSPIFFS) \|\| defined(STM32SDIO)
	if (ifile) c=ifile.read(); else { ert=1; return 0; }
	if (c == -1 \|\| c == 255) ert=-1;
	return c;
	#endif
	#ifdef RP2040LITTLEFS
	if (ifile) c=fgetc(ifile); else { ert=1; return 0; }
	if (c == -1 \|\| c == 255) ert=-1;
	return c;
	#endif
	#ifdef ARDUINOEFS
	if (ifile) c=EFS.fgetc(ifile); else { ert=1; return 0; }
	if (c == -1\|\| c == 255) ert=-1;
	return c;
	#endif
	return 0;
	}

	int fileavailable(){
	#if defined(ARDUINOSD) \|\| defined(ESPSPIFFS) \|\| defined(STM32SDIO)
	return ifile.available();
	#endif
	#ifdef RP2040LITTLEFS
	return !feof(ifile);
	#endif
	#ifdef ARDUINOEFS
	return EFS.available(ifile);
	#endif
	return 0;
	}

	char ifileopen(const char* filename){
	#if defined(ARDUINOSD)
	ifile=SD.open(mkfilename(filename), FILE_READ);
	return (int) ifile;
	#endif
	#if defined(STM32SDIO)
	ifile=SD.open(filename);
	return (int) ifile;
	#endif
	#ifdef ESPSPIFFS
	ifile=SPIFFS.open(mkfilename(filename), "r");
	return (int) ifile;
	#endif
	#ifdef RP2040LITTLEFS
	ifile=fopen(mkfilename(filename), "r");
	return (int) ifile;
	#endif
	#ifdef ARDUINOEFS
	ifile=EFS.fopen(filename, "r");
	return (int) ifile;
	#endif
	return 0;
	}

	void ifileclose(){
	#if defined(ARDUINOSD) \|\| defined(ESPSPIFFS) \|\| defined(STM32SDIO)
	ifile.close();
	#endif
	#ifdef RP2040LITTLEFS
	if (ifile) fclose(ifile);
	ifile=NULL;
	#endif
	#ifdef ARDUINOEFS
	if (ifile) EFS.fclose(ifile);
	ifile=0;
	#endif
	}

	char ofileopen(char* filename, const char* m){
	#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 (int) ofile;
	#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 (int) ofile;
	#endif
	#ifdef ESPSPIFFS
	ofile=SPIFFS.open(mkfilename(filename), m);
	return (int) ofile;
	#endif
	#ifdef RP2040LITTLEFS
	ofile=fopen(mkfilename(filename), m);
	return (int) ofile;
	#endif
	#ifdef ARDUINOEFS
	ofile=EFS.fopen(filename, m);
	return (int) ofile;
	#endif
	return 0;
	}

	void ofileclose(){
	#if defined(ARDUINOSD) \|\| defined(ESPSPIFFS) \|\| defined(STM32SDIO)
	ofile.close();
	#endif
	#ifdef RP2040LITTLEFS
	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() {
	#if defined(ARDUINOSD) \|\| defined(STM32SDIO)
	root=SD.open("/");
	#endif
	#ifdef ESPSPIFFS
	#ifdef ARDUINO_ARCH_ESP8266
	root=SPIFFS.openDir("/");
	#endif
	#ifdef ARDUINO_ARCH_ESP32
	root=SPIFFS.open("/");
	#endif
	#endif
	#ifdef RP2040LITTLEFS
	root=opendir(rootfsprefix);
	#endif
	#ifdef ARDUINOEFS
	EFS.dirp=0;
	#endif
	}

	int rootnextfile() {
	#if defined(ARDUINOSD) \|\| defined(STM32SDIO)
	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 RP2040LITTLEFS
	file = readdir(root);
	return (file != 0);
	#endif
	#ifdef ARDUINOEFS
	file = EFS.readdir();
	return (file != 0);
	#endif
	return 0;
	}

	int rootisfile() {
	#if defined(ARDUINOSD) \|\| defined(STM32SDIO)
	return (! file.isDirectory());
	#endif
	#ifdef ESPSPIFFS
	#ifdef ARDUINO_ARCH_ESP8266
	return 1;
	#endif
	#ifdef ARDUINO_ARCH_ESP32
	return (! file.isDirectory());
	#endif
	#endif
	#ifdef RP2040LITTLEFS
	return (file->d_type == DT_REG);
	#endif
	#ifdef ARDUINOEFS
	return 1;
	#endif
	return 0;
	}

	const char* rootfilename() {
	#if defined(ARDUINOSD)
	//return (char*) file.name();
	return rmrootfsprefix(file.name());
	#endif
	#if defined(STM32SDIO)
	return (char*) file.name();
	#endif
	#ifdef ESPSPIFFS
	#ifdef ARDUINO_ARCH_ESP8266
	// c_str() and copy - real ugly
	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 RP2040LITTLEFS
	return (file->d_name);
	#endif
	#ifdef ARDUINOEFS
	return EFS.filename(file);
	#endif
	return 0;
	}

	long rootfilesize() {
	#if defined(ARDUINOSD) \|\| defined(ESPSPIFFS) \|\| defined(STM32SDIO)
	return file.size();
	#endif
	#ifdef RP2040LITTLEFS
	#endif
	#ifdef ARDUINOEFS
	return EFS.filesize(file);
	#endif
	return 0;
	}

	void rootfileclose() {
	#if defined(ARDUINOSD) \|\| defined(ESPSPIFFS) \|\| defined(STM32SDIO)
	file.close();
	#endif
	#ifdef RP2040LITTLEFS
	#endif
	#ifdef ARDUINOEFS
	#endif
	}

	void rootclose(){
	#if defined(ARDUINOSD) \|\| defined(STM32SDIO)
	root.close();
	#endif
	#ifdef ESPSPIFFS
	#ifdef ARDUINO_ARCH_ESP8266
	return;
	#endif
	#ifdef ARDUINO_ARCH_ESP32
	root.close();
	#endif
	#endif
	#ifdef RP2040LITTLEFS
	#endif
	#ifdef ARDUINOEFS
	#endif
	}

	/*
	* remove method for files
	*/
	void removefile(char *filename) {
	#if defined(ARDUINOSD)
	SD.remove(mkfilename(filename));
	return;
	#endif
	#if defined(STM32SDIO)
	SD.remove(filename);
	return;
	#endif
	#ifdef ESPSPIFFS
	SPIFFS.remove(mkfilename(filename));
	return;
	#endif
	#ifdef RP2040LITTLEFS
	remove(mkfilename(filename));
	return;
	#endif
	#ifdef ARDUINOEFS
	EFS.remove(filename);
	return;
	#endif
	}

	/*
	* formatting for fdisk of the internal filesystems
	*/
	void formatdisk(short i) {
	#if defined(ARDUINOSD) \|\| defined(STM32SDIO)
	return;
	#endif
	#ifdef ESPSPIFFS
	if (SPIFFS.format()) { SPIFFS.begin(); outsc("ok\n"); } else { outsc("fail\n"); }
	#endif
	#ifdef RP2040LITTLEFS
	fs.reformat(&bd);
	return;
	#endif
	#ifdef ARDUINOEFS
	if (i>0 && i<256) {
	if (EFS.format(i)) { EFS.begin(); outsc("ok\n"); } else { outsc("fail\n"); }
	outcr();
	} else error(EORANGE);
	return;
	#endif
	}

	/*
	* 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 USESPICOSERIAL
	volatile static char picochar;
	volatile static char picoa = 0;
	volatile static char* picob = NULL;
	static short picobsize = 0;
	volatile static short picoi = 1;

	/* this is mostly taken from PicoSerial */
	const uint16_t MIN_2X_BAUD = F_CPU/(4(20XFFF + 1)) + 1;

	/* the begin code */
	void picobegin(unsigned long 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;
	z.a=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 */
	void picoins(char *b, short nb) {
	char c;
	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();
	outcr();
	return;
	}

	/* 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 USESPICOSERIAL
	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 USESPICOSERIAL
	picobegin(serial_baudrate);
	#else
	SERIALPORT.begin(serial_baudrate);
	#endif
	bdelay(1000);
	}

	/* state information on the serial port */
	int serialstat(char c) {
	if (c == 0) return 1;
	if (c == 1) return serial_baudrate;
	return 0;
	}

	/* write to a serial stream */
	void serialwrite(char c) {
	#ifdef USESPICOSERIAL
	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 */
	short serialcheckch() {
	#ifdef USESPICOSERIAL
	return picochar;
	#else
	if (SERIALPORT.available()) return SERIALPORT.peek(); else return 0; // should really be -1
	#endif
	}

	/* avail method, needed for AVAIL() */
	short serialavailable() {
	#ifdef USESPICOSERIAL
	return picoi;
	#else
	return SERIALPORT.available();
	#endif
	}

	/* flush serial */
	void serialflush() {
	#ifdef USESPICOSERIAL
	return;
	#else
	while (SERIALPORT.available()) SERIALPORT.read();
	#endif
	}


	/*
	* reading from the console with inch or the picoserial callback
	* this mixes interpreter levels as inch/outch are used here
	* this code needs to go to the main interpreter section after
	* thorough rewrite
	*/
	void consins(char *b, short nb) {
	char c;

	z.a = 1;
	#ifdef USESPICOSERIAL
	if (id == ISERIAL) {
	picoins(b, nb);
	return;
	}
	#endif
	while(z.a < 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) {
	if (z.a>1) z.a--;
	} else {
	b[z.a++]=c;
	}
	}
	b[z.a]=0;
	z.a--;
	b[0]=(unsigned char)z.a;
	}

	/*
	* 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)
	#include <SoftwareSerial.h>
	const int software_serial_rx = SOFTSERIALRX;
	const int software_serial_tx = SOFTSERIALTX;
	SoftwareSerial PRTSERIAL(software_serial_rx, software_serial_tx);
	#endif

	/* second serial port */
	void prtbegin() {
	PRTSERIAL.begin(serial1_baudrate);
	}

	/* the open functions are not needed here */
	char prtopen(char* filename, int mode) {}
	void prtclose() {}

	int prtstat(char 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();
	}

	short prtcheckch() {
	if (PRTSERIAL.available()) return PRTSERIAL.peek(); else return 0;
	}

	short prtavailable() {
	return PRTSERIAL.available();
	}

	void prtset(int s) {
	serial1_baudrate=s;
	prtbegin();
	}
	#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 */
	#ifdef 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(ARDUINOWIRE) && defined(HASFILEIO))
	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(char s) {
	#ifndef SDA_PIN
	Wire.begin(s);
	#else
	Wire.begin(SDA_PIN, SCL_PIN, s);
	#endif
	}

	/* wire status - just checks if wire is compiled */
	int wirestat(char 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*/
	short 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(char s, char 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
	} else
	error(EORANGE);
	}

	/* input an entire string */
	void wireins(char *b, uint8_t l) {
	if (wire_myid == 0) {
	z.a=0;
	if (l>ARDUINOWIREBUFFER) l=ARDUINOWIREBUFFER;
	if (!Wire.requestFrom(wire_slaveid, l)) ert=1;
	while (Wire.available() && z.a<l) b[++z.a]=Wire.read();
	} else {
	#ifdef ARDUINOWIRESLAVE
	for (z.a=0; z.a<wirereceivechars && z.a<l; z.a++) b[z.a+1]=wirereceivebuffer[z.a];
	wirereceivechars=0; /* clear the entire buffer on read, bytewise read not really supported */
	#endif
	}
	b[0]=z.a;
	}

	/* send an entire string - truncate radically */
	void wireouts(char *b, uint8_t l) {
	if (l>ARDUINOWIREBUFFER) l=ARDUINOWIREBUFFER;
	if (wire_myid == 0) {
	Wire.beginTransmission(wire_slaveid);
	#ifdef ARDUINO_ARCH_ESP32
	for(z.a=0; z.a<l; z.a++) Wire.write(b[z.a]);
	#else
	Wire.write(b, l);
	#endif
	ert=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(ARDUINOWIRE))
	/* single byte access functions on Wire */
	short wirereadbyte(short port) {
	if (!Wire.requestFrom(port, 1)) ert=1;
	return Wire.read();
	}
	void wirewritebyte(short port, short data) {
	Wire.beginTransmission(port);
	Wire.write(data);
	Wire.endTransmission();
	}
	void wirewriteword(short port, short data1, short data2) {
	Wire.beginTransmission(port);
	Wire.write(data1);
	Wire.write(data2);
	Wire.endTransmission();
	}
	#endif

	#if (defined(ARDUINOWIRE) && !defined(HASFILEIO))
	int wirestat(char c) {return 0; }
	void wireopen(char s, char m) {}
	void wireins(char *b, uint8_t l) { b[0]=0; z.a=0; }
	void wireouts(char *b, uint8_t l) {}
	short wireavailable() { return 0; }
	#endif

	#ifndef ARDUINOWIRE
	void wirebegin() {}
	int wirestat(char c) {return 0; }
	void wireopen(char s, char m) {}
	void wireins(char *b, uint8_t l) { b[0]=0; z.a=0; }
	void wireouts(char *b, uint8_t l) {}
	short wireavailable() { return 0; }
	short wirereadbyte(short port) { return 0; }
	void wirewritebyte(short port, short data) { return; }
	void wirewriteword(short port, short data1, short data2) { return; }
	#endif

	/*
	* Read from the radio interface, radio is always block
	* oriented. 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 */
	int radiostat(char c) {
	#if defined(ARDUINORF24)
	if (c == 0) return 1;
	if (c == 1) return radio.isChipConnected();
	#endif
	return 0;
	}

	/* generate a uint64_t pipe address from the filename string for RF24 */
	uint64_t pipeaddr(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;
	}
	#endif

	/* read an entire string */
	void radioins(char *b, short nb) {
	#ifdef ARDUINORF24
	if (radio.available()) {
	radio.read(b+1, nb);
	if (!blockmode) {
	for (z.a=0; z.a<nb; z.a++) if (b[z.a+1]==0) break;
	} else {
	z.a=radio.getPayloadSize();
	if (z.a > nb) z.a=nb;
	}
	b[0]=z.a;
	} else {
	b[0]=0;
	b[1]=0;
	z.a=0;
	}
	#else
	b[0]=0;
	b[1]=0;
	z.a=0;
	#endif
	}

	/* write to radio, no character mode here */
	void radioouts(char *b, short l) {
	#ifdef ARDUINORF24
	radio.stopListening();
	if (!radio.write(b, l)) ert=1;
	radio.startListening();
	#endif
	}

	/* radio available */
	short radioavailable() {
	#ifdef ARDUINORF24
	return radio.available();
	#endif
	return 0;
	}

	/*
	* 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(char *filename) {
	#ifdef ARDUINORF24
	if (!radio.begin()) ert=1;
	radio.openReadingPipe(1, pipeaddr(filename));
	radio.startListening();
	#endif
	}

	void oradioopen(char *filename) {
	#ifdef ARDUINORF24
	if (!radio.begin()) ert=1;
	radio.openWritingPipe(pipeaddr(filename));
	#endif
	}

	void radioset(int s) {
	#ifdef ARDUINORF24
	if ((s<0) && (s>3)) {error(EORANGE); return; }
	rf24_pa=(rf24_pa_dbm_e) s;
	radio.setPALevel(rf24_pa);
	#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
	}

	number_t sensorread(short s, short 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() {}
	number_t sensorread(short s, short v) {return 0;};
	#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
	#define USEMEMINTERFACE
	#define SPIRAMINTERFACE

	/*
	* 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 */
	address_t spirambegin() {
	pinMode(RAMPIN, OUTPUT);
	digitalWrite(RAMPIN, LOW);
	SPI.transfer(SPIRAMRSTIO);
	SPI.transfer(SPIRAMWRMR);
	//SPI.transfer(SPIRAMBYTE);
	SPI.transfer(SPIRAMSEQ);
	digitalWrite(RAMPIN, HIGH);
	/* only 32 kB addressable with 16 bit integers because address_t has to fit into number_t
	the interpreter would work also with 64kB but PEEK, POKE and the DARKARTS are broken then*/
	if (maxnum>32767) return 65534; else return 32766;
	}

	/* the simple unbuffered byte read, with a cast to signed char */
	mem_t spiramrawread(address_t a) {
	mem_t c;
	digitalWrite(RAMPIN, LOW);
	SPI.transfer(SPIRAMREAD);
	SPI.transfer((byte)(a >> 8));
	SPI.transfer((byte)a);
	c = SPI.transfer(0x00);
	digitalWrite(RAMPIN, HIGH);
	return c;
	}

	/* one read only buffer for access from the token stream
	memread calls this */
	address_t spiram_robufferaddr = 0;
	mem_t spiram_robuffervalid=0;
	const address_t spiram_robuffersize = 32;
	mem_t spiram_robuffer[spiram_robuffersize];

	/* one rw buffer for access to the heap and all the program editing
	memread2 and memwrite2 call this*/
	address_t spiram_rwbufferaddr = 0;
	mem_t spiram_rwbuffervalid=0;
	const address_t spiram_rwbuffersize = 32; /* also change the addressmask if you want to play here */
	mem_t spiram_rwbuffer[spiram_rwbuffersize];
	mem_t spiram_rwbufferclean = 1;

	const address_t spiram_addrmask=0xffe0;
	/* const address_t spiram_addrmask=0xffd0; // 64 byte frame */

	/* the elementary buffer access functions used almost everywhere */

	void spiram_bufferread(address_t a, mem_t* b, address_t l) {
	digitalWrite(RAMPIN, LOW);
	SPI.transfer(SPIRAMREAD);
	SPI.transfer((byte)(a >> 8));
	SPI.transfer((byte)a);
	SPI.transfer(b, l);
	digitalWrite(RAMPIN, HIGH);
	}

	void spiram_bufferwrite(address_t a, mem_t* b, address_t l) {
	digitalWrite(RAMPIN, LOW);
	SPI.transfer(SPIRAMWRITE);
	SPI.transfer((byte)(a >> 8));
	SPI.transfer((byte)a);
	SPI.transfer(b, l);
	digitalWrite(RAMPIN, HIGH);
	}

	mem_t spiram_robufferread(address_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;
	}
	}

	mem_t spiram_rwbufferread(address_t a) {
	/* page fault, do read, ignore the ro buffer buffer */
	address_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(address_t a, mem_t c) {
	address_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(address_t a, mem_t c) {
	digitalWrite(RAMPIN, LOW);
	SPI.transfer(SPIRAMWRITE);
	SPI.transfer((byte)(a >> 8));
	SPI.transfer((byte)a);
	SPI.transfer((byte) 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


	/* the code to address EEPROMs directly */
	#ifdef ARDUINOPGMEEPROM
	#define USEMEMINTERFACE
	#define EEPROMMEMINTERFACE
	#else
	#undef EEPROMMEMINTERFACE
	#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

	/*
	* 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.
	*/
	#ifdef ARDUINOTONEEMULATION
	static mem_t tone_enabled;
	static mem_t tone_pinstate = 0;
	static unsigned long tone_intervall;
	static unsigned long tone_micros;
	static int tone_duration;
	static unsigned long tone_start;
	static mem_t tone_pin;

	void playtone(int pin, int frequency, int duration){

	/* 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 or frequency 0 stops playing */
	if (duration == 0 \|\| 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);
	}
	}
	#endif

	/*
	* the events API for Arduino with interrupt service routines
	* analogous to the timer API
	*
	* we use raw modes here
	*
	* #define CHANGE 1
	* #define FALLING 2
	* #define RISING 3
	*
	*/

	#ifdef HASEVENTS
	/* interrupts in BASIC fire once and then disable themselves, BASIC reenables them */
	void bintroutine0() {
	eventlist[0].active=1;
	detachInterrupt(digitalPinToInterrupt(eventlist[0].pin));
	}
	void bintroutine1() {
	eventlist[1].active=1;
	detachInterrupt(digitalPinToInterrupt(eventlist[1].pin));
	}
	void bintroutine2() {
	eventlist[2].active=1;
	detachInterrupt(digitalPinToInterrupt(eventlist[2].pin));
	}
	void bintroutine3() {
	eventlist[3].active=1;
	detachInterrupt(digitalPinToInterrupt(eventlist[3].pin));
	}


	#if !(defined(ARDUINO_ARCH_MBED_RP2040) \|\| defined(ARDUINO_ARCH_MBED_NANO) \|\| defined(ARDUINO_ARCH_RENESAS))
	typedef int PinStatus;
	#endif


	mem_t enableevent(int pin) {
	mem_t interrupt;
	int i;

	/* do we have the data */
	if ((i=eventindex(pin))<0) return 0;

	/* can we use this pin */
	interrupt=digitalPinToInterrupt(eventlist[i].pin);
	if (interrupt < 0) return 0;

	/* attach the interrupt function to this pin */
	switch(i) {
	case 0:
	attachInterrupt(interrupt, bintroutine0, (PinStatus) eventlist[i].mode);
	break;
	case 1:
	attachInterrupt(interrupt, bintroutine1, (PinStatus) eventlist[i].mode);
	break;
	case 2:
	attachInterrupt(interrupt, bintroutine2, (PinStatus) eventlist[i].mode);
	break;
	case 3:
	attachInterrupt(interrupt, bintroutine3, (PinStatus) eventlist[i].mode);
	break;
	default:
	return 0;
	}

	/* now set it enabled in BASIC */
	eventlist[i].enabled=1;
	return 1;

	}

	void disableevent(mem_t pin) {
	detachInterrupt(digitalPinToInterrupt(pin));
	}
	#endif


	/*
	* This code measures the fast ticker frequency in microseconds
	* It leaves the data in variable F. Activate this only for test
	* purposes.
	*/
	#undef FASTTICKERPROFILE

	#ifdef FASTTICKERPROFILE
	static unsigned long lastfasttick = 0;
	static unsigned long fasttickcalls = 0;
	static int avgfasttick = 0;
	static long devfasttick = 0;

	void fasttickerprofile() {
	if (lastfasttick == 0) { lastfasttick=micros(); return; }
	int delta=micros()-lastfasttick;
	lastfasttick=micros();
	avgfasttick=(avgfasttick*fasttickcalls+delta)/(fasttickcalls+1);
	fasttickcalls++;
	vars[5]=avgfasttick;
	}
	#endif



	// defined HARDWARE_H
	#endif