995 lines
46 KiB
C++
995 lines
46 KiB
C++
/***************************************************
|
|
Arduino TFT graphics library targeted at ESP8266
|
|
and ESP32 based boards.
|
|
|
|
This is a stand-alone library that contains the
|
|
hardware driver, the graphics functions and the
|
|
proportional fonts.
|
|
|
|
The built-in fonts 4, 6, 7 and 8 are Run Length
|
|
Encoded (RLE) to reduce the FLASH footprint.
|
|
|
|
Last review/edit by Bodmer: 04/02/22
|
|
****************************************************/
|
|
|
|
// Stop fonts etc being loaded multiple times
|
|
#ifndef _TFT_eSPIH_
|
|
#define _TFT_eSPIH_
|
|
|
|
#define TFT_ESPI_VERSION "2.5.22"
|
|
|
|
// Bit level feature flags
|
|
// Bit 0 set: viewport capability
|
|
#define TFT_ESPI_FEATURES 1
|
|
|
|
/***************************************************************************************
|
|
** Section 1: Load required header files
|
|
***************************************************************************************/
|
|
|
|
//Standard support
|
|
#include <Arduino.h>
|
|
#include <Print.h>
|
|
#include <SPI.h>
|
|
|
|
/***************************************************************************************
|
|
** Section 2: Load library and processor specific header files
|
|
***************************************************************************************/
|
|
// Include header file that defines the fonts loaded, the TFT drivers
|
|
// available and the pins to be used, etc, etc
|
|
#ifdef CONFIG_TFT_eSPI_ESPIDF
|
|
#include "TFT_config.h"
|
|
#endif
|
|
|
|
// New ESP8266 board package uses ARDUINO_ARCH_ESP8266
|
|
// old package defined ESP8266
|
|
#if defined (ESP8266)
|
|
#ifndef ARDUINO_ARCH_ESP8266
|
|
#define ARDUINO_ARCH_ESP8266
|
|
#endif
|
|
#endif
|
|
|
|
// The following lines allow the user setup to be included in the sketch folder, see
|
|
// "Sketch_with_tft_setup" generic example.
|
|
#if !defined __has_include
|
|
#if !defined(DISABLE_ALL_LIBRARY_WARNINGS)
|
|
#warning Compiler does not support __has_include, so sketches cannot define the setup
|
|
#endif
|
|
#else
|
|
#if __has_include(<tft_setup.h>)
|
|
// Include the sketch setup file
|
|
#include <tft_setup.h>
|
|
#ifndef USER_SETUP_LOADED
|
|
// Prevent loading further setups
|
|
#define USER_SETUP_LOADED
|
|
#endif
|
|
#endif
|
|
#endif
|
|
|
|
#include <User_Setup_Select.h>
|
|
|
|
// Handle FLASH based storage e.g. PROGMEM
|
|
#if defined(ARDUINO_ARCH_RP2040)
|
|
#undef pgm_read_byte
|
|
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
|
|
#undef pgm_read_word
|
|
#define pgm_read_word(addr) ({ \
|
|
typeof(addr) _addr = (addr); \
|
|
*(const unsigned short *)(_addr); \
|
|
})
|
|
#undef pgm_read_dword
|
|
#define pgm_read_dword(addr) ({ \
|
|
typeof(addr) _addr = (addr); \
|
|
*(const unsigned long *)(_addr); \
|
|
})
|
|
#elif defined(__AVR__)
|
|
#include <avr/pgmspace.h>
|
|
#elif defined(ARDUINO_ARCH_ESP8266) || defined(ESP32)
|
|
#include <pgmspace.h>
|
|
#else
|
|
#ifndef PROGMEM
|
|
#define PROGMEM
|
|
#endif
|
|
#endif
|
|
|
|
// Include the processor specific drivers
|
|
#if defined(CONFIG_IDF_TARGET_ESP32S3)
|
|
#include "Processors/TFT_eSPI_ESP32_S3.h"
|
|
#elif defined(CONFIG_IDF_TARGET_ESP32C3)
|
|
#include "Processors/TFT_eSPI_ESP32_C3.h"
|
|
#elif defined (ESP32)
|
|
#include "Processors/TFT_eSPI_ESP32.h"
|
|
#elif defined (ARDUINO_ARCH_ESP8266)
|
|
#include "Processors/TFT_eSPI_ESP8266.h"
|
|
#elif defined (STM32)
|
|
#include "Processors/TFT_eSPI_STM32.h"
|
|
#elif defined(ARDUINO_ARCH_RP2040)
|
|
#include "Processors/TFT_eSPI_RP2040.h"
|
|
#else
|
|
#include "Processors/TFT_eSPI_Generic.h"
|
|
#define GENERIC_PROCESSOR
|
|
#endif
|
|
|
|
/***************************************************************************************
|
|
** Section 3: Interface setup
|
|
***************************************************************************************/
|
|
#ifndef TAB_COLOUR
|
|
#define TAB_COLOUR 0
|
|
#endif
|
|
|
|
// If the SPI frequency is not defined, set a default
|
|
#ifndef SPI_FREQUENCY
|
|
#define SPI_FREQUENCY 20000000
|
|
#endif
|
|
|
|
// If the SPI read frequency is not defined, set a default
|
|
#ifndef SPI_READ_FREQUENCY
|
|
#define SPI_READ_FREQUENCY 10000000
|
|
#endif
|
|
|
|
// Some ST7789 boards do not work with Mode 0
|
|
#ifndef TFT_SPI_MODE
|
|
#if defined(ST7789_DRIVER) || defined(ST7789_2_DRIVER)
|
|
#define TFT_SPI_MODE SPI_MODE3
|
|
#else
|
|
#define TFT_SPI_MODE SPI_MODE0
|
|
#endif
|
|
#endif
|
|
|
|
// If the XPT2046 SPI frequency is not defined, set a default
|
|
#ifndef SPI_TOUCH_FREQUENCY
|
|
#define SPI_TOUCH_FREQUENCY 2500000
|
|
#endif
|
|
|
|
#ifndef SPI_BUSY_CHECK
|
|
#define SPI_BUSY_CHECK
|
|
#endif
|
|
|
|
// If half duplex SDA mode is defined then MISO pin should be -1
|
|
#ifdef TFT_SDA_READ
|
|
#ifdef TFT_MISO
|
|
#if TFT_MISO != -1
|
|
#undef TFT_MISO
|
|
#define TFT_MISO -1
|
|
#warning TFT_MISO set to -1
|
|
#endif
|
|
#endif
|
|
#endif
|
|
|
|
/***************************************************************************************
|
|
** Section 4: Setup fonts
|
|
***************************************************************************************/
|
|
// Use GLCD font in error case where user requests a smooth font file
|
|
// that does not exist (this is a temporary fix to stop ESP32 reboot)
|
|
#ifdef SMOOTH_FONT
|
|
#ifndef LOAD_GLCD
|
|
#define LOAD_GLCD
|
|
#endif
|
|
#endif
|
|
|
|
// Only load the fonts defined in User_Setup.h (to save space)
|
|
// Set flag so RLE rendering code is optionally compiled
|
|
#ifdef LOAD_GLCD
|
|
#include <Fonts/glcdfont.c>
|
|
#endif
|
|
|
|
#ifdef LOAD_FONT2
|
|
#include <Fonts/Font16.h>
|
|
#endif
|
|
|
|
#ifdef LOAD_FONT4
|
|
#include <Fonts/Font32rle.h>
|
|
#define LOAD_RLE
|
|
#endif
|
|
|
|
#ifdef LOAD_FONT6
|
|
#include <Fonts/Font64rle.h>
|
|
#ifndef LOAD_RLE
|
|
#define LOAD_RLE
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef LOAD_FONT7
|
|
#include <Fonts/Font7srle.h>
|
|
#ifndef LOAD_RLE
|
|
#define LOAD_RLE
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef LOAD_FONT8
|
|
#include <Fonts/Font72rle.h>
|
|
#ifndef LOAD_RLE
|
|
#define LOAD_RLE
|
|
#endif
|
|
#elif defined LOAD_FONT8N // Optional narrower version
|
|
#define LOAD_FONT8
|
|
#include <Fonts/Font72x53rle.h>
|
|
#ifndef LOAD_RLE
|
|
#define LOAD_RLE
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef LOAD_GFXFF
|
|
// We can include all the free fonts and they will only be built into
|
|
// the sketch if they are used
|
|
#include <Fonts/GFXFF/gfxfont.h>
|
|
// Call up any user custom fonts
|
|
#include <User_Setups/User_Custom_Fonts.h>
|
|
#endif // #ifdef LOAD_GFXFF
|
|
|
|
// Create a null default font in case some fonts not used (to prevent crash)
|
|
const uint8_t widtbl_null[1] = {0};
|
|
PROGMEM const uint8_t chr_null[1] = {0};
|
|
PROGMEM const uint8_t* const chrtbl_null[1] = {chr_null};
|
|
|
|
// This is a structure to conveniently hold information on the default fonts
|
|
// Stores pointer to font character image address table, width table and height
|
|
typedef struct {
|
|
const uint8_t *chartbl;
|
|
const uint8_t *widthtbl;
|
|
uint8_t height;
|
|
uint8_t baseline;
|
|
} fontinfo;
|
|
|
|
// Now fill the structure
|
|
const PROGMEM fontinfo fontdata [] = {
|
|
#ifdef LOAD_GLCD
|
|
{ (const uint8_t *)font, widtbl_null, 0, 0 },
|
|
#else
|
|
{ (const uint8_t *)chrtbl_null, widtbl_null, 0, 0 },
|
|
#endif
|
|
// GLCD font (Font 1) does not have all parameters
|
|
{ (const uint8_t *)chrtbl_null, widtbl_null, 8, 7 },
|
|
|
|
#ifdef LOAD_FONT2
|
|
{ (const uint8_t *)chrtbl_f16, widtbl_f16, chr_hgt_f16, baseline_f16},
|
|
#else
|
|
{ (const uint8_t *)chrtbl_null, widtbl_null, 0, 0 },
|
|
#endif
|
|
|
|
// Font 3 current unused
|
|
{ (const uint8_t *)chrtbl_null, widtbl_null, 0, 0 },
|
|
|
|
#ifdef LOAD_FONT4
|
|
{ (const uint8_t *)chrtbl_f32, widtbl_f32, chr_hgt_f32, baseline_f32},
|
|
#else
|
|
{ (const uint8_t *)chrtbl_null, widtbl_null, 0, 0 },
|
|
#endif
|
|
|
|
// Font 5 current unused
|
|
{ (const uint8_t *)chrtbl_null, widtbl_null, 0, 0 },
|
|
|
|
#ifdef LOAD_FONT6
|
|
{ (const uint8_t *)chrtbl_f64, widtbl_f64, chr_hgt_f64, baseline_f64},
|
|
#else
|
|
{ (const uint8_t *)chrtbl_null, widtbl_null, 0, 0 },
|
|
#endif
|
|
|
|
#ifdef LOAD_FONT7
|
|
{ (const uint8_t *)chrtbl_f7s, widtbl_f7s, chr_hgt_f7s, baseline_f7s},
|
|
#else
|
|
{ (const uint8_t *)chrtbl_null, widtbl_null, 0, 0 },
|
|
#endif
|
|
|
|
#ifdef LOAD_FONT8
|
|
{ (const uint8_t *)chrtbl_f72, widtbl_f72, chr_hgt_f72, baseline_f72}
|
|
#else
|
|
{ (const uint8_t *)chrtbl_null, widtbl_null, 0, 0 }
|
|
#endif
|
|
};
|
|
|
|
/***************************************************************************************
|
|
** Section 5: Font datum enumeration
|
|
***************************************************************************************/
|
|
//These enumerate the text plotting alignment (reference datum point)
|
|
#define TL_DATUM 0 // Top left (default)
|
|
#define TC_DATUM 1 // Top centre
|
|
#define TR_DATUM 2 // Top right
|
|
#define ML_DATUM 3 // Middle left
|
|
#define CL_DATUM 3 // Centre left, same as above
|
|
#define MC_DATUM 4 // Middle centre
|
|
#define CC_DATUM 4 // Centre centre, same as above
|
|
#define MR_DATUM 5 // Middle right
|
|
#define CR_DATUM 5 // Centre right, same as above
|
|
#define BL_DATUM 6 // Bottom left
|
|
#define BC_DATUM 7 // Bottom centre
|
|
#define BR_DATUM 8 // Bottom right
|
|
#define L_BASELINE 9 // Left character baseline (Line the 'A' character would sit on)
|
|
#define C_BASELINE 10 // Centre character baseline
|
|
#define R_BASELINE 11 // Right character baseline
|
|
|
|
/***************************************************************************************
|
|
** Section 6: Colour enumeration
|
|
***************************************************************************************/
|
|
// Default color definitions
|
|
#define TFT_BLACK 0x0000 /* 0, 0, 0 */
|
|
#define TFT_NAVY 0x000F /* 0, 0, 128 */
|
|
#define TFT_DARKGREEN 0x03E0 /* 0, 128, 0 */
|
|
#define TFT_DARKCYAN 0x03EF /* 0, 128, 128 */
|
|
#define TFT_MAROON 0x7800 /* 128, 0, 0 */
|
|
#define TFT_PURPLE 0x780F /* 128, 0, 128 */
|
|
#define TFT_OLIVE 0x7BE0 /* 128, 128, 0 */
|
|
#define TFT_LIGHTGREY 0xD69A /* 211, 211, 211 */
|
|
#define TFT_DARKGREY 0x7BEF /* 128, 128, 128 */
|
|
#define TFT_BLUE 0x001F /* 0, 0, 255 */
|
|
#define TFT_GREEN 0x07E0 /* 0, 255, 0 */
|
|
#define TFT_CYAN 0x07FF /* 0, 255, 255 */
|
|
#define TFT_RED 0xF800 /* 255, 0, 0 */
|
|
#define TFT_MAGENTA 0xF81F /* 255, 0, 255 */
|
|
#define TFT_YELLOW 0xFFE0 /* 255, 255, 0 */
|
|
#define TFT_WHITE 0xFFFF /* 255, 255, 255 */
|
|
#define TFT_ORANGE 0xFDA0 /* 255, 180, 0 */
|
|
#define TFT_GREENYELLOW 0xB7E0 /* 180, 255, 0 */
|
|
#define TFT_PINK 0xFE19 /* 255, 192, 203 */ //Lighter pink, was 0xFC9F
|
|
#define TFT_BROWN 0x9A60 /* 150, 75, 0 */
|
|
#define TFT_GOLD 0xFEA0 /* 255, 215, 0 */
|
|
#define TFT_SILVER 0xC618 /* 192, 192, 192 */
|
|
#define TFT_SKYBLUE 0x867D /* 135, 206, 235 */
|
|
#define TFT_VIOLET 0x915C /* 180, 46, 226 */
|
|
|
|
// Next is a special 16 bit colour value that encodes to 8 bits
|
|
// and will then decode back to the same 16 bit value.
|
|
// Convenient for 8 bit and 16 bit transparent sprites.
|
|
#define TFT_TRANSPARENT 0x0120 // This is actually a dark green
|
|
|
|
// Default palette for 4 bit colour sprites
|
|
static const uint16_t default_4bit_palette[] PROGMEM = {
|
|
TFT_BLACK, // 0 ^
|
|
TFT_BROWN, // 1 |
|
|
TFT_RED, // 2 |
|
|
TFT_ORANGE, // 3 |
|
|
TFT_YELLOW, // 4 Colours 0-9 follow the resistor colour code!
|
|
TFT_GREEN, // 5 |
|
|
TFT_BLUE, // 6 |
|
|
TFT_PURPLE, // 7 |
|
|
TFT_DARKGREY, // 8 |
|
|
TFT_WHITE, // 9 v
|
|
TFT_CYAN, // 10 Blue+green mix
|
|
TFT_MAGENTA, // 11 Blue+red mix
|
|
TFT_MAROON, // 12 Darker red colour
|
|
TFT_DARKGREEN,// 13 Darker green colour
|
|
TFT_NAVY, // 14 Darker blue colour
|
|
TFT_PINK // 15
|
|
};
|
|
|
|
/***************************************************************************************
|
|
** Section 7: Diagnostic support
|
|
***************************************************************************************/
|
|
// #define TFT_eSPI_DEBUG // Switch on debug support serial messages (not used yet)
|
|
// #define TFT_eSPI_FNx_DEBUG // Switch on debug support for function "x" (not used yet)
|
|
|
|
// This structure allows sketches to retrieve the user setup parameters at runtime
|
|
// by calling getSetup(), zero impact on code size unless used, mainly for diagnostics
|
|
typedef struct
|
|
{
|
|
String version = TFT_ESPI_VERSION;
|
|
String setup_info; // Setup reference name available to use in a user setup
|
|
uint32_t setup_id; // ID available to use in a user setup
|
|
int32_t esp; // Processor code
|
|
uint8_t trans; // SPI transaction support
|
|
uint8_t serial; // Serial (SPI) or parallel
|
|
#ifndef GENERIC_PROCESSOR
|
|
uint8_t port; // SPI port
|
|
#endif
|
|
uint8_t overlap; // ESP8266 overlap mode
|
|
uint8_t interface; // Interface type
|
|
|
|
uint16_t tft_driver; // Hexadecimal code
|
|
uint16_t tft_width; // Rotation 0 width and height
|
|
uint16_t tft_height;
|
|
|
|
uint8_t r0_x_offset; // Display offsets, not all used yet
|
|
uint8_t r0_y_offset;
|
|
uint8_t r1_x_offset;
|
|
uint8_t r1_y_offset;
|
|
uint8_t r2_x_offset;
|
|
uint8_t r2_y_offset;
|
|
uint8_t r3_x_offset;
|
|
uint8_t r3_y_offset;
|
|
|
|
int8_t pin_tft_mosi; // SPI pins
|
|
int8_t pin_tft_miso;
|
|
int8_t pin_tft_clk;
|
|
int8_t pin_tft_cs;
|
|
|
|
int8_t pin_tft_dc; // Control pins
|
|
int8_t pin_tft_rd;
|
|
int8_t pin_tft_wr;
|
|
int8_t pin_tft_rst;
|
|
|
|
int8_t pin_tft_d0; // Parallel port pins
|
|
int8_t pin_tft_d1;
|
|
int8_t pin_tft_d2;
|
|
int8_t pin_tft_d3;
|
|
int8_t pin_tft_d4;
|
|
int8_t pin_tft_d5;
|
|
int8_t pin_tft_d6;
|
|
int8_t pin_tft_d7;
|
|
|
|
int8_t pin_tft_led;
|
|
int8_t pin_tft_led_on;
|
|
|
|
int8_t pin_tch_cs; // Touch chip select pin
|
|
|
|
int16_t tft_spi_freq;// TFT write SPI frequency
|
|
int16_t tft_rd_freq; // TFT read SPI frequency
|
|
int16_t tch_spi_freq;// Touch controller read/write SPI frequency
|
|
} setup_t;
|
|
|
|
/***************************************************************************************
|
|
** Section 8: Class member and support functions
|
|
***************************************************************************************/
|
|
|
|
// Callback prototype for smooth font pixel colour read
|
|
typedef uint16_t (*getColorCallback)(uint16_t x, uint16_t y);
|
|
|
|
// Class functions and variables
|
|
class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has access to protected members
|
|
|
|
//--------------------------------------- public ------------------------------------//
|
|
public:
|
|
|
|
TFT_eSPI(int16_t _W = TFT_WIDTH, int16_t _H = TFT_HEIGHT);
|
|
|
|
// init() and begin() are equivalent, begin() included for backwards compatibility
|
|
// Sketch defined tab colour option is for ST7735 displays only
|
|
void init(uint8_t tc = TAB_COLOUR), begin(uint8_t tc = TAB_COLOUR);
|
|
|
|
// These are virtual so the TFT_eSprite class can override them with sprite specific functions
|
|
virtual void drawPixel(int32_t x, int32_t y, uint32_t color),
|
|
drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uint32_t bg, uint8_t size),
|
|
drawLine(int32_t xs, int32_t ys, int32_t xe, int32_t ye, uint32_t color),
|
|
drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color),
|
|
drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color),
|
|
fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color);
|
|
|
|
virtual int16_t drawChar(uint16_t uniCode, int32_t x, int32_t y, uint8_t font),
|
|
drawChar(uint16_t uniCode, int32_t x, int32_t y),
|
|
height(void),
|
|
width(void);
|
|
|
|
// Read the colour of a pixel at x,y and return value in 565 format
|
|
virtual uint16_t readPixel(int32_t x, int32_t y);
|
|
|
|
virtual void setWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye); // Note: start + end coordinates
|
|
|
|
// Push (aka write pixel) colours to the set window
|
|
virtual void pushColor(uint16_t color);
|
|
|
|
// These are non-inlined to enable override
|
|
virtual void begin_nin_write();
|
|
virtual void end_nin_write();
|
|
|
|
void setRotation(uint8_t r); // Set the display image orientation to 0, 1, 2 or 3
|
|
uint8_t getRotation(void); // Read the current rotation
|
|
|
|
// Change the origin position from the default top left
|
|
// Note: setRotation, setViewport and resetViewport will revert origin to top left corner of screen/sprite
|
|
void setOrigin(int32_t x, int32_t y);
|
|
int32_t getOriginX(void);
|
|
int32_t getOriginY(void);
|
|
|
|
void invertDisplay(bool i); // Tell TFT to invert all displayed colours
|
|
|
|
|
|
// The TFT_eSprite class inherits the following functions (not all are useful to Sprite class
|
|
void setAddrWindow(int32_t xs, int32_t ys, int32_t w, int32_t h); // Note: start coordinates + width and height
|
|
|
|
// Viewport commands, see "Viewport_Demo" sketch
|
|
void setViewport(int32_t x, int32_t y, int32_t w, int32_t h, bool vpDatum = true);
|
|
bool checkViewport(int32_t x, int32_t y, int32_t w, int32_t h);
|
|
int32_t getViewportX(void);
|
|
int32_t getViewportY(void);
|
|
int32_t getViewportWidth(void);
|
|
int32_t getViewportHeight(void);
|
|
bool getViewportDatum(void);
|
|
void frameViewport(uint16_t color, int32_t w);
|
|
void resetViewport(void);
|
|
|
|
// Clip input window to viewport bounds, return false if whole area is out of bounds
|
|
bool clipAddrWindow(int32_t* x, int32_t* y, int32_t* w, int32_t* h);
|
|
// Clip input window area to viewport bounds, return false if whole area is out of bounds
|
|
bool clipWindow(int32_t* xs, int32_t* ys, int32_t* xe, int32_t* ye);
|
|
|
|
// Push (aka write pixel) colours to the TFT (use setAddrWindow() first)
|
|
void pushColor(uint16_t color, uint32_t len), // Deprecated, use pushBlock()
|
|
pushColors(uint16_t *data, uint32_t len, bool swap = true), // With byte swap option
|
|
pushColors(uint8_t *data, uint32_t len); // Deprecated, use pushPixels()
|
|
|
|
// Write a solid block of a single colour
|
|
void pushBlock(uint16_t color, uint32_t len);
|
|
|
|
// Write a set of pixels stored in memory, use setSwapBytes(true/false) function to correct endianess
|
|
void pushPixels(const void * data_in, uint32_t len);
|
|
|
|
// Support for half duplex (bi-directional SDA) SPI bus where MOSI must be switched to input
|
|
#ifdef TFT_SDA_READ
|
|
#if defined (TFT_eSPI_ENABLE_8_BIT_READ)
|
|
uint8_t tft_Read_8(void); // Read 8 bit value from TFT command register
|
|
#endif
|
|
void begin_SDA_Read(void); // Begin a read on a half duplex (bi-directional SDA) SPI bus - sets MOSI to input
|
|
void end_SDA_Read(void); // Restore MOSI to output
|
|
#endif
|
|
|
|
|
|
// Graphics drawing
|
|
void fillScreen(uint32_t color),
|
|
drawRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color),
|
|
drawRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t radius, uint32_t color),
|
|
fillRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t radius, uint32_t color);
|
|
|
|
void fillRectVGradient(int16_t x, int16_t y, int16_t w, int16_t h, uint32_t color1, uint32_t color2);
|
|
void fillRectHGradient(int16_t x, int16_t y, int16_t w, int16_t h, uint32_t color1, uint32_t color2);
|
|
|
|
void drawCircle(int32_t x, int32_t y, int32_t r, uint32_t color),
|
|
drawCircleHelper(int32_t x, int32_t y, int32_t r, uint8_t cornername, uint32_t color),
|
|
fillCircle(int32_t x, int32_t y, int32_t r, uint32_t color),
|
|
fillCircleHelper(int32_t x, int32_t y, int32_t r, uint8_t cornername, int32_t delta, uint32_t color),
|
|
|
|
drawEllipse(int16_t x, int16_t y, int32_t rx, int32_t ry, uint16_t color),
|
|
fillEllipse(int16_t x, int16_t y, int32_t rx, int32_t ry, uint16_t color),
|
|
|
|
// Corner 1 Corner 2 Corner 3
|
|
drawTriangle(int32_t x1,int32_t y1, int32_t x2,int32_t y2, int32_t x3,int32_t y3, uint32_t color),
|
|
fillTriangle(int32_t x1,int32_t y1, int32_t x2,int32_t y2, int32_t x3,int32_t y3, uint32_t color);
|
|
|
|
|
|
// Smooth (anti-aliased) graphics drawing
|
|
// Draw a pixel blended with the background pixel colour (bg_color) specified, return blended colour
|
|
// If the bg_color is not specified, the background pixel colour will be read from TFT or sprite
|
|
uint16_t drawPixel(int32_t x, int32_t y, uint32_t color, uint8_t alpha, uint32_t bg_color = 0x00FFFFFF);
|
|
|
|
// Draw an anti-aliased (smooth) arc between start and end angles. Arc ends are anti-aliased.
|
|
// By default the arc is drawn with square ends unless the "roundEnds" parameter is included and set true
|
|
// Angle = 0 is at 6 o'clock position, 90 at 9 o'clock etc. The angles must be in range 0-360 or they will be clipped to these limits
|
|
// The start angle may be larger than the end angle. Arcs are always drawn clockwise from the start angle.
|
|
void drawSmoothArc(int32_t x, int32_t y, int32_t r, int32_t ir, uint32_t startAngle, uint32_t endAngle, uint32_t fg_color, uint32_t bg_color, bool roundEnds = false);
|
|
|
|
// As per "drawSmoothArc" except the ends of the arc are NOT anti-aliased, this facilitates dynamic arc length changes with
|
|
// arc segments and ensures clean segment joints.
|
|
// The sides of the arc are anti-aliased by default. If smoothArc is false sides will NOT be anti-aliased
|
|
void drawArc(int32_t x, int32_t y, int32_t r, int32_t ir, uint32_t startAngle, uint32_t endAngle, uint32_t fg_color, uint32_t bg_color, bool smoothArc = true);
|
|
|
|
// Draw an anti-aliased filled circle at x, y with radius r
|
|
// Note: The thickness of line is 3 pixels to reduce the visible "braiding" effect of anti-aliasing narrow lines
|
|
// this means the inner anti-alias zone is always at r-1 and the outer zone at r+1
|
|
void drawSmoothCircle(int32_t x, int32_t y, int32_t r, uint32_t fg_color, uint32_t bg_color);
|
|
|
|
// Draw an anti-aliased filled circle at x, y with radius r
|
|
// If bg_color is not included the background pixel colour will be read from TFT or sprite
|
|
void fillSmoothCircle(int32_t x, int32_t y, int32_t r, uint32_t color, uint32_t bg_color = 0x00FFFFFF);
|
|
|
|
// Draw a rounded rectangle that has a line thickness of r-ir+1 and bounding box defined by x,y and w,h
|
|
// The outer corner radius is r, inner corner radius is ir
|
|
// The inside and outside of the border are anti-aliased
|
|
void drawSmoothRoundRect(int32_t x, int32_t y, int32_t r, int32_t ir, int32_t w, int32_t h, uint32_t fg_color, uint32_t bg_color = 0x00FFFFFF, uint8_t quadrants = 0xF);
|
|
|
|
// Draw a filled rounded rectangle , corner radius r and bounding box defined by x,y and w,h
|
|
void fillSmoothRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t radius, uint32_t color, uint32_t bg_color = 0x00FFFFFF);
|
|
|
|
// Draw a small anti-aliased filled circle at ax,ay with radius r (uses drawWideLine)
|
|
// If bg_color is not included the background pixel colour will be read from TFT or sprite
|
|
void drawSpot(float ax, float ay, float r, uint32_t fg_color, uint32_t bg_color = 0x00FFFFFF);
|
|
|
|
// Draw an anti-aliased wide line from ax,ay to bx,by width wd with radiused ends (radius is wd/2)
|
|
// If bg_color is not included the background pixel colour will be read from TFT or sprite
|
|
void drawWideLine(float ax, float ay, float bx, float by, float wd, uint32_t fg_color, uint32_t bg_color = 0x00FFFFFF);
|
|
|
|
// Draw an anti-aliased wide line from ax,ay to bx,by with different width at each end aw, bw and with radiused ends
|
|
// If bg_color is not included the background pixel colour will be read from TFT or sprite
|
|
void drawWedgeLine(float ax, float ay, float bx, float by, float aw, float bw, uint32_t fg_color, uint32_t bg_color = 0x00FFFFFF);
|
|
|
|
|
|
// Image rendering
|
|
// Swap the byte order for pushImage() and pushPixels() - corrects endianness
|
|
void setSwapBytes(bool swap);
|
|
bool getSwapBytes(void);
|
|
|
|
// Draw bitmap
|
|
void drawBitmap( int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t fgcolor),
|
|
drawBitmap( int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t fgcolor, uint16_t bgcolor),
|
|
drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t fgcolor),
|
|
drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t fgcolor, uint16_t bgcolor),
|
|
setBitmapColor(uint16_t fgcolor, uint16_t bgcolor); // Define the 2 colours for 1bpp sprites
|
|
|
|
// Set TFT pivot point (use when rendering rotated sprites)
|
|
void setPivot(int16_t x, int16_t y);
|
|
int16_t getPivotX(void), // Get pivot x
|
|
getPivotY(void); // Get pivot y
|
|
|
|
// The next functions can be used as a pair to copy screen blocks (or horizontal/vertical lines) to another location
|
|
// Read a block of pixels to a data buffer, buffer is 16 bit and the size must be at least w * h
|
|
void readRect(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *data);
|
|
// Write a block of pixels to the screen which have been read by readRect()
|
|
void pushRect(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *data);
|
|
|
|
// These are used to render images or sprites stored in RAM arrays (used by Sprite class for 16bpp Sprites)
|
|
void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *data);
|
|
void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *data, uint16_t transparent);
|
|
|
|
// These are used to render images stored in FLASH (PROGMEM)
|
|
void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint16_t *data, uint16_t transparent);
|
|
void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint16_t *data);
|
|
|
|
// These are used by Sprite class pushSprite() member function for 1, 4 and 8 bits per pixel (bpp) colours
|
|
// They are not intended to be used with user sketches (but could be)
|
|
// Set bpp8 true for 8bpp sprites, false otherwise. The cmap pointer must be specified for 4bpp
|
|
void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint8_t *data, bool bpp8 = true, uint16_t *cmap = nullptr);
|
|
void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint8_t *data, uint8_t transparent, bool bpp8 = true, uint16_t *cmap = nullptr);
|
|
// FLASH version
|
|
void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint8_t *data, bool bpp8, uint16_t *cmap = nullptr);
|
|
|
|
// Render a 16 bit colour image with a 1bpp mask
|
|
void pushMaskedImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *img, uint8_t *mask);
|
|
|
|
// This next function has been used successfully to dump the TFT screen to a PC for documentation purposes
|
|
// It reads a screen area and returns the 3 RGB 8 bit colour values of each pixel in the buffer
|
|
// Set w and h to 1 to read 1 pixel's colour. The data buffer must be at least w * h * 3 bytes
|
|
void readRectRGB(int32_t x, int32_t y, int32_t w, int32_t h, uint8_t *data);
|
|
|
|
|
|
// Text rendering - value returned is the pixel width of the rendered text
|
|
int16_t drawNumber(long intNumber, int32_t x, int32_t y, uint8_t font), // Draw integer using specified font number
|
|
drawNumber(long intNumber, int32_t x, int32_t y), // Draw integer using current font
|
|
|
|
// Decimal is the number of decimal places to render
|
|
// Use with setTextDatum() to position values on TFT, and setTextPadding() to blank old displayed values
|
|
drawFloat(float floatNumber, uint8_t decimal, int32_t x, int32_t y, uint8_t font), // Draw float using specified font number
|
|
drawFloat(float floatNumber, uint8_t decimal, int32_t x, int32_t y), // Draw float using current font
|
|
|
|
// Handle char arrays
|
|
// Use with setTextDatum() to position string on TFT, and setTextPadding() to blank old displayed strings
|
|
drawString(const char *string, int32_t x, int32_t y, uint8_t font), // Draw string using specified font number
|
|
drawString(const char *string, int32_t x, int32_t y), // Draw string using current font
|
|
drawString(const String& string, int32_t x, int32_t y, uint8_t font),// Draw string using specified font number
|
|
drawString(const String& string, int32_t x, int32_t y), // Draw string using current font
|
|
|
|
drawCentreString(const char *string, int32_t x, int32_t y, uint8_t font), // Deprecated, use setTextDatum() and drawString()
|
|
drawRightString(const char *string, int32_t x, int32_t y, uint8_t font), // Deprecated, use setTextDatum() and drawString()
|
|
drawCentreString(const String& string, int32_t x, int32_t y, uint8_t font),// Deprecated, use setTextDatum() and drawString()
|
|
drawRightString(const String& string, int32_t x, int32_t y, uint8_t font); // Deprecated, use setTextDatum() and drawString()
|
|
|
|
|
|
// Text rendering and font handling support funtions
|
|
void setCursor(int16_t x, int16_t y), // Set cursor for tft.print()
|
|
setCursor(int16_t x, int16_t y, uint8_t font); // Set cursor and font number for tft.print()
|
|
|
|
int16_t getCursorX(void), // Read current cursor x position (moves with tft.print())
|
|
getCursorY(void); // Read current cursor y position
|
|
|
|
void setTextColor(uint16_t color), // Set character (glyph) color only (background not over-written)
|
|
setTextColor(uint16_t fgcolor, uint16_t bgcolor, bool bgfill = false), // Set character (glyph) foreground and background colour, optional background fill for smooth fonts
|
|
setTextSize(uint8_t size); // Set character size multiplier (this increases pixel size)
|
|
|
|
void setTextWrap(bool wrapX, bool wrapY = false); // Turn on/off wrapping of text in TFT width and/or height
|
|
|
|
void setTextDatum(uint8_t datum); // Set text datum position (default is top left), see Section 6 above
|
|
uint8_t getTextDatum(void);
|
|
|
|
void setTextPadding(uint16_t x_width); // Set text padding (background blanking/over-write) width in pixels
|
|
uint16_t getTextPadding(void); // Get text padding
|
|
|
|
#ifdef LOAD_GFXFF
|
|
void setFreeFont(const GFXfont *f = NULL), // Select the GFX Free Font
|
|
setTextFont(uint8_t font); // Set the font number to use in future
|
|
#else
|
|
void setFreeFont(uint8_t font), // Not used, historical fix to prevent an error
|
|
setTextFont(uint8_t font); // Set the font number to use in future
|
|
#endif
|
|
|
|
int16_t textWidth(const char *string, uint8_t font), // Returns pixel width of string in specified font
|
|
textWidth(const char *string), // Returns pixel width of string in current font
|
|
textWidth(const String& string, uint8_t font), // As above for String types
|
|
textWidth(const String& string),
|
|
fontHeight(int16_t font), // Returns pixel height of string in specified font
|
|
fontHeight(void); // Returns pixel width of string in current font
|
|
|
|
// Used by library and Smooth font class to extract Unicode point codes from a UTF8 encoded string
|
|
uint16_t decodeUTF8(uint8_t *buf, uint16_t *index, uint16_t remaining),
|
|
decodeUTF8(uint8_t c);
|
|
|
|
// Support function to UTF8 decode and draw characters piped through print stream
|
|
size_t write(uint8_t);
|
|
// size_t write(const uint8_t *buf, size_t len);
|
|
|
|
// Used by Smooth font class to fetch a pixel colour for the anti-aliasing
|
|
void setCallback(getColorCallback getCol);
|
|
|
|
uint16_t fontsLoaded(void); // Each bit in returned value represents a font type that is loaded - used for debug/error handling only
|
|
|
|
|
|
// Low level read/write
|
|
void spiwrite(uint8_t); // legacy support only
|
|
#ifdef RM68120_DRIVER
|
|
void writecommand(uint16_t c); // Send a 16 bit command, function resets DC/RS high ready for data
|
|
void writeRegister8(uint16_t c, uint8_t d); // Write 8 bit data data to 16 bit command register
|
|
void writeRegister16(uint16_t c, uint16_t d); // Write 16 bit data data to 16 bit command register
|
|
#else
|
|
void writecommand(uint8_t c); // Send an 8 bit command, function resets DC/RS high ready for data
|
|
#endif
|
|
void writedata(uint8_t d); // Send data with DC/RS set high
|
|
|
|
void commandList(const uint8_t *addr); // Send a initialisation sequence to TFT stored in FLASH
|
|
|
|
uint8_t readcommand8( uint8_t cmd_function, uint8_t index = 0); // read 8 bits from TFT
|
|
uint16_t readcommand16(uint8_t cmd_function, uint8_t index = 0); // read 16 bits from TFT
|
|
uint32_t readcommand32(uint8_t cmd_function, uint8_t index = 0); // read 32 bits from TFT
|
|
|
|
|
|
// Colour conversion
|
|
// Convert 8 bit red, green and blue to 16 bits
|
|
uint16_t color565(uint8_t red, uint8_t green, uint8_t blue);
|
|
|
|
// Convert 8 bit colour to 16 bits
|
|
uint16_t color8to16(uint8_t color332);
|
|
// Convert 16 bit colour to 8 bits
|
|
uint8_t color16to8(uint16_t color565);
|
|
|
|
// Convert 16 bit colour to/from 24 bit, R+G+B concatenated into LS 24 bits
|
|
uint32_t color16to24(uint16_t color565);
|
|
uint32_t color24to16(uint32_t color888);
|
|
|
|
// Alpha blend 2 colours, see generic "alphaBlend_Test" example
|
|
// alpha = 0 = 100% background colour
|
|
// alpha = 255 = 100% foreground colour
|
|
inline uint16_t alphaBlend(uint8_t alpha, uint16_t fgc, uint16_t bgc);
|
|
// 16 bit colour alphaBlend with alpha dither (dither reduces colour banding)
|
|
uint16_t alphaBlend(uint8_t alpha, uint16_t fgc, uint16_t bgc, uint8_t dither);
|
|
// 24 bit colour alphaBlend with optional alpha dither
|
|
uint32_t alphaBlend24(uint8_t alpha, uint32_t fgc, uint32_t bgc, uint8_t dither = 0);
|
|
|
|
// Direct Memory Access (DMA) support functions
|
|
// These can be used for SPI writes when using the ESP32 (original) or STM32 processors.
|
|
// DMA also works on a RP2040 processor with PIO based SPI and parallel (8 and 16 bit) interfaces
|
|
// Bear in mind DMA will only be of benefit in particular circumstances and can be tricky
|
|
// to manage by noobs. The functions have however been designed to be noob friendly and
|
|
// avoid a few DMA behaviour "gotchas".
|
|
//
|
|
// At best you will get a 2x TFT rendering performance improvement when using DMA because
|
|
// this library handles the SPI bus so efficiently during normal (non DMA) transfers. The best
|
|
// performance improvement scenario is the DMA transfer time is exactly the same as the time it
|
|
// takes for the processor to prepare the next image buffer and initiate another DMA transfer.
|
|
//
|
|
// DMA transfer to the TFT is done while the processor moves on to handle other tasks. Bear
|
|
// this in mind and watch out for "gotchas" like the image buffer going out of scope as the
|
|
// processor leaves a function or its content being changed while the DMA engine is reading it.
|
|
//
|
|
// The compiler MAY change the implied scope of a buffer which has been set aside by creating
|
|
// an array. For example a buffer defined before a "for-next" loop may get de-allocated when
|
|
// the loop ends. To avoid this use, for example, malloc() and free() to take control of when
|
|
// the buffer space is available and ensure it is not released until DMA is complete.
|
|
//
|
|
// Clearly you should not modify a buffer that is being DMA'ed to the TFT until the DMA is over.
|
|
// Use the dmaBusy() function to check this. Use tft.startWrite() before invoking DMA so the
|
|
// TFT chip select stays low. If you use tft.endWrite() before DMA is complete then the endWrite
|
|
// function will wait for the DMA to complete, so this may defeat any DMA performance benefit.
|
|
//
|
|
|
|
bool initDMA(bool ctrl_cs = false); // Initialise the DMA engine and attach to SPI bus - typically used in setup()
|
|
// Parameter "true" enables DMA engine control of TFT chip select (ESP32 only)
|
|
// For ESP32 only, TFT reads will not work if parameter is true
|
|
void deInitDMA(void); // De-initialise the DMA engine and detach from SPI bus - typically not used
|
|
|
|
// Push an image to the TFT using DMA, buffer is optional and grabs (double buffers) a copy of the image
|
|
// Use the buffer if the image data will get over-written or destroyed while DMA is in progress
|
|
//
|
|
// Note 1: If swapping colour bytes is defined, and the double buffer option is NOT used, then the bytes
|
|
// in the original image buffer content will be byte swapped by the function before DMA is initiated.
|
|
//
|
|
// Note 2: If part of the image will be off screen or outside of a set viewport, then the the original
|
|
// image buffer content will be altered to a correctly clipped image before DMA is initiated.
|
|
//
|
|
// The function will wait for the last DMA to complete if it is called while a previous DMA is still
|
|
// in progress, this simplifies the sketch and helps avoid "gotchas".
|
|
void pushImageDMA(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t* data, uint16_t* buffer = nullptr);
|
|
|
|
#if defined (ESP32) // ESP32 only at the moment
|
|
// For case where pointer is a const and the image data must not be modified (clipped or byte swapped)
|
|
void pushImageDMA(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t const* data);
|
|
#endif
|
|
// Push a block of pixels into a window set up using setAddrWindow()
|
|
void pushPixelsDMA(uint16_t* image, uint32_t len);
|
|
|
|
// Check if the DMA is complete - use while(tft.dmaBusy); for a blocking wait
|
|
bool dmaBusy(void); // returns true if DMA is still in progress
|
|
void dmaWait(void); // wait until DMA is complete
|
|
|
|
bool DMA_Enabled = false; // Flag for DMA enabled state
|
|
uint8_t spiBusyCheck = 0; // Number of ESP32 transfer buffers to check
|
|
|
|
// Bare metal functions
|
|
void startWrite(void); // Begin SPI transaction
|
|
void writeColor(uint16_t color, uint32_t len); // Deprecated, use pushBlock()
|
|
void endWrite(void); // End SPI transaction
|
|
|
|
// Set/get an arbitrary library configuration attribute or option
|
|
// Use to switch ON/OFF capabilities such as UTF8 decoding - each attribute has a unique ID
|
|
// id = 0: reserved - may be used in future to reset all attributes to a default state
|
|
// id = 1: Turn on (a=true) or off (a=false) GLCD cp437 font character error correction
|
|
// id = 2: Turn on (a=true) or off (a=false) UTF8 decoding
|
|
// id = 3: Enable or disable use of ESP32 PSRAM (if available)
|
|
#define CP437_SWITCH 1
|
|
#define UTF8_SWITCH 2
|
|
#define PSRAM_ENABLE 3
|
|
void setAttribute(uint8_t id = 0, uint8_t a = 0); // Set attribute value
|
|
uint8_t getAttribute(uint8_t id = 0); // Get attribute value
|
|
|
|
// Used for diagnostic sketch to see library setup adopted by compiler, see Section 7 above
|
|
void getSetup(setup_t& tft_settings); // Sketch provides the instance to populate
|
|
bool verifySetupID(uint32_t id);
|
|
|
|
// Global variables
|
|
static SPIClass& getSPIinstance(void); // Get SPI class handle
|
|
|
|
uint32_t textcolor, textbgcolor; // Text foreground and background colours
|
|
|
|
uint32_t bitmap_fg, bitmap_bg; // Bitmap foreground (bit=1) and background (bit=0) colours
|
|
|
|
uint8_t textfont, // Current selected font number
|
|
textsize, // Current font size multiplier
|
|
textdatum, // Text reference datum
|
|
rotation; // Display rotation (0-3)
|
|
|
|
uint8_t decoderState = 0; // UTF8 decoder state - not for user access
|
|
uint16_t decoderBuffer; // Unicode code-point buffer - not for user access
|
|
|
|
//--------------------------------------- private ------------------------------------//
|
|
private:
|
|
// Legacy begin and end prototypes - deprecated TODO: delete
|
|
void spi_begin();
|
|
void spi_end();
|
|
|
|
void spi_begin_read();
|
|
void spi_end_read();
|
|
|
|
// New begin and end prototypes
|
|
// begin/end a TFT write transaction
|
|
// For SPI bus the transmit clock rate is set
|
|
inline void begin_tft_write() __attribute__((always_inline));
|
|
inline void end_tft_write() __attribute__((always_inline));
|
|
|
|
// begin/end a TFT read transaction
|
|
// For SPI bus: begin lowers SPI clock rate, end reinstates transmit clock rate
|
|
inline void begin_tft_read() __attribute__((always_inline));
|
|
inline void end_tft_read() __attribute__((always_inline));
|
|
|
|
// Initialise the data bus GPIO and hardware interfaces
|
|
void initBus(void);
|
|
|
|
// Temporary library development function TODO: remove need for this
|
|
void pushSwapBytePixels(const void* data_in, uint32_t len);
|
|
|
|
// Same as setAddrWindow but exits with CGRAM in read mode
|
|
void readAddrWindow(int32_t xs, int32_t ys, int32_t w, int32_t h);
|
|
|
|
// Byte read prototype
|
|
uint8_t readByte(void);
|
|
|
|
// GPIO parallel bus input/output direction control
|
|
void busDir(uint32_t mask, uint8_t mode);
|
|
|
|
// Single GPIO input/output direction control
|
|
void gpioMode(uint8_t gpio, uint8_t mode);
|
|
|
|
// Smooth graphics helper
|
|
uint8_t sqrt_fraction(uint32_t num);
|
|
|
|
// Helper function: calculate distance of a point from a finite length line between two points
|
|
float wedgeLineDistance(float pax, float pay, float bax, float bay, float dr);
|
|
|
|
// Display variant settings
|
|
uint8_t tabcolor, // ST7735 screen protector "tab" colour (now invalid)
|
|
colstart = 0, rowstart = 0; // Screen display area to CGRAM area coordinate offsets
|
|
|
|
// Port and pin masks for control signals (ESP826 only) - TODO: remove need for this
|
|
volatile uint32_t *dcport, *csport;
|
|
uint32_t cspinmask, dcpinmask, wrpinmask, sclkpinmask;
|
|
|
|
#if defined(ESP32_PARALLEL)
|
|
// Bit masks for ESP32 parallel bus interface
|
|
uint32_t xclr_mask, xdir_mask; // Port set/clear and direction control masks
|
|
|
|
// Lookup table for ESP32 parallel bus interface uses 1kbyte RAM,
|
|
uint32_t xset_mask[256]; // Makes Sprite rendering test 33% faster, for slower macro equivalent
|
|
// see commented out #define set_mask(C) within TFT_eSPI_ESP32.h
|
|
#endif
|
|
|
|
//uint32_t lastColor = 0xFFFF; // Last colour - used to minimise bit shifting overhead
|
|
|
|
getColorCallback getColor = nullptr; // Smooth font callback function pointer
|
|
|
|
bool locked, inTransaction, lockTransaction; // SPI transaction and mutex lock flags
|
|
|
|
//-------------------------------------- protected ----------------------------------//
|
|
protected:
|
|
|
|
//int32_t win_xe, win_ye; // Window end coords - not needed
|
|
|
|
int32_t _init_width, _init_height; // Display w/h as input, used by setRotation()
|
|
int32_t _width, _height; // Display w/h as modified by current rotation
|
|
int32_t addr_row, addr_col; // Window position - used to minimise window commands
|
|
|
|
int16_t _xPivot; // TFT x pivot point coordinate for rotated Sprites
|
|
int16_t _yPivot; // TFT x pivot point coordinate for rotated Sprites
|
|
|
|
// Viewport variables
|
|
int32_t _vpX, _vpY, _vpW, _vpH; // Note: x start, y start, x end + 1, y end + 1
|
|
int32_t _xDatum;
|
|
int32_t _yDatum;
|
|
int32_t _xWidth;
|
|
int32_t _yHeight;
|
|
bool _vpDatum;
|
|
bool _vpOoB;
|
|
|
|
int32_t cursor_x, cursor_y, padX; // Text cursor x,y and padding setting
|
|
int32_t bg_cursor_x; // Background fill cursor
|
|
int32_t last_cursor_x; // Previous text cursor position when fill used
|
|
|
|
uint32_t fontsloaded; // Bit field of fonts loaded
|
|
|
|
uint8_t glyph_ab, // Smooth font glyph delta Y (height) above baseline
|
|
glyph_bb; // Smooth font glyph delta Y (height) below baseline
|
|
|
|
bool isDigits; // adjust bounding box for numbers to reduce visual jiggling
|
|
bool textwrapX, textwrapY; // If set, 'wrap' text at right and optionally bottom edge of display
|
|
bool _swapBytes; // Swap the byte order for TFT pushImage()
|
|
|
|
bool _booted; // init() or begin() has already run once
|
|
|
|
// User sketch manages these via set/getAttribute()
|
|
bool _cp437; // If set, use correct CP437 charset (default is ON)
|
|
bool _utf8; // If set, use UTF-8 decoder in print stream 'write()' function (default ON)
|
|
bool _psram_enable; // Enable PSRAM use for library functions (TBD) and Sprites
|
|
|
|
uint32_t _lastColor; // Buffered value of last colour used
|
|
|
|
bool _fillbg; // Fill background flag (just for for smooth fonts at the moment)
|
|
|
|
#if defined (SSD1963_DRIVER)
|
|
uint16_t Cswap; // Swap buffer for SSD1963
|
|
uint8_t r6, g6, b6; // RGB buffer for SSD1963
|
|
#endif
|
|
|
|
#ifdef LOAD_GFXFF
|
|
GFXfont *gfxFont;
|
|
#endif
|
|
|
|
/***************************************************************************************
|
|
** Section 9: TFT_eSPI class conditional extensions
|
|
***************************************************************************************/
|
|
// Load the Touch extension
|
|
#ifdef TOUCH_CS
|
|
#if defined (TFT_PARALLEL_8_BIT) || defined (RP2040_PIO_INTERFACE)
|
|
#if !defined(DISABLE_ALL_LIBRARY_WARNINGS)
|
|
#error >>>>------>> Touch functions not supported in 8/16 bit parallel mode or with RP2040 PIO.
|
|
#endif
|
|
#else
|
|
#include "Extensions/Touch.h" // Loaded if TOUCH_CS is defined by user
|
|
#endif
|
|
#else
|
|
#if !defined(DISABLE_ALL_LIBRARY_WARNINGS)
|
|
#warning >>>>------>> TOUCH_CS pin not defined, TFT_eSPI touch functions will not be available!
|
|
#endif
|
|
#endif
|
|
|
|
// Load the Anti-aliased font extension
|
|
#ifdef SMOOTH_FONT
|
|
#include "Extensions/Smooth_font.h" // Loaded if SMOOTH_FONT is defined by user
|
|
#endif
|
|
|
|
}; // End of class TFT_eSPI
|
|
|
|
// Swap any type
|
|
template <typename T> static inline void
|
|
transpose(T& a, T& b) { T t = a; a = b; b = t; }
|
|
|
|
/***************************************************************************************
|
|
** Section 10: Additional extension classes
|
|
***************************************************************************************/
|
|
// Load the Button Class
|
|
#include "Extensions/Button.h"
|
|
|
|
// Load the Sprite Class
|
|
#include "Extensions/Sprite.h"
|
|
|
|
#endif // ends #ifndef _TFT_eSPIH_
|