diff --git "a/data/Basic1/TinyVT52/hardware-arduino.h" "b/data/Basic1/TinyVT52/hardware-arduino.h" new file mode 100644--- /dev/null +++ "b/data/Basic1/TinyVT52/hardware-arduino.h" @@ -0,0 +1,4748 @@ +/* + * + * $Id: hardware-arduino.h,v 1.7 2022/12/15 06:19:42 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, sl001@serverfabrik.de + * + * 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 + * sensors ARDUINORTC, ARDUINOWIRE, ARDUINOSENSORS + * network ARDUINORF24, ARDUNIOMQTT + * memory ARDUINOSPIRAM + * + * 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 ARDUINOGRAPHDUMMY +#undef LCDSHIELD +#undef ARDUINOTFT +#undef ARDUINOVGA +#define ARDUINOEEPROM +#undef ARDUINOI2CEEPROM +#undef ARDUINOEFS +#undef ARDUINOSD +#undef ESPSPIFFS +#undef RP2040LITTLEFS +#undef ARDUINORTC +#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 5 +#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 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 +#undef ARDUINOSHT +#undef 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 NEEDSWIRE +#endif + +/* + * the hardware models + * These are predefined hardware configutations + */ + +/* 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; +#else +const mem_t bsystype = SYSTYPE_UNKNOWN; +#endif + +/* + * the non AVR arcitectures - this is somehow raw + * the ARDUINO 100 definition is probably not needed anymore + */ + +#if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_MBED_RP2040) +/* removed, unneeded, takes more space than it should */ +/* #include */ +#define ARDUINO 100 +#endif + +/* + * Some settings, defaults, and dependencies + * + * NEEDSWIRE 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 NEEDSWIRE +#endif + +/* a display needs wire */ +#if defined(ARDUINOLCDI2C) || defined(ARDUINOSSD1306) +#define NEEDSWIRE +#endif + +/* EEPROM storage needs wire */ +#if defined(ARDUINOEFS) +#define NEEDSWIRE +#endif + +/* external EEPROMs also need wire */ +#if defined(ARDUINOI2CEEPROM) +#define NEEDSWIRE +#endif + +/* plain Wire support also needs wire ;-) */ +#if defined(ARDUINOWIRE) +#define NEEDSWIRE +#endif + +/* radio needs SPI */ +#ifdef ARDUINORF24 +#define ARDUINOSPI +#endif + +/* a filesystem needs SPI */ +#if defined(ARDUINOSD) || defined(ESPSPIFFS) +#define ARDUINOSPI +#endif + +/* networking may need SPI */ +#ifdef 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 ARDUINOBGTASK +#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) +#undef HASGRAPH +#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 +#endif + +/* + * The USB keyboard code - tested only on DUE and the like + * not really good + */ +#ifdef ARDUINOUSBKBD +#include +#endif + +/* + * The ZX81 keyboard code - tested on AVR MEGA256 + */ +#ifdef ARDUINOZX81KBD +#include +#endif + +/* + * ESPy stuff, pgmspace has changed location + */ + +#ifdef ARDUINOPROGMEM +#ifdef ARDUINO_ARCH_ESP32 +#include +#else +#include +#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 +#else +#include +#endif +#endif + +/* Standard SPI */ +#ifdef ARDUINOSPI +#include +#endif + +/* Standard wire - triggered by the NEEDSWIRE macro now */ +#ifdef NEEDSWIRE +#include +#endif + +/* + * the display library includes for LCD + */ +#ifdef LCDSHIELD +#include +#endif + +/* + * I2C displays + */ + +#ifdef ARDUINOLCDI2C +#include +#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 +#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 +#include +#endif + +/* + * This is the MCUFRIED library originally for parallel TFTs + * https://github.com/prenticedavid/MCUFRIEND_kbv + * + */ +#ifdef ARDUINOMCUFRIEND +#include +#include +#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 +#include +#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 +#else +#ifdef ARDUINO_ARCH_ESP8266 +#include +#endif +#ifdef ARDUINO_ARCH_ESP32 +#include +#endif +#if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_SAMD) +#include +#endif +#endif +#include +#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 +#include +#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 +#else +#include +#endif +#endif + +/* + * ESPSPIFFS tested on ESP8266 and ESP32 + * supports formating in BASIC + */ +#ifdef ESPSPIFFS +#define FILESYSTEMDRIVER +#ifdef ARDUINO_ARCH_ESP8266 +#include +#endif +#ifdef ARDUINO_ARCH_ESP32 +#include +#include +#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 +#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 +#define FILESYSTEMDRIVER +#endif + +/* the EFS object is used for filesystems and raw EEPROM access */ +#if (defined(ARDUINOI2CEEPROM) && defined(ARDUINOI2CEEPROM_BUFFERED)) || defined(ARDUINOEFS) +#include +#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() {} + +/* + * 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) +extern "C" char* sbrk(int incr); +long freeRam() { + char top; + return &top - reinterpret_cast(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_ESP32) || defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_SAMD) + 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 ARDUINOWIRE + overhead+=128; +#endif +#ifdef ARDUINORF24 + overhead+=128; +#endif +#ifdef 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 +} + +/* + * Used these two articles + * https://randomnerdtutorials.com/esp8266-deep-sleep-with-arduino-ide/ + * https://randomnerdtutorials.com/esp32-deep-sleep-arduino-ide-wake-up-sources/ + * for this very simple implementation - needs to be improved (pass data from sleep + * state to sleep state via EEPROM) + */ +#if defined(ARDUINO_ARCH_SAMD) +#include "RTCZero.h" +#include "ArduinoLowPower.h" +#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/128*2+b/128*4; + return vga; +} + +/* + * global variables for a standard LCD shield. + * Includes the standard Arduino LiquidCrystal library + */ +#ifdef LCDSHIELD +#define DISPLAYDRIVER +#undef DISPLAYHASCOLOR +#undef DISPLAYHASGRAPH +/* LCD shield pins to Arduino + * RS, EN, d4, d5, d6, d7; + * backlight on pin 10; + */ +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); 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= */ +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'; +} +#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); 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; u8g2.drawStr(col*dspfontsize+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 + +/* + * 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; u8g2.drawStr(col*dspfontsize+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) { tft.drawChar(col*dspfontsize, row*dspfontsize, 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) { tft.drawChar(col*dspfontsize, row*dspfontsize, 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) { tft.printChar(c, col*dspfontsize, row*dspfontsize); } +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/128*2+b/128*4; + 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) delay(2); else return 0; + if (c == keypadread()) return 1; else return 0; + /* return keypadread()!=0; */ +#endif + return 0; +} + +char kbdread() { + char c; + 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 + c=keypadread(); +/* if you uncommend this we wait for key release on a keypad */ + while(kbdavailable()) byield(); +#endif + if (c == 13) c=10; + return c; +} + +char kbdcheckch() { +char c; +#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(); +#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=0 && r=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> 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; rline; r--) { + for (c=0; c> 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_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 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 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': // alternate keypad off + break; + case 'b': // GEMDOS / TOS extension text color + case 'c': // GEMDOS / TOS extension background color + vt52s=*c; + dspesc=1; + *c=0; + return; + case 'e': // GEMDOS / TOS extension enable cursor + dspsetcursor(1); + break; + case 'f': // GEMDOS / TOS extension disable cursor + dspsetcursor(0); + break; + case 'p': // GEMDOS / TOS extension reverse video + dspsetreverse(1); + break; + case 'q': // GEMDOS / TOS extension normal video + dspsetreverse(0); + break; + case 'A': // cursor up + if (dspmyrow>0) dspmyrow--; + break; + case 'B': // cursor down + if (dspmyrow < dsp_rows-1) dspmyrow++; + break; + case 'C': // cursor right + if (dspmycol < dsp_columns-1) dspmycol++; + break; + case 'D': // cursor left + if (dspmycol>0) dspmycol--; + break; + case 'E': // GEMDOS / TOS extension clear screen + dspbufferclear(); + dspclear(); + break; + case 'H': // cursor home + dspmyrow=dspmycol=0; + break; + case 'Y': // Set cursor position + vt52s='Y'; + dspesc=2; + *c=0; + return; + case 'J': // clear to end of screen + for (int i=dspmycol+dsp_columns*dspmyrow; i0) 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 +/* 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 + +/* + * Arduino Real Time clock. The interface here + * offers the values as number_t plus a string, + * combining all values. + * + * The code does not use an RTC library any more + * all the rtc support is builtin now. + * + * Supported clocks DS1307, DS3231, and DS3232 (not tested) + * + * 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 + * + * Registers 7-255 are returned as + */ + +#ifdef ARDUINORTC +char rtcstring[20] = { 0 }; +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; + } +} + +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(); +} + +char* rtcmkstr() { + int cc = 2; + short t; + char ch; + /* the first read refreshes - not needed here but still ... */ + t=rtcget(2); + rtcstring[cc++]=t/10+'0'; + rtcstring[cc++]=t%10+'0'; + rtcstring[cc++]=':'; + t=rtcget(1); + rtcstring[cc++]=t/10+'0'; + rtcstring[cc++]=t%10+'0'; + rtcstring[cc++]=':'; + t=rtcget(0); + rtcstring[cc++]=t/10+'0'; + rtcstring[cc++]=t%10+'0'; + rtcstring[cc++]='-'; + t=rtcget(4); + if (t/10 > 0) rtcstring[cc++]=t/10+'0'; + rtcstring[cc++]=t%10+'0'; + rtcstring[cc++]='/'; + t=rtcget(5); + if (t/10 > 0) rtcstring[cc++]=t/10+'0'; + rtcstring[cc++]=t%10+'0'; + rtcstring[cc++]='/'; + t=rtcget(6); + if (t/10 > 0) rtcstring[cc++]=t/10+'0'; + rtcstring[cc++]=t%10+'0'; + rtcstring[cc]=0; + /* needed for BASIC strings, reserve the first byte for two byte length handling in the upstream code */ + rtcstring[1]=cc-2; + rtcstring[0]=0; + return rtcstring+1; +} +#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) + 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) + WiFi.end(); +#endif +#endif +} + +/* + * network reconnect methode + * + */ +void netreconnect() { +#ifdef ARDUINOETH +/* */ +#else +#if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266) + WiFi.reconnect(); + delay(1000); +#elif defined(ARDUINO_ARCH_SAMD) + WiFi.end(); + WiFi.begin(ssid, password); + delay(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 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.a0) { + ch=mqtt_buffer[0]; + for (i=0; i= 0 && v<256) analogWrite(p, v); + else error(EORANGE); +} + +void dwrite(number_t p, number_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(number_t p, number_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; + } +} + +void bmillis() { + number_t m; +/* millis is processed as integer and is cyclic mod maxnumber and not cast to float!! */ + m=(number_t) (millis()/(unsigned long)pop() % (unsigned long)maxnum); + push(m); +}; + +void bpulsein() { + unsigned long t, pt; + t=((unsigned long) pop())*1000; + y=pop(); + x=pop(); + pt=pulseIn(x, y, t)/10; + push(pt); +} + +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_ARCH_SAM) || defined(ARDUINO_ARCH_ESP32) +#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); + } +#else + return; +#endif +#else + if (x == 0) { + noTone(y); + } else if (a == 2) { + tone(y, x); + } else { + tone(y, x, d); + } +#endif +} + +/* + * the byield function is called after every statement + * it allows two levels of background tasks. + * + * ARDUINOBGTASK 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. + */ +void byield() { +#if defined(ARDUINOBGTASK) + if (millis()-lastyield > YIELDINTERVAL-1) { + yieldfunction(); + lastyield=millis(); + } + if (millis()-lastlongyield > LONGYIELDINTERVAL-1) { + longyieldfunction(); + lastlongyield=millis(); + } + #endif + /* delay 0 blocks XMC unlike other boards where it is either yield() or no operation, it is needed on ESP8266 */ + #if !defined(ARDUINO_ARCH_XMC) + delay(0); + #endif +} + +/* everything that needs to be done often - 32 ms */ +void yieldfunction() { +#ifdef ARDUINOMQTT + bmqtt.loop(); +#endif +#ifdef ARDUINOUSBKBD + usb.Task(); +#endif +#ifdef ARDUINOZX81KBD + (void) keyboard.peek(); /* scan once and set lastkey properly every 32 ms */ +#endif +#ifdef ARDUINOMQTT + delay(YIELDTIME); /* ESP8266 heuristics, needed for Wifi stability */ +#endif +} + +/* everything that needs to be done not so often - 1 second */ +void longyieldfunction() { +#ifdef ARDUINOETH + Ethernet.maintain(); +#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) +File ifile; +File ofile; +char tempname[SBUFSIZE]; +#ifdef ARDUINOSD +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 +#ifdef ARDUINO_ARCH_ESP32 +#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 have a path prefix */ +#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; jinit() && 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) + 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) + 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) + return ifile.available(); +#endif +#ifdef RP2040LITTLEFS + return !feof(ifile); +#endif +#ifdef ARDUINOEFS + return EFS.available(ifile); +#endif + return 0; +} + +char ifileopen(const char* filename){ +#ifdef ARDUINOSD + ifile=SD.open(mkfilename(filename), FILE_READ); + 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) + 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){ +#ifdef 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 +#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) + 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() { +#ifdef ARDUINOSD + 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() { +#ifdef ARDUINOSD + 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() { +#ifdef ARDUINOSD + 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() { +#ifdef ARDUINOSD + //return (char*) file.name(); + return rmrootfsprefix(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; id_name); +#endif +#ifdef ARDUINOEFS + return EFS.filename(file); +#endif + return 0; +} + +int rootfilesize() { +#if defined(ARDUINOSD) || defined(ESPSPIFFS) + return file.size(); +#endif +#ifdef RP2040LITTLEFS +#endif +#ifdef ARDUINOEFS + return EFS.filesize(file); +#endif + return 0; +} + +void rootfileclose() { +#if defined(ARDUINOSD) || defined(ESPSPIFFS) + file.close(); +#endif +#ifdef RP2040LITTLEFS +#endif +#ifdef ARDUINOEFS +#endif +} + +void rootclose(){ +#ifdef ARDUINOSD + 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) { +#ifdef ARDUINOSD + SD.remove(mkfilename(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) { +#ifdef ARDUINOSD + 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*(2*0XFFF + 1)) + 1; + +/* the begin code */ +void picobegin(uint32_t baud) { + uint16_t baud_setting; + cli(); + if ((F_CPU != 16000000UL || baud != 57600) && baud > MIN_2X_BAUD) { + UCSR0A = 1 << U2X0; + baud_setting = (F_CPU / 4 / baud - 1) / 2; + } else { + UCSR0A = 0; + baud_setting = (F_CPU / 8 / baud - 1) / 2; + } +/* assign the baud_setting */ + UBRR0H = baud_setting >> 8; + UBRR0L = baud_setting; +/* enable transmit and receive */ + UCSR0B |= (1 << TXEN0) | (1 << RXEN0) | (1 << RXCIE0); + sei(); +} + +/* the write code, sending bytes directly to the UART */ +void picowrite(char b) { + while (((1 << UDRIE0) & UCSR0B) || !(UCSR0A & (1 << UDRE0))) {} + UDR0 = b; +} + +/* + * picogetchar: this is the interrupt service routine. It + * recieves a character and feeds it into a buffer and echos it + * back. The logic here is that the ins() code sets the buffer + * to the input buffer. Only then the routine starts writing to the + * buffer. Once a newline is received, the length information is set + * and picoa is also set to 1 indicating an available string, this stops + * recevieing bytes until the input is processed by the calling code. + */ +void picogetchar(char c){ + if (picob && (! picoa)) { + picochar=c; + if (picochar != '\n' && picochar != '\r' && picoi1) 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 (!Serial.available()) byield(); + return Serial.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 + Serial.begin(serial_baudrate); +#endif + delay(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 HASMSTAB + if (c > 31) charcount+=1; + if (c == 10) charcount=0; +#endif +#ifdef USESPICOSERIAL + picowrite(c); +#else +/* write never blocks. discard any bytes we can't get rid of */ + Serial.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 (Serial.available()) return Serial.peek(); else return 0; +#endif +} + +/* avail method, needed for AVAIL() */ +short serialavailable() { +#ifdef USESPICOSERIAL + return picoi; +#else + return Serial.available(); +#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 +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 NEEDSWIRE +/* 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 +} +#else +void wirebegin() {} +#endif + +/* this is code needed for the OPEN/CLOSE and wireslave mechanisms */ +#ifdef ARDUINOWIRE +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; +#endif +} + +#ifdef ARDUINOWIRESLAVE +/* event handler for receive */ +void wireonreceive(int h) { + wirereceivechars=h; + if (h>ARDUINOWIREBUFFER) h=ARDUINOWIREBUFFER; + for (int i=0; iARDUINOWIREBUFFER) l=ARDUINOWIREBUFFER; + if (!Wire.requestFrom(wire_slaveid, l)) ert=1; + while (Wire.available() && z.aARDUINOWIREBUFFER) l=ARDUINOWIREBUFFER; + if (wire_myid == 0) { + Wire.beginTransmission(wire_slaveid); +#ifdef ARDUINO_ARCH_ESP32 + for(z.a=0; z.a +#include +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=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 SHT; +#endif +#ifdef ARDUINOMQ2 +#include +MQ2 mq2(MQ2PIN); +#endif +#ifdef ARDUINOLMS6 +#include +/* https://www.arduino.cc/en/Reference/Arduino_LSM6DSOX */ +#endif +#ifdef ARDUINOAHT +#include +Adafruit_AHTX0 aht; +#endif +#ifdef ARDUINOBMP280 +#include +Adafruit_BMP280 bmp; +#endif +#ifdef ARDUINOBME280 +#include +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 + +// defined HARDWARE_H +#endif