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