/* * * $Id: hardware-arduino.h,v 1.8 2023/02/18 20:16:59 stefan Exp stefan $ * * Stefan's basic interpreter * * Playing around with frugal programming. See the licence file on * https://github.com/slviajero/tinybasic for copyright/left. * (GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007) * * Author: Stefan Lenz, 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, RP2040LITTLEFS * storage ARDUINOEFS, SM32SDIO * sensors ARDUINOWIRE, ARDUINOSENSORS * network ARDUINORF24, ARDUNIOMQTT * memory ARDUINOSPIRAM * real time clocks ARDUINORTC, ARDUINORTCEMULATION * * leave this unset if you use the definitions below */ #undef USESPICOSERIAL #undef ARDUINOPS2 #undef ARDUINOUSBKBD #undef ARDUINOZX81KBD #undef ARDUINOPRT #undef DISPLAYCANSCROLL #undef ARDUINOLCDI2C #undef ARDUINONOKIA51 #undef ARDUINOILI9488 #undef ARDUINOSSD1306 #undef ARDUINOMCUFRIEND #undef ARDUINOEDP47 #undef ARDUINOGRAPHDUMMY #undef LCDSHIELD #undef ARDUINOTFT #undef ARDUINOVGA #define ARDUINOEEPROM #undef ARDUINOI2CEEPROM #undef ARDUINOEFS #undef ARDUINOSD #undef ESPSPIFFS #undef RP2040LITTLEFS #undef STM32SDIO #undef ARDUINORTC #undef ARDUINORTCEMULATION #undef ARDUINOTONEEMULATION #undef ARDUINOWIRE #undef ARDUINOWIRESLAVE #undef ARDUINORF24 #undef ARDUINOETH #undef ARDUINOMQTT #undef ARDUINOSENSORS #undef ARDUINOSPIRAM #undef STANDALONE #undef STANDALONESECONDSERIAL /* experimental features, don't use unless you know the code */ /* * this setting uses the EEPROM as program storage * The idea is to create a virtual memory layout starting from 0 with the EEPROM * from elength() and then adding the BASIC RAM to it. himem and top need to be * handled carefully. */ #undef ARDUINOPGMEEPROM /* * Predefined hardware configurations, this assumes that all of the * above are undef * * UNOPLAIN: * a plain UNO with no peripherals * AVRLCD: * a AVR system with an LCD shield * WEMOSSHIELD: * a Wemos D1 with a modified simple datalogger shield * optional keyboard and i2c display * MEGASHIELD: * an Arduino Mega with Ethernet Shield * optional keyboard and i2c display * TTGOVGA: * TTGO VGA1.4 system with PS2 keyboard, standalone * MEGATFT, DUETFT * TFT 7inch screen systems, standalone * NANOBOARD: * Arduino Nano Every board with PS2 keyboard and sensor * kit * MEGABOARD: * A board for the MEGA with 64 kB RAM, SD Card, and real time * clock * UNOBOARD: * A board for an UNO with 64kB memory and EEPROM disk * fits into an UNO flash only with integer * ESP01BOARD: * ESP01 based board as a sensor / MQTT interface * RP2040BOARD: * A ILI9488 hardware design based on an Arduino connect RP2040. * RP2040BOARD2: * like the one above but based on the Pi Pico core * ESP32BOARD: * same like above with an ESP32 core * MKRBOARD: * a digital signage and low energy board */ #undef UNOPLAIN #undef AVRLCD #undef WEMOSSHIELD #undef MEGASHIELD #undef TTGOVGA #undef DUETFT #undef MEGATFT #undef NANOBOARD #undef MEGABOARD #undef UNOBOARD #undef ESP01BOARD #undef RP2040BOARD #undef RP2040BOARD2 #undef ESP32BOARD #undef MKR1010BOARD /* * PIN settings and I2C addresses for various hardware configurations * used a few heuristics and then the hardware definitions above * * #define SDPIN sets the SD CS pin - can be left as a default for most HW configs * TTGO needs it as default definitions in the board file are broken * #define PS2DATAPIN, PS2IRQPIN sets PS2 pin */ /* PS2 Keyboard pins for AVR - use one interrupt pin 2 and one date pin 5 not 4 because 4 conflicts with SDPIN of the standard SD shield */ #define PS2DATAPIN 3 #define PS2IRQPIN 2 /* Ethernet - 10 is the default */ /* #define ETHPIN 10 */ /* The Pretzelboard definitions for Software Serial, conflicts with SPI */ #define SOFTSERIALRX 11 #define SOFTSERIALTX 12 /* near field pin settings for CE and CSN*/ #define RF24CEPIN 8 #define RF24CSNPIN 9 /* use standard I2C pins almost always */ #undef SDA_PIN #undef SCL_PIN /* set this is you want pin 4 on low interrupting the interpreter */ /* #define BREAKPIN 4 */ #undef BREAKPIN /* the primary serial stream aka serial aka sream 1 */ #ifndef ALTSERIAL #define SERIALPORT Serial #endif /* the secondary serial port aka prt aka stream 4 */ #ifndef PRTSERIAL #define PRTSERIAL Serial1 #endif /* * Pin settings for the ZX81 Keyboard * first the 8 rows, then the 5 columns or the keyboard * * MEGAs have many pins and default is to use the odd pins on the side * UNOs, NANOs, and others use the lower pins by default avoiding the * pin 13 which is LED and doesn't work with standard schematics */ #ifdef ARDUINOZX81KBD #ifdef ARDUINO_AVR_MEGA2560 const byte zx81pins[] = {37, 35, 33, 31, 29, 27, 25, 23, 47, 45, 43, 41, 39}; #else const char zx81pins[] = {7, 8, 9, 10, 11, 12, A0, A1, 2, 3, 4, 5, 6 }; #endif #endif /* * this is soft SPI for SD cards on MEGAs using * pins 10-13, a patched SD library is needed * for this: https://github.com/slviajero/SoftSD * only needed for MEGA boards with an UNO shield */ #undef SOFTWARE_SPI_FOR_SD /* * list of default i2c addresses * * some clock modules do have their EEPROM at 0x57. * 0x050 this is the default lowest adress of standard EEPROMs * Configurable range is between 0x50 and 0x57 for modules with jumpers. * Some clock modules do have their EEPROM at 0x57. * * Clock default for the size is 4096. Define your EFS EEPROM and I2C EEPROM * size here. One parameter set is for EFS and one parameter set is for * plain serial EEPROMs. * * RTCs are often at 0x68 */ #define EFSEEPROMADDR 0x050 /* #define EFSEEPROMSIZE 32768 */ #define RTCI2CADDR 0x068 /* the size of the plain I2C EEPROM, typically a clock */ #define I2CEEPROMADDR 0x057 /* #define I2CEEPROMSIZE 4096 */ /* is the I2C EEPROM buffered */ #define ARDUINOI2CEEPROM_BUFFERED /* * Sensor library code - configure your sensors here */ #ifdef ARDUINOSENSORS #undef ARDUINODHT #define DHTTYPE DHT22 #define DHTPIN 2 #define ARDUINOSHT #define ARDUINOMQ2 #define MQ2PIN A0 #undef ARDUINOLMS6 #undef ARDUINOAHT #undef ARDUINOBMP280 #undef ARDUINOBME280 #endif #if defined(ARDUINOSHT) || defined(ARDUINOLMS6) || defined(ARDUINOAHT) || defined(ARDUINOBMP280) || defined(RDUINOBME280) #define ARDUINOWIRE #endif /* * The hardware models. * These are predefined hardware configurations. */ /* an AVR based Arduino with nothing else */ #if defined(UNOPLAIN) #define ARDUINOEEPROM #endif /* an AVR ARDUINO (UNO or MEGA) with the classical LCD shield */ #if defined(AVRLCD) #define ARDUINOEEPROM #define DISPLAYCANSCROLL #define LCDSHIELD #endif /* * a Wemos ESP8266 with a mdified datalogger shield * standalone capable, with Wire and MQTT. */ #if defined(WEMOSSHIELD) #define ARDUINOEEPROM #define ARDUINOPS2 #define DISPLAYCANSCROLL #define ARDUINOLCDI2C #define ARDUINOSD #define ARDUINORTC #define ARDUINOWIRE #define SDPIN D8 #define PS2DATAPIN D2 #define PS2IRQPIN D9 #define ARDUINOMQTT #endif /* * mega with a Ethernet shield * standalone capable, Ethernet is not enabled by default */ #if defined(MEGASHIELD) #define ARDUINOEEPROM #define ARDUINOPS2 #define DISPLAYCANSCROLL #define ARDUINOLCDI2C #define ARDUINOSD #define ARDUINOWIRE #define ARDUINOPRT #define SDPIN 4 #endif /* * VGA system with SD card, based on the TTGO VGA 1.4 * ESP32 * standalone by default, with MQTT */ #if defined(TTGOVGA) #define ARDUINOEEPROM #define ARDUINOVGA #define ARDUINOSD /* #define ARDUINOMQTT */ #define SDPIN 13 #define STANDALONE #endif /* * MEGA with a TFT shield, standalone by default */ #if defined(MEGATFT) #define ARDUINOEEPROM #define ARDUINOPS2 #define DISPLAYCANSCROLL #define ARDUINOTFT #define ARDUINOSD #define ARDUINOWIRE #define ARDUINOPRT #define PS2DATAPIN 18 #define PS2IRQPIN 19 #define SDPIN 53 #define STANDALONE #endif /* * DUE with a TFT shield, standalone by default */ #if defined(DUETFT) #undef ARDUINOEEPROM #define ARDUINOPS2 #undef ARDUINOUSBKBD #define DISPLAYCANSCROLL #define ARDUINOTFT #define ARDUINOSD #define ARDUINOWIRE #define ARDUINOPRT #define ARDUINORTC #define PS2DATAPIN 9 #define PS2IRQPIN 8 #define SDPIN 53 #define STANDALONE #endif #if defined(NANOBOARD) #undef USESPICOSERIAL #define ARDUINOPS2 #define DISPLAYCANSCROLL #define ARDUINOLCDI2C #define ARDUINOEEPROM #define ARDUINOPRT #define ARDUINOEFS #define ARDUINORTC #define ARDUINOWIRE #define EFSEEPROMADDR 0x050 /* use clock EEPROM 0x057, set to 0x050 for external EEPROM */ #define STANDALONE #endif /* a UNO shield with memory and EFS EEPROM */ #if defined(UNOBOARD) #define ARDUINOEEPROM #define ARDUINOSPIRAM #define ARDUINOEFS #define ARDUINOWIRE #define EFSEEPROMADDR 0x050 #define EFSEEPROMSIZE 65534 #endif /* a MEGA shield with memory and SD card */ #if defined(MEGABOARD) #undef USESPICOSERIAL #define DISPLAYCANSCROLL #define ARDUINOLCDI2C #define ARDUINOEEPROM #define ARDUINOPRT #define ARDUINOSD #define ARDUINOWIRE #define ARDUINORTC #define ARDUINOSPIRAM #define RAMPIN 53 #define SDPIN 49 #endif /* an ESP01 board, using the internal flash * with the ESP01-8266 only pins 0 and 2 are usable freely * on ESP01-ESP32C3 this is 9 and 2 while 2 is an analog pin * 9 cannot be pulled on low by any peripheral on boot because this * brings the board to flash mode */ #if defined(ESP01BOARD) #undef ARDUINOEEPROM #define ESPSPIFFS #define ARDUINOMQTT #define ARDUINOWIRE #if defined(ARDUINOWIRE) && defined(ARDUINO_ARCH_ESP8266) #define SDA_PIN 0 #define SCL_PIN 2 #endif /* see: https://github.com/espressif/arduino-esp32/issues/6376 * nothing should block the port, e.g. DHT or anything */ #if defined(ARDUINOWIRE) && defined(ARDUINO_ARCH_ESP32) #define SDA_PIN 9 #define SCL_PIN 2 #endif /* * * Currently only 8=SDA and 9=SCL works / tested with AHT10 */ #endif /* an RP2040 based board with an ILI9488 display */ #if defined(RP2040BOARD) #undef USESPICOSERIAL #define DISPLAYCANSCROLL #define ARDUINOILI9488 #undef ARDUINOEEPROM #define ARDUINOI2CEEPROM #define ARDUINOPRT #define ARDUINOSD #undef RP2040LITTLEFS #define ARDUINOWIRE #define ARDUINORTC #define ARDUINOPS2 #define ARDUINOMQTT #undef STANDALONE #endif /* an RP2040 Raspberry Pi Pico based board with an ILI9488 display */ #if defined(RP2040BOARD2) #undef USESPICOSERIAL #define DISPLAYCANSCROLL #define ARDUINOILI9488 #undef ARDUINOEEPROM #undef ARDUINOPRT #undef ARDUINOSD #define RP2040LITTLEFS #undef ARDUINOWIRE #undef ARDUINORTC #undef ARDUINOPS2 #undef ARDUINOMQTT #undef STANDALONE #define ILI_LED A2 #define ILI_CS 15 #define ILI_RST 14 #define ILI_DC 13 #endif /* an ESP32 board with an ILI9488 display, some SD problems here with some hardware */ #if defined(ESP32BOARD) #define ILI_CS 12 #define ILI_DC 27 #define ILI_RST 14 #define ILI_LED 26 #undef USESPICOSERIAL #define ESPSPIFFS #define DISPLAYCANSCROLL #define ARDUINOILI9488 #define ARDUINOEEPROM #define ARDUINOMQTT #define ARDUINOWIRE #endif /* a board based on the Arduino MKR 1010 Wifi * made for low energy games */ #if defined(MKR1010BOARD) #define ILI_CS 7 #define ILI_DC 4 #define ILI_RST 6 #define ILI_LED A3 #undef USESPICOSERIAL #define DISPLAYCANSCROLL #define ARDUINOILI9488 #define ARDUINOEFS #define ARDUINOMQTT #define ARDUINOWIRE /* careful with the setting, lockout possible easily */ #undef ARDUINOUSBKBD #undef STANDALONE #endif /* * defining the systype variable which informs BASIC about the platform at runtime */ #if defined(ARDUINO_ARCH_AVR) const mem_t bsystype = SYSTYPE_AVR; #elif defined(ARDUINO_ARCH_ESP8266) const mem_t bsystype = SYSTYPE_ESP8266; #elif defined(ARDUINO_ARCH_ESP32) const mem_t bsystype = SYSTYPE_ESP32; #elif defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_MBED_RP2040) const mem_t bsystype = SYSTYPE_RP2040; #elif defined(ARDUINO_ARCH_SAM) && defined(ARDUINO_ARCH_SAMD) const mem_t bsystype = SYSTYPE_SAM; #elif defined(ARDUINO_ARCH_XMC) const mem_t bsystype = SYSTYPE_XMC; #elif defined(ARDUINO_ARCH_SMT32) const mem_t bsystype = SYSTYPE_SMT32; #elif defined(ARDUINO_ARCH_RENESAS) const mem_t bsystype = SYSTYPE_NRENESA; #else const mem_t bsystype = SYSTYPE_UNKNOWN; #endif /* * DUE has no tone, we switch to emulation mode automatically */ #ifdef ARDUINO_SAM_DUE #define ARDUINOTONEEMULATION #endif /* * Some settings, defaults, and dependencies * * HASWIRE is set to start wire. Some libraries do this again. * * Handling Wire and SPI is tricky as some of the libraries * also include and start SPI and Wire code. */ /* a clock needs wire */ #ifdef ARDUINORTC #define ARDUINOWIRE #endif /* a display needs wire */ #if defined(ARDUINOLCDI2C) || defined(ARDUINOSSD1306) #define ARDUINOWIRE #endif /* EEPROM storage needs wire */ #if defined(ARDUINOEFS) #define ARDUINOWIRE #endif /* external EEPROMs also need wire */ #if defined(ARDUINOI2CEEPROM) #define ARDUINOWIRE #endif /* plain Wire support also needs wire ;-) */ #if defined(ARDUINOWIRE) #define HASWIRE #endif /* radio needs SPI */ #if defined(ARDUINORF24) #define ARDUINOSPI #endif /* a filesystem needs SPI */ #if defined(ARDUINOSD) || defined(ESPSPIFFS) #define ARDUINOSPI #endif /* networking may need SPI */ #if defined(ARDUINOMQTT) #define ARDUINOSPI #endif /* the NOKIA and ILI9488 display needs SPI */ #if defined(ARDUINONOKIA51) || defined(ARDUINOILI9488) #define ARDUINOSPI #endif /* the RAM chips */ #if defined(ARDUINOSPIRAM) #define ARDUINOSPI #endif /* Networking and keyboards need the background task capability */ #if defined(ARDUINOMQTT) || defined(ARDUINOETH) || defined(ARDUINOUSBKBD) || defined(ARDUINOZX81KBD) #define BASICBGTASK #endif /* picoserial is not a available on many platforms */ #ifdef USESPICOSERIAL #ifndef UCSR0A #undef USESPICOSERIAL #endif #endif /* * graphics adapter only when graphics hardware, overriding the * language setting * this is odd and can be removed later on */ #if !defined(ARDUINOTFT) && !defined(ARDUINOVGA) && !defined(ARDUINOILI9488) && !defined(ARDUINONOKIA51) && !defined(ARDUINOSSD1306) && !defined(ARDUINOMCUFRIEND) && !defined(ARDUINOGRAPHDUMMY) && !defined(ARDUINOEDP47) #undef HASGRAPH #endif /* * incompatibilities and library stuff */ /* these platforms have no EEPROM and no emulation built-in */ #if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_MBED_RP2040) #undef ARDUINOEEPROM #endif /* * Keyboard library, on AVR systems Paul Stoffregens original * PS2 library works. * I recommend to use my patched version from * https://github.com/slviajero/PS2Keyboard * works with ESP, has keyboard.peek() */ #ifdef ARDUINOPS2 #include #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 #ifdef ARDUINO_ARCH_SAMD //#include #else #include #endif #endif #endif /* Standard SPI */ #ifdef ARDUINOSPI #include #endif /* Standard wire - triggered by the HASWIRE macro now */ #ifdef HASWIRE #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 /* * Lilygo EDP47 displays, 4.7 inch epapers using the respective library * from Lilygo * https://github.com/Xinyuan-LilyGO/LilyGo-EPD47 * */ #ifdef ARDUINOEDP47 #include "epd_driver.h" #include "font/firasans.h" #endif /* * experimental networking code * currently the standard Ethernet shield, ESP Wifi * MKW Wifi, and RP2040 Wifi is supported. All of them * with the standard library. * * In addition to this Pubsub is used * https://github.com/slviajero/pubsubclient * for MQTT */ #ifdef ARDUINOMQTT #ifdef ARDUINOETH #include #else #ifdef ARDUINO_ARCH_ESP8266 #include #endif #ifdef ARDUINO_ARCH_ESP32 #include #endif #if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_SAMD) #include #endif #if defined(ARDUINO_UNOR4_WIFI) #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 /* * STM32 SDIO driver for he SD card slot of the STM32F4 boards (and others) */ #ifdef STM32SDIO #define FILESYSTEMDRIVER #include #ifndef SD_DETECT_PIN #define SD_DETECT_PIN SD_DETECT_NONE #endif #endif /* * external flash file systems override internal filesystems * currently BASIC can only have one filesystem */ #ifdef ARDUINOSD #undef ESPSPIFFS #undef RP2040LITTLEFS #endif /* * support for external EEPROMs as filesystem * overriding all other filessystems. This is a minimalistic * filesystem meant for very small systems with not enough * memory for real filesystems * https://github.com/slviajero/EepromFS */ #ifdef ARDUINOEFS #undef ESPSPIFFS #undef RP2040LITTLEFS #undef ARDUINOSD #undef STM32SDIO #define FILESYSTEMDRIVER #endif /* the EFS object is used for filesystems and raw EEPROM access */ #if (defined(ARDUINOI2CEEPROM) && defined(ARDUINOI2CEEPROM_BUFFERED)) || defined(ARDUINOEFS) #include #endif /* if there is an unbuffered I2C EEPROM, use an autodetect mechanism */ #if defined(ARDUINOI2CEEPROM) unsigned int i2ceepromsize = 0; #endif /* * Software SPI only on Mega2560 */ #ifndef ARDUINO_AVR_MEGA2560 #undef SOFTWARE_SPI_FOR_SD #endif /* * Arduino default serial baudrate and serial flags for the * two supported serial interfaces. Serial is always active and * connected to channel &1 with 9600 baud. * * channel 4 (ARDUINOPRT) can be either in character or block * mode. Blockmode is set as default here. This means that all * available characters are always loaded to a string -> inb() */ const int serial_baudrate = 9600; mem_t sendcr = 0; #ifdef ARDUINOPRT int serial1_baudrate = 9600; mem_t blockmode = 1; #else const int serial1_baudrate = 0; mem_t blockmode = 0; #endif /* handling time - part of the Arduino core - only needed on POSIX OSes */ void timeinit() {} /* starting wiring is only needed on raspberry */ void wiringbegin() {} /* POSIX signals - not needed here */ void signalon() {} /* * helper functions OS, heuristic on how much memory is * available in BASIC * Arduino information from * data from https://docs.arduino.cc/learn/programming/memory-guide */ #if defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_ARCH_XMC) || defined(ARDUINO_ARCH_STM32) || defined(ARDUINO_ARCH_RENESAS) extern "C" char* sbrk(int incr); long freeRam() { char top; return &top - reinterpret_cast(sbrk(0)); } #elif defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR) || defined(ARDUINO_ARCH_LGT8F) long freeRam() { extern int __heap_start,*__brkval; int v; return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int) __brkval); } #elif defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266) long freeRam() { return ESP.getFreeHeap(); } #else long freeRam() { return 0; } #endif /* * Heuristic Wifi systems reserve 4k by default, small 8 bit AVR try to guess sizes conservatively * RP2040 cannot measure, we set to 16 bit full address space */ long freememorysize() { #if defined(ARDUINO_ARCH_RENESAS) return freeRam() - 2000; #endif #if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_STM32) return freeRam() - 4000; #endif #if defined(ARDUINO_ARCH_XMC) return freeRam() - 2000; #endif #if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR) || defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_ARCH_LGT8F) int overhead=192; #ifdef HASFLOAT overhead+=96; #endif #ifdef ARDUINO_AVR_MEGA2560 overhead+=96; #endif #ifdef ARDUINOWIRE overhead+=128; #endif #ifdef ARDUINORF24 overhead+=128; #endif #if defined(ARDUINOSD) overhead+=512; #endif #ifdef ARDUINOZX81KBD overhead+=64; #endif #ifdef ARDUINOETH overhead+=256; #endif #ifdef HASGRAPH overhead+=256; /* a bit on the safe side */ #endif return freeRam() - overhead; #endif #if defined(ARDUINO_NANO_RP2040_CONNECT) || defined(ARDUINO_RASPBERRY_PI_PICO) return 65536; #endif return 0; } /* * the sleep and restart functions - only implemented for some controllers */ #if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR) void(* callzero)() = 0; #endif void restartsystem() { eflush(); /* if there is a I2C eeprom dummy, flush the buffer */ #if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266) ESP.restart(); #endif #if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR) callzero(); #endif #if defined(ARDUINO_ARCH_LGT8F) #endif } /* * I used these two articles * https://randomnerdtutorials.com/esp8266-deep-sleep-with-arduino-ide/ * https://randomnerdtutorials.com/esp32-deep-sleep-arduino-ide-wake-up-sources/ * for this very simple implementation - needs to be improved (pass data from sleep * state to sleep state via EEPROM) */ #if defined(ARDUINO_ARCH_SAMD) #define HASBUILTINRTC #include "RTCZero.h" #include "ArduinoLowPower.h" RTCZero rtc; #endif /* STM32duino have the same structure */ #if defined(ARDUINO_ARCH_STM32) #define HASBUILTINRTC #include "STM32RTC.h" #include "STM32LowPower.h" STM32RTC& rtc = STM32RTC::getInstance(); #endif /* the NRENESA board have a buildin RTC as well */ #if defined(ARDUINO_ARCH_RENESAS) #define HASBUILTINRTC #include "RTC.h" RTCTime rtc; #endif /* for ESP32 we also include the time stuctures and offer a POSIX style clock*/ #if defined(ARDUINO_ARCH_ESP32) #include "time.h" #include #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); if (c) lcd.write(c);} void dspclear() { lcd.clear(); } void dspupdate() {} void dspsetcursor(mem_t c) { if (c) lcd.blink(); else lcd.noBlink(); } void dspsetfgcolor(uint8_t c) {} void dspsetbgcolor(uint8_t c) {} void dspsetreverse(mem_t c) {} mem_t dspident() {return 0; } #define HASKEYPAD /* elementary keypad reader left=1, right=2, up=3, down=4, select= */ short keypadread(){ int a=analogRead(A0); if (a >= 850) return 0; else if (a>=600 && a<850) return 10; else if (a>=400 && a<600) return '1'; else if (a>=200 && a<400) return '3'; else if (a>=60 && a<200) return '4'; else return '2'; } /* repeat mode of the keypad - off means block, on means return immediately */ mem_t kbdrepeat=0; #endif /* * A LCD display connnected via I2C, uses the standard * Arduino I2C display library. */ #ifdef ARDUINOLCDI2C #define DISPLAYDRIVER #undef DISPLAYHASCOLOR #undef DISPLAYHASGRAPH const int dsp_rows=4; const int dsp_columns=20; LiquidCrystal_I2C lcd(0x27, dsp_columns, dsp_rows); void dspbegin() { lcd.init(); lcd.backlight(); dspsetscrollmode(1, 1); } void dspprintchar(char c, mem_t col, mem_t row) { lcd.setCursor(col, row); if (c) lcd.write(c); } void dspclear() { lcd.clear(); } void dspupdate() {} void dspsetcursor(mem_t c) { if (c) lcd.blink(); else lcd.noBlink(); } void dspsetfgcolor(uint8_t c) {} void dspsetbgcolor(uint8_t c) {} void dspsetreverse(mem_t c) {} mem_t dspident() {return 0; } #endif /* * A Nokia 5110 with ug8lib2 - can scroll quite well * https://github.com/olikraus/u8g2/wiki/u8g2reference * This is a buffered display it has a dspupdate() function * it also needs to call dspgraphupdate() after each graphic * operation * * default PIN settings here are for ESP8266, using the standard * SPI SS for 15 for CS/CE, and 0 for DC, 2 for reset * */ #ifdef ARDUINONOKIA51 #define DISPLAYDRIVER #define DISPLAYPAGEMODE #undef DISPLAYHASCOLOR /* display driver not color aware for this display */ #define DISPLAYHASGRAPH #ifndef NOKIA_CS #define NOKIA_CS 15 #endif #ifndef NOKIA_DC #define NOKIA_DC 0 #endif #ifndef NOKIA_RST #define NOKIA_RST 2 #endif U8G2_PCD8544_84X48_F_4W_HW_SPI u8g2(U8G2_R0, NOKIA_CS, NOKIA_DC, NOKIA_RST); const int dsp_rows=6; const int dsp_columns=10; typedef uint8_t dspcolor_t; dspcolor_t dspfgcolor = 1; dspcolor_t dspbgcolor = 0; char dspfontsize = 8; void dspbegin() { u8g2.begin(); u8g2.setFont(u8g2_font_amstrad_cpc_extended_8r); } void dspprintchar(char c, mem_t col, mem_t row) { char b[] = { 0, 0 }; b[0]=c; if (c) u8g2.drawStr(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 /* * 4.7 inch epaper displays are derived from the NOKIA51 code, no grayscales * at the moment. Forcing the font into rectangles and hoping this works. * * Epapers bypass the display driver here and use a graphics based display * mode instead */ #ifdef ARDUINOEDP47 #define GRAPHDISPLAYDRIVER #define DISPLAYPAGEMODE #undef DISPLAYHASCOLOR /* display driver not color aware for this display */ #define DISPLAYHASGRAPH const int dsp_width=960; const int dsp_height=540; const int dsp_rows=0; const int dsp_columns=0; typedef uint8_t dspcolor_t; dspcolor_t dspfgcolor = 1; dspcolor_t dspbgcolor = 0; char dspfontsize = 24; int dspgraphcursor_x = 0; int dspgraphcursor_y = dspfontsize; void dspbegin() { epd_init(); dspclear(); } void dspprintstring(char* s) { epd_poweron(); writeln((GFXfont *)&FiraSans, s, &dspgraphcursor_x, &dspgraphcursor_y, NULL); epd_poweroff(); } void dspclear() { epd_poweron(); epd_clear(); epd_poweroff(); dspfgcolor=1; } void dspupdate() { } void dspsetcursor(mem_t c) {} void dspsetfgcolor(uint8_t c) {} void dspsetbgcolor(uint8_t c) {} void dspsetreverse(mem_t c) {} mem_t dspident() {return 0;} void rgbcolor(int r, int g, int b) {} void vgacolor(short c) { dspfgcolor=c%3; } void plot(int x, int y) { } void line(int x0, int y0, int x1, int y1) { } void rect(int x0, int y0, int x1, int y1) { } void frect(int x0, int y0, int x1, int y1) { } void circle(int x0, int y0, int r) { } void fcircle(int x0, int y0, int r) { } #endif /* * Small SSD1306 OLED displays with I2C interface * This is a buffered display it has a dspupdate() function * it also needs to call dspgraphupdate() after each graphic * operation */ #ifdef ARDUINOSSD1306 #define DISPLAYDRIVER #define DISPLAYPAGEMODE #undef DISLAYHASCOLOR /* display driver not color aware for this display */ #define DISPLAYHASGRAPH #define SSD1306WIDTH 32 #define SSD1306HEIGHT 128 /* constructors may look like this, last argument is the reset pin * //U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE); * //U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE); */ #if SSD1306WIDTH == 32 /* U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE); * use hardware I2C instead of software. Tested (only) on ESP32C3 and ESP8266 so far. */ U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0); #endif #if SSD1306WIDTH == 64 /* the Heltec board has an internal software I2C on pins 4=SDA and 15=SCL */ #ifdef ARDUINO_heltec_wifi_lora_32_V2 U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, 15, 4, 16); #else /* use hardware I2C instead of software. Tested (only) on ESP32C3 and ESP8266 so far. */ U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0); #endif #endif const char dspfontsize = 8; const int dsp_rows=SSD1306WIDTH/dspfontsize; const int dsp_columns=SSD1306HEIGHT/dspfontsize; typedef uint8_t dspcolor_t; dspcolor_t dspfgcolor = 1; dspcolor_t dspbgcolor = 0; void dspbegin() { u8g2.begin(); u8g2.setFont(u8g2_font_amstrad_cpc_extended_8r); } void dspprintchar(char c, mem_t col, mem_t row) { char b[] = { 0, 0 }; b[0]=c; if (c) u8g2.drawStr(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) { if (c) tft.drawChar(col*dspfontsize, row*dspfontsize, c, dspfgcolor, dspbgcolor, 2); } void dspclear() { tft.fillScreen(dspbgcolor); dspfgcolor = dspdefaultfgcolor; dspfgvgacolor = dspdefaultfgvgacolor; } void dspupdate() {} void dspsetcursor(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, y0, x1, y1, dspfgcolor);} void frect(int x0, int y0, int x1, int y1) { tft.fillRect(x0, y0, x1, y1, dspfgcolor); } void circle(int x0, int y0, int r) { tft.drawCircle(x0, y0, r, dspfgcolor); } void fcircle(int x0, int y0, int r) { tft.fillCircle(x0, y0, r, dspfgcolor); } #endif /* * A MCUFRIEND parallel port display for the various tft shields * This implementation is mainly for Arduino MEGA * * currently only slow software scrolling implemented in BASIC * */ #ifdef ARDUINOMCUFRIEND #define DISPLAYDRIVER #define DISPLAYHASCOLOR #define DISPLAYHASGRAPH #ifndef LCD_CS #define LCD_CS A3 #endif #ifndef LCD_CD #define LCD_CD A2 #endif #ifndef LCD_WR #define LCD_WR A1 #endif #ifndef LCD_RD #define LCD_RD A0 #endif #ifndef LCD_RESET #define LCD_RESET A4 #endif MCUFRIEND_kbv tft; /* ILI in landscape */ const int dsp_rows=20; const int dsp_columns=30; char dspfontsize = 16; typedef uint16_t dspcolor_t; const uint16_t dspdefaultfgcolor = 0xFFFF; const uint8_t dspdefaultfgvgacolor = 0x0F; dspcolor_t dspfgcolor = dspdefaultfgcolor; dspcolor_t dspbgcolor = 0; dspcolor_t dsptmpcolor = 0; uint8_t dspfgvgacolor = dspdefaultfgvgacolor; uint8_t dsptmpvgacolor = 0; void dspbegin() { uint16_t ID = tft.readID(); if (ID == 0xD3D3) ID = 0x9481; /* write-only shield - taken from the MCDFRIEND demo */ tft.begin(ID); tft.setRotation(1); /* ILI in landscape, 3: SD slot on right the side */ tft.setTextColor(dspfgcolor); tft.setTextSize(2); tft.fillScreen(dspbgcolor); dspsetscrollmode(1, 4); /* scrolling is on, scroll 4 lines at once */ } void dspprintchar(char c, mem_t col, mem_t row) { if (c) tft.drawChar(col*dspfontsize, row*dspfontsize, c, dspfgcolor, dspbgcolor, 2); } void dspclear() { tft.fillScreen(dspbgcolor); dspfgcolor = dspdefaultfgcolor; dspfgvgacolor = dspdefaultfgvgacolor; } void dspupdate() {} void dspsetcursor(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, y0, x1, y1, dspfgcolor);} void frect(int x0, int y0, int x1, int y1) { tft.fillRect(x0, y0, x1, y1, dspfgcolor); } void circle(int x0, int y0, int r) { tft.drawCircle(x0, y0, r, dspfgcolor); } void fcircle(int x0, int y0, int r) { tft.fillCircle(x0, y0, r, dspfgcolor); } #endif /* * A no operations graphics dummy * Tests the BASIC side of the graphics code without triggering * any output */ #ifdef ARDUINOGRAPHDUMMY #define DISPLAYDRIVER #undef DISPLAYHASCOLOR #define DISPLAYHASGRAPH const int dsp_rows=20; const int dsp_columns=30; const uint16_t dspdefaultfgcolor = 1; char dspfontsize = 16; typedef uint16_t dspcolor_t; dspcolor_t dspfgcolor = 0xFFFF; dspcolor_t dspbgcolor = 0x0000; void dspbegin() { dspsetscrollmode(1, 4); } void dspprintchar(char c, mem_t col, mem_t row) {} void dspclear() {} void dspupdate() {} void dspsetcursor(mem_t c) {} void dspsetfgcolor(uint8_t c) {} void dspsetbgcolor(uint8_t c) {} void dspsetreverse(mem_t c) {} mem_t dspident() {return 0; } void rgbcolor(int r, int g, int b) { dspfgcolor=0; } void vgacolor(short c) { short base=128; if (c==8) { rgbcolor(64, 64, 64); return; } if (c>8) base=255; rgbcolor(base*(c&1), base*((c&2)/2), base*((c&4)/4)); } void plot(int x, int y) {} void line(int x0, int y0, int x1, int y1) {} void rect(int x0, int y0, int x1, int y1) {} void frect(int x0, int y0, int x1, int y1) {} void circle(int x0, int y0, int r) {} void fcircle(int x0, int y0, int r) {} #endif /* * SD1963 TFT display code with UTFT. * Tested witth SD1963 800*480 board. * it is mainly intended for a MEGA or DUE as a all in one system * this is for a MEGA shield and the CTE DUE shield, for the due * you need to read the comment in Arduino/libraries/UTFT/hardware/arm * HW_ARM_defines.h -> uncomment the DUE shield * See also * https://github.com/slviajero/tinybasic/wiki/Projects:-4.-A-standalone-computer-with-a-TFT-screen-based-on-a-DUE */ #ifdef ARDUINOTFT #define DISPLAYDRIVER #define DISPLAYHASCOLOR #define DISPLAYHASGRAPH extern uint8_t SmallFont[]; extern uint8_t BigFont[]; #ifdef ARDUINO_SAM_DUE UTFT tft(CTE70,25,26,27,28); #else UTFT tft(CTE70,38,39,40,41); #endif const int dsp_rows=30; const int dsp_columns=50; char dspfontsize = 16; const uint32_t dspdefaultfgcolor = 0x00FFFFFF; const uint8_t dspdefaultfgvgacolor = 0x0F; typedef uint32_t dspcolor_t; dspcolor_t dspfgcolor = dspdefaultfgcolor; dspcolor_t dspbgcolor = 0; dspcolor_t dsptmpcolor = 0; uint8_t dspfgvgacolor = dspdefaultfgvgacolor; uint8_t dsptmpvgacolor = 0; void dspbegin() { tft.InitLCD(); tft.setFont(BigFont); tft.clrScr(); dspsetscrollmode(1, 4); } void dspprintchar(char c, mem_t col, mem_t row) { if (c) tft.printChar(c, 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 != 0) { bdelay(2); if (c == keypadread()) return 1; } #endif return 0; } char kbdread() { char c = 0; while(!kbdavailable()) byield(); #ifdef PS2KEYBOARD c=keyboard.read(); #endif #ifdef PS2FABLIB if (fabgllastchar) { c=fabgllastchar; fabgllastchar=0; } else c=Terminal.read(); #else #ifdef USBKEYBOARD /* if we have read a key before, return it else look it up */ c=usbkey; usbkey=0; #else #ifdef ZX81KEYBOARD c=keyboard.read(); #endif #endif #endif #ifdef HASKEYPAD if (c == 0) { /* we have no character from a real keyboard, ask the keypad */ c=keypadread(); /* if the keypad is in non repeat mode, block */ if (!kbdrepeat) while(kbdavailable()) byield(); } #endif if (c == 13) c=10; return c; } char kbdcheckch() { #ifdef PS2KEYBOARD /* * only works with the patched library https://github.com/slviajero/PS2Keyboard */ #ifdef PS2KEYBOARD_HASPEEK return keyboard.peek(); #else /* * for the original library https://github.com/PaulStoffregen/PS2Keyboard * GET does not work properly with it as there is no peek functionality which is needed * for non blocking IO and the ability to stop programs */ if (kbdavailable()) return kbdread(); else return 0; #endif #else #ifdef PS2FABLIB if (fabgllastchar) return fabgllastchar; if (kbdavailable()) { fabgllastchar=Terminal.read(); return fabgllastchar; } #else #ifdef USBKEYBOARD return usbkey; #else #ifdef ZX81KEYBOARD return keyboard.lastKey; /* dont peek here as checkch called in a fast loop in statement(), peek done in byield*/ #endif #endif #endif #endif #ifdef HASKEYPAD return keypadread(); #endif return 0; } /* * this is a generic display code * it combines the functions of LCD and TFT drivers * if this code is active * * dspprintchar(char c, short col, short row) * dspclear() * dspbegin() * dspupdate() * dspsetcursor(mem_t c) * dspsetfgcolor(address_t c) * void dspsetbgcolor(address_t c) * void dspsetreverse(mem_t c) * mem_t dspident() * * have to be defined before in a hardware dependent section. * Only dspprintchar and dspclear are needed, all other can be stubs * * VGA systems don't use the display driver for text based output. * * The display driver exists as a buffered version that can scroll * or an unbuffered version that cannot scroll. Interfaces to hardware * scrolling are not yet implemented. * * A VT52 state engine is implemented and works for buffered and * unbuffered displays. Only buffered displays have the full VT52 * feature set including most of the GEMDOS extensions described here: * https://en.wikipedia.org/wiki/VT52 * * dspupdatemode controls the page update behaviour * 0: character mode, display each character separately * 1: line mode, update the display after each line * 2: page mode, update the display after an ETX * ignored if the display has no update function * */ #ifdef DISPLAYDRIVER /* the cursor position */ mem_t dspmycol = 0; mem_t dspmyrow = 0; /* the escape state of the vt52 terminal */ mem_t dspesc = 0; /* which update mode do we have */ mem_t dspupdatemode = 0; /* how do we handle wrap 0 is wrap, 1 is no wrap */ mem_t dspwrap = 0; /* the print mode */ mem_t dspprintmode = 0; /* the scroll control variables */ mem_t dspscrollmode = 0; mem_t dsp_scroll_rows = 1; int dspstat(char c) { return 0; } void dspsetcursorx(mem_t c) { if (c>=0 && c=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 #ifdef GRAPHDISPLAYDRIVER /* a super simple display driver for graphics only systems, only handles drawing and graphics cursor stuff, experimental for epapers */ #undef HASVT52 #define GBUFFERSIZE 80 static char gbuffer[GBUFFERSIZE]; void dspouts(char* s, address_t l) { int i; for (i=0; i> 4) & 0b00000111) * 10; case 2: return (v & 0b00001111)+((v >> 4) & 0b00000011) * 10 ; /* only 24 hour support */ case 3: return (v & 0b00001111); case 4: return (v & 0b00001111) + ((v >> 4) & 0b00000011) * 10; case 5: return (v & 0b00001111) + ((v >> 4) & 0b00000001) * 10; case 6: return (v & 0b00001111) + (v >> 4) * 10; default: return v; } } /* set the registers */ void rtcset(uint8_t i, short v) { uint8_t b; /* to bcd if we deal with a clock byte (0-6) */ if (i<7) b=(v%10 + ((v/10) << 4)); else b=v; switch (i) { case 0: case 1: b = b & 0b01111111; break; case 2: case 4: b = b & 0b00111111; /* only 24 hour support */ break; case 3: b = b & 0b00000111; break; case 5: b = b & 0b00011111; } /* send the address and then the byte */ Wire.beginTransmission(RTCI2CADDR); Wire.write(i); Wire.write(b); Wire.endTransmission(); } #else #if defined(HASBUILTINRTC) #define HASCLOCK /* * Built-in clocks of STM32 and MKR are based on the RTCZero interface * an rtc object is created after loading the libraries * for NRENESAs the interface is slightly different */ #ifndef ARDUINO_ARCH_RENESAS /* begin method */ void rtcbegin() { rtc.begin(); /* 24 hours mode */ } /* get the time */ short rtcget(short i) { switch (i) { case 0: return rtc.getSeconds(); case 1: return rtc.getMinutes(); case 2: return rtc.getHours(); case 3: // return rtc.getWeekDay(); return 0; case 4: return rtc.getDay(); case 5: return rtc.getMonth(); case 6: return rtc.getYear(); default: return 0; } } /* set the time */ void rtcset(uint8_t i, short v) { switch (i) { case 0: rtc.setSeconds(v); break; case 1: rtc.setMinutes(v); break; case 2: rtc.setHours(v); break; case 3: // rtc.setWeekDay(v); break; case 4: rtc.setDay(v); break; case 5: rtc.setMonth(v); break; case 6: rtc.setYear(v); break; default: return; } } #else /* NRENESA code, interface different to my great ennui! */ /* begin method */ void rtcbegin() { RTC.begin(); /* 24 hours mode */ } /* get the time */ short rtcget(short i) { RTC.getTime(rtc); switch (i) { case 0: return rtc.getSeconds(); case 1: return rtc.getMinutes(); case 2: return rtc.getHour(); case 3: return static_cast(rtc.getDayOfWeek()); case 4: return rtc.getDayOfMonth(); case 5: return Month2int(rtc.getMonth()); case 6: return rtc.getYear(); default: return 0; } } /* set the time */ void rtcset(uint8_t i, short v) { RTC.getTime(rtc); switch (i) { case 0: rtc.setSecond(v); break; case 1: rtc.setMinute(v); break; case 2: rtc.setHour(v); break; case 3: rtc.setDayOfWeek(static_cast(v)); break; case 4: rtc.setDayOfMonth(v); break; case 5: rtc.setMonthOfYear(static_cast(v-1)); break; case 6: rtc.setYear(v); break; default: return; } RTC.setTime(rtc); } #endif #else #ifdef ARDUINORTCEMULATION #define HASCLOCK /* * A millis() based real time clock emulation. It creates a 32bit Unix time * variable and adds millis()/1000 */ /* the begin method - standard interface to BASIC*/ void rtcbegin() {} /* the current unix time - initialized to the begin of the epoch */ long rtcutime = 0; /* the offset of millis()/1000 when we last set the clock */ long rtcutimeoffset = 0; /* the current unix date - initialized to the begin of the epoch */ struct { uint8_t second; uint8_t minute; uint8_t hour; uint8_t weekday; uint8_t day; uint8_t month; uint16_t year; } rtctime = { 0, 0, 0, 4, 1, 1, 1970 }; /* the number of days per month */ const int rtcmonthdays[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334}; /* convert the time to a unix time number from https://de.wikipedia.org/wiki/Unixzeit */ void rtctimetoutime() { int leapyear = ((rtctime.year-1)-1968)/4 - ((rtctime.year-1)-1900)/100 + ((rtctime.year-1)-1600)/400; long epochdays = (rtctime.year-1970)*365 + leapyear + rtcmonthdays[rtctime.month-1] + rtctime.day - 1; if ((rtctime.month > 2) && (rtctime.year%4 == 0 && (rtctime.year%100 != 0 || rtctime.year%400 == 0))) epochdays+=1; rtcutime = rtctime.second + 60*(rtctime.minute + 60*(rtctime.hour + 24*epochdays)); } /* convert the unix time to time and date from https://de.wikipedia.org/wiki/Unixzeit */ void rtcutimetotime() { const unsigned long int secondsperday = 86400ul; /* 24* 60 * 60 */ const unsigned long int daysperyear = 365ul; /* no leap year */ const unsigned long int daysinfoury = 1461ul; /* 4*365 + 1 */ const unsigned long int daysinhundredy = 36524ul; /* 100*365 + 25 - 1 */ const unsigned long int daysinfourhundredy = 146097ul; /* 400*365 + 100 - 4 + 1 */ const unsigned long int daynumberzero = 719468ul; /* day number of March, 1 1970 */ unsigned long int daynumber = daynumberzero + rtcutime/secondsperday; unsigned long int secondssincemidnight = rtcutime%secondsperday; unsigned long int temp; /* the weekday is based in the daynumber since March, 1, 1970 a SUNDAY */ rtctime.weekday = daynumber % 7; /* leap years of the Gregorian calendar */ temp = 4 * (daynumber + daysinhundredy + 1) / daysinfourhundredy - 1; rtctime.year = 100 * temp; daynumber -= daysinhundredy * temp + temp / 4; /* leap years of the Julian calendar */ temp = 4 * (daynumber + daysperyear + 1) / daysinfoury - 1; rtctime.year += temp; daynumber -= daysperyear * temp + temp / 4; /* calculate day and month, reference March 1 */ rtctime.month = (5 * daynumber + 2) / 153; rtctime.day = daynumber - (rtctime.month * 153 + 2) / 5 + 1; /* recalulate to a normal year */ rtctime.month += 3; if (rtctime.month > 12) { rtctime.month -= 12; rtctime.year++; } /* calculate hours, months, seconds */ rtctime.hour = secondssincemidnight / 3600; rtctime.minute = secondssincemidnight % 3600 / 60; rtctime.second = secondssincemidnight % 60; } /* get the time elements -> standard interface to BASIC */ short rtcget(short i) { /* add to the last time we set the clock and subtract the offset*/ rtcutime = millis()/1000 + rtcutimeoffset; /* calulate the time data */ rtcutimetotime(); switch (i) { case 0: return rtctime.second; case 1: return rtctime.minute; case 2: return rtctime.hour; case 3: return rtctime.weekday; case 4: return rtctime.day; case 5: return rtctime.month; case 6: return rtctime.year; default: return 0; } } /* set the time elements -> standard interface to BASIC */ void rtcset(uint8_t i, short v) { /* how much time has elapsed since we last set the clock */ rtcutime = millis()/1000 + rtcutimeoffset; /* generate the time structure */ rtcutimetotime(); /* set the clock */ switch (i) { case 0: if (v>=0 && v<60) rtctime.second=v; break; case 1: if (v>=0 && v<60) rtctime.minute=v; break; case 2: if (v>=0 && v<24) rtctime.hour=v; break; case 3: if (v>=0 && v<7) rtctime.weekday=v; break; case 4: if (v>0 && v<32) rtctime.day=v; break; case 5: if (v>0 && v<13) rtctime.month=v; break; case 6: if (v>=1970 && v<2100) rtctime.year=v; break; default: return; } /* recalulate the right offset by first finding the second value of the new date*/ rtctimetoutime(); /* remember when we set the clock */ rtcutimeoffset = rtcutime - millis()/1000; } #else #if defined(ARDUINO_ARCH_ESP32) #define HASCLOCK /* * On ESP32 we use the builtin clock, this is a generic Unix time mechanism equivalent * to the code in hardware-posix.h */ /* no begin needed */ void rtcbegin() {} /* get the time */ short rtcget(short i) { struct tm rtctime; time_t now; time(&now); localtime_r(&now, &rtctime); switch (i) { case 0: return rtctime.tm_sec; case 1: return rtctime.tm_min; case 2: return rtctime.tm_hour; case 3: return rtctime.tm_wday; case 4: return rtctime.tm_mday; case 5: return rtctime.tm_mon+1; case 6: if (rtctime.tm_year > 100) return rtctime.tm_year-100; else return rtctime.tm_year; default: return 0; } return 0; } /* set the time */ void rtcset(uint8_t i, short v) { struct tm rtctime; struct timeval tv; /* get the time stucture from the system */ time_t now; time(&now); localtime_r(&now, &rtctime); /* change what needs to be changed */ switch (i) { case 0: rtctime.tm_sec = v%60; break; case 1: rtctime.tm_min = v%60; break; case 2: rtctime.tm_hour = v%24; break; case 3: rtctime.tm_wday = v%7; break; case 4: rtctime.tm_mday = v; break; case 5: rtctime.tm_mon = v-1; break; case 6: if (v > 1900) v=v-1900; /* get years to the right value */ if (v < 50) v=v+100; rtctime.tm_year = v; break; } /* calculate the seconds and put it back*/ time_t epocht = mktime(&rtctime); if (epocht > 2082758399){ tv.tv_sec = epocht - 2082758399; } else { tv.tv_sec = epocht; } tv.tv_usec = 0; settimeofday(&tv, NULL); } #else /* no clock at all, no operations */ void rtcbegin() {} short rtcget(short i) { return 0; } void rtcset(uint8_t i, short v) { } #endif #endif #endif #endif /* * External EEPROM is handled through an EFS filesystem object * see https://github.com/slviajero/EepromFS * for details. Here the most common parameters are set as a default. */ #ifdef ARDUINOEFS #undef ARDUINOI2CEEPROM #ifndef EFSEEPROMADDR #define EFSEEPROMADDR 0x50 #endif #ifdef EFSEEPROMSIZE EepromFS EFS(EFSEEPROMADDR, EFSEEPROMSIZE); #else EepromFS EFS(EFSEEPROMADDR); #endif #endif /* * External EEPROM is handled through an EFS filesystem object in raw mode * see https://github.com/slviajero/EepromFS * for details. Here the most common parameters are set as a default. */ #if defined(ARDUINOI2CEEPROM) && defined(ARDUINOI2CEEPROM_BUFFERED) #ifndef I2CEEPROMADDR #define I2CEEPROMADDR 0x50 #endif #ifdef I2CEEPROMSIZE EepromFS EFSRAW(I2CEEPROMADDR, I2CEEPROMSIZE); #else EepromFS EFSRAW(I2CEEPROMADDR); #endif #endif /* * definitions for ESP Wifi and MQTT, super experimental. * As networking is only used for MQTT at the moment, * mqtt, Wifi and Ethernet comes all in one. * * No encryption/authetication is implemented in MQTT. * Only public, open servers can be used. * * MQTT topics can only be 32 bytes long. * Buffered incoming and outgoing messages can be 128 bytes * per default. * * wifisettings.h is the generic network definition file * all network settings are compiled into the code * BASIC cannot change them at runtime. */ #ifdef ARDUINOMQTT #include "wifisettings.h" #ifdef ARDUINOETH EthernetClient bethclient; PubSubClient bmqtt(bethclient); #else WiFiClient bwifi; PubSubClient bmqtt(bwifi); #endif /* the buffers of the outgoing and incoming MQTT topic */ #define MQTTLENGTH 32 static char mqtt_otopic[MQTTLENGTH]; static char mqtt_itopic[MQTTLENGTH]; /* * the buffers for MQTT messages, input and output goes * through these static buffers. */ #define MQTTBLENGTH 128 volatile char mqtt_buffer[MQTTBLENGTH]; volatile short mqtt_messagelength; volatile char mqtt_obuffer[MQTTBLENGTH]; volatile short mqtt_charsforsend; /* the name of the client, generated pseudo randomly to avoind naming conflicts */ static char mqttname[12] = "iotbasicxxx"; void mqttsetname() { long m = millis(); mqttname[8]=(char)(65+m%26); m=m/26; mqttname[9]=(char)(65+m%26); m=m/26; mqttname[10]=(char)(65+m%26); } /* * network begin method * needs the settings from wifisettings.h * * Default is right now that Wifi is started at boot * This may change in the future. * * Ethernet begin has to be reviewed to avoid DHCP * start timeout if network is not connected */ void netbegin() { #ifdef ARDUINOETH #ifdef ETHPIN Ethernet.init(ETHPIN); #endif Ethernet.begin(mac); #else #if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266) WiFi.mode(WIFI_STA); WiFi.begin(ssid, password); WiFi.setAutoReconnect(1); #endif #if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_UNOR4_WIFI) WiFi.begin(ssid, password); #endif #endif } /* * network stop methode, needed sometime to reinit networking * completely or to save power * */ void netstop() { #ifdef ARDUINOETH /* to be done */ #else #if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266) WiFi.mode(WIFI_OFF); #endif #if defined(ARDUINO_ARCH_RP2040) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_UNOR4_WIFI) WiFi.end(); #endif #endif } /* * network reconnect methode * */ void netreconnect() { #ifdef ARDUINOETH /* */ #else #if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_ESP8266) WiFi.reconnect(); bdelay(1000); #elif defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_UNOR4_WIFI) WiFi.end(); WiFi.begin(ssid, password); bdelay(1000); #endif #endif } /* * network connected method * on ESP Wifi try to reconnect, the delay is odd * This is a partial reconnect, BASIC needs to handle * repeated reconnects */ char netconnected() { #ifdef ARDUINOETH return bethclient.connected(); #else return(WiFi.status() == WL_CONNECTED); #endif } /* * mqtt callback function, using the byte type here * because payload can be binary - interface to BASIC * strings need to be done * * mqtt event handling in BASIC can be triggered here */ void mqttcallback(char* t, byte* p, unsigned int l) { short i; mqtt_messagelength=l; for(i=0; i 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(address_t p, address_t v){ if (v == 0) digitalWrite(p, LOW); else if (v == 1) digitalWrite(p, HIGH); else error(EORANGE); } /* we normalize the pinMode as ESP32, ESP8266, and other boards behave rather * differently. Following Arduino conventions we map 0 always to INPUT * and 1 always to OUTPUT, all the other numbers are passed through to the HAL * layer of the platform. * Example: OUTPUT on ESP32 is 3 and 1 is assigned to INPUT. * XMC also needs special treatment here. */ void pinm(address_t p, address_t m){ uint8_t ml = m; uint8_t pl = p; switch (ml) { case 0: pinMode(pl, INPUT); break; case 1: pinMode(pl, OUTPUT); break; default: pinMode(pl, ml); break; } } /* read a pulse, units given by bpulseunit - default 10 microseconds */ void bpulsein() { address_t x,y; unsigned long t, pt; t=((unsigned long) pop())*1000; y=popaddress(); x=popaddress(); if (er != 0) return; pt=pulseIn(x, y, t)/bpulseunit; push(pt); } /* write a pulse in microsecond range */ void bpulseout(short a) { short pin, duration; short value = 1; short intervall = 0; short repetition = 1; if (a == 5) { intervall=pop(); repetition=pop(); } if (a > 2) value=pop(); duration=pop(); pin=pop(); while (repetition--) { digitalWrite(pin, value); delayMicroseconds(duration*bpulseunit); digitalWrite(pin, !value); delayMicroseconds(intervall*bpulseunit); } } void btone(short a) { number_t d = 0; number_t v = 100; if (a == 4) v=pop(); if (a >= 3) d=pop(); x=pop(); y=pop(); #if defined(ARDUINO_TTGO_T7_V14_Mini32) && defined(HASTONE) /* fabGL soundgenerator code of suggestes by testerrossa * pin numbers below 128 are real arduino pins while * pin numvers from 128 onwards are sound generator capabilities * this is different from the original code * * Sound generator capabilities are numbered as follows * 128: Sine wave * 129: Symmetric square wave * 130: Sawtooth * 131: Triangle * 132: VIC noise * 133: noise * * 256-511: square wave with variable duty cycle * */ if (x == 0) { soundGenerator.play(false); soundGenerator.clear(); return; } if (a == 2) d=60000; if (y == 128) soundGenerator.playSound(SineWaveformGenerator(), x, d, v); if (y == 129) soundGenerator.playSound(SquareWaveformGenerator(), x, d, v); if (y == 130) soundGenerator.playSound(SawtoothWaveformGenerator(), x, d, v); if (y == 131) soundGenerator.playSound(TriangleWaveformGenerator(), x, d, v); if (y == 132) soundGenerator.playSound(VICNoiseGenerator(), x, d, v); if (y == 133) soundGenerator.playSound(NoiseWaveformGenerator(), x, d, v); if (y >= 255 && y < 512 ) { y=y-255; SquareWaveformGenerator sqw; sqw.setDutyCycle(y); soundGenerator.playSound(sqw, x, d, v); } return; #endif #ifndef ARDUINOTONEEMULATION if (x == 0) { noTone(y); } else if (a == 2) { tone(y, x); } else { tone(y, x, d); } #else if (x == 0) { playtone(0, 0, 0); } else if (a == 2) { playtone(y, x, 32767); } else { playtone(y, x, d); } #endif } /* * the byield function is called after every statement * it allows two levels of background tasks. * * BASICBGTASK controls if time for background tasks is * needed, usually set by hardware features * * YIELDINTERVAL by default is 32, generating a 32 ms call * to the network loop function. YIELDTIME is 2 generating * a 2 ms wait after the network loop to allow for buffer * clearing after - this is needed on ESP8266 * * LONGYIELDINTERVAL by default is 1000, generating a one second * call to maintenance functions. * * On an ESP8266 byield() is called every 100 microseconds * (after each statement) in RUN mode. BASIC DELAY calls * this every YIELDTIME ms. */ /* everything that needs to be done often - 32 ms */ void yieldfunction() { #ifdef ARDUINOMQTT bmqtt.loop(); #endif #ifdef ARDUINOUSBKBD usb.Task(); #endif #ifdef ARDUINOZX81KBD (void) keyboard.peek(); /* scan once and set lastkey properly every 32 ms */ #endif /* this was delay(YIELDTIME) originally - removed now */ } /* everything that needs to be done not so often - 1 second */ void longyieldfunction() { #ifdef ARDUINOETH Ethernet.maintain(); #endif } void yieldschedule() { /* delay(0) is only needed on ESP8266! it calls the scheduler - no bdelay here!! */ #if defined(ARDUINO_ARCH_ESP8266) delay(0); #endif } /* * The file system driver - all methods needed to support BASIC fs access * Different filesystems need different prefixes and fs objects, these * filesystems use the stream API */ #if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(STM32SDIO) File ifile; File ofile; char tempname[SBUFSIZE]; #if defined(ARDUINOSD) || defined(STM32SDIO) File root; File file; #ifdef ARDUINO_ARCH_ESP32 const char rootfsprefix[2] = "/"; #else const char rootfsprefix[1] = ""; #endif #endif #ifdef ESPSPIFFS const char rootfsprefix[2] = "/"; #ifdef ARDUINO_ARCH_ESP8266 Dir root; File file; #endif #ifdef ARDUINO_ARCH_ESP32 File root; File file; #endif #endif #ifdef ARDUINO_ARCH_ESP8266 #define FILE_OWRITE (sdfat::O_READ | sdfat::O_WRITE | sdfat::O_CREAT | sdfat::O_TRUNC) #else #if defined(ARDUINO_ARCH_ESP32) || defined(ARDUINO_ARCH_STM32) #define FILE_OWRITE FILE_WRITE #else #define FILE_OWRITE (O_READ | O_WRITE | O_CREAT | O_TRUNC) #endif #endif #endif /* using the POSIX API in LittleFS */ #ifdef RP2040LITTLEFS #define FILESYSTEMDRIVER FILE* ifile; FILE* ofile; DIR* root; struct dirent* file; LittleFS_MBED *myFS; const char rootfsprefix[10] = MBED_LITTLEFS_FILE_PREFIX; #endif /* use EEPROM as filesystem */ #ifdef ARDUINOEFS byte ifile; byte ofile; byte file; #endif /* these filesystems may have a path prefixes, we treat STM32SDIO like an SD here */ #if defined(RP2040LITTLEFS) || defined(ESPSPIFFS) || defined(ARDUINOSD) char tmpfilename[10+SBUFSIZE]; /* add the prefix to the filename */ char* mkfilename(const char* filename) { short i,j; for(i=0; i<10 && rootfsprefix[i]!=0; i++) tmpfilename[i]=rootfsprefix[i]; tmpfilename[i++]='/'; for(j=0; 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) || defined(STM32SDIO) if (ofile) ofile.write(c); else ert=1; #endif #if defined(RP2040LITTLEFS) if (ofile) fputc(c, ofile); else ert=1; #endif #if defined(ARDUINOEFS) if (ofile) { if (!EFS.fputc(c, ofile)) ert=-1; } else ert=1; #endif } char fileread(){ char c; #if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(STM32SDIO) if (ifile) c=ifile.read(); else { ert=1; return 0; } if (c == -1 || c == 255) ert=-1; return c; #endif #ifdef RP2040LITTLEFS if (ifile) c=fgetc(ifile); else { ert=1; return 0; } if (c == -1 || c == 255) ert=-1; return c; #endif #ifdef ARDUINOEFS if (ifile) c=EFS.fgetc(ifile); else { ert=1; return 0; } if (c == -1|| c == 255) ert=-1; return c; #endif return 0; } int fileavailable(){ #if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(STM32SDIO) return ifile.available(); #endif #ifdef RP2040LITTLEFS return !feof(ifile); #endif #ifdef ARDUINOEFS return EFS.available(ifile); #endif return 0; } char ifileopen(const char* filename){ #if defined(ARDUINOSD) ifile=SD.open(mkfilename(filename), FILE_READ); return (int) ifile; #endif #if defined(STM32SDIO) ifile=SD.open(filename); return (int) ifile; #endif #ifdef ESPSPIFFS ifile=SPIFFS.open(mkfilename(filename), "r"); return (int) ifile; #endif #ifdef RP2040LITTLEFS ifile=fopen(mkfilename(filename), "r"); return (int) ifile; #endif #ifdef ARDUINOEFS ifile=EFS.fopen(filename, "r"); return (int) ifile; #endif return 0; } void ifileclose(){ #if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(STM32SDIO) ifile.close(); #endif #ifdef RP2040LITTLEFS if (ifile) fclose(ifile); ifile=NULL; #endif #ifdef ARDUINOEFS if (ifile) EFS.fclose(ifile); ifile=0; #endif } char ofileopen(char* filename, const char* m){ #if defined(ARDUINOSD) if (*m == 'w') ofile=SD.open(mkfilename(filename), FILE_OWRITE); /* ESP32 has FILE_APPEND defined */ #ifdef FILE_APPEND if (*m == 'a') ofile=SD.open(mkfilename(filename), FILE_APPEND); #else if (*m == 'a') ofile=SD.open(mkfilename(filename), FILE_WRITE); #endif return (int) ofile; #endif #if defined(STM32SDIO) if (*m == 'w') ofile=SD.open(filename, FILE_OWRITE); /* ESP32 has FILE_APPEND defined */ #ifdef FILE_APPEND if (*m == 'a') ofile=SD.open(filename, FILE_APPEND); #else if (*m == 'a') ofile=SD.open(filename, FILE_WRITE); #endif return (int) ofile; #endif #ifdef ESPSPIFFS ofile=SPIFFS.open(mkfilename(filename), m); return (int) ofile; #endif #ifdef RP2040LITTLEFS ofile=fopen(mkfilename(filename), m); return (int) ofile; #endif #ifdef ARDUINOEFS ofile=EFS.fopen(filename, m); return (int) ofile; #endif return 0; } void ofileclose(){ #if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(STM32SDIO) ofile.close(); #endif #ifdef RP2040LITTLEFS if (ofile) fclose(ofile); #endif #ifdef ARDUINOEFS if (ofile) EFS.fclose(ofile); #endif } /* * directory handling for the catalog function * these methods are needed for a walkthtrough of * one directory * * rootopen() * while rootnextfile() * if rootisfile() print rootfilename() rootfilesize() * rootfileclose() * rootclose() */ void rootopen() { #if defined(ARDUINOSD) || defined(STM32SDIO) root=SD.open("/"); #endif #ifdef ESPSPIFFS #ifdef ARDUINO_ARCH_ESP8266 root=SPIFFS.openDir("/"); #endif #ifdef ARDUINO_ARCH_ESP32 root=SPIFFS.open("/"); #endif #endif #ifdef RP2040LITTLEFS root=opendir(rootfsprefix); #endif #ifdef ARDUINOEFS EFS.dirp=0; #endif } int rootnextfile() { #if defined(ARDUINOSD) || defined(STM32SDIO) file=root.openNextFile(); return (file != 0); #endif #ifdef ESPSPIFFS #ifdef ARDUINO_ARCH_ESP8266 if (root.next()) { file=root.openFile("r"); return 1; } else { return 0; } #endif #ifdef ARDUINO_ARCH_ESP32 file=root.openNextFile(); return (file != 0); #endif #endif #ifdef RP2040LITTLEFS file = readdir(root); return (file != 0); #endif #ifdef ARDUINOEFS file = EFS.readdir(); return (file != 0); #endif return 0; } int rootisfile() { #if defined(ARDUINOSD) || defined(STM32SDIO) return (! file.isDirectory()); #endif #ifdef ESPSPIFFS #ifdef ARDUINO_ARCH_ESP8266 return 1; #endif #ifdef ARDUINO_ARCH_ESP32 return (! file.isDirectory()); #endif #endif #ifdef RP2040LITTLEFS return (file->d_type == DT_REG); #endif #ifdef ARDUINOEFS return 1; #endif return 0; } const char* rootfilename() { #if defined(ARDUINOSD) //return (char*) file.name(); return rmrootfsprefix(file.name()); #endif #if defined(STM32SDIO) return (char*) file.name(); #endif #ifdef ESPSPIFFS #ifdef ARDUINO_ARCH_ESP8266 // c_str() and copy - real ugly int i=0; String s=root.fileName(); for (i=0; id_name); #endif #ifdef ARDUINOEFS return EFS.filename(file); #endif return 0; } long rootfilesize() { #if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(STM32SDIO) return file.size(); #endif #ifdef RP2040LITTLEFS #endif #ifdef ARDUINOEFS return EFS.filesize(file); #endif return 0; } void rootfileclose() { #if defined(ARDUINOSD) || defined(ESPSPIFFS) || defined(STM32SDIO) file.close(); #endif #ifdef RP2040LITTLEFS #endif #ifdef ARDUINOEFS #endif } void rootclose(){ #if defined(ARDUINOSD) || defined(STM32SDIO) root.close(); #endif #ifdef ESPSPIFFS #ifdef ARDUINO_ARCH_ESP8266 return; #endif #ifdef ARDUINO_ARCH_ESP32 root.close(); #endif #endif #ifdef RP2040LITTLEFS #endif #ifdef ARDUINOEFS #endif } /* * remove method for files */ void removefile(char *filename) { #if defined(ARDUINOSD) SD.remove(mkfilename(filename)); return; #endif #if defined(STM32SDIO) SD.remove(filename); return; #endif #ifdef ESPSPIFFS SPIFFS.remove(mkfilename(filename)); return; #endif #ifdef RP2040LITTLEFS remove(mkfilename(filename)); return; #endif #ifdef ARDUINOEFS EFS.remove(filename); return; #endif } /* * formatting for fdisk of the internal filesystems */ void formatdisk(short i) { #if defined(ARDUINOSD) || defined(STM32SDIO) return; #endif #ifdef ESPSPIFFS if (SPIFFS.format()) { SPIFFS.begin(); outsc("ok\n"); } else { outsc("fail\n"); } #endif #ifdef RP2040LITTLEFS fs.reformat(&bd); return; #endif #ifdef ARDUINOEFS if (i>0 && i<256) { if (EFS.format(i)) { EFS.begin(); outsc("ok\n"); } else { outsc("fail\n"); } outcr(); } else error(EORANGE); return; #endif } /* * Primary serial code uses the Serial object or Picoserial * * The picoseria an own interrupt function. This is used to fill * the input buffer directly on read. Write is standard like in * the serial code. * * As echoing is done in the interrupt routine, the code cannot be * used to receive keystrokes from serial and then display the echo * directly to a display. To do this the write command in picogetchar * would have to be replaced with a outch() that then redirects to the * display driver. This would be very tricky from the timing point of * view if the display driver code is slow. * * The code for the UART control is mostly taken from PicoSerial * https://github.com/gitcnd/PicoSerial, originally written by Chris Drake * and published under GPL3.0 just like this code * */ #ifdef USESPICOSERIAL volatile static char picochar; volatile static char picoa = 0; volatile static char* picob = NULL; static short picobsize = 0; volatile static short picoi = 1; /* this is mostly taken from PicoSerial */ const uint16_t MIN_2X_BAUD = F_CPU/(4*(2*0XFFF + 1)) + 1; /* the begin code */ void picobegin(unsigned long baud) { uint16_t baud_setting; cli(); if ((F_CPU != 16000000UL || baud != 57600) && baud > MIN_2X_BAUD) { UCSR0A = 1 << U2X0; baud_setting = (F_CPU / 4 / baud - 1) / 2; } else { UCSR0A = 0; baud_setting = (F_CPU / 8 / baud - 1) / 2; } /* assign the baud_setting */ UBRR0H = baud_setting >> 8; UBRR0L = baud_setting; /* enable transmit and receive */ UCSR0B |= (1 << TXEN0) | (1 << RXEN0) | (1 << RXCIE0); sei(); } /* the write code, sending bytes directly to the UART */ void picowrite(char b) { while (((1 << UDRIE0) & UCSR0B) || !(UCSR0A & (1 << UDRE0))) {} UDR0 = b; } /* * picogetchar: this is the interrupt service routine. It * recieves a character and feeds it into a buffer and echos it * back. The logic here is that the ins() code sets the buffer * to the input buffer. Only then the routine starts writing to the * buffer. Once a newline is received, the length information is set * and picoa is also set to 1 indicating an available string, this stops * recevieing bytes until the input is processed by the calling code. */ void picogetchar(char c){ if (picob && (! picoa)) { picochar=c; if (picochar != '\n' && picochar != '\r' && 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 (!SERIALPORT.available()) byield(); return SERIALPORT.read(); #endif } /* * serial begin code with a one second delay after start * this is not needed any more */ void serialbegin() { #ifdef USESPICOSERIAL picobegin(serial_baudrate); #else SERIALPORT.begin(serial_baudrate); #endif bdelay(1000); } /* state information on the serial port */ int serialstat(char c) { if (c == 0) return 1; if (c == 1) return serial_baudrate; return 0; } /* write to a serial stream */ void serialwrite(char c) { #ifdef USESPICOSERIAL picowrite(c); #else /* write never blocks. discard any bytes we can't get rid of */ SERIALPORT.write(c); /* if (Serial.availableForWrite()>0) Serial.write(c); */ #endif } /* check on a character, needed for breaking */ short serialcheckch() { #ifdef USESPICOSERIAL return picochar; #else if (SERIALPORT.available()) return SERIALPORT.peek(); else return 0; // should really be -1 #endif } /* avail method, needed for AVAIL() */ short serialavailable() { #ifdef USESPICOSERIAL return picoi; #else return SERIALPORT.available(); #endif } /* flush serial */ void serialflush() { #ifdef USESPICOSERIAL return; #else while (SERIALPORT.available()) SERIALPORT.read(); #endif } /* * reading from the console with inch or the picoserial callback * this mixes interpreter levels as inch/outch are used here * this code needs to go to the main interpreter section after * thorough rewrite */ void consins(char *b, short nb) { char c; z.a = 1; #ifdef USESPICOSERIAL if (id == ISERIAL) { picoins(b, nb); return; } #endif while(z.a < nb) { c=inch(); if (id == ISERIAL || id == IKEYBOARD) outch(c); /* this is local echo */ if (c == '\r') c=inch(); /* skip carriage return */ if (c == '\n' || c == -1 || c == 255) { /* terminal character is either newline or EOF */ break; } else if (c == 127 || c == 8) { if (z.a>1) z.a--; } else { b[z.a++]=c; } } b[z.a]=0; z.a--; b[0]=(unsigned char)z.a; } /* * Start a secondary serial port for printing and/or networking * This is either Serial1 on a MEGA or DUE or Nano Every or a SoftwareSerial * instance */ #ifdef ARDUINOPRT #if !defined(ARDUINO_AVR_MEGA2560) && !defined(ARDUINO_SAM_DUE) && !defined(ARDUINO_AVR_NANO_EVERY) && !defined(ARDUINO_NANO_RP2040_CONNECT) && !defined(ARDUINO_RASPBERRY_PI_PICO) && !defined(ARDUINO_SEEED_XIAO_M0) #include const int software_serial_rx = SOFTSERIALRX; const int software_serial_tx = SOFTSERIALTX; SoftwareSerial PRTSERIAL(software_serial_rx, software_serial_tx); #endif /* second serial port */ void prtbegin() { PRTSERIAL.begin(serial1_baudrate); } /* the open functions are not needed here */ char prtopen(char* filename, int mode) {} void prtclose() {} int prtstat(char c) { if (c == 0) return 1; if (c == 1) return serial1_baudrate; return 0; } void prtwrite(char c) { PRTSERIAL.write(c); } char prtread() { while (!PRTSERIAL.available()) byield(); return PRTSERIAL.read(); } short prtcheckch() { if (PRTSERIAL.available()) return PRTSERIAL.peek(); else return 0; } short prtavailable() { return PRTSERIAL.available(); } void prtset(int s) { serial1_baudrate=s; prtbegin(); } #endif /* * The wire code, direct access to wire communication * in master mode wire_slaveid is the I2C address bound * to channel &7 and wire_myid is 0 * in slave mode wire_myid is the devices slave address * and wire_slaveid is 0 * ARDUINOWIREBUFFER is the maximum length of meesages the * underlying library can process. This is 32 for the Wire * library */ /* this is always here, if Wire is needed by a subsysem */ #ifdef HASWIRE /* default begin is as a master * This doesn't work properly on the ESP32C3 platform * See https://github.com/espressif/arduino-esp32/issues/6376 * for more details */ void wirebegin() { #ifndef SDA_PIN Wire.begin(); #else Wire.begin(SDA_PIN, SCL_PIN); #endif } #endif /* this is code needed for the OPEN/CLOSE and wireslave mechanisms */ #if (defined(ARDUINOWIRE) && defined(HASFILEIO)) uint8_t wire_slaveid = 0; uint8_t wire_myid = 0; #define ARDUINOWIREBUFFER 32 #ifdef ARDUINOWIRESLAVE char wirereceivebuffer[ARDUINOWIREBUFFER]; short wirereceivechars = 0; char wirerequestbuffer[ARDUINOWIREBUFFER]; short wirerequestchars = 0; #endif void wireslavebegin(char s) { #ifndef SDA_PIN Wire.begin(s); #else Wire.begin(SDA_PIN, SCL_PIN, s); #endif } /* wire status - just checks if wire is compiled */ int wirestat(char c) { switch (c) { case 0: return 1; #ifdef ARDUINOWIRESLAVE case 1: return wirerequestchars; #endif default: return 0; } } /* available characters - test code ecapsulation prep for slave*/ short wireavailable() { /* as a master we return 1, as a slave the received chars*/ if (wire_myid == 0) return 1; #ifdef ARDUINOWIRESLAVE else return wirereceivechars; #else else return 0; #endif } #ifdef ARDUINOWIRESLAVE /* event handler for receive */ void wireonreceive(int h) { wirereceivechars=h; if (h>ARDUINOWIREBUFFER) h=ARDUINOWIREBUFFER; for (int i=0; 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 /* * A tone emulation based on the byield loop. The maximum frequency depends * on the byield call speed. 10-20 kHz is possible. Will be unreliable if * the loop functions need a lot of CPU cycles. */ #ifdef ARDUINOTONEEMULATION static mem_t tone_enabled; static mem_t tone_pinstate = 0; static unsigned long tone_intervall; static unsigned long tone_micros; static int tone_duration; static unsigned long tone_start; static mem_t tone_pin; void playtone(int pin, int frequency, int duration){ /* the pin we are using is reset every time this is called*/ tone_pin=pin; pinMode(tone_pin, OUTPUT); digitalWrite(tone_pin, LOW); tone_pinstate=0; /* duration 0 or frequency 0 stops playing */ if (duration == 0 || frequency == 0) { tone_enabled=0; return; } /* calculate the toggle intervall in micros and remember where we are */ tone_intervall=1000000/frequency/2; tone_micros=micros(); /* set the duration and remember where we are*/ tone_duration=duration; tone_start=millis(); /* start the play */ tone_enabled=1; } void tonetoggle() { /* is this active? */ if (!tone_enabled) return; /* check if we are done playing */ if (millis() > tone_duration+tone_start) { tone_enabled=0; digitalWrite(tone_pin, LOW); tone_pinstate=0; return; } /* if not, check if the intervall is over */ if (micros() > tone_intervall+tone_micros) { tone_micros=micros(); tone_pinstate=!tone_pinstate; digitalWrite(tone_pin, tone_pinstate); } } #endif /* * the events API for Arduino with interrupt service routines * analogous to the timer API * * we use raw modes here * * #define CHANGE 1 * #define FALLING 2 * #define RISING 3 * */ #ifdef HASEVENTS /* interrupts in BASIC fire once and then disable themselves, BASIC reenables them */ void bintroutine0() { eventlist[0].active=1; detachInterrupt(digitalPinToInterrupt(eventlist[0].pin)); } void bintroutine1() { eventlist[1].active=1; detachInterrupt(digitalPinToInterrupt(eventlist[1].pin)); } void bintroutine2() { eventlist[2].active=1; detachInterrupt(digitalPinToInterrupt(eventlist[2].pin)); } void bintroutine3() { eventlist[3].active=1; detachInterrupt(digitalPinToInterrupt(eventlist[3].pin)); } #if !(defined(ARDUINO_ARCH_MBED_RP2040) || defined(ARDUINO_ARCH_MBED_NANO) || defined(ARDUINO_ARCH_RENESAS)) typedef int PinStatus; #endif mem_t enableevent(int pin) { mem_t interrupt; int i; /* do we have the data */ if ((i=eventindex(pin))<0) return 0; /* can we use this pin */ interrupt=digitalPinToInterrupt(eventlist[i].pin); if (interrupt < 0) return 0; /* attach the interrupt function to this pin */ switch(i) { case 0: attachInterrupt(interrupt, bintroutine0, (PinStatus) eventlist[i].mode); break; case 1: attachInterrupt(interrupt, bintroutine1, (PinStatus) eventlist[i].mode); break; case 2: attachInterrupt(interrupt, bintroutine2, (PinStatus) eventlist[i].mode); break; case 3: attachInterrupt(interrupt, bintroutine3, (PinStatus) eventlist[i].mode); break; default: return 0; } /* now set it enabled in BASIC */ eventlist[i].enabled=1; return 1; } void disableevent(mem_t pin) { detachInterrupt(digitalPinToInterrupt(pin)); } #endif /* * This code measures the fast ticker frequency in microseconds * It leaves the data in variable F. Activate this only for test * purposes. */ #undef FASTTICKERPROFILE #ifdef FASTTICKERPROFILE static unsigned long lastfasttick = 0; static unsigned long fasttickcalls = 0; static int avgfasttick = 0; static long devfasttick = 0; void fasttickerprofile() { if (lastfasttick == 0) { lastfasttick=micros(); return; } int delta=micros()-lastfasttick; lastfasttick=micros(); avgfasttick=(avgfasttick*fasttickcalls+delta)/(fasttickcalls+1); fasttickcalls++; vars[5]=avgfasttick; } #endif // defined HARDWARE_H #endif