| /* | |
| * Stefan's basic interpreter. | |
| * | |
| * Prototypes for the runtime environment of the BASIC interpreter. | |
| * | |
| * Needs to be included by runtime.c or runtime.cpp and basic.c as | |
| * it describes the interface between the BASIC interpreter and the | |
| * runtime environment. | |
| * | |
| * Most configurable parameters are in hardware.h. | |
| * | |
| * Author: Stefan Lenz, [email protected] | |
| * | |
| */ | |
| /* | |
| * The system type identifiers | |
| * | |
| * SYSTYPE_UNKNOWN: unknown system, typically an unknown Arduino | |
| * SYSTYPE_AVR: an AVR based Arduino, like the UNO, NANO, MEGA, PRO | |
| * SYSTYPE_ESP8266: an ESP8266 based Arduino, like the Wemos D1, very common and generic | |
| * SYSTYPE_ESP32: an ESP32 based Arduino, like the Wemos Lolin32, very common and generic | |
| * SYSTYPE_RP2040: a Raspberry PI Pico, the first RP2040 based Arduino | |
| * SYSTYPE_SAM: a SAM based Arduino, like the DUE | |
| * SYSTYPE_XMC: an XMC based Arduino, like the Infineon XMC1100 | |
| * SYSTYPE_SMT32: an STM32 based Arduino, like the Blue Pill | |
| * SYSTYPE_NRENESA: a Renesas based Arduino, like the R4 Wifi and Minimal | |
| * SYSTYPE_GIGA: Arduino GIGA board | |
| * SYSTYPE_POSIX: a POSIX system, like Linux, MacOS | |
| * SYSTYPE_MSDOS: a DOS system, like FreeDOS | |
| * SYSTYPE_MINGW: a Windows system with MinGW | |
| * SYSTYPE_RASPPI: a Raspberry PI system | |
| * | |
| * Number ranges from 0-31 are reserved for Arduino systems | |
| * Number ranges from 32-63 are reserved for POSIX systems | |
| */ | |
| /* | |
| * Input and output channels. | |
| * | |
| * The channels are used to identify the I/O devices in the | |
| * runtime environment. | |
| * | |
| * NULL is the memory channel outputting to a buffer. | |
| * SERIAL is the standard serial channel and the default device. | |
| * DSP is the display channel. | |
| * GRAPH is the additional graphics display channel. | |
| * PRT is the second serial channel used for printing and communication | |
| * with external devices. | |
| * WIRE is the I2C channel. | |
| * RADIO is the RF24 channel. | |
| * MQTT is the MQTT channel. | |
| * FILE is the file system channel. | |
| */ | |
| /* | |
| * Global variables of the runtime env, visible to BASIC. | |
| * These are the variables that BASIC provides to the runtime | |
| * environment. They are used all over the BASIC code. Some | |
| * could be encapsulated as function calls calls. | |
| * | |
| * Variables to control the io device channels. | |
| * | |
| * id: the current input device | |
| * od: the current output device | |
| * idd: the default input device in interactive mode | |
| * odd: the default output device in interactive mode | |
| * ioer: the io error | |
| */ | |
| extern int8_t id; | |
| extern int8_t od; | |
| extern int8_t idd; | |
| extern int8_t odd; | |
| extern int8_t ioer; | |
| /* | |
| * Io control flags. | |
| * | |
| * These flags are used to control the I/O devices. | |
| * kbdrepeat: the keyboard repeat flag for the keypad of a shield | |
| * only used by SET and defined in the keypad code | |
| * blockmode: the blockmode flag, switch a channel to blockmode | |
| * sendcr: the sendcr flag, send a carriage return after a newline if true | |
| */ | |
| extern uint8_t kbdrepeat; | |
| extern uint8_t blockmode; | |
| extern uint8_t sendcr; | |
| /* breaks, signaly back that the breakcondition has been detected */ | |
| extern char breakcondition; | |
| /* counts the outputed characters on streams 0-4, used to emulate a real tab */ | |
| extern uint8_t charcount[5]; /* devices 0-4 support tabing */ | |
| /* the memory buffer comes from BASIC in this version, it is the input buffer for lines */ | |
| extern char ibuffer[BUFSIZE]; | |
| /* only needed in POSIX worlds */ | |
| extern uint8_t breaksignal; | |
| extern uint8_t vt52active; | |
| /* the string buffer the interpreter needs, here to be known by BASIC */ | |
| extern char spistrbuf1[SPIRAMSBSIZE], spistrbuf2[SPIRAMSBSIZE]; | |
| /* | |
| * the mqtt variable the interpreter needs. | |
| * The following parameters are configured here: | |
| * | |
| * MQTTLENGTH: the length of the mqtt topic, restricted to 32 by default. | |
| * MQTTBLENGTH: the length of the mqtt buffer, 128 by default. | |
| * MQTTNAMELENGTH: the length of the autogenerated mqtt name, 12 by default. | |
| * The mqtt name is used to identify the device in the mqtt network. | |
| * | |
| * mqtt_otopic: the outgoing topic | |
| * mqtt_itopic: the incoming topic | |
| * mqttname: the name of the device in the mqtt network | |
| */ | |
| extern char mqtt_otopic[MQTTLENGTH]; | |
| extern char mqtt_itopic[MQTTLENGTH]; | |
| extern char mqttname[]; | |
| /* a byte in the runtime memory containing the system type */ | |
| extern uint8_t bsystype; | |
| /* | |
| * Console logger functions for the runtime code. Runtime does not know | |
| * anything about output deviced. BASIC is to provide this. This | |
| * is used for debugging and logging. | |
| */ | |
| extern void consolelog(char*); | |
| extern void consolelognum(int); | |
| /* | |
| * Statup function. They start the runtime environment. | |
| * | |
| * The functions timeinit(), wiringbegin(), signalon() | |
| * are always empty on Arduino, they are only used in | |
| * the POSIX branch of the code. | |
| * | |
| * timeinit() initializes the time functions. | |
| * wiringbegin() initializes the wiring functions, this is needed on | |
| * Raspberry PI. | |
| * signalon() initializes the signal handling, this is needed on | |
| * Unix like systems and Windows. | |
| * | |
| * BASIC calls these functions once to start the timing, wiring, and | |
| * signal handling. | |
| */ | |
| void timeinit(); | |
| void wiringbegin(); | |
| void signalon(); | |
| /* | |
| * Start the SPI bus. Called once on start. Needed on Arduino. | |
| * Empty in the POSIX branch of the code. | |
| * | |
| * 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. | |
| * for the libraries used here. Old SD card libraries have problems as they always | |
| * start the SPI bus with default settings and cannot get the settings from the | |
| * SPI.begin() call. In these cases patching of the SD library is needed. | |
| */ | |
| void spibegin(); | |
| /* | |
| * Memory allocation functions. | |
| * | |
| * BASIC calls freememorysize() to detemine how much memory can be allocated | |
| * savely on the heap. | |
| * BASIC calls restartsystem() for a complete reboot. | |
| * freeRam() is the actual free heap. Used by freememorysize() and in USR() | |
| * | |
| * Arduino data from https://docs.arduino.cc/learn/programming/memory-guide | |
| */ | |
| long freememorysize(); /* determine how much actually to allocate */ | |
| void restartsystem(); /* cold start of the MCU */ | |
| long freeRam(); /* try to find the free heap after alocating all globals */ | |
| /* Test function for real time clock interrupt, currently not useable. | |
| Kept for the future. */ | |
| void rtcsqw(); | |
| void aftersleepinterrupt(void); | |
| void activatesleep(long); | |
| /* | |
| * The main IO interface. This is how BASIC uses I/O functions. | |
| * | |
| * ioinit(): called at setup to initialize what ever io is needed | |
| * iostat(): check which io devices are available | |
| * iodefaults(): called at setup and while changing to interactive mode | |
| * to set the default io devices | |
| * cheof(): checks for end of file condition on the current input stream | |
| * inch(): gets one character from the current input stream and waits for it | |
| * checkch(): checks for one character on the current input stream, non blocking | |
| * availch(): checks for available characters on the current input stream | |
| * inb(): reads a block of characters from the current input stream | |
| * ins(): reads an entire line from the current input stream, usually by consins() | |
| * outch(): prints one ascii character to the current output stream | |
| * outs(): prints a string of characters to the current output stream | |
| */ | |
| void ioinit(); | |
| int iostat(int); | |
| void iodefaults(); | |
| int cheof(int); | |
| char inch(); | |
| char checkch(); | |
| uint16_t availch(); | |
| uint16_t inb(char*, int16_t); | |
| uint16_t ins(char*, uint16_t); | |
| void outch(char); | |
| void outs(char*, uint16_t); | |
| /* | |
| * Timeing functions and background tasks. | |
| * | |
| * byield() must be called after every statement and in all | |
| * waiting loops for I/O. BASIC gives back the unneeded | |
| * CPU cycles by calling byield(). | |
| * | |
| * byield() allows three 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. This is the frequency | |
| * yieldfunction() is called. | |
| * | |
| * LONGYIELDINTERVAL by default is 1000, generating a one second | |
| * call to maintenance functions. This is the frequency | |
| * longyieldfunction() is called. | |
| * | |
| * fastticker() is called in every byield for fast I/O control. | |
| * It is currently only used for the tone emulation. | |
| * | |
| * byield() calls back bloop() in the BASIC interpreter for user | |
| * defined background tasks in an Arduino style loop() function. | |
| * | |
| * bdelay() is a delay function using byield() to allow for | |
| * background tasks to run even when the main code does a delay. | |
| * | |
| * The yield mechanism is needed for ESP8266 yields, network client | |
| * loops and other timing related functions. | |
| * | |
| * yieldschedule() is a function that calls the buildin scheduler | |
| * of some platforms. Currently it is only used in ESP8266. The | |
| * core on this boards does not tolerate that the loop() function | |
| * does not return and crashes the system. This can be prevented | |
| * by calling yieldschedule() often enough. | |
| */ | |
| void byield(); | |
| void bdelay(uint32_t); | |
| void fastticker(); | |
| void yieldfunction(); | |
| void longyieldfunction(); | |
| void yieldschedule(); | |
| /* | |
| * This function measures the fast ticker frequency in microseconds. | |
| * This can be accessed with USR(0, 35) in BASIC. | |
| * Activate this only for test purposes as it slows down the interpreter. | |
| * The value is the shortest timeframe the interpreter can handle. Activated | |
| * if the code is compiled with FASTTICKERPROFILE in hardware.h. | |
| */ | |
| void fasttickerprofile(); | |
| void clearfasttickerprofile(); | |
| int avgfastticker(); | |
| /* | |
| * EEPROM handling, these function enable the @E array and | |
| * loading and saving to EEPROM with the "!" mechanism | |
| * | |
| * The EEPROM code can address EEPROMS up to 64 kB. It returns | |
| * signed byte values which corresponds to the definition of | |
| * mem_t in BASIC. This is needed because running from EEPROM | |
| * requires negative token values to be recongized. | |
| * | |
| * ebegin() starts the EEPROM code. Needed for the emulations. | |
| * eflush() writes the EEPROM buffer to the EEPROM. Also this is | |
| * mainly needed in the emulations. | |
| * elength() returns the length of the EEPROM. | |
| * eupdate() updates one EEPROM cell with a value. Does not flush. | |
| * eread() reads one EEPROM cell. | |
| */ | |
| void ebegin(); | |
| void eflush(); | |
| uint16_t elength(); | |
| void eupdate(uint16_t, int8_t); | |
| int8_t eread(uint16_t); | |
| /* | |
| * The wrappers of the arduino io functions. | |
| * | |
| * The normalize the differences of some of the Arduino cores | |
| * and raspberyy PI wiring implementations. | |
| * | |
| * Pin numbers are the raw numerical pin values in BASIC. | |
| * The functions are called with this raw pin number and the value. | |
| * | |
| * The functions are: | |
| * aread(pin): read an analog value from a pin | |
| * dread(pin): read a digital value from a pin | |
| * awrite(pin, value): write an analog value to a pin | |
| * dwrite(pin, value): write a digital value to a pin | |
| * pinm(pin, mode): set the mode of a pin, mode is also the raw value from the core | |
| * pulsein(pin, value, timeout): read a pulse from a pin, timeout in microseconds | |
| * void pulseout(unit, pin, duration, val, repetition, interval): generate a pulse on a pin | |
| * unit is the timeunit in microsecind and the duration is the pulse length in this unit. | |
| * This is needed for system were the number_t is only 16 bit. This way longer pulses can | |
| * be generated. | |
| * void playtone(pin, frequency, duration, volume): generate a tone on a pin. | |
| * frequency is the frequency in Hz, duration the duration in ms, volume the volume in percent. | |
| * The tone is generated in the background, the function returns immediately. | |
| * tonetoggle(): toggle the tone generation, needed for the tone emulation, this is called | |
| * by byield() to generate the tone. | |
| */ | |
| uint16_t aread(uint8_t); | |
| uint8_t dread(uint8_t); | |
| void awrite(uint8_t, uint16_t); | |
| void dwrite(uint8_t, uint8_t); | |
| void pinm(uint8_t, uint8_t); | |
| uint32_t pulsein(uint8_t, uint8_t, uint32_t); | |
| void pulseout(uint16_t, uint8_t, uint16_t, uint16_t, uint16_t, uint16_t); | |
| void playtone(uint8_t, uint16_t, uint16_t, uint8_t); | |
| void tonetoggle(); /* internal function of the tone emulation, called by byield */ | |
| /* | |
| * The break pin code. This is a pin that can be used to break the execution of the | |
| * BASIC code. This is used as an alternative to the BREAK key in the terminal. | |
| * | |
| * brakepinbegin() initializes the break pin, usually a button connected to a pin. | |
| * getbreakpin() returns the state of the break pin. This is called in statement() to | |
| * check if the break condition is met and then change the interpreter state at the end | |
| * of the statement. | |
| */ | |
| void breakpinbegin(); | |
| uint8_t getbreakpin(); | |
| /* | |
| * The hardware port register access functions. | |
| * They can be used to directly access hardware ports. Typically they | |
| * call port macros like PORTB on the Arduino AVR platform. They are very | |
| * fast and can be used to implement fast I/O functions but they are hardware | |
| * dependent and not portable. Currently only AVR UNO and MEGA are implemented. | |
| * | |
| * The calling mechanism in BASIC is the special array @P()for read and write. | |
| */ | |
| void portwrite(uint8_t, int); | |
| int portread(uint8_t); | |
| void ddrwrite(uint8_t, int); | |
| int ddrread(uint8_t); | |
| int pinread(uint8_t); | |
| /* | |
| * Prototypes for the interrupt interface. This uses the standard Arduino | |
| * interrupt functions. | |
| */ | |
| uint8_t pintointerrupt(uint8_t); | |
| void attachinterrupt(uint8_t, void (*f)(), uint8_t); | |
| void detachinterrupt(uint8_t); | |
| /* some have PinStatus and some don't */ | |
| typedef int PinStatus; | |
| /* | |
| * IO channel 0 - the buffer I/O device. | |
| * | |
| * This is a stream to write to the input buffer from BASIC. | |
| */ | |
| void bufferbegin(); | |
| uint8_t bufferstat(uint8_t); | |
| void bufferwrite(char); | |
| char bufferread(); | |
| char buffercheckch(); | |
| uint16_t bufferavailable(); | |
| uint16_t bufferins(char*, uint16_t); | |
| void bufferouts(char*, uint16_t); | |
| /* | |
| * IO channel 1 - the serial I/O device. | |
| * | |
| * Primary serial code uses the Serial object or Picoserial on | |
| * Arduino. On POSIX systems it uses the standard input/output. | |
| * | |
| * Functions are: | |
| * | |
| * serialbegin(): start the serial port | |
| * serialread(): read a character from the serial port, this is blocking | |
| * for the standard Serial object and non blocking for Picoserial. | |
| * Picoserial is not character oriented. It read one entire line. | |
| * serialstat(s): check the status of the serial port | |
| * serialwrite(c): write a character to the serial port | |
| * serialcheckch(): check if a character is available without blocking | |
| * serialavailable(): check if characters are available | |
| * serialflush(): flush the serial port | |
| * serialins(s, l): read a line from the serial port | |
| */ | |
| void serialbegin(); | |
| char serialread(); | |
| uint8_t serialstat(uint8_t); /* state information on the serial port */ | |
| void serialwrite(char); /* write to a serial stream */ | |
| char serialcheckch(); /* check on a character, needed for breaking */ | |
| uint16_t serialavailable(); /* avail method, needed for AVAIL() */ | |
| void serialflush(); /* flush serial */ | |
| uint16_t serialins(char*, uint16_t); /* read a line from serial */ | |
| /* | |
| * reading from the console with inch or the picoserial callback. | |
| * consins() is used for all devices that have a character oriented | |
| * input and creates entire lines from it. | |
| */ | |
| uint16_t consins(char *, uint16_t); | |
| /* | |
| * On Arduino Serial is a big object that needs a lot of memory | |
| * on the smaller boards. Picoserial is smaller. It is mainly | |
| * for the small 8bit AVR boards. It uses the UART macros directly. | |
| * | |
| * The picoseria has an own interrupt function. This is used to fill | |
| * the input buffer directly on read. Write is standard like in | |
| * the serial code. Currently picoserial is only implemented for | |
| * AVR UNO, NANO and MEGA. | |
| * | |
| * 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. | |
| * | |
| * Functions for the picoserial code are: | |
| * | |
| * picobegin(baud): start the picoserial port with the baud rate baud | |
| * picowrite(c): write a character to the picoserial port | |
| * picoins(s, l): read a line from the picoserial port | |
| * | |
| */ | |
| void picobegin(uint32_t); | |
| void picowrite(char); | |
| uint16_t picoins(char *, uint16_t); | |
| /* | |
| * 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); | |
| /* | |
| * IO channel 2 - the display I/O device. | |
| * | |
| * DISPLAY driver code section. The display driver is a generic text and graphics | |
| * output device. Characters are buffered in a display buffer if DISPLAYCANSCROLL | |
| * is defined. These displays can scroll. Scrolling is handled by the display driver. | |
| * It is soft scroll, meaning that the display buffer is scrolled and the display is | |
| * updated. This is slow for large displays. Hardware scrolling is not yet implemented. | |
| * | |
| * The display driver is used by the terminal code to output text and | |
| * graphics. It is needed because there is no standard terminal emulation on Arduino | |
| * systems. It tries to be so generic that everything from small 16*2 LCDs to large | |
| * TFT displays can be used. It contains a VT52 state engine to process control | |
| * sequences. | |
| * | |
| * The hardware dependent part of the display driver has to implement the following | |
| * functions: | |
| * | |
| * Text display functions: | |
| * | |
| * dsp_rows, dsp_columns: size of the display | |
| * dspbegin(): start the display - can be empty | |
| * dspprintchar(c, col, row): print a character at a given position | |
| * logic here that col is the x coordinate and row the y coordinate | |
| * for text and graphics the display coordinate system has its origin | |
| * in the upper left corner | |
| * dspclear(): clear the display | |
| * dspupdate(): update the display, this function is needed for displays that | |
| * have a buffer and can update the display after a series of prints. | |
| * Examples are epaper displays and LCD displays like the Nokia. Writing | |
| * directly to them is slow. | |
| * dspsetcursor(c): switch the cursor on or off, typically used for text | |
| * displays with blinking cursors. | |
| * dspsetfgcolor(c): set the foreground color of the display. | |
| * dspsetbgcolor(c): set the background color of the display. | |
| * c is a VGA color. 4bit VGA colors are used for text displays. | |
| * Graphics is 24 bit color rgb and 8 bit VGA color. | |
| * dspsetreverse(c): set the reverse mode of the display, currently unused. | |
| * dspident(): return the display type, currently unused. | |
| * | |
| * For displays with color, the macro DISPLAYHASCOLOR has to be defined. | |
| * The text display buffer then contains one byte for the character and | |
| * one byte for color and font. | |
| * | |
| * All displays which have these functions can be used with the | |
| * generic display driver below. For minimal functionality only | |
| * dspprintchar() and dspclear() are needed. The screen dimensions | |
| * have to be set in dsp_rows and dsp_columns. | |
| * | |
| * Graphics displays need to implement the functions | |
| * | |
| * rgbcolor(r, g, b): set the color for graphics. The color | |
| * is 24 bit rgb. This function needs to convert the byte | |
| * values to the native color of the display. | |
| * vgacolor(c): set the color for text. The color is a 256 VGA | |
| * color for most displays. This function needs to convert this | |
| * one byte value to the native color of the display. | |
| * These two functions are called by the BASIC COLOR command. | |
| * | |
| * plot(x, y): plot a pixel at x, y | |
| * line(x1, y1, x2, y2): draw a line from x1, y1 to x2, y2 | |
| * rect(x1, y1, x2, y2): draw a rectangle from x1, y1 to x2, y2 | |
| * frect(x1, y1, x2, y2): draw a filled rectangle from x1, y1 to x2, y2 | |
| * circle(x, y, r): draw a circle with center x, y and radius r | |
| * fcircle(x, y, r): draw a filled circle with center x, y and radius r | |
| * | |
| * | |
| * Color is currently either 24 bit or 8 bit 16 VGA color. BW and displays | |
| * only have 0 and 1 as colors. Text is buffered in 4 bit VGA color (see below). | |
| */ | |
| /* Generate a 4 bit vga color from a given rgb color, to be checked */ | |
| uint8_t rgbtovga(uint8_t, uint8_t, uint8_t); | |
| /* Text functions */ | |
| void dspbegin(); | |
| void dspprintchar(char, uint8_t, uint8_t); | |
| void dspclear(); | |
| void dspupdate(); | |
| void dspsetcursor(uint8_t); | |
| void dspsavepen(); | |
| void dsprestorepen(); | |
| void dspsetfgcolor(uint8_t); | |
| void dspsetbgcolor(uint8_t); | |
| void dspsetreverse(uint8_t); | |
| uint8_t dspident(); | |
| /* Graphics functions */ | |
| void rgbcolor(uint8_t, uint8_t, uint8_t); | |
| void vgacolor(uint8_t); | |
| void plot(int, int); | |
| void line(int, int, int, int); | |
| void rect(int, int, int, int); | |
| void frect(int, int, int, int); | |
| void circle(int, int, int); | |
| void fcircle(int, int, int); | |
| /* to whom the bell tolls - implement this to you own liking, reacts to ASCII 7 */ | |
| void dspbell(); | |
| /* | |
| * The public functions of the display driver are the following: | |
| * | |
| * dspouts(s, l): print a string of length l to the display. This | |
| * function is only used for output on certain graphics displays | |
| * These displays expect an entire string to be printed at once. | |
| * Currently this is only implemented for epaper displays. | |
| * dspwrite(c): print a character to the display. This function is | |
| * the main output method for text displays. It prints a character | |
| * at the current cursor position and updates the cursor position. | |
| * For vt52 capable displays, the character goes through the vt52 | |
| * state engine and it processed there. | |
| * dspstat(s): check the status of the display. It returns 1 if the | |
| * display is present and 0 if it is not. | |
| * dspactive(): check if the display is the current output device. | |
| * This function is used to control scrolling in the LIST command. | |
| * dspwaitonscroll(): this function waits for character input if the | |
| * display wants to scroll. This is used in the LIST command to | |
| * wait for a keypress before scrolling the display. It returns the | |
| * character that was pressed. This can also be used to end the output | |
| * of the LIST command. | |
| * dspsetupdatemode(m): set the update mode of the display. Valid update | |
| * modes are 0, 1, 2. 0 is character mode, 1 is line mode, 2 is page mode. | |
| * In character mode, the display is updated after every character. In line | |
| * mode, the display is updated after every line. In page mode, the display | |
| * is updated after an ETX character. This function is only used for displays | |
| * that implement the dspupdate() function. | |
| * dspgetupdatemode(): get the current update mode of the display. | |
| * dspgraphupdate(): update the display after a series of graphics commands. While | |
| * dspsetupdatemode() and dspgetupdatemode() control the update from the text buffer, | |
| * dspgraphupdate() controls the update from the graphics buffer. See for example | |
| * the Nokia display as an example. This function must be called after graphics | |
| * operations to update the display. Typically this is done in the graphics functions | |
| * like line(), rect(), circle(), etc. | |
| * dspsetcursorx(x): set the x coordinate of the cursor | |
| * dspsetcursory(y): set the y coordinate of the cursor | |
| * dspgetcursorx(): get the x coordinate of the cursor | |
| * dspgetcursory(): get the y coordinate of the cursor | |
| */ | |
| void dspouts(char*, uint16_t); | |
| void dspwrite(char); | |
| uint8_t dspstat(uint8_t); | |
| uint8_t dspactive(); | |
| char dspwaitonscroll(); | |
| void dspsetupdatemode(uint8_t); | |
| uint8_t dspgetupdatemode(); | |
| void dspgraphupdate(); | |
| void dspsetcursorx(uint8_t); | |
| void dspsetcursory(uint8_t); | |
| uint8_t dspgetcursorx(); | |
| uint8_t dspgetcursory(); | |
| /* | |
| * These are the buffer control functions for the display driver. | |
| * | |
| * Color handling: | |
| * | |
| * Non scrolling displays simply use the pen color of the display | |
| * stored in dspfgcolor() to paint the information on the screen. | |
| * | |
| * For scrolling displays we store the color information of every | |
| * character in the display buffer to enable scrolling with color. | |
| * To limit the storage requirements, this code translates the color | |
| * to a 4 bit VGA color. This means that if BASIC uses 24 bit colors, | |
| * the color may change at scroll | |
| * | |
| * For color displays the buffer is a 16 bit object. The lower 8 bits | |
| * plus the sign are the character, higher 7 the color and font. | |
| * For monochrome just the character is stored in an 8 bit object. | |
| * | |
| * The type dspbuffer_t is defined according to the display type. | |
| * | |
| * The following functions are used to control the display buffer: | |
| * | |
| * dspget(): get a character from the display buffer in form of a linear | |
| * address. This is only used for the special array @D() in BASIC. | |
| * It allows direct access to the display buffer. | |
| * dspgetrc(r, c): get a character from the display buffer at row r and column c. | |
| * This is used for the print function of the vt52 terminal. An entire display | |
| * can be sent to the printer device OPRT | |
| * dspgetc(c): get a character from the current line at column c. Also this is | |
| * used for the print function of the VT52 terminal. This only sents the | |
| * current line to the printer device OPRT. | |
| * For both functions the actual print code is in the VT52 object. | |
| * These three functions are somewhat redundant. | |
| * | |
| * dspsetxy(c, x, y): set a character at x, y in the display buffer and on the | |
| * display. This function is needed for various control sequences of the VT52 | |
| * terminal. | |
| * dspset(c, v): set a character at a linear address in the display buffer. Also u | |
| * used for the @D() array in BASIC. | |
| * | |
| * dspsetscrollmode(m, l): set the scroll mode. m is the mode and l is the number | |
| * of lines to be scrolled. Mode 0 means that dspwaitonscroll() does not | |
| * wait for keyboard input. Mode 1 is wait for input. | |
| * dspbufferclear(): clears the input buffer. | |
| * dspscroll(l, t): do the actual scrolling. l is the number of lines to be scrolled. | |
| * t is the topmost line included in the scroll. O by default. | |
| * dspreversescroll(l): reverse scroll from line l downward. | |
| */ | |
| typedef short dspbuffer_t; | |
| typedef char dspbuffer_t; | |
| dspbuffer_t dspget(uint16_t); | |
| dspbuffer_t dspgetrc(uint8_t, uint8_t); | |
| dspbuffer_t dspgetc(uint8_t); | |
| void dspsetxy(dspbuffer_t, uint8_t, uint8_t); | |
| void dspset(uint16_t, dspbuffer_t); | |
| void dspsetscrollmode(uint8_t, uint8_t); | |
| void dspbufferclear(); | |
| void dspscroll(uint8_t, uint8_t); | |
| void dspreversescroll(uint8_t); | |
| /* | |
| * A VT52 state engine is implemented and works for buffered and | |
| * unbuffered displays. Only buffered displays have the full VT52 | |
| * feature set including most of the GEMDOS extensions described here: | |
| * https://en.wikipedia.org/wiki/VT52 | |
| * | |
| * The VT52 state engine processes sequences of the form <ESC> char. | |
| * | |
| * In addition to this, it also gives back certain return values. | |
| * The can be read by vt52read() and vt52avail(). | |
| * vt52push() is used to push characters into the VT52 buffer. | |
| * vt52number() is used to convert a character into the VT52 number format. | |
| * vt52graphcommand() is a VT52 extension to display graphics on the screen. | |
| */ | |
| char vt52read(); | |
| uint8_t vt52avail(); | |
| void vt52push(char); | |
| uint8_t vt52number(char); | |
| void vt52graphcommand(uint8_t); | |
| /* | |
| * this is a special part of the vt52 code with this, the terminal | |
| * can control the digital and analog pins. | |
| * | |
| * It is meant for situations where the terminal is controlled by a (powerful) | |
| * device with no or very few I/O pins. It can use the pins of the Arduino through | |
| * the terminal. | |
| * | |
| * This works as long as everything stays within the terminals timescale. | |
| * On a 9600 baud interface, the character processing time is 1ms, everything | |
| * slower than approximately 10ms can be done through the serial line. | |
| */ | |
| void vt52wiringcommand(uint8_t); | |
| /* the vt52 state engine */ | |
| void dspvt52(char*); | |
| /* | |
| * Code for the VGA system of Fabgl. This is a full VT52 terminal. The | |
| * display driver is not used for this. | |
| */ | |
| void vgabegin(); | |
| int vgastat(uint8_t); | |
| void vgascale(int*, int*); | |
| void vgawrite(char); | |
| void vgaend(); | |
| /* | |
| * IO channel 2 (input) - the keyboard I/O device. | |
| * | |
| * Keyboard code for either the Fablib Terminal class, | |
| * PS2Keyboard or other keyboards. | |
| * | |
| * PS2Keyboard: please note that you need the patched | |
| * version here as mentioned above. | |
| * | |
| * Keyboards implement kbdbegin() which is called at startup | |
| * and kbdstat() which is called to check if the keyboard is | |
| * available. | |
| * | |
| * Keyboards need to provide the following functions: | |
| * | |
| * kbdavailable(): check if a character is available | |
| * kbdread(): read a character from the keyboard | |
| * kbdcheckch(): check if a character is available without blocking | |
| * kbdins(): read a line from the keyboard | |
| * | |
| * kbdcheckch() is for interrupting running BASIC code with a | |
| * BREAKCHAR character from the keyboard. If this functions is | |
| * not implemented, the BREAKCHAR character is ignored. | |
| * | |
| * kbdins() is usually using consins() to read a line from the | |
| * keyboard repeatedly calling kbdread() until a newline is | |
| * received. A keyboard can also bring its on kbdins() function. | |
| */ | |
| void kbdbegin(); | |
| uint8_t kbdstat(uint8_t); | |
| uint8_t kbdavailable(); | |
| char kbdread(); | |
| char kbdcheckch(); | |
| uint16_t kbdins(char*, uint16_t); | |
| /* IO channel 3 - reserved for future use */ | |
| /* | |
| * IO channel 4 - the second serial I/O device. | |
| * | |
| * This is the (mostly) the Serial1 object | |
| * on Arduino. On POSIX systems this opens a serial port like /dev/ttyUSB1. | |
| * This &4 in BASIC. | |
| * | |
| * Functions are: | |
| * | |
| * prtbegin(): start the serial port | |
| * prtopen(name, baud): open the serial port with the baud rate baud. Only | |
| * neded in POSIX to open the port. | |
| * prtclose(): close the serial port | |
| * prtstat(s): check the status of the serial port | |
| * prtwrite(c): write a character to the serial port | |
| * prtread(): read a character from the serial port | |
| * prtcheckch(): check if a character is available without blocking | |
| * prtavailable(): check if characters are available | |
| * prtset(baud): set the baud rate of the serial port | |
| * prtins(s, l): read a line from the serial port | |
| */ | |
| void prtbegin(); | |
| char prtopen(char*, uint16_t); | |
| void prtclose(); | |
| uint8_t prtstat(uint8_t); | |
| void prtwrite(char); | |
| char prtread(); | |
| char prtcheckch(); | |
| uint16_t prtavailable(); | |
| void prtset(uint32_t); | |
| uint16_t prtins(char*, uint16_t); | |
| /* | |
| * IO channel 7 - I2C through the Wire library. | |
| * | |
| * 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. | |
| * | |
| * The maximum number of bytes the Wire library can handle | |
| * is 32. This is given by the Wire library. | |
| * | |
| * Wire is handled through the following functions: | |
| * | |
| * wirebegin(): start the wire system. | |
| * wireslavebegin(id): start the wire system as a slave with the id. | |
| * wirestat(s): check if the wire system is available. | |
| * wireavailable(): check if characters are available in slave mode. | |
| * wireonreceive(h): set the event handler for received data on a slave. | |
| * wireonrequest(): set the event handler for request on a slave. | |
| * wireopen(id, slaveid): open the wire system as a master with id to | |
| * the slave id. | |
| * wireread(): read a character from the wire system. | |
| * wirewrite(c): write a character to the wire system. | |
| * wireins(l, s): read a line l from the wire system max length is s. | |
| * wireouts(l, s): write a line l to the wire system max length is s. | |
| * They are available in BASIC as the WIRE | |
| * command. | |
| */ | |
| void wirebegin(); | |
| void wireslavebegin(uint8_t); | |
| uint8_t wirestat(uint8_t); | |
| uint16_t wireavailable(); | |
| void wireonreceive(int); | |
| void wireonrequest(); | |
| void wireopen(uint8_t, uint8_t); | |
| char wireread(); | |
| void wirewrite(char c); | |
| uint16_t wireins(char*, uint8_t); | |
| void wireouts(char*, uint8_t); | |
| /* new byte wire interface for direct access */ | |
| void wirestart(uint8_t, uint8_t); | |
| void wirewritebyte(uint8_t); | |
| uint8_t wirestop(); | |
| int16_t wirereadbyte(); | |
| /* | |
| * IO channel 8 - the RF24 radio I/O device. | |
| * | |
| * Read from the radio interface, radio is always block | |
| * oriented. This function is called from ins for an entire | |
| * line. | |
| * | |
| * In blockmode the entire message is returned in the | |
| * receiving string while in line mode the length of the | |
| * string is adapted. Blockmode can be used to transfer | |
| * binary data. | |
| * | |
| * The radio code is rather obsolet and not used a lot. | |
| * | |
| * On RF24 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. | |
| */ | |
| uint8_t radiostat(uint8_t); | |
| uint64_t pipeaddr(const char*); | |
| uint16_t radioins(char*, uint8_t); | |
| void radioouts(char *, uint8_t); | |
| uint16_t radioavailable(); | |
| char radioread(); | |
| void iradioopen(const char *); | |
| void oradioopen(const char *); | |
| void radioset(uint8_t); | |
| /* | |
| * IO channel 9 - the network I/O device. | |
| * | |
| * Only MQTT is implemented at the moment. Other protocols | |
| * will be channel 10-15. | |
| * | |
| * Underlying networks can be the Wifi classes of the ESP, MKR, and | |
| * STM32 cores. The network code is based on the PubSubClient library. | |
| * Ethernet is supported with the standard Ethernet library on Arduino. | |
| * | |
| * On POSIX systems networking is currently not supported. | |
| * | |
| * No encryptionis implemented in MQTT. Only unencrypted servers can be used. | |
| * | |
| * Buffers are defined above in the mqtt section. | |
| * | |
| * MQTTLENGTH: the length of the mqtt topic, restricted to 32 by default. | |
| * MQTTBLENGTH: the length of the mqtt buffer, 128 by default. | |
| * MQTTNAMELENGTH: the length of the autogenerated mqtt name, 12 by default. | |
| * | |
| * wifisettings.h is the generic network definition file all network settings | |
| * are compiled into the code. BASIC cannot change them at runtime. | |
| * | |
| * Low level network functions are: | |
| * | |
| * netbegin(): start the network | |
| * netstop(): stop the network | |
| * netreconnect(): reconnect the network | |
| * netconnected(): check if the network is connected | |
| * | |
| * BASIC uses these function to control the network and reconnect if | |
| * the connection is lost. | |
| */ | |
| void netbegin(); | |
| void netstop(); | |
| void netreconnect(); | |
| uint8_t netconnected(); | |
| /* | |
| * The mqtt prototypes used by BASIC are: | |
| * | |
| * mqttbegin(): start the mqtt client | |
| * mqttsetname(): set the name of the mqtt client. The name is autogenerated. | |
| * mqttstat(s): check the status of the mqtt client | |
| * mqttreconnect(): reconnect the mqtt client | |
| * mqttstate(): get the state of the mqtt client (redunant to mqttstat()) | |
| * mqttsubscribe(t): subscribe to a topic | |
| * mqttunsubscribe(): unsubscribe from a topic | |
| * mqttsettopic(t): set the topic of the mqtt client | |
| * mqttouts(s, l): send a string of length l to the mqtt server | |
| * mqttwrite(c): send a character to the mqtt server. | |
| * These two functions work buffered. The write to the MQTT output buffer. Only | |
| * when the buffer is full or a newline is received, the buffer is sent to the | |
| * server. | |
| * mqttread(): read a character from the mqtt input buffer. | |
| * mqttins(s, l): read a line from the mqtt input buffer. | |
| * mqttavailable(): check if characters are available in the mqtt input buffer. | |
| * mqttcheckch(): get the next character from the mqtt input buffer without advancing. | |
| */ | |
| void mqttbegin(); | |
| void mqttsetname(); | |
| uint8_t mqttstat(uint8_t); | |
| uint8_t mqttreconnect(); | |
| uint8_t mqttstate(); | |
| void mqttsubscribe(const char*); | |
| void mqttunsubscribe(); | |
| void mqttsettopic(const char*); | |
| void mqttouts(const char*, uint16_t); | |
| void mqttwrite(const char); | |
| char mqttread(); | |
| uint16_t mqttins(char*, uint16_t); | |
| uint16_t mqttavailable(); | |
| char mqttcheckch(); | |
| /* | |
| * The callback function of the pubsub client. This is called when a | |
| * message is received from the mqtt server. | |
| * | |
| * The Arduino type byte is used here because it is used this way in Pubsub. | |
| */ | |
| void mqttcallback(char*, byte*, unsigned int); | |
| /* | |
| * IO channel 16 - the file system I/O device. | |
| * | |
| * 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 in the Arduino world. | |
| * | |
| * The functions to access the filesystem are: | |
| * | |
| * fsbegin(): start the filesystem | |
| * fsstat(s): check the status of the filesystem | |
| * mkfilename(s): make a filename from a string | |
| * rmrootfsprefix(s): remove the prefix from a filename | |
| * | |
| * Different filesystems have different prefixes. In BASIC we | |
| * only show a flat file system with no path names and prefixes. | |
| * | |
| * Supported filesystems are: | |
| * | |
| * SPIFF - the internal flash file system of the ESP32 and ESP8266 | |
| * SD - the SD card file system (no formatting) | |
| * EFS - the file system EFS for I2C EEPROMs | |
| * LittleFS - the LittleFS file system on RP2040 | |
| * USB devices on Arduino GIGA boards | |
| * Posix and Windows file systems on POSIX systems | |
| */ | |
| void fsbegin(); | |
| uint8_t fsstat(uint8_t); | |
| char* mkfilename(const char*); | |
| const char* rmrootfsprefix(const char*); | |
| /* | |
| * File I/O function on an Arduino: | |
| * | |
| * filewrite(c): write a character to a file | |
| * fileread(): read a character from a file | |
| * fileavailable(): check if a character is available in the file | |
| * ifileopen(s): open a file for input | |
| * ifileclose(): close a file for input | |
| * ofileopen(s, m): open a file for output with mode m | |
| * ofileclose(): close a file for output | |
| * | |
| * The wrapper and BASIC currently only support one file for read | |
| * and one file for write. | |
| */ | |
| void filewrite(char); | |
| char fileread(); | |
| int fileavailable(); /* is int because some of the fs do this */ | |
| uint8_t ifileopen(const char*); | |
| void ifileclose(); | |
| uint8_t ofileopen(const char*, const char*); | |
| void ofileclose(); | |
| /* | |
| * Directory handling for the catalog function these methods are | |
| * needed for a walkthtrough of one directory. | |
| * | |
| * The logic is: | |
| * | |
| * rootopen() | |
| * while rootnextfile() | |
| * if rootisfile() print rootfilename() rootfilesize() | |
| * rootfileclose() | |
| * rootclose() | |
| * | |
| * rootopen(): opens the root directory | |
| * rootnextfile(): gets the next file in the directory | |
| * rootisfile(): checks if the file is a file or something else | |
| * rootfilename(): gets the name of the file | |
| * rootfilesize(): gets the size of the file | |
| * rootfileclose(): closes the root file | |
| */ | |
| void rootopen(); | |
| uint8_t rootnextfile(); | |
| uint8_t rootisfile(); | |
| const char* rootfilename(); | |
| uint32_t rootfilesize(); | |
| void rootfileclose(); | |
| void rootclose(); | |
| /* delete a file, needed in the DELETE command of BASIC */ | |
| void removefile(const char*); | |
| /* | |
| * Formatting for fdisk of the internal filesystems. This | |
| * is not implemented for all filesystems. | |
| */ | |
| void formatdisk(uint8_t); | |
| /* | |
| * The Real Time clock. The interface here offers the values as number_t | |
| * combining all values. | |
| * | |
| * On Arduino, he code does not use an RTC library any more all the | |
| * RTC support is builtin now for standard I2C clocks. | |
| * | |
| * A clock must activate the macro #define HASCLOCK to make the clock | |
| * available in BASIC. | |
| * | |
| * Four software models are supported in runtime.cpp for Arduino: | |
| * - Built-in clocks of STM32, MKR, and ESP32 are supported by default. | |
| * - I2C clocks can be activated: DS1307, DS3231, and DS3232 | |
| * - A Real Time Clock emulation using millis() | |
| * | |
| * On POSIX the standard time functions are used and mapped to this API. | |
| * | |
| * rtcget(r) accesses the internal registers of the clock. | |
| * r==0 is the seconds, r==1 the minutes, r==2 the hours, r==3 the | |
| * day of week, r==4 the day, r==5 the month, r==6 the year. | |
| * The day of the week feature is not supported by all clocks. | |
| * rtcset(r, v) sets the internal registers of the clock. | |
| * | |
| * On I2C clocks with NVRAM the registers 7-255 are accessed as | |
| * memory cells through these functions. | |
| * | |
| * rtcbegin() is called at startup to initialize the clock, normally | |
| * a dummy function. | |
| * | |
| * rtctimetoutime() converts the clock time to a unix time number. | |
| * rtcutimetotime() converts the unix time number to a clock time. | |
| * Both are private functions of the clock emulation. | |
| * | |
| * Code in these two functions is taken from the German Wikipedia | |
| * article on Unix time. https://de.wikipedia.org/wiki/Unixzeit | |
| */ | |
| void rtcbegin(); | |
| uint16_t rtcget(uint8_t); | |
| void rtcset(uint8_t, uint16_t); | |
| void rtctimetoutime(); | |
| void rtcutimetotime(); | |
| /* | |
| * 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. | |
| */ | |
| void sensorbegin(); | |
| float sensorread(uint8_t, uint8_t); | |
| /* | |
| * Experimental code to drive SPI SRAM | |
| * | |
| * Currently only the 23LCV512 is implemented, assuming a 64kB SRAM. | |
| * Part of code 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. | |
| * | |
| */ | |
| /* the RAM begin method sets the RAM to sequential mode */ | |
| uint16_t spirambegin(); | |
| int8_t spiramrawread(uint16_t); | |
| void spiram_bufferread(uint16_t, int8_t*, uint16_t); | |
| void spiram_bufferwrite(uint16_t, int8_t*, uint16_t); | |
| int8_t spiram_robufferread(uint16_t); | |
| void spiram_rwbufferflush(); /* flush the buffer */ | |
| int8_t spiram_rwbufferread(uint16_t); | |
| void spiram_rwbufferwrite(uint16_t, int8_t); /* the buffered file write */ | |
| void spiramrawwrite(uint16_t, int8_t); /* the simple unbuffered byte write, with a cast to signed char */ | |
| // defined RUNTIMEH | |