Compare commits

..

No commits in common. "master" and "V2.4.51" have entirely different histories.

96 changed files with 7766 additions and 21871 deletions

View File

@ -1,36 +0,0 @@
---
name: Issue template
about: Guide to content
title: ''
labels: ''
assignees: ''
---
Only raise issues for problems with the library and/or provided examples. Post questions, comments and useful tips etc in the "Discussions" section.
To minimise effort to resolve issues the following should be provided as a minimum:
1. A description of the problem and the conditions that cause it to occur
2. IDE (e.g. Arduino or PlatformIO)
3. TFT_eSPI library version (try the latest, the problem may have been resolved!) from the Manage Libraries... menu
4. Board package version (e.g. 2.0.3) available from the Boards Manager... menu
5. Procesor, e.g RP2040, ESP32 S3 etc
6. TFT driver (e.g. ILI9341), a link to the vendors product web page is useful too.
7. Interface type (SPI or parallel)
Plus further information as appropriate to the problem:
1. TFT to processor connections used
2. A zip file containing your setup file (just drag and drop in message window - do not paste in long files!)
3. A zip file containing a simple and complete example sketch that demonstrates the problem but needs no special hardware sensors or libraries.
4. Screen shot pictures showing the problem (just drag and drop in message window)
The idea is to provide sufficient information so I can setup the exact same (or sufficiently similar) scenario to investigate and resolve the issue without having a tedious ping-pong of Q&A.
DO NOT paste code directly into the issue. To correctly format code put three ticks ( ` character on key next to "1" key) at the start and end of short pasted code segments to avoid format/markup anomolies. [See here:](https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#quoting-code)
Example output:
```
Serial.begin(115200);
tft.init();
```

5
.gitignore vendored
View File

@ -17,11 +17,6 @@ $RECYCLE.BIN/
# Windows shortcuts
*.lnk
# Arduino debug
debug.cfg
debug_custom.json
*.svd
# =========================
# Operating System Files
# =========================

View File

@ -8,8 +8,6 @@ TFT_eSPI_Button::TFT_eSPI_Button(void) {
_yd = 0;
_textdatum = MC_DATUM;
_label[9] = '\0';
currstate = false;
laststate = false;
}
// Classic initButton() function: pass center & size

View File

@ -430,15 +430,14 @@ void TFT_eSPI::drawGlyph(uint16_t code)
startWrite(); // Avoid slow ESP32 transaction overhead for every pixel
int16_t fillwidth = 0;
int16_t fillheight = 0;
int16_t fillwidth = 0;
uint16_t fillheight = 0;
// Fill area above glyph
if (_fillbg) {
fillwidth = (cursor_x + gxAdvance[gNum]) - bg_cursor_x;
if (fillwidth > 0) {
fillheight = gFont.maxAscent - gdY[gNum];
// Could be negative
if (fillheight > 0) {
fillRect(bg_cursor_x, cursor_y, fillwidth, fillheight, textbgcolor);
}

View File

@ -3,7 +3,7 @@
public:
// These are for the new anti-aliased fonts
// These are for the new antialiased fonts
void loadFont(const uint8_t array[]);
#ifdef FONT_FS_AVAILABLE
void loadFont(String fontName, fs::FS &ffs);

View File

@ -423,7 +423,7 @@ bool TFT_eSprite::pushRotated(int16_t angle, uint32_t transp)
if (_bpp == 4) tpcolor = _colorMap[transp & 0x0F];
tpcolor = tpcolor>>8 | tpcolor<<8; // Working with swapped color bytes
}
_tft->startWrite(); // Avoid transaction overhead for every tft pixel
_tft->startWrite(); // Avoid transaction overhead for every tft pixel
// Scan destination bounding box and fetch transformed pixels from source Sprite
for (int32_t y = min_y; y <= max_y; y++, yt++) {
@ -441,7 +441,7 @@ bool TFT_eSprite::pushRotated(int16_t angle, uint32_t transp)
int32_t yp = ys >> FP_SCALE;
if (_bpp == 16) {rp = _img[xp + yp * _iwidth]; }
else { rp = readPixel(xp, yp); rp = (uint16_t)(rp>>8 | rp<<8); }
if (transp != 0x00FFFFFF && tpcolor == rp) {
if (tpcolor == rp) {
if (pixel_count) {
// TFT window is already clipped, so this is faster than pushImage()
_tft->setWindow(x - pixel_count, y, x - 1, y);
@ -517,7 +517,7 @@ bool TFT_eSprite::pushRotated(TFT_eSprite *spr, int16_t angle, uint32_t transp)
int32_t yp = ys >> FP_SCALE;
if (_bpp == 16) rp = _img[xp + yp * _iwidth];
else { rp = readPixel(xp, yp); rp = (uint16_t)(rp>>8 | rp<<8); }
if (transp != 0x00FFFFFF && tpcolor == rp) {
if (tpcolor == rp) {
if (pixel_count) {
spr->pushImage(x - pixel_count, y, pixel_count, 1, sline_buffer);
pixel_count = 0;
@ -717,7 +717,7 @@ void TFT_eSprite::pushSprite(int32_t x, int32_t y, uint16_t transp)
// 16bpp -> 16bpp
// 16bpp -> 8bpp
// 8bpp -> 8bpp
// 4bpp -> 4bpp (note: color translation depends on the 2 sprites palette colors)
// 4bpp -> 4bpp (note: color translation depends on the 2 sprites pallete colors)
// 1bpp -> 1bpp (note: color translation depends on the 2 sprites bitmap colors)
bool TFT_eSprite::pushToSprite(TFT_eSprite *dspr, int32_t x, int32_t y)
@ -1257,8 +1257,8 @@ void TFT_eSprite::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const u
// Intentionally not constrained to viewport area, does not manage 1bpp rotations
void TFT_eSprite::setWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
{
if (x0 > x1) transpose(x0, x1);
if (y0 > y1) transpose(y0, y1);
if (x0 > x1) swap_coord(x0, x1);
if (y0 > y1) swap_coord(y0, y1);
int32_t w = width();
int32_t h = height();
@ -1555,7 +1555,7 @@ void TFT_eSprite::fillSprite(uint32_t color)
** Function name: width
** Description: Return the width of sprite
***************************************************************************************/
// Return the size of the sprite
// Return the size of the display
int16_t TFT_eSprite::width(void)
{
if (!_created ) return 0;
@ -1700,13 +1700,13 @@ void TFT_eSprite::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint3
bool steep = abs(y1 - y0) > abs(x1 - x0);
if (steep) {
transpose(x0, y0);
transpose(x1, y1);
swap_coord(x0, y0);
swap_coord(x1, y1);
}
if (x0 > x1) {
transpose(x0, x1);
transpose(y0, y1);
swap_coord(x0, x1);
swap_coord(y0, y1);
}
int32_t dx = x1 - x0, dy = abs(y1 - y0);;
@ -1990,8 +1990,10 @@ void TFT_eSprite::drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uin
{
if ( _vpOoB || !_created ) return;
if ((x >= _vpW - _xDatum) || // Clip right
(y >= _vpH - _yDatum)) // Clip bottom
if ((x >= _vpW - _xDatum) || // Clip right
(y >= _vpH - _yDatum) || // Clip bottom
((x + 6 * size - 1) < (_vpX - _xDatum)) || // Clip left
((y + 8 * size - 1) < (_vpY - _yDatum))) // Clip top
return;
if (c < 32) return;
@ -2002,10 +2004,6 @@ void TFT_eSprite::drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uin
#endif
//>>>>>>>>>>>>>>>>>>
if (((x + 6 * size - 1) < (_vpX - _xDatum)) || // Clip left
((y + 8 * size - 1) < (_vpY - _yDatum))) // Clip top
return;
bool fillbg = (bg != color);
if ((size==1) && fillbg)
@ -2073,21 +2071,15 @@ void TFT_eSprite::drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uin
c -= pgm_read_word(&gfxFont->first);
GFXglyph *glyph = &(((GFXglyph *)pgm_read_dword(&gfxFont->glyph))[c]);
uint8_t *bitmap = (uint8_t *)pgm_read_dword(&gfxFont->bitmap);
uint32_t bo = pgm_read_word(&glyph->bitmapOffset);
uint8_t w = pgm_read_byte(&glyph->width),
h = pgm_read_byte(&glyph->height);
//xa = pgm_read_byte(&glyph->xAdvance);
int8_t xo = pgm_read_byte(&glyph->xOffset),
yo = pgm_read_byte(&glyph->yOffset);
if (((x + xo + w * size - 1) < (_vpX - _xDatum)) || // Clip left
((y + yo + h * size - 1) < (_vpY - _yDatum))) // Clip top
return;
uint8_t *bitmap = (uint8_t *)pgm_read_dword(&gfxFont->bitmap);
uint32_t bo = pgm_read_word(&glyph->bitmapOffset);
uint8_t xx, yy, bits=0, bit=0;
//uint8_t xa = pgm_read_byte(&glyph->xAdvance);
int16_t xo16 = 0, yo16 = 0;
if(size > 1) {
@ -2127,12 +2119,6 @@ void TFT_eSprite::drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uin
#ifdef LOAD_GFXFF
} // End classic vs custom font
#endif
#else
#ifndef LOAD_GFXFF
color = color;
bg = bg;
size = size;
#endif
#endif
}
@ -2140,7 +2126,7 @@ void TFT_eSprite::drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uin
/***************************************************************************************
** Function name: drawChar
** Description: draw a unicode glyph into the sprite
** Description: draw a unicode glyph onto the screen
***************************************************************************************/
// TODO: Rationalise with TFT_eSPI
// Any UTF-8 decoding must be done before calling drawChar()
@ -2392,17 +2378,6 @@ int16_t TFT_eSprite::drawChar(uint16_t uniCode, int32_t x, int32_t y, uint8_t fo
}
// End of RLE font rendering
#endif
#if !defined (LOAD_FONT2) && !defined (LOAD_RLE)
// Stop warnings
flash_address = flash_address;
w = w;
pX = pX;
pY = pY;
line = line;
clip = clip;
#endif
return width * textsize; // x +
}
@ -2417,30 +2392,16 @@ void TFT_eSprite::drawGlyph(uint16_t code)
{
uint16_t fg = textcolor;
uint16_t bg = textbgcolor;
bool getBG = false;
if (fg == bg) getBG = true;
// Check if cursor has moved
if (last_cursor_x != cursor_x)
{
bg_cursor_x = cursor_x;
last_cursor_x = cursor_x;
}
if (code < 0x21)
{
if (code == 0x20) {
if (_fillbg) fillRect(bg_cursor_x, cursor_y, (cursor_x + gFont.spaceWidth) - bg_cursor_x, gFont.yAdvance, bg);
cursor_x += gFont.spaceWidth;
bg_cursor_x = cursor_x;
last_cursor_x = cursor_x;
return;
}
if (code == '\n') {
cursor_x = 0;
bg_cursor_x = 0;
last_cursor_x = 0;
cursor_y += gFont.yAdvance;
if (textwrapY && (cursor_y >= height())) cursor_y = 0;
return;
@ -2460,8 +2421,6 @@ void TFT_eSprite::drawGlyph(uint16_t code)
createSprite(gWidth[gNum], gFont.yAdvance);
if(fg != bg) fillSprite(bg);
cursor_x = -gdX[gNum];
bg_cursor_x = cursor_x;
last_cursor_x = cursor_x;
cursor_y = 0;
}
else
@ -2469,11 +2428,10 @@ void TFT_eSprite::drawGlyph(uint16_t code)
if( textwrapX && ((cursor_x + gWidth[gNum] + gdX[gNum]) > width())) {
cursor_y += gFont.yAdvance;
cursor_x = 0;
bg_cursor_x = 0;
last_cursor_x = 0;
}
if( textwrapY && ((cursor_y + gFont.yAdvance) > height())) cursor_y = 0;
if ( cursor_x == 0) cursor_x -= gdX[gNum];
}
@ -2487,45 +2445,11 @@ void TFT_eSprite::drawGlyph(uint16_t code)
}
#endif
int16_t cy = cursor_y + gFont.maxAscent - gdY[gNum];
int16_t cx = cursor_x + gdX[gNum];
// if (cx > width() && bg_cursor_x > width()) return;
// if (cursor_y > height()) return;
int16_t fxs = cx;
uint32_t fl = 0;
int16_t bxs = cx;
uint32_t bl = 0;
int16_t bx = 0;
int16_t xs = 0;
uint16_t dl = 0;
uint8_t pixel = 0;
int16_t fillwidth = 0;
int16_t fillheight = 0;
// Fill area above glyph
if (_fillbg) {
fillwidth = (cursor_x + gxAdvance[gNum]) - bg_cursor_x;
if (fillwidth > 0) {
fillheight = gFont.maxAscent - gdY[gNum];
if (fillheight > 0) {
fillRect(bg_cursor_x, cursor_y, fillwidth, fillheight, textbgcolor);
}
}
else {
// Could be negative
fillwidth = 0;
}
// Fill any area to left of glyph
if (bg_cursor_x < cx) fillRect(bg_cursor_x, cy, cx - bg_cursor_x, gHeight[gNum], textbgcolor);
// Set x position in glyph area where background starts
if (bg_cursor_x > cx) bx = bg_cursor_x - cx;
// Fill any area to right of glyph
if (cx + gWidth[gNum] < cursor_x + gxAdvance[gNum]) {
fillRect(cx + gWidth[gNum], cy, (cursor_x + gxAdvance[gNum]) - (cx + gWidth[gNum]), gHeight[gNum], textbgcolor);
}
}
int32_t cgy = cursor_y + gFont.maxAscent - gdY[gNum];
int32_t cgx = cursor_x + gdX[gNum];
for (int32_t y = 0; y < gHeight[gNum]; y++)
{
@ -2534,65 +2458,49 @@ void TFT_eSprite::drawGlyph(uint16_t code)
fontFile.read(pbuffer, gWidth[gNum]);
}
#endif
for (int32_t x = 0; x < gWidth[gNum]; x++)
{
#ifdef FONT_FS_AVAILABLE
if (fs_font) pixel = pbuffer[x];
if (fs_font) {
pixel = pbuffer[x];
}
else
#endif
pixel = pgm_read_byte(gPtr + gBitmap[gNum] + x + gWidth[gNum] * y);
if (pixel)
{
if (bl) { drawFastHLine( bxs, y + cy, bl, bg); bl = 0; }
if (pixel != 0xFF)
{
if (fl) {
if (fl==1) drawPixel(fxs, y + cy, fg);
else drawFastHLine( fxs, y + cy, fl, fg);
fl = 0;
if (dl) { drawFastHLine( xs, y + cgy, dl, fg); dl = 0; }
if (_bpp != 1) {
if (fg == bg) drawPixel(x + cgx, y + cgy, alphaBlend(pixel, fg, readPixel(x + cgx, y + cgy)));
else drawPixel(x + cgx, y + cgy, alphaBlend(pixel, fg, bg));
}
if (getBG) bg = readPixel(x + cx, y + cy);
drawPixel(x + cx, y + cy, alphaBlend(pixel, fg, bg));
else if (pixel>127) drawPixel(x + cgx, y + cgy, fg);
}
else
{
if (fl==0) fxs = x + cx;
fl++;
if (dl==0) xs = x + cgx;
dl++;
}
}
else
{
if (fl) { drawFastHLine( fxs, y + cy, fl, fg); fl = 0; }
if (_fillbg) {
if (x >= bx) {
if (bl==0) bxs = x + cx;
bl++;
}
}
if (dl) { drawFastHLine( xs, y + cgy, dl, fg); dl = 0; }
}
}
if (fl) { drawFastHLine( fxs, y + cy, fl, fg); fl = 0; }
if (bl) { drawFastHLine( bxs, y + cy, bl, bg); bl = 0; }
}
// Fill area below glyph
if (fillwidth > 0) {
fillheight = (cursor_y + gFont.yAdvance) - (cy + gHeight[gNum]);
if (fillheight > 0) {
fillRect(bg_cursor_x, cy + gHeight[gNum], fillwidth, fillheight, textbgcolor);
}
if (dl) { drawFastHLine( xs, y + cgy, dl, fg); dl = 0; }
}
if (pbuffer) free(pbuffer);
cursor_x += gxAdvance[gNum];
if (newSprite)
{
pushSprite(cx, cursor_y);
pushSprite(cgx, cursor_y);
deleteSprite();
}
cursor_x += gxAdvance[gNum];
}
else
{
@ -2600,8 +2508,6 @@ void TFT_eSprite::drawGlyph(uint16_t code)
drawRect(cursor_x, cursor_y + gFont.maxAscent - gFont.ascent, gFont.spaceWidth, gFont.ascent, fg);
cursor_x += gFont.spaceWidth + 1;
}
bg_cursor_x = cursor_x;
last_cursor_x = cursor_x;
}

View File

@ -16,9 +16,9 @@ class TFT_eSprite : public TFT_eSPI {
// Sketch can cast returned value to (uint16_t*) for 16 bit depth if needed
// RAM required is:
// - 1 bit per pixel for 1 bit colour depth
// - 1 nibble per pixel for 4 bit colour (with palette table)
// - 1 byte per pixel for 8 bit colour (332 RGB format)
// - 2 bytes per pixel for 16 bit color depth (565 RGB format)
// - 1 nibble per pixel for 4 bit colour
// - 1 byte per pixel for 8 bit colour
// - 2 bytes per pixel for 16 bit color depth
void* createSprite(int16_t width, int16_t height, uint8_t frames = 1);
// Returns a pointer to the sprite or nullptr if not created, user must cast to pointer type
@ -34,7 +34,7 @@ class TFT_eSprite : public TFT_eSPI {
// Returns a pointer to the Sprite frame buffer
void* frameBuffer(int8_t f);
// Set or get the colour depth to 1, 4, 8 or 16 bits. Can be used to change depth an existing
// Set or get the colour depth to 4, 8 or 16 bits. Can be used to change depth an existing
// sprite, but clears it to black, returns a new pointer if sprite is re-created.
void* setColorDepth(int8_t b);
int8_t getColorDepth(void);
@ -52,11 +52,9 @@ class TFT_eSprite : public TFT_eSPI {
// Set foreground and background colours for 1 bit per pixel Sprite
void setBitmapColor(uint16_t fg, uint16_t bg);
// Draw a single pixel at x,y
void drawPixel(int32_t x, int32_t y, uint32_t color);
// Draw a single character in the GLCD or GFXFF font
void drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uint32_t bg, uint8_t size),
void drawChar(int32_t x, int32_t y, uint16_t c, uint32_t color, uint32_t bg, uint8_t font),
// Fill Sprite with a colour
fillSprite(uint32_t color),
@ -64,18 +62,18 @@ class TFT_eSprite : public TFT_eSPI {
// Define a window to push 16 bit colour pixels into in a raster order
// Colours are converted to the set Sprite colour bit depth
setWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1),
// Push a color (aka singe pixel) to the sprite's set window area
// Push a color (aka singe pixel) to the screen
pushColor(uint16_t color),
// Push len colors (pixels) to the sprite's set window area
// Push len colors (pixels) to the screen
pushColor(uint16_t color, uint32_t len),
// Push a pixel pre-formatted as a 1, 4, 8 or 16 bit colour (avoids conversion overhead)
// Push a pixel preformatted as a 8 or 16 bit colour (avoids conversion overhead)
writeColor(uint16_t color),
// Set the scroll zone, top left corner at x,y with defined width and height
// The colour (optional, black is default) is used to fill the gap after the scroll
setScrollRect(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t color = TFT_BLACK),
// Scroll the defined zone dx,dy pixels. Negative values left,up, positive right,down
// dy is optional (default is 0, so no up/down scroll).
// dy is optional (default is then no up/down scroll).
// The sprite coordinate frame does not move because pixels are moved
scroll(int16_t dx, int16_t dy = 0),
@ -94,9 +92,9 @@ class TFT_eSprite : public TFT_eSPI {
uint8_t getRotation(void);
// Push a rotated copy of Sprite to TFT with optional transparent colour
bool pushRotated(int16_t angle, uint32_t transp = 0x00FFFFFF);
bool pushRotated(int16_t angle, uint32_t transp = 0x00FFFFFF); // Using fixed point maths
// Push a rotated copy of Sprite to another different Sprite with optional transparent colour
bool pushRotated(TFT_eSprite *spr, int16_t angle, uint32_t transp = 0x00FFFFFF);
bool pushRotated(TFT_eSprite *spr, int16_t angle, uint32_t transp = 0x00FFFFFF); // Using fixed point maths
// Get the TFT bounding box for a rotated copy of this Sprite
bool getRotatedBounds(int16_t angle, int16_t *min_x, int16_t *min_y, int16_t *max_x, int16_t *max_y);
@ -127,10 +125,10 @@ class TFT_eSprite : public TFT_eSPI {
bool pushSprite(int32_t tx, int32_t ty, int32_t sx, int32_t sy, int32_t sw, int32_t sh);
// Push the sprite to another sprite at x,y. This fn calls pushImage() in the destination sprite (dspr) class.
// >>>>>> Using a transparent color is not supported at the moment <<<<<<
bool pushToSprite(TFT_eSprite *dspr, int32_t x, int32_t y);
bool pushToSprite(TFT_eSprite *dspr, int32_t x, int32_t y, uint16_t transparent);
// Draw a single character in the selected font
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);
@ -139,13 +137,9 @@ class TFT_eSprite : public TFT_eSPI {
height(void);
// Functions associated with anti-aliased fonts
// Draw a single unicode character using the loaded font
void drawGlyph(uint16_t code);
// Print string to sprite using loaded font at cursor position
void printToSprite(String string);
// Print char array to sprite using loaded font at cursor position
void printToSprite(char *cbuffer, uint16_t len);
// Print indexed glyph to sprite using loaded font at x,y
int16_t printToSprite(int16_t x, int16_t y, uint16_t index);
private:
@ -161,19 +155,19 @@ class TFT_eSprite : public TFT_eSPI {
protected:
uint8_t _bpp; // bits per pixel (1, 4, 8 or 16)
uint8_t _bpp; // bits per pixel (1, 8 or 16)
uint16_t *_img; // pointer to 16 bit sprite
uint8_t *_img8; // pointer to 1 and 8 bit sprite frame 1 or frame 2
uint8_t *_img8; // pointer to 8 bit sprite frame 1 or frame 2
uint8_t *_img4; // pointer to 4 bit sprite (uses color map)
uint8_t *_img8_1; // pointer to frame 1
uint8_t *_img8_2; // pointer to frame 2
uint16_t *_colorMap; // color map pointer: 16 entries, used with 4 bit color map.
uint16_t *_colorMap; // color map: 16 entries, used with 4 bit color map.
int32_t _sinra; // Sine of rotation angle in fixed point
int32_t _cosra; // Cosine of rotation angle in fixed point
int32_t _sinra;
int32_t _cosra;
bool _created; // A Sprite has been created and memory reserved
bool _created; // A Sprite has been created and memory reserved
bool _gFont = false;
int32_t _xs, _ys, _xe, _ye, _xptr, _yptr; // for setWindow
@ -182,7 +176,7 @@ class TFT_eSprite : public TFT_eSPI {
uint32_t _scolor; // gap fill colour for scroll zone
int32_t _iwidth, _iheight; // Sprite memory image bit width and height (swapped during rotations)
int32_t _dwidth, _dheight; // Real sprite width and height (for <8bpp Sprites)
int32_t _dwidth, _dheight; // Real display width and height (for <8bpp Sprites)
int32_t _bitwidth; // Sprite image bit width for drawPixel (for <8bpp Sprites, not swapped)
};

View File

@ -107,8 +107,6 @@ uint16_t TFT_eSPI::getTouchRawZ(void){
end_touch_read_write();
if (tz == 4095) tz = 0;
return (uint16_t)tz;
}

15
Kconfig
View File

@ -212,21 +212,6 @@ menu "TFT_eSPI"
menu "Display SPI config"
depends on !TFT_PARALLEL_8_BIT
choice TFT_SPI_PORT
prompt "SPI port"
default TFT_VSPI_PORT
help
The ESP32 has 2 free SPI ports i.e. VSPI (SPI2) and HSPI (SPI3),
the VSPI is the default. If the VSPI port is in use and pins are
not accessible (e.g. TTGO T-Beam) then use the HSPI port for the
TFT display.
config TFT_VSPI_PORT
bool "VSPI (SPI2)"
config TFT_HSPI_PORT
bool "HSPI (SPI3)"
endchoice
config TFT_MISO
int "TFT MISO pin"
default -1

View File

@ -64,35 +64,29 @@
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: beginSDA - VSPI port only, FPSI port only for S2
** Description: Detach MOSI and attach MISO to SDA for reads
** Function name: beginSDA
** Description: Detach SPI from pin to permit software SPI
***************************************************************************************/
void TFT_eSPI::begin_SDA_Read(void)
{
gpio_set_direction((gpio_num_t)TFT_MOSI, GPIO_MODE_INPUT);
#ifdef CONFIG_IDF_TARGET_ESP32
pinMatrixInAttach(TFT_MOSI, VSPIQ_IN_IDX, false);
#else // S2
pinMatrixInAttach(TFT_MOSI, FSPIQ_IN_IDX, false);
#endif
pinMatrixOutDetach(TFT_MOSI, false, false);
pinMode(TFT_MOSI, INPUT);
pinMatrixInAttach(TFT_MOSI, VSPIQ_IN_IDX, false);
SET_BUS_READ_MODE;
}
/***************************************************************************************
** Function name: endSDA - VSPI port only, FPSI port only for S2
** Description: Attach MOSI to SDA and detach MISO for writes
** Function name: endSDA
** Description: Attach SPI pins after software SPI
***************************************************************************************/
void TFT_eSPI::end_SDA_Read(void)
{
gpio_set_direction((gpio_num_t)TFT_MOSI, GPIO_MODE_OUTPUT);
#ifdef CONFIG_IDF_TARGET_ESP32
pinMatrixOutAttach(TFT_MOSI, VSPID_OUT_IDX, false, false);
#else // S2
pinMatrixOutAttach(TFT_MOSI, FSPID_OUT_IDX, false, false);
#endif
pinMode(TFT_MOSI, OUTPUT);
pinMatrixOutAttach(TFT_MOSI, VSPID_OUT_IDX, false, false);
pinMode(TFT_MISO, INPUT);
pinMatrixInAttach(TFT_MISO, VSPIQ_IN_IDX, false);
SET_BUS_WRITE_MODE;
}
////////////////////////////////////////////////////////////////////////////////////////
#endif // #if defined (TFT_SDA_READ)
////////////////////////////////////////////////////////////////////////////////////////
@ -148,6 +142,7 @@ void TFT_eSPI::busDir(uint32_t mask, uint8_t mode)
pinMode(TFT_D5, mode);
pinMode(TFT_D6, mode);
pinMode(TFT_D7, mode);
return;
}
/***************************************************************************************
@ -520,11 +515,7 @@ void TFT_eSPI::pushSwapBytePixels(const void* data_in, uint32_t len){
** Description: Write a block of pixels of the same colour
***************************************************************************************/
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len){
#if defined (SSD1963_DRIVER)
if ( ((color & 0xF800)>> 8) == ((color & 0x07E0)>> 3) && ((color & 0xF800)>> 8)== ((color & 0x001F)<< 3) )
#else
if ( (color >> 8) == (color & 0x00FF) )
#endif
{ if (!len) return;
tft_Write_16(color);
#if defined (SSD1963_DRIVER)

View File

@ -139,7 +139,6 @@ SPI3_HOST = 2
#define FONT_FS_AVAILABLE
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Define the DC (TFT Data/Command or Register Select (RS))pin drive code
////////////////////////////////////////////////////////////////////////////////////////
@ -152,9 +151,6 @@ SPI3_HOST = 2
#if (TFT_DC >= 0) && (TFT_DC < 32)
#define DC_C GPIO.out_w1tc = (1 << TFT_DC)
#define DC_D GPIO.out_w1ts = (1 << TFT_DC)
#elif (TFT_DC >= 32)
#define DC_C GPIO.out1_w1tc.val = (1 << (TFT_DC- 32))
#define DC_D GPIO.out1_w1ts.val = (1 << (TFT_DC- 32))
#else
#define DC_C
#define DC_D
@ -354,16 +350,16 @@ SPI3_HOST = 2
} \
// Mask for the 8 data bits to set pin directions
#define GPIO_DIR_MASK ((1 << TFT_D0) | (1 << TFT_D1) | (1 << TFT_D2) | (1 << TFT_D3) | (1 << TFT_D4) | (1 << TFT_D5) | (1 << TFT_D6) | (1 << TFT_D7))
#define dir_mask ((1 << TFT_D0) | (1 << TFT_D1) | (1 << TFT_D2) | (1 << TFT_D3) | (1 << TFT_D4) | (1 << TFT_D5) | (1 << TFT_D6) | (1 << TFT_D7))
#if (TFT_WR >= 32)
// Data bits and the write line are cleared sequentially
#define GPIO_OUT_CLR_MASK (GPIO_DIR_MASK); WR_L
#define clr_mask (dir_mask); WR_L
#elif (TFT_WR >= 0)
// Data bits and the write line are cleared to 0 in one step (1.25x faster)
#define GPIO_OUT_CLR_MASK (GPIO_DIR_MASK | (1 << TFT_WR))
#define clr_mask (dir_mask | (1 << TFT_WR))
#else
#define GPIO_OUT_CLR_MASK
#define clr_mask
#endif
// A lookup table is used to set the different bit patterns, this uses 1kByte of RAM
@ -375,14 +371,14 @@ SPI3_HOST = 2
//*/
// Write 8 bits to TFT
#define tft_Write_8(C) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t)(C)); WR_H
#define tft_Write_8(C) GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t)(C)); WR_H
#if defined (SSD1963_DRIVER)
// Write 18 bit color to TFT
#define tft_Write_16(C) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0xF800)>> 8)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0x07E0)>> 3)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0x001F)<< 3)); WR_H
#define tft_Write_16(C) GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0xF800)>> 8)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0x07E0)>> 3)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0x001F)<< 3)); WR_H
// 18 bit color write with swapped bytes
#define tft_Write_16S(C) Cswap = ((C) >>8 | (C) << 8); tft_Write_16(Cswap)
@ -391,37 +387,37 @@ SPI3_HOST = 2
#ifdef PSEUDO_16_BIT
// One write strobe for both bytes
#define tft_Write_16(C) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H
#define tft_Write_16S(C) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H
#define tft_Write_16(C) GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H
#define tft_Write_16S(C) GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H
#else
// Write 16 bits to TFT
#define tft_Write_16(C) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H
#define tft_Write_16(C) GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H
// 16 bit write with swapped bytes
#define tft_Write_16S(C) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H
#define tft_Write_16S(C) GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H
#endif
#endif
// Write 32 bits to TFT
#define tft_Write_32(C) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 24)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 16)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H
#define tft_Write_32(C) GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 24)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 16)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H
// Write two concatenated 16 bit values to TFT
#define tft_Write_32C(C,D) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((D) >> 8)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((D) >> 0)); WR_H
#define tft_Write_32C(C,D) GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((D) >> 8)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((D) >> 0)); WR_H
// Write 16 bit value twice to TFT - used by drawPixel()
#define tft_Write_32D(C) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H
#define tft_Write_32D(C) GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc = clr_mask; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H
// Read pin
#ifdef TFT_RD

View File

@ -1,857 +0,0 @@
////////////////////////////////////////////////////
// TFT_eSPI driver functions for ESP32 processors //
////////////////////////////////////////////////////
// Temporarily a separate file to TFT_eSPI_ESP32.c until board package low level API stabilises
////////////////////////////////////////////////////////////////////////////////////////
// Global variables
////////////////////////////////////////////////////////////////////////////////////////
// Select the SPI port to use, ESP32 has 2 options
#if !defined (TFT_PARALLEL_8_BIT)
#ifdef CONFIG_IDF_TARGET_ESP32
#ifdef USE_HSPI_PORT
SPIClass spi = SPIClass(HSPI);
#elif defined(USE_FSPI_PORT)
SPIClass spi = SPIClass(FSPI);
#else // use default VSPI port
SPIClass spi = SPIClass(VSPI);
#endif
#else
#ifdef USE_HSPI_PORT
SPIClass spi = SPIClass(HSPI);
#elif defined(USE_FSPI_PORT)
SPIClass spi = SPIClass(FSPI);
#else // use FSPI port
SPIClass& spi = SPI;
#endif
#endif
#endif
#ifdef ESP32_DMA
// DMA SPA handle
spi_device_handle_t dmaHAL;
#ifdef CONFIG_IDF_TARGET_ESP32
#define DMA_CHANNEL 1
#ifdef USE_HSPI_PORT
spi_host_device_t spi_host = HSPI_HOST;
#elif defined(USE_FSPI_PORT)
spi_host_device_t spi_host = SPI_HOST;
#else // use VSPI port
spi_host_device_t spi_host = VSPI_HOST;
#endif
#else
#ifdef USE_HSPI_PORT
#define DMA_CHANNEL 2
spi_host_device_t spi_host = (spi_host_device_t) DMA_CHANNEL; // Draws once then freezes
#else // use FSPI port
#define DMA_CHANNEL 1
spi_host_device_t spi_host = (spi_host_device_t) DMA_CHANNEL; // Draws once then freezes
#endif
#endif
#endif
#if !defined (TFT_PARALLEL_8_BIT)
// Volatile for register reads:
volatile uint32_t* _spi_cmd = (volatile uint32_t*)(SPI_CMD_REG(SPI_PORT));
volatile uint32_t* _spi_user = (volatile uint32_t*)(SPI_USER_REG(SPI_PORT));
// Register writes only:
volatile uint32_t* _spi_mosi_dlen = (volatile uint32_t*)(SPI_MOSI_DLEN_REG(SPI_PORT));
volatile uint32_t* _spi_w = (volatile uint32_t*)(SPI_W0_REG(SPI_PORT));
#endif
////////////////////////////////////////////////////////////////////////////////////////
#if defined (TFT_SDA_READ) && !defined (TFT_PARALLEL_8_BIT)
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: beginSDA - FPSI port only
** Description: Detach MOSI and attach MISO to SDA for reads
***************************************************************************************/
void TFT_eSPI::begin_SDA_Read(void)
{
gpio_set_direction((gpio_num_t)TFT_MOSI, GPIO_MODE_INPUT);
pinMatrixInAttach(TFT_MOSI, FSPIQ_IN_IDX, false);
SET_BUS_READ_MODE;
}
/***************************************************************************************
** Function name: endSDA - FPSI port only
** Description: Attach MOSI to SDA and detach MISO for writes
***************************************************************************************/
void TFT_eSPI::end_SDA_Read(void)
{
gpio_set_direction((gpio_num_t)TFT_MOSI, GPIO_MODE_OUTPUT);
pinMatrixOutAttach(TFT_MOSI, FSPID_OUT_IDX, false, false);
SET_BUS_WRITE_MODE;
}
////////////////////////////////////////////////////////////////////////////////////////
#endif // #if defined (TFT_SDA_READ)
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: read byte - supports class functions
** Description: Read a byte from ESP32 8 bit data port
***************************************************************************************/
// Parallel bus MUST be set to input before calling this function!
uint8_t TFT_eSPI::readByte(void)
{
uint8_t b = 0xAA;
#if defined (TFT_PARALLEL_8_BIT)
RD_L;
uint32_t reg; // Read all GPIO pins 0-31
reg = gpio_input_get(); // Read three times to allow for bus access time
reg = gpio_input_get();
reg = gpio_input_get(); // Data should be stable now
RD_H;
// Check GPIO bits used and build value
b = (((reg>>TFT_D0)&1) << 0);
b |= (((reg>>TFT_D1)&1) << 1);
b |= (((reg>>TFT_D2)&1) << 2);
b |= (((reg>>TFT_D3)&1) << 3);
b |= (((reg>>TFT_D4)&1) << 4);
b |= (((reg>>TFT_D5)&1) << 5);
b |= (((reg>>TFT_D6)&1) << 6);
b |= (((reg>>TFT_D7)&1) << 7);
#endif
return b;
}
////////////////////////////////////////////////////////////////////////////////////////
#ifdef TFT_PARALLEL_8_BIT
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: GPIO direction control - supports class functions
** Description: Set parallel bus to INPUT or OUTPUT
***************************************************************************************/
void TFT_eSPI::busDir(uint32_t mask, uint8_t mode)
{
// Arduino generic native function
pinMode(TFT_D0, mode);
pinMode(TFT_D1, mode);
pinMode(TFT_D2, mode);
pinMode(TFT_D3, mode);
pinMode(TFT_D4, mode);
pinMode(TFT_D5, mode);
pinMode(TFT_D6, mode);
pinMode(TFT_D7, mode);
}
/***************************************************************************************
** Function name: GPIO direction control - supports class functions
** Description: Set ESP32 GPIO pin to input or output (set high) ASAP
***************************************************************************************/
void TFT_eSPI::gpioMode(uint8_t gpio, uint8_t mode)
{
pinMode(gpio, mode);
digitalWrite(gpio, HIGH);
}
////////////////////////////////////////////////////////////////////////////////////////
#endif // #ifdef TFT_PARALLEL_8_BIT
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
#if defined (RPI_WRITE_STROBE) && !defined (TFT_PARALLEL_8_BIT) // Code for RPi TFT
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: pushBlock - for ESP32 or ESP8266 RPi TFT
** Description: Write a block of pixels of the same colour
***************************************************************************************/
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len)
{
uint8_t colorBin[] = { (uint8_t) (color >> 8), (uint8_t) color };
if(len) spi.writePattern(&colorBin[0], 2, 1); len--;
while(len--) {WR_L; WR_H;}
}
/***************************************************************************************
** Function name: pushPixels - for ESP32 or ESP8266 RPi TFT
** Description: Write a sequence of pixels
***************************************************************************************/
void TFT_eSPI::pushPixels(const void* data_in, uint32_t len)
{
uint8_t *data = (uint8_t*)data_in;
if(_swapBytes) {
while ( len-- ) {tft_Write_16(*data); data++;}
return;
}
while ( len >=64 ) {spi.writePattern(data, 64, 1); data += 64; len -= 64; }
if (len) spi.writePattern(data, len, 1);
}
////////////////////////////////////////////////////////////////////////////////////////
#elif !defined (SPI_18BIT_DRIVER) && !defined (TFT_PARALLEL_8_BIT) // Most SPI displays
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: pushBlock - for ESP32
** Description: Write a block of pixels of the same colour
***************************************************************************************/
/*
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len){
uint32_t color32 = (color<<8 | color >>8)<<16 | (color<<8 | color >>8);
bool empty = true;
volatile uint32_t* spi_w = (volatile uint32_t*)_spi_w;
if (len > 31)
{
*_spi_mosi_dlen = 511;
spi_w[0] = color32;
spi_w[1] = color32;
spi_w[2] = color32;
spi_w[3] = color32;
spi_w[4] = color32;
spi_w[5] = color32;
spi_w[6] = color32;
spi_w[7] = color32;
spi_w[8] = color32;
spi_w[9] = color32;
spi_w[10] = color32;
spi_w[11] = color32;
spi_w[12] = color32;
spi_w[13] = color32;
spi_w[14] = color32;
spi_w[15] = color32;
while(len>31)
{
while ((*_spi_cmd)&SPI_USR);
*_spi_cmd = SPI_USR;
len -= 32;
}
empty = false;
}
if (len)
{
if(empty) {
for (uint32_t i=0; i <= len; i+=2) *spi_w++ = color32;
}
len = (len << 4) - 1;
while (*_spi_cmd&SPI_USR);
*_spi_mosi_dlen = len;
*_spi_cmd = SPI_USR;
}
while ((*_spi_cmd)&SPI_USR); // Move to later in code to use transmit time usefully?
}
//*/
//*
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len){
volatile uint32_t* spi_w = _spi_w;
uint32_t color32 = (color<<8 | color >>8)<<16 | (color<<8 | color >>8);
uint32_t i = 0;
uint32_t rem = len & 0x1F;
len = len - rem;
// Start with partial buffer pixels
if (rem)
{
while (*_spi_cmd&SPI_USR);
for (i=0; i < rem; i+=2) *spi_w++ = color32;
*_spi_mosi_dlen = (rem << 4) - 1;
#if CONFIG_IDF_TARGET_ESP32C3
*_spi_cmd = SPI_UPDATE;
while (*_spi_cmd & SPI_UPDATE);
#endif
*_spi_cmd = SPI_USR;
if (!len) return; //{while (*_spi_cmd&SPI_USR); return; }
i = i>>1; while(i++<16) *spi_w++ = color32;
}
while (*_spi_cmd&SPI_USR);
if (!rem) while (i++<16) *spi_w++ = color32;
*_spi_mosi_dlen = 511;
// End with full buffer to maximise useful time for downstream code
while(len)
{
while (*_spi_cmd&SPI_USR);
#if CONFIG_IDF_TARGET_ESP32C3
*_spi_cmd = SPI_UPDATE;
while (*_spi_cmd & SPI_UPDATE);
#endif
*_spi_cmd = SPI_USR;
len -= 32;
}
// Do not wait here
//while (*_spi_cmd&SPI_USR);
}
//*/
/***************************************************************************************
** Function name: pushSwapBytePixels - for ESP32
** Description: Write a sequence of pixels with swapped bytes
***************************************************************************************/
void TFT_eSPI::pushSwapBytePixels(const void* data_in, uint32_t len){
uint8_t* data = (uint8_t*)data_in;
uint32_t color[16];
if (len > 31)
{
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 511);
while(len>31)
{
uint32_t i = 0;
while(i<16)
{
color[i++] = DAT8TO32(data);
data+=4;
}
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), color[0]);
WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), color[1]);
WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), color[2]);
WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), color[3]);
WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), color[4]);
WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), color[5]);
WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), color[6]);
WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), color[7]);
WRITE_PERI_REG(SPI_W8_REG(SPI_PORT), color[8]);
WRITE_PERI_REG(SPI_W9_REG(SPI_PORT), color[9]);
WRITE_PERI_REG(SPI_W10_REG(SPI_PORT), color[10]);
WRITE_PERI_REG(SPI_W11_REG(SPI_PORT), color[11]);
WRITE_PERI_REG(SPI_W12_REG(SPI_PORT), color[12]);
WRITE_PERI_REG(SPI_W13_REG(SPI_PORT), color[13]);
WRITE_PERI_REG(SPI_W14_REG(SPI_PORT), color[14]);
WRITE_PERI_REG(SPI_W15_REG(SPI_PORT), color[15]);
#if CONFIG_IDF_TARGET_ESP32C3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
len -= 32;
}
}
if (len > 15)
{
uint32_t i = 0;
while(i<8)
{
color[i++] = DAT8TO32(data);
data+=4;
}
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 255);
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), color[0]);
WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), color[1]);
WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), color[2]);
WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), color[3]);
WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), color[4]);
WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), color[5]);
WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), color[6]);
WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), color[7]);
#if CONFIG_IDF_TARGET_ESP32C3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
len -= 16;
}
if (len)
{
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), (len << 4) - 1);
for (uint32_t i=0; i <= (len<<1); i+=4) {
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT)+i, DAT8TO32(data)); data+=4;
}
#if CONFIG_IDF_TARGET_ESP32C3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
}
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
}
/***************************************************************************************
** Function name: pushPixels - for ESP32
** Description: Write a sequence of pixels
***************************************************************************************/
void TFT_eSPI::pushPixels(const void* data_in, uint32_t len){
if(_swapBytes) {
pushSwapBytePixels(data_in, len);
return;
}
uint32_t *data = (uint32_t*)data_in;
if (len > 31)
{
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 511);
while(len>31)
{
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W8_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W9_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W10_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W11_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W12_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W13_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W14_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W15_REG(SPI_PORT), *data++);
#if CONFIG_IDF_TARGET_ESP32C3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
len -= 32;
}
}
if (len)
{
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), (len << 4) - 1);
for (uint32_t i=0; i <= (len<<1); i+=4) WRITE_PERI_REG((SPI_W0_REG(SPI_PORT) + i), *data++);
#if CONFIG_IDF_TARGET_ESP32C3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
}
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
}
////////////////////////////////////////////////////////////////////////////////////////
#elif defined (SPI_18BIT_DRIVER) // SPI 18 bit colour
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: pushBlock - for ESP32 and 3 byte RGB display
** Description: Write a block of pixels of the same colour
***************************************************************************************/
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len)
{
// Split out the colours
uint32_t r = (color & 0xF800)>>8;
uint32_t g = (color & 0x07E0)<<5;
uint32_t b = (color & 0x001F)<<19;
// Concatenate 4 pixels into three 32 bit blocks
uint32_t r0 = r<<24 | b | g | r;
uint32_t r1 = r0>>8 | g<<16;
uint32_t r2 = r1>>8 | b<<8;
if (len > 19)
{
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 479);
while(len>19)
{
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W8_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W9_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W10_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W11_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W12_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W13_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W14_REG(SPI_PORT), r2);
#if CONFIG_IDF_TARGET_ESP32C3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
len -= 20;
}
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
}
if (len)
{
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), (len * 24) - 1);
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), r2);
if (len > 8 )
{
WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W8_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W9_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W10_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W11_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W12_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W13_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W14_REG(SPI_PORT), r2);
}
#if CONFIG_IDF_TARGET_ESP32C3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
}
}
/***************************************************************************************
** Function name: pushPixels - for ESP32 and 3 byte RGB display
** Description: Write a sequence of pixels
***************************************************************************************/
void TFT_eSPI::pushPixels(const void* data_in, uint32_t len){
uint16_t *data = (uint16_t*)data_in;
// ILI9488 write macro is not endianess dependant, hence !_swapBytes
if(!_swapBytes) { while ( len-- ) {tft_Write_16S(*data); data++;} }
else { while ( len-- ) {tft_Write_16(*data); data++;} }
}
/***************************************************************************************
** Function name: pushSwapBytePixels - for ESP32 and 3 byte RGB display
** Description: Write a sequence of pixels with swapped bytes
***************************************************************************************/
void TFT_eSPI::pushSwapBytePixels(const void* data_in, uint32_t len){
uint16_t *data = (uint16_t*)data_in;
// ILI9488 write macro is not endianess dependant, so swap byte macro not used here
while ( len-- ) {tft_Write_16(*data); data++;}
}
////////////////////////////////////////////////////////////////////////////////////////
#elif defined (TFT_PARALLEL_8_BIT) // Now the code for ESP32 8 bit parallel
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: pushBlock - for ESP32 and parallel display
** Description: Write a block of pixels of the same colour
***************************************************************************************/
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len){
if ( (color >> 8) == (color & 0x00FF) )
{ if (!len) return;
tft_Write_16(color);
#if defined (SSD1963_DRIVER)
while (--len) {WR_L; WR_H; WR_L; WR_H; WR_L; WR_H;}
#else
#ifdef PSEUDO_16_BIT
while (--len) {WR_L; WR_H;}
#else
while (--len) {WR_L; WR_H; WR_L; WR_H;}
#endif
#endif
}
else while (len--) {tft_Write_16(color);}
}
/***************************************************************************************
** Function name: pushSwapBytePixels - for ESP32 and parallel display
** Description: Write a sequence of pixels with swapped bytes
***************************************************************************************/
void TFT_eSPI::pushSwapBytePixels(const void* data_in, uint32_t len){
uint16_t *data = (uint16_t*)data_in;
while ( len-- ) {tft_Write_16(*data); data++;}
}
/***************************************************************************************
** Function name: pushPixels - for ESP32 and parallel display
** Description: Write a sequence of pixels
***************************************************************************************/
void TFT_eSPI::pushPixels(const void* data_in, uint32_t len){
uint16_t *data = (uint16_t*)data_in;
if(_swapBytes) { while ( len-- ) {tft_Write_16(*data); data++; } }
else { while ( len-- ) {tft_Write_16S(*data); data++;} }
}
////////////////////////////////////////////////////////////////////////////////////////
#endif // End of display interface specific functions
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
#if defined (ESP32_DMA) && !defined (TFT_PARALLEL_8_BIT) // DMA FUNCTIONS
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: dmaBusy
** Description: Check if DMA is busy
***************************************************************************************/
bool TFT_eSPI::dmaBusy(void)
{
if (!DMA_Enabled || !spiBusyCheck) return false;
spi_transaction_t *rtrans;
esp_err_t ret;
uint8_t checks = spiBusyCheck;
for (int i = 0; i < checks; ++i)
{
ret = spi_device_get_trans_result(dmaHAL, &rtrans, 0);
if (ret == ESP_OK) spiBusyCheck--;
}
//Serial.print("spiBusyCheck=");Serial.println(spiBusyCheck);
if (spiBusyCheck ==0) return false;
return true;
}
/***************************************************************************************
** Function name: dmaWait
** Description: Wait until DMA is over (blocking!)
***************************************************************************************/
void TFT_eSPI::dmaWait(void)
{
if (!DMA_Enabled || !spiBusyCheck) return;
spi_transaction_t *rtrans;
esp_err_t ret;
for (int i = 0; i < spiBusyCheck; ++i)
{
ret = spi_device_get_trans_result(dmaHAL, &rtrans, portMAX_DELAY);
assert(ret == ESP_OK);
}
spiBusyCheck = 0;
}
/***************************************************************************************
** Function name: pushPixelsDMA
** Description: Push pixels to TFT (len must be less than 32767)
***************************************************************************************/
// This will byte swap the original image if setSwapBytes(true) was called by sketch.
void TFT_eSPI::pushPixelsDMA(uint16_t* image, uint32_t len)
{
if ((len == 0) || (!DMA_Enabled)) return;
dmaWait();
if(_swapBytes) {
for (uint32_t i = 0; i < len; i++) (image[i] = image[i] << 8 | image[i] >> 8);
}
esp_err_t ret;
static spi_transaction_t trans;
memset(&trans, 0, sizeof(spi_transaction_t));
trans.user = (void *)1;
trans.tx_buffer = image; //finally send the line data
trans.length = len * 16; //Data length, in bits
trans.flags = 0; //SPI_TRANS_USE_TXDATA flag
ret = spi_device_queue_trans(dmaHAL, &trans, portMAX_DELAY);
assert(ret == ESP_OK);
spiBusyCheck++;
}
/***************************************************************************************
** Function name: pushImageDMA
** Description: Push image to a window (w*h must be less than 65536)
***************************************************************************************/
// Fixed const data assumed, will NOT clip or swap bytes
void TFT_eSPI::pushImageDMA(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t const* image)
{
if ((w == 0) || (h == 0) || (!DMA_Enabled)) return;
uint32_t len = w*h;
dmaWait();
setAddrWindow(x, y, w, h);
esp_err_t ret;
static spi_transaction_t trans;
memset(&trans, 0, sizeof(spi_transaction_t));
trans.user = (void *)1;
trans.tx_buffer = image; //Data pointer
trans.length = len * 16; //Data length, in bits
trans.flags = 0; //SPI_TRANS_USE_TXDATA flag
ret = spi_device_queue_trans(dmaHAL, &trans, portMAX_DELAY);
assert(ret == ESP_OK);
spiBusyCheck++;
}
/***************************************************************************************
** Function name: pushImageDMA
** Description: Push image to a window (w*h must be less than 65536)
***************************************************************************************/
// This will clip and also swap bytes if setSwapBytes(true) was called by sketch
void TFT_eSPI::pushImageDMA(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t* image, uint16_t* buffer)
{
if ((x >= _vpW) || (y >= _vpH) || (!DMA_Enabled)) return;
int32_t dx = 0;
int32_t dy = 0;
int32_t dw = w;
int32_t dh = h;
if (x < _vpX) { dx = _vpX - x; dw -= dx; x = _vpX; }
if (y < _vpY) { dy = _vpY - y; dh -= dy; y = _vpY; }
if ((x + dw) > _vpW ) dw = _vpW - x;
if ((y + dh) > _vpH ) dh = _vpH - y;
if (dw < 1 || dh < 1) return;
uint32_t len = dw*dh;
if (buffer == nullptr) {
buffer = image;
dmaWait();
}
// If image is clipped, copy pixels into a contiguous block
if ( (dw != w) || (dh != h) ) {
if(_swapBytes) {
for (int32_t yb = 0; yb < dh; yb++) {
for (int32_t xb = 0; xb < dw; xb++) {
uint32_t src = xb + dx + w * (yb + dy);
(buffer[xb + yb * dw] = image[src] << 8 | image[src] >> 8);
}
}
}
else {
for (int32_t yb = 0; yb < dh; yb++) {
memcpy((uint8_t*) (buffer + yb * dw), (uint8_t*) (image + dx + w * (yb + dy)), dw << 1);
}
}
}
// else, if a buffer pointer has been provided copy whole image to the buffer
else if (buffer != image || _swapBytes) {
if(_swapBytes) {
for (uint32_t i = 0; i < len; i++) (buffer[i] = image[i] << 8 | image[i] >> 8);
}
else {
memcpy(buffer, image, len*2);
}
}
if (spiBusyCheck) dmaWait(); // In case we did not wait earlier
setAddrWindow(x, y, dw, dh);
esp_err_t ret;
static spi_transaction_t trans;
memset(&trans, 0, sizeof(spi_transaction_t));
trans.user = (void *)1;
trans.tx_buffer = buffer; //finally send the line data
trans.length = len * 16; //Data length, in bits
trans.flags = 0; //SPI_TRANS_USE_TXDATA flag
ret = spi_device_queue_trans(dmaHAL, &trans, portMAX_DELAY);
assert(ret == ESP_OK);
spiBusyCheck++;
}
////////////////////////////////////////////////////////////////////////////////////////
// Processor specific DMA initialisation
////////////////////////////////////////////////////////////////////////////////////////
// The DMA functions here work with SPI only (not parallel)
/***************************************************************************************
** Function name: dc_callback
** Description: Toggles DC line during transaction
***************************************************************************************/
extern "C" void dc_callback();
void IRAM_ATTR dc_callback(spi_transaction_t *spi_tx)
{
if ((bool)spi_tx->user) {DC_D;}
else {DC_C;}
}
/***************************************************************************************
** Function name: initDMA
** Description: Initialise the DMA engine - returns true if init OK
***************************************************************************************/
bool TFT_eSPI::initDMA(bool ctrl_cs)
{
if (DMA_Enabled) return false;
esp_err_t ret;
spi_bus_config_t buscfg = {
.mosi_io_num = TFT_MOSI,
.miso_io_num = TFT_MISO,
.sclk_io_num = TFT_SCLK,
.quadwp_io_num = -1,
.quadhd_io_num = -1,
.max_transfer_sz = TFT_WIDTH * TFT_HEIGHT * 2 + 8, // TFT screen size
.flags = 0,
.intr_flags = 0
};
int8_t pin = -1;
if (ctrl_cs) pin = TFT_CS;
spi_device_interface_config_t devcfg = {
.command_bits = 0,
.address_bits = 0,
.dummy_bits = 0,
.mode = TFT_SPI_MODE,
.duty_cycle_pos = 0,
.cs_ena_pretrans = 0,
.cs_ena_posttrans = 0,
.clock_speed_hz = SPI_FREQUENCY,
.input_delay_ns = 0,
.spics_io_num = pin,
.flags = SPI_DEVICE_NO_DUMMY, //0,
.queue_size = 1,
.pre_cb = 0, //dc_callback, //Callback to handle D/C line
.post_cb = 0
};
ret = spi_bus_initialize(spi_host, &buscfg, DMA_CHANNEL);
ESP_ERROR_CHECK(ret);
ret = spi_bus_add_device(spi_host, &devcfg, &dmaHAL);
ESP_ERROR_CHECK(ret);
DMA_Enabled = true;
spiBusyCheck = 0;
return true;
}
/***************************************************************************************
** Function name: deInitDMA
** Description: Disconnect the DMA engine from SPI
***************************************************************************************/
void TFT_eSPI::deInitDMA(void)
{
if (!DMA_Enabled) return;
spi_bus_remove_device(dmaHAL);
spi_bus_free(spi_host);
DMA_Enabled = false;
}
////////////////////////////////////////////////////////////////////////////////////////
#endif // End of DMA FUNCTIONS
////////////////////////////////////////////////////////////////////////////////////////

View File

@ -1,597 +0,0 @@
////////////////////////////////////////////////////
// TFT_eSPI driver functions for ESP32 processors //
////////////////////////////////////////////////////
// Temporarily a separate file to TFT_eSPI_ESP32.h until board package low level API stabilises
#ifndef _TFT_eSPI_ESP32H_
#define _TFT_eSPI_ESP32H_
#if !defined(DISABLE_ALL_LIBRARY_WARNINGS)
#warning >>>>------>> DMA is not supported on the ESP32 C3 (possible future update)
#endif
// Processor ID reported by getSetup()
#define PROCESSOR_ID 0x32
// Include processor specific header
#include "soc/spi_reg.h"
#include "driver/spi_master.h"
#if !defined(CONFIG_IDF_TARGET_ESP32C3) && !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32)
#define CONFIG_IDF_TARGET_ESP32
#endif
#ifndef VSPI
#define VSPI FSPI
#endif
// Fix IDF problems with ESP32C3
#if CONFIG_IDF_TARGET_ESP32C3
// Fix ESP32C3 IDF bug for missing definition (VSPI/FSPI only tested at the moment)
#ifndef REG_SPI_BASE
#define REG_SPI_BASE(i) DR_REG_SPI2_BASE
#endif
// Fix ESP32C3 IDF bug for name change
#ifndef SPI_MOSI_DLEN_REG
#define SPI_MOSI_DLEN_REG(x) SPI_MS_DLEN_REG(x)
#endif
#endif
// SUPPORT_TRANSACTIONS is mandatory for ESP32 so the hal mutex is toggled
#if !defined (SUPPORT_TRANSACTIONS)
#define SUPPORT_TRANSACTIONS
#endif
/*
ESP32:
FSPI not defined
HSPI = 2, uses SPI2
VSPI = 3, uses SPI3
ESP32-S2:
FSPI = 1, uses SPI2
HSPI = 2, uses SPI3
VSPI not defined so have made VSPI = HSPI
ESP32 C3: Only 1 SPI port available
FSPI = 1, uses SPI2
HSPI = 1, uses SPI2
VSPI not defined so have made VSPI = HSPI
For ESP32/S2/C3:
SPI1_HOST = 0
SPI2_HOST = 1
SPI3_HOST = 2
*/
// ESP32 specific SPI port selection - only SPI2_HOST available on C3
#define SPI_PORT SPI2_HOST
#ifdef RPI_DISPLAY_TYPE
#define CMD_BITS (16-1)
#else
#define CMD_BITS (8-1)
#endif
// Initialise processor specific SPI functions, used by init()
#define INIT_TFT_DATA_BUS // Not used
// Define a generic flag for 8 bit parallel
#if defined (ESP32_PARALLEL) // Specific to ESP32 for backwards compatibility
#if !defined (TFT_PARALLEL_8_BIT)
#define TFT_PARALLEL_8_BIT // Generic parallel flag
#endif
#endif
// Ensure ESP32 specific flag is defined for 8 bit parallel
#if defined (TFT_PARALLEL_8_BIT)
#if !defined (ESP32_PARALLEL)
#define ESP32_PARALLEL
#endif
#endif
// Processor specific code used by SPI bus transaction startWrite and endWrite functions
#if !defined (ESP32_PARALLEL)
#if (TFT_SPI_MODE == SPI_MODE1) || (TFT_SPI_MODE == SPI_MODE2)
#define SET_BUS_WRITE_MODE *_spi_user = SPI_USR_MOSI | SPI_CK_OUT_EDGE
#define SET_BUS_READ_MODE *_spi_user = SPI_USR_MOSI | SPI_USR_MISO | SPI_DOUTDIN | SPI_CK_OUT_EDGE
#else
#define SET_BUS_WRITE_MODE *_spi_user = SPI_USR_MOSI
#define SET_BUS_READ_MODE *_spi_user = SPI_USR_MOSI | SPI_USR_MISO | SPI_DOUTDIN
#endif
#else
// Not applicable to parallel bus
#define SET_BUS_WRITE_MODE
#define SET_BUS_READ_MODE
#endif
// Code to check if DMA is busy, used by SPI bus transaction transaction and endWrite functions
#if !defined(TFT_PARALLEL_8_BIT) && !defined(SPI_18BIT_DRIVER)
#define ESP32_DMA
// Code to check if DMA is busy, used by SPI DMA + transaction + endWrite functions
#define DMA_BUSY_CHECK dmaWait()
#else
#define DMA_BUSY_CHECK
#endif
#if defined(TFT_PARALLEL_8_BIT)
#define SPI_BUSY_CHECK
#else
#define SPI_BUSY_CHECK while (*_spi_cmd&SPI_USR)
#endif
// If smooth font is used then it is likely SPIFFS will be needed
#ifdef SMOOTH_FONT
// Call up the SPIFFS (SPI FLASH Filing System) for the anti-aliased fonts
#define FS_NO_GLOBALS
#include <FS.h>
#include "SPIFFS.h" // ESP32 only
#define FONT_FS_AVAILABLE
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Define the DC (TFT Data/Command or Register Select (RS))pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#ifndef TFT_DC
#define DC_C // No macro allocated so it generates no code
#define DC_D // No macro allocated so it generates no code
#else
#if defined (TFT_PARALLEL_8_BIT)
// TFT_DC, by design, must be in range 0-31 for single register parallel write
#if (TFT_DC >= 0) && (TFT_DC < 32)
#define DC_C GPIO.out_w1tc.val = (1 << TFT_DC)
#define DC_D GPIO.out_w1ts.val = (1 << TFT_DC)
#elif (TFT_DC >= 32)
#define DC_C GPIO.out_w1tc.val = (1 << (TFT_DC- 32))
#define DC_D GPIO.out_w1ts.val = (1 << (TFT_DC- 32))
#else
#define DC_C
#define DC_D
#endif
#else
#if (TFT_DC >= 32)
#ifdef RPI_DISPLAY_TYPE // RPi displays need a slower DC change
#define DC_C GPIO.out_w1ts.val = (1 << (TFT_DC - 32)); \
GPIO.out_w1tc.val = (1 << (TFT_DC - 32))
#define DC_D GPIO.out_w1tc.val = (1 << (TFT_DC - 32)); \
GPIO.out_w1ts.val = (1 << (TFT_DC - 32))
#else
#define DC_C GPIO.out_w1tc.val = (1 << (TFT_DC - 32))//;GPIO.out_w1tc.val = (1 << (TFT_DC - 32))
#define DC_D GPIO.out_w1ts.val = (1 << (TFT_DC - 32))//;GPIO.out_w1ts.val = (1 << (TFT_DC - 32))
#endif
#elif (TFT_DC >= 0)
#if defined (RPI_DISPLAY_TYPE)
#if defined (ILI9486_DRIVER)
// RPi ILI9486 display needs a slower DC change
#define DC_C GPIO.out_w1tc.val = (1 << TFT_DC); \
GPIO.out_w1tc.val = (1 << TFT_DC)
#define DC_D GPIO.out_w1tc.val = (1 << TFT_DC); \
GPIO.out_w1ts.val = (1 << TFT_DC)
#else
// Other RPi displays need a slower C->D change
#define DC_C GPIO.out_w1tc.val = (1 << TFT_DC)
#define DC_D GPIO.out_w1tc.val = (1 << TFT_DC); \
GPIO.out_w1ts.val = (1 << TFT_DC)
#endif
#else
#define DC_C GPIO.out_w1tc.val = (1 << TFT_DC)//;GPIO.out_w1tc.val = (1 << TFT_DC)
#define DC_D GPIO.out_w1ts.val = (1 << TFT_DC)//;GPIO.out_w1ts.val = (1 << TFT_DC)
#endif
#else
#define DC_C
#define DC_D
#endif
#endif
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Define the CS (TFT chip select) pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#ifndef TFT_CS
#define TFT_CS -1 // Keep DMA code happy
#define CS_L // No macro allocated so it generates no code
#define CS_H // No macro allocated so it generates no code
#else
#if defined (TFT_PARALLEL_8_BIT)
#if TFT_CS >= 32
#define CS_L GPIO.out_w1tc.val = (1 << (TFT_CS - 32))
#define CS_H GPIO.out_w1ts.val = (1 << (TFT_CS - 32))
#elif TFT_CS >= 0
#define CS_L GPIO.out_w1tc.val = (1 << TFT_CS)
#define CS_H GPIO.out_w1ts.val = (1 << TFT_CS)
#else
#define CS_L
#define CS_H
#endif
#else
#if (TFT_CS >= 32)
#ifdef RPI_DISPLAY_TYPE // RPi display needs a slower CS change
#define CS_L GPIO.out_w1ts.val = (1 << (TFT_CS - 32)); \
GPIO.out_w1tc.val = (1 << (TFT_CS - 32))
#define CS_H GPIO.out_w1tc.val = (1 << (TFT_CS - 32)); \
GPIO.out_w1ts.val = (1 << (TFT_CS - 32))
#else
#define CS_L GPIO.out_w1tc.val = (1 << (TFT_CS - 32)); GPIO.out_w1tc.val = (1 << (TFT_CS - 32))
#define CS_H GPIO.out_w1ts.val = (1 << (TFT_CS - 32))//;GPIO.out_w1ts.val = (1 << (TFT_CS - 32))
#endif
#elif (TFT_CS >= 0)
#ifdef RPI_DISPLAY_TYPE // RPi display needs a slower CS change
#define CS_L GPIO.out_w1ts.val = (1 << TFT_CS); GPIO.out_w1tc.val = (1 << TFT_CS)
#define CS_H GPIO.out_w1tc.val = (1 << TFT_CS); GPIO.out_w1ts.val = (1 << TFT_CS)
#else
#define CS_L GPIO.out_w1tc.val = (1 << TFT_CS); GPIO.out_w1tc.val = (1 << TFT_CS)
#define CS_H GPIO.out_w1ts.val = (1 << TFT_CS)//;GPIO.out_w1ts.val = (1 << TFT_CS)
#endif
#else
#define CS_L
#define CS_H
#endif
#endif
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Define the WR (TFT Write) pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#if defined (TFT_WR)
#if (TFT_WR >= 32)
// Note: it will be ~1.25x faster if the TFT_WR pin uses a GPIO pin lower than 32
#define WR_L GPIO.out_w1tc.val = (1 << (TFT_WR - 32))
#define WR_H GPIO.out_w1ts.val = (1 << (TFT_WR - 32))
#elif (TFT_WR >= 0)
// TFT_WR, for best performance, should be in range 0-31 for single register parallel write
#define WR_L GPIO.out_w1tc.val = (1 << TFT_WR)
#define WR_H GPIO.out_w1ts.val = (1 << TFT_WR)
#else
#define WR_L
#define WR_H
#endif
#else
#define WR_L
#define WR_H
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Define the touch screen chip select pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#ifndef TOUCH_CS
#define T_CS_L // No macro allocated so it generates no code
#define T_CS_H // No macro allocated so it generates no code
#else // XPT2046 is slow, so use slower digitalWrite here
#define T_CS_L digitalWrite(TOUCH_CS, LOW)
#define T_CS_H digitalWrite(TOUCH_CS, HIGH)
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Make sure SPI default pins are assigned if not specified by user or set to -1
////////////////////////////////////////////////////////////////////////////////////////
#if !defined (TFT_PARALLEL_8_BIT)
#ifdef USE_HSPI_PORT
#ifndef TFT_MISO
#define TFT_MISO -1
#endif
#ifndef TFT_MOSI
#define TFT_MOSI 13
#endif
#if (TFT_MOSI == -1)
#undef TFT_MOSI
#define TFT_MOSI 13
#endif
#ifndef TFT_SCLK
#define TFT_SCLK 14
#endif
#if (TFT_SCLK == -1)
#undef TFT_SCLK
#define TFT_SCLK 14
#endif
#else // VSPI port
#ifndef TFT_MISO
#define TFT_MISO -1
#endif
#ifndef TFT_MOSI
#define TFT_MOSI 23
#endif
#if (TFT_MOSI == -1)
#undef TFT_MOSI
#define TFT_MOSI 23
#endif
#ifndef TFT_SCLK
#define TFT_SCLK 18
#endif
#if (TFT_SCLK == -1)
#undef TFT_SCLK
#define TFT_SCLK 18
#endif
#if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32S2)
#if (TFT_MISO == -1)
#undef TFT_MISO
#define TFT_MISO TFT_MOSI
#endif
#endif
#endif
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Define the parallel bus interface chip pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#if defined (TFT_PARALLEL_8_BIT)
// Create a bit set lookup table for data bus - wastes 1kbyte of RAM but speeds things up dramatically
// can then use e.g. GPIO.out_w1ts.val = set_mask(0xFF); to set data bus to 0xFF
#define PARALLEL_INIT_TFT_DATA_BUS \
for (int32_t c = 0; c<256; c++) \
{ \
xset_mask[c] = 0; \
if ( c & 0x01 ) xset_mask[c] |= (1 << TFT_D0); \
if ( c & 0x02 ) xset_mask[c] |= (1 << TFT_D1); \
if ( c & 0x04 ) xset_mask[c] |= (1 << TFT_D2); \
if ( c & 0x08 ) xset_mask[c] |= (1 << TFT_D3); \
if ( c & 0x10 ) xset_mask[c] |= (1 << TFT_D4); \
if ( c & 0x20 ) xset_mask[c] |= (1 << TFT_D5); \
if ( c & 0x40 ) xset_mask[c] |= (1 << TFT_D6); \
if ( c & 0x80 ) xset_mask[c] |= (1 << TFT_D7); \
} \
// Mask for the 8 data bits to set pin directions
#define GPIO_DIR_MASK ((1 << TFT_D0) | (1 << TFT_D1) | (1 << TFT_D2) | (1 << TFT_D3) | (1 << TFT_D4) | (1 << TFT_D5) | (1 << TFT_D6) | (1 << TFT_D7))
#if (TFT_WR >= 32)
// Data bits and the write line are cleared sequentially
#define GPIO_OUT_CLR_MASK (GPIO_DIR_MASK); WR_L
#elif (TFT_WR >= 0)
// Data bits and the write line are cleared to 0 in one step (1.25x faster)
#define GPIO_OUT_CLR_MASK (GPIO_DIR_MASK | (1 << TFT_WR))
#else
#define GPIO_OUT_CLR_MASK
#endif
// A lookup table is used to set the different bit patterns, this uses 1kByte of RAM
#define set_mask(C) xset_mask[C] // 63fps Sprite rendering test 33% faster, graphicstest only 1.8% faster than shifting in real time
// Real-time shifting alternative to above to save 1KByte RAM, 47 fps Sprite rendering test
/*#define set_mask(C) (((C)&0x80)>>7)<<TFT_D7 | (((C)&0x40)>>6)<<TFT_D6 | (((C)&0x20)>>5)<<TFT_D5 | (((C)&0x10)>>4)<<TFT_D4 | \
(((C)&0x08)>>3)<<TFT_D3 | (((C)&0x04)>>2)<<TFT_D2 | (((C)&0x02)>>1)<<TFT_D1 | (((C)&0x01)>>0)<<TFT_D0
//*/
// Write 8 bits to TFT
#define tft_Write_8(C) GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t)(C)); WR_H
#if defined (SSD1963_DRIVER)
// Write 18 bit color to TFT
#define tft_Write_16(C) GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) (((C) & 0xF800)>> 8)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) (((C) & 0x07E0)>> 3)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) (((C) & 0x001F)<< 3)); WR_H
// 18 bit color write with swapped bytes
#define tft_Write_16S(C) Cswap = ((C) >>8 | (C) << 8); tft_Write_16(Cswap)
#else
#ifdef PSEUDO_16_BIT
// One write strobe for both bytes
#define tft_Write_16(C) GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 0)); WR_H
#define tft_Write_16S(C) GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 8)); WR_H
#else
// Write 16 bits to TFT
#define tft_Write_16(C) GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 0)); WR_H
// 16 bit write with swapped bytes
#define tft_Write_16S(C) GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 8)); WR_H
#endif
#endif
// Write 32 bits to TFT
#define tft_Write_32(C) GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 24)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 16)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 0)); WR_H
// Write two concatenated 16 bit values to TFT
#define tft_Write_32C(C,D) GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((D) >> 8)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((D) >> 0)); WR_H
// Write 16 bit value twice to TFT - used by drawPixel()
#define tft_Write_32D(C) GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO.out_w1tc.val = GPIO_OUT_CLR_MASK; GPIO.out_w1ts.val = set_mask((uint8_t) ((C) >> 0)); WR_H
// Read pin
#ifdef TFT_RD
#if (TFT_RD >= 32)
#define RD_L GPIO.out_w1tc.val = (1 << (TFT_RD - 32))
#define RD_H GPIO.out_w1ts.val = (1 << (TFT_RD - 32))
#elif (TFT_RD >= 0)
#define RD_L GPIO.out_w1tc.val = (1 << TFT_RD)
//#define RD_L digitalWrite(TFT_WR, LOW)
#define RD_H GPIO.out_w1ts.val = (1 << TFT_RD)
//#define RD_H digitalWrite(TFT_WR, HIGH)
#else
#define RD_L
#define RD_H
#endif
#else
#define TFT_RD -1
#define RD_L
#define RD_H
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Macros to write commands/pixel colour data to a SPI ILI948x TFT
////////////////////////////////////////////////////////////////////////////////////////
#elif defined (SPI_18BIT_DRIVER) // SPI 18 bit colour
// Write 8 bits to TFT
#define tft_Write_8(C) spi.transfer(C)
// Convert 16 bit colour to 18 bit and write in 3 bytes
#define tft_Write_16(C) spi.transfer(((C) & 0xF800)>>8); \
spi.transfer(((C) & 0x07E0)>>3); \
spi.transfer(((C) & 0x001F)<<3)
// Future option for transfer without wait
#define tft_Write_16N(C) tft_Write_16(C)
// Convert swapped byte 16 bit colour to 18 bit and write in 3 bytes
#define tft_Write_16S(C) spi.transfer((C) & 0xF8); \
spi.transfer(((C) & 0xE000)>>11 | ((C) & 0x07)<<5); \
spi.transfer(((C) & 0x1F00)>>5)
// Write 32 bits to TFT
#define tft_Write_32(C) spi.write32(C)
// Write two concatenated 16 bit values to TFT
#define tft_Write_32C(C,D) spi.write32((C)<<16 | (D))
// Write 16 bit value twice to TFT
#define tft_Write_32D(C) spi.write32((C)<<16 | (C))
////////////////////////////////////////////////////////////////////////////////////////
// Macros to write commands/pixel colour data to an Raspberry Pi TFT
////////////////////////////////////////////////////////////////////////////////////////
#elif defined (RPI_DISPLAY_TYPE)
// ESP32 low level SPI writes for 8, 16 and 32 bit values
// to avoid the function call overhead
#define TFT_WRITE_BITS(D, B) \
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), B-1); \
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), D); \
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR); \
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
// Write 8 bits
#define tft_Write_8(C) TFT_WRITE_BITS((C)<<8, 16)
// Write 16 bits with corrected endianness for 16 bit colours
#define tft_Write_16(C) TFT_WRITE_BITS((C)<<8 | (C)>>8, 16)
// Future option for transfer without wait
#define tft_Write_16N(C) tft_Write_16(C)
// Write 16 bits
#define tft_Write_16S(C) TFT_WRITE_BITS(C, 16)
// Write 32 bits
#define tft_Write_32(C) TFT_WRITE_BITS(C, 32)
// Write two address coordinates
#define tft_Write_32C(C,D) TFT_WRITE_BITS((C)<<24 | (C), 32); \
TFT_WRITE_BITS((D)<<24 | (D), 32)
// Write same value twice
#define tft_Write_32D(C) tft_Write_32C(C,C)
////////////////////////////////////////////////////////////////////////////////////////
// Macros for all other SPI displays
////////////////////////////////////////////////////////////////////////////////////////
#else
/* Old macros
// ESP32 low level SPI writes for 8, 16 and 32 bit values
// to avoid the function call overhead
#define TFT_WRITE_BITS(D, B) \
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), B-1); \
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), D); \
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR); \
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
// Write 8 bits
#define tft_Write_8(C) TFT_WRITE_BITS(C, 8)
// Write 16 bits with corrected endianness for 16 bit colours
#define tft_Write_16(C) TFT_WRITE_BITS((C)<<8 | (C)>>8, 16)
// Write 16 bits
#define tft_Write_16S(C) TFT_WRITE_BITS(C, 16)
// Write 32 bits
#define tft_Write_32(C) TFT_WRITE_BITS(C, 32)
// Write two address coordinates
#define tft_Write_32C(C,D) TFT_WRITE_BITS((uint16_t)((D)<<8 | (D)>>8)<<16 | (uint16_t)((C)<<8 | (C)>>8), 32)
// Write same value twice
#define tft_Write_32D(C) TFT_WRITE_BITS((uint16_t)((C)<<8 | (C)>>8)<<16 | (uint16_t)((C)<<8 | (C)>>8), 32)
//*/
//* Replacement slimmer macros
#if !defined(CONFIG_IDF_TARGET_ESP32C3)
#define TFT_WRITE_BITS(D, B) *_spi_mosi_dlen = B-1; \
*_spi_w = D; \
*_spi_cmd = SPI_USR; \
while (*_spi_cmd & SPI_USR);
#else
#define TFT_WRITE_BITS(D, B) *_spi_mosi_dlen = B-1; \
*_spi_w = D; \
*_spi_cmd = SPI_UPDATE; \
while (*_spi_cmd & SPI_UPDATE); \
*_spi_cmd = SPI_USR; \
while (*_spi_cmd & SPI_USR);
#endif
// Write 8 bits
#define tft_Write_8(C) TFT_WRITE_BITS(C, 8)
// Write 16 bits with corrected endianness for 16 bit colours
#define tft_Write_16(C) TFT_WRITE_BITS((C)<<8 | (C)>>8, 16)
// Future option for transfer without wait
#if !defined(CONFIG_IDF_TARGET_ESP32C3)
#define tft_Write_16N(C) *_spi_mosi_dlen = 16-1; \
*_spi_w = ((C)<<8 | (C)>>8); \
*_spi_cmd = SPI_USR;
#else
#define tft_Write_16N(C) *_spi_mosi_dlen = 16-1; \
*_spi_w = ((C)<<8 | (C)>>8); \
*_spi_cmd = SPI_UPDATE; \
while (*_spi_cmd & SPI_UPDATE); \
*_spi_cmd = SPI_USR;
#endif
// Write 16 bits
#define tft_Write_16S(C) TFT_WRITE_BITS(C, 16)
// Write 32 bits
#define tft_Write_32(C) TFT_WRITE_BITS(C, 32)
// Write two address coordinates
#define tft_Write_32C(C,D) TFT_WRITE_BITS((uint16_t)((D)<<8 | (D)>>8)<<16 | (uint16_t)((C)<<8 | (C)>>8), 32)
// Write same value twice
#define tft_Write_32D(C) TFT_WRITE_BITS((uint16_t)((C)<<8 | (C)>>8)<<16 | (uint16_t)((C)<<8 | (C)>>8), 32)
//*/
#endif
#ifndef tft_Write_16N
#define tft_Write_16N tft_Write_16
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Macros to read from display using SPI or software SPI
////////////////////////////////////////////////////////////////////////////////////////
#if !defined (TFT_PARALLEL_8_BIT)
// Read from display using SPI or software SPI
// Use a SPI read transfer
#define tft_Read_8() spi.transfer(0)
#endif
// Concatenate a byte sequence A,B,C,D to CDAB, P is a uint8_t pointer
#define DAT8TO32(P) ( (uint32_t)P[0]<<8 | P[1] | P[2]<<24 | P[3]<<16 )
#endif // Header end

View File

@ -1,885 +0,0 @@
////////////////////////////////////////////////////
// TFT_eSPI driver functions for ESP32 processors //
////////////////////////////////////////////////////
// Temporarily a separate file to TFT_eSPI_ESP32.c until board package low level API stabilises
////////////////////////////////////////////////////////////////////////////////////////
// Global variables
////////////////////////////////////////////////////////////////////////////////////////
// Select the SPI port to use, ESP32 has 2 options
#if !defined (TFT_PARALLEL_8_BIT)
#ifdef CONFIG_IDF_TARGET_ESP32
#ifdef USE_HSPI_PORT
SPIClass spi = SPIClass(HSPI);
#elif defined(USE_FSPI_PORT)
SPIClass spi = SPIClass(FSPI);
#else // use default VSPI port
SPIClass spi = SPIClass(VSPI);
#endif
#else
#ifdef USE_HSPI_PORT
SPIClass spi = SPIClass(HSPI);
#elif defined(USE_FSPI_PORT)
SPIClass spi = SPIClass(FSPI);
#else // use FSPI port
SPIClass& spi = SPI;
#endif
#endif
#endif
#ifdef ESP32_DMA
// DMA SPA handle
spi_device_handle_t dmaHAL;
#ifdef CONFIG_IDF_TARGET_ESP32
#define DMA_CHANNEL 1
#ifdef USE_HSPI_PORT
spi_host_device_t spi_host = HSPI_HOST;
#elif defined(USE_FSPI_PORT)
spi_host_device_t spi_host = SPI_HOST;
#else // use VSPI port
spi_host_device_t spi_host = VSPI_HOST;
#endif
#else
#ifdef USE_HSPI_PORT
#define DMA_CHANNEL SPI_DMA_CH_AUTO
spi_host_device_t spi_host = SPI3_HOST;
#else // use FSPI port
#define DMA_CHANNEL SPI_DMA_CH_AUTO
spi_host_device_t spi_host = SPI2_HOST;
#endif
#endif
#endif
////////////////////////////////////////////////////////////////////////////////////////
#if defined (TFT_SDA_READ) && !defined (TFT_PARALLEL_8_BIT)
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: beginSDA - FPSI port only
** Description: Detach MOSI and attach MISO to SDA for reads
***************************************************************************************/
void TFT_eSPI::begin_SDA_Read(void)
{
gpio_set_direction((gpio_num_t)TFT_MOSI, GPIO_MODE_INPUT);
pinMatrixInAttach(TFT_MOSI, FSPIQ_IN_IDX, false);
SET_BUS_READ_MODE;
}
/***************************************************************************************
** Function name: endSDA - FPSI port only
** Description: Attach MOSI to SDA and detach MISO for writes
***************************************************************************************/
void TFT_eSPI::end_SDA_Read(void)
{
gpio_set_direction((gpio_num_t)TFT_MOSI, GPIO_MODE_OUTPUT);
pinMatrixOutAttach(TFT_MOSI, FSPID_OUT_IDX, false, false);
SET_BUS_WRITE_MODE;
}
////////////////////////////////////////////////////////////////////////////////////////
#endif // #if defined (TFT_SDA_READ)
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: read byte - supports class functions
** Description: Read a byte from ESP32 8 bit data port
***************************************************************************************/
// Parallel bus MUST be set to input before calling this function!
uint8_t TFT_eSPI::readByte(void)
{
uint8_t b = 0xAA;
#if defined (TFT_PARALLEL_8_BIT)
RD_L;
b = gpio_get_level((gpio_num_t)(TFT_D0-MASK_OFFSET)); // Read three times to allow for bus access time
b = gpio_get_level((gpio_num_t)(TFT_D0-MASK_OFFSET));
b = gpio_get_level((gpio_num_t)(TFT_D0-MASK_OFFSET)); // Data should be stable now
RD_H;
// Check GPIO bits used and build value
b = (gpio_get_level((gpio_num_t)(TFT_D0-MASK_OFFSET)) << 0);
b |= (gpio_get_level((gpio_num_t)(TFT_D1-MASK_OFFSET)) << 1);
b |= (gpio_get_level((gpio_num_t)(TFT_D2-MASK_OFFSET)) << 2);
b |= (gpio_get_level((gpio_num_t)(TFT_D3-MASK_OFFSET)) << 3);
b |= (gpio_get_level((gpio_num_t)(TFT_D4-MASK_OFFSET)) << 4);
b |= (gpio_get_level((gpio_num_t)(TFT_D5-MASK_OFFSET)) << 5);
b |= (gpio_get_level((gpio_num_t)(TFT_D6-MASK_OFFSET)) << 6);
b |= (gpio_get_level((gpio_num_t)(TFT_D7-MASK_OFFSET)) << 7);
#endif
return b;
}
////////////////////////////////////////////////////////////////////////////////////////
#ifdef TFT_PARALLEL_8_BIT
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: GPIO direction control - supports class functions
** Description: Set parallel bus to INPUT or OUTPUT
***************************************************************************************/
void TFT_eSPI::busDir(uint32_t mask, uint8_t mode)
{
// Arduino generic native function
pinMode(TFT_D0, mode);
pinMode(TFT_D1, mode);
pinMode(TFT_D2, mode);
pinMode(TFT_D3, mode);
pinMode(TFT_D4, mode);
pinMode(TFT_D5, mode);
pinMode(TFT_D6, mode);
pinMode(TFT_D7, mode);
}
/***************************************************************************************
** Function name: GPIO direction control - supports class functions
** Description: Set ESP32 GPIO pin to input or output (set high) ASAP
***************************************************************************************/
void TFT_eSPI::gpioMode(uint8_t gpio, uint8_t mode)
{
pinMode(gpio, mode);
digitalWrite(gpio, HIGH);
}
////////////////////////////////////////////////////////////////////////////////////////
#endif // #ifdef TFT_PARALLEL_8_BIT
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
#if defined (RPI_WRITE_STROBE) && !defined (TFT_PARALLEL_8_BIT) // Code for RPi TFT
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: pushBlock - for ESP32 or ESP8266 RPi TFT
** Description: Write a block of pixels of the same colour
***************************************************************************************/
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len)
{
uint8_t colorBin[] = { (uint8_t) (color >> 8), (uint8_t) color };
if(len) spi.writePattern(&colorBin[0], 2, 1); len--;
while(len--) {WR_L; WR_H;}
}
/***************************************************************************************
** Function name: pushPixels - for ESP32 or ESP8266 RPi TFT
** Description: Write a sequence of pixels
***************************************************************************************/
void TFT_eSPI::pushPixels(const void* data_in, uint32_t len)
{
uint8_t *data = (uint8_t*)data_in;
if(_swapBytes) {
while ( len-- ) {tft_Write_16(*data); data++;}
return;
}
while ( len >=64 ) {spi.writePattern(data, 64, 1); data += 64; len -= 64; }
if (len) spi.writePattern(data, len, 1);
}
////////////////////////////////////////////////////////////////////////////////////////
#elif !defined (SPI_18BIT_DRIVER) && !defined (TFT_PARALLEL_8_BIT) // Most SPI displays
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: pushBlock - for ESP32
** Description: Write a block of pixels of the same colour
***************************************************************************************/
/*
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len){
uint32_t color32 = (color<<8 | color >>8)<<16 | (color<<8 | color >>8);
bool empty = true;
volatile uint32_t* spi_w = (volatile uint32_t*)_spi_w;
if (len > 31)
{
*_spi_mosi_dlen = 511;
spi_w[0] = color32;
spi_w[1] = color32;
spi_w[2] = color32;
spi_w[3] = color32;
spi_w[4] = color32;
spi_w[5] = color32;
spi_w[6] = color32;
spi_w[7] = color32;
spi_w[8] = color32;
spi_w[9] = color32;
spi_w[10] = color32;
spi_w[11] = color32;
spi_w[12] = color32;
spi_w[13] = color32;
spi_w[14] = color32;
spi_w[15] = color32;
while(len>31)
{
while ((*_spi_cmd)&SPI_USR);
*_spi_cmd = SPI_USR;
len -= 32;
}
empty = false;
}
if (len)
{
if(empty) {
for (uint32_t i=0; i <= len; i+=2) *spi_w++ = color32;
}
len = (len << 4) - 1;
while (*_spi_cmd&SPI_USR);
*_spi_mosi_dlen = len;
*_spi_cmd = SPI_USR;
}
while ((*_spi_cmd)&SPI_USR); // Move to later in code to use transmit time usefully?
}
//*/
//*
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len){
volatile uint32_t* spi_w = _spi_w;
uint32_t color32 = (color<<8 | color >>8)<<16 | (color<<8 | color >>8);
uint32_t i = 0;
uint32_t rem = len & 0x1F;
len = len - rem;
// Start with partial buffer pixels
if (rem)
{
while (*_spi_cmd&SPI_USR);
for (i=0; i < rem; i+=2) *spi_w++ = color32;
*_spi_mosi_dlen = (rem << 4) - 1;
#if CONFIG_IDF_TARGET_ESP32S3
*_spi_cmd = SPI_UPDATE;
while (*_spi_cmd & SPI_UPDATE);
#endif
*_spi_cmd = SPI_USR;
if (!len) return; //{while (*_spi_cmd&SPI_USR); return; }
i = i>>1; while(i++<16) *spi_w++ = color32;
}
while (*_spi_cmd&SPI_USR);
if (!rem) while (i++<16) *spi_w++ = color32;
*_spi_mosi_dlen = 511;
// End with full buffer to maximise useful time for downstream code
while(len)
{
while (*_spi_cmd&SPI_USR);
#if CONFIG_IDF_TARGET_ESP32S3
*_spi_cmd = SPI_UPDATE;
while (*_spi_cmd & SPI_UPDATE);
#endif
*_spi_cmd = SPI_USR;
len -= 32;
}
// Do not wait here
//while (*_spi_cmd&SPI_USR);
}
//*/
/***************************************************************************************
** Function name: pushSwapBytePixels - for ESP32
** Description: Write a sequence of pixels with swapped bytes
***************************************************************************************/
void TFT_eSPI::pushSwapBytePixels(const void* data_in, uint32_t len){
uint8_t* data = (uint8_t*)data_in;
uint32_t color[16];
if (len > 31)
{
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 511);
while(len>31)
{
uint32_t i = 0;
while(i<16)
{
color[i++] = DAT8TO32(data);
data+=4;
}
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), color[0]);
WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), color[1]);
WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), color[2]);
WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), color[3]);
WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), color[4]);
WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), color[5]);
WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), color[6]);
WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), color[7]);
WRITE_PERI_REG(SPI_W8_REG(SPI_PORT), color[8]);
WRITE_PERI_REG(SPI_W9_REG(SPI_PORT), color[9]);
WRITE_PERI_REG(SPI_W10_REG(SPI_PORT), color[10]);
WRITE_PERI_REG(SPI_W11_REG(SPI_PORT), color[11]);
WRITE_PERI_REG(SPI_W12_REG(SPI_PORT), color[12]);
WRITE_PERI_REG(SPI_W13_REG(SPI_PORT), color[13]);
WRITE_PERI_REG(SPI_W14_REG(SPI_PORT), color[14]);
WRITE_PERI_REG(SPI_W15_REG(SPI_PORT), color[15]);
#if CONFIG_IDF_TARGET_ESP32S3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
len -= 32;
}
}
if (len > 15)
{
uint32_t i = 0;
while(i<8)
{
color[i++] = DAT8TO32(data);
data+=4;
}
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 255);
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), color[0]);
WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), color[1]);
WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), color[2]);
WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), color[3]);
WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), color[4]);
WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), color[5]);
WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), color[6]);
WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), color[7]);
#if CONFIG_IDF_TARGET_ESP32S3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
len -= 16;
}
if (len)
{
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), (len << 4) - 1);
for (uint32_t i=0; i <= (len<<1); i+=4) {
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT)+i, DAT8TO32(data)); data+=4;
}
#if CONFIG_IDF_TARGET_ESP32S3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
}
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
}
/***************************************************************************************
** Function name: pushPixels - for ESP32
** Description: Write a sequence of pixels
***************************************************************************************/
void TFT_eSPI::pushPixels(const void* data_in, uint32_t len){
if(_swapBytes) {
pushSwapBytePixels(data_in, len);
return;
}
uint32_t *data = (uint32_t*)data_in;
if (len > 31)
{
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 511);
while(len>31)
{
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W8_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W9_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W10_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W11_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W12_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W13_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W14_REG(SPI_PORT), *data++);
WRITE_PERI_REG(SPI_W15_REG(SPI_PORT), *data++);
#if CONFIG_IDF_TARGET_ESP32S3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
len -= 32;
}
}
if (len)
{
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), (len << 4) - 1);
for (uint32_t i=0; i <= (len<<1); i+=4) WRITE_PERI_REG((SPI_W0_REG(SPI_PORT) + i), *data++);
#if CONFIG_IDF_TARGET_ESP32S3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
}
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
}
////////////////////////////////////////////////////////////////////////////////////////
#elif defined (SPI_18BIT_DRIVER) // SPI 18 bit colour
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: pushBlock - for ESP32 and 3 byte RGB display
** Description: Write a block of pixels of the same colour
***************************************************************************************/
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len)
{
// Split out the colours
uint32_t r = (color & 0xF800)>>8;
uint32_t g = (color & 0x07E0)<<5;
uint32_t b = (color & 0x001F)<<19;
// Concatenate 4 pixels into three 32 bit blocks
uint32_t r0 = r<<24 | b | g | r;
uint32_t r1 = r0>>8 | g<<16;
uint32_t r2 = r1>>8 | b<<8;
if (len > 19)
{
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 479);
while(len>19)
{
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W8_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W9_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W10_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W11_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W12_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W13_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W14_REG(SPI_PORT), r2);
#if CONFIG_IDF_TARGET_ESP32S3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
len -= 20;
}
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
}
if (len)
{
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), (len * 24) - 1);
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), r2);
if (len > 8 )
{
WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W8_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W9_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W10_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W11_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W12_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W13_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W14_REG(SPI_PORT), r2);
}
#if CONFIG_IDF_TARGET_ESP32S3
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_UPDATE);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_UPDATE);
#endif
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
}
}
/***************************************************************************************
** Function name: pushPixels - for ESP32 and 3 byte RGB display
** Description: Write a sequence of pixels
***************************************************************************************/
void TFT_eSPI::pushPixels(const void* data_in, uint32_t len){
uint16_t *data = (uint16_t*)data_in;
// ILI9488 write macro is not endianess dependant, hence !_swapBytes
if(!_swapBytes) { while ( len-- ) {tft_Write_16S(*data); data++;} }
else { while ( len-- ) {tft_Write_16(*data); data++;} }
}
/***************************************************************************************
** Function name: pushSwapBytePixels - for ESP32 and 3 byte RGB display
** Description: Write a sequence of pixels with swapped bytes
***************************************************************************************/
void TFT_eSPI::pushSwapBytePixels(const void* data_in, uint32_t len){
uint16_t *data = (uint16_t*)data_in;
// ILI9488 write macro is not endianess dependant, so swap byte macro not used here
while ( len-- ) {tft_Write_16(*data); data++;}
}
////////////////////////////////////////////////////////////////////////////////////////
#elif defined (TFT_PARALLEL_8_BIT) // Now the code for ESP32 8 bit parallel
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: pushBlock - for ESP32 and parallel display
** Description: Write a block of pixels of the same colour
***************************************************************************************/
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len){
if ( (color >> 8) == (color & 0x00FF) )
{ if (!len) return;
tft_Write_16(color);
#if defined (SSD1963_DRIVER)
while (--len) {WR_L; WR_H; WR_L; WR_H; WR_L; WR_H;}
#else
#ifdef PSEUDO_16_BIT
while (--len) {WR_L; WR_H;}
#else
while (--len) {WR_L; WR_H; WR_L; WR_H;}
#endif
#endif
}
else while (len--) {tft_Write_16(color);}
}
/***************************************************************************************
** Function name: pushSwapBytePixels - for ESP32 and parallel display
** Description: Write a sequence of pixels with swapped bytes
***************************************************************************************/
void TFT_eSPI::pushSwapBytePixels(const void* data_in, uint32_t len){
uint16_t *data = (uint16_t*)data_in;
while ( len-- ) {tft_Write_16(*data); data++;}
}
/***************************************************************************************
** Function name: pushPixels - for ESP32 and parallel display
** Description: Write a sequence of pixels
***************************************************************************************/
void TFT_eSPI::pushPixels(const void* data_in, uint32_t len){
uint16_t *data = (uint16_t*)data_in;
if(_swapBytes) { while ( len-- ) {tft_Write_16(*data); data++; } }
else { while ( len-- ) {tft_Write_16S(*data); data++;} }
}
////////////////////////////////////////////////////////////////////////////////////////
#endif // End of display interface specific functions
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
#if defined (ESP32_DMA) && !defined (TFT_PARALLEL_8_BIT) // DMA FUNCTIONS
////////////////////////////////////////////////////////////////////////////////////////
/***************************************************************************************
** Function name: dmaBusy
** Description: Check if DMA is busy
***************************************************************************************/
bool TFT_eSPI::dmaBusy(void)
{
if (!DMA_Enabled || !spiBusyCheck) return false;
spi_transaction_t *rtrans;
esp_err_t ret;
uint8_t checks = spiBusyCheck;
for (int i = 0; i < checks; ++i)
{
ret = spi_device_get_trans_result(dmaHAL, &rtrans, 0);
if (ret == ESP_OK) spiBusyCheck--;
}
//Serial.print("spiBusyCheck=");Serial.println(spiBusyCheck);
if (spiBusyCheck ==0) return false;
return true;
}
/***************************************************************************************
** Function name: dmaWait
** Description: Wait until DMA is over (blocking!)
***************************************************************************************/
void TFT_eSPI::dmaWait(void)
{
if (!DMA_Enabled || !spiBusyCheck) return;
spi_transaction_t *rtrans;
esp_err_t ret;
for (int i = 0; i < spiBusyCheck; ++i)
{
ret = spi_device_get_trans_result(dmaHAL, &rtrans, portMAX_DELAY);
assert(ret == ESP_OK);
}
spiBusyCheck = 0;
}
/***************************************************************************************
** Function name: pushPixelsDMA
** Description: Push pixels to TFT (len must be less than 32767)
***************************************************************************************/
// This will byte swap the original image if setSwapBytes(true) was called by sketch.
void TFT_eSPI::pushPixelsDMA(uint16_t* image, uint32_t len)
{
if ((len == 0) || (!DMA_Enabled)) return;
dmaWait();
if(_swapBytes) {
for (uint32_t i = 0; i < len; i++) (image[i] = image[i] << 8 | image[i] >> 8);
}
// DMA byte count for transmit is 64Kbytes maximum, so to avoid this constraint
// small transfers are performed using a blocking call until DMA capacity is reached.
// User sketch can prevent blocking by managing pixel count and splitting into blocks
// of 32768 pixels maximum. (equivalent to an area of ~320 x 100 pixels)
while(len>0x4000) { // Transfer 16 bit pixels in blocks if len*2 over 65536 bytes
pushPixels(image, 0x400);
len -= 0x400; image+= 0x400; // Arbitrarily send 1K pixel blocks (2Kbytes)
}
esp_err_t ret;
static spi_transaction_t trans;
memset(&trans, 0, sizeof(spi_transaction_t));
trans.user = (void *)1;
trans.tx_buffer = image; //finally send the line data
trans.length = len * 16; //Data length, in bits
trans.flags = 0; //SPI_TRANS_USE_TXDATA flag
ret = spi_device_queue_trans(dmaHAL, &trans, portMAX_DELAY);
assert(ret == ESP_OK);
spiBusyCheck++;
}
/***************************************************************************************
** Function name: pushImageDMA
** Description: Push image to a window (w*h must be less than 65536)
***************************************************************************************/
// Fixed const data assumed, will NOT clip or swap bytes
void TFT_eSPI::pushImageDMA(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t const* image)
{
if ((w == 0) || (h == 0) || (!DMA_Enabled)) return;
uint16_t *buffer = (uint16_t*)image;
uint32_t len = w*h;
dmaWait();
setAddrWindow(x, y, w, h);
// DMA byte count for transmit is 64Kbytes maximum, so to avoid this constraint
// small transfers are performed using a blocking call until DMA capacity is reached.
// User sketch can prevent blocking by managing pixel count and splitting into blocks
// of 32768 pixels maximum. (equivalent to an area of ~320 x 100 pixels)
while(len>0x4000) { // Transfer 16 bit pixels in blocks if len*2 over 65536 bytes
pushPixels(buffer, 0x400);
len -= 0x400; buffer+= 0x400; // Arbitrarily send 1K pixel blocks (2Kbytes)
}
esp_err_t ret;
static spi_transaction_t trans;
memset(&trans, 0, sizeof(spi_transaction_t));
trans.user = (void *)1;
trans.tx_buffer = buffer; //Data pointer
trans.length = len * 16; //Data length, in bits
trans.flags = 0; //SPI_TRANS_USE_TXDATA flag
ret = spi_device_queue_trans(dmaHAL, &trans, portMAX_DELAY);
assert(ret == ESP_OK);
spiBusyCheck++;
}
/***************************************************************************************
** Function name: pushImageDMA
** Description: Push image to a window (w*h must be less than 65536)
***************************************************************************************/
// This will clip and also swap bytes if setSwapBytes(true) was called by sketch
void TFT_eSPI::pushImageDMA(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t* image, uint16_t* buffer)
{
if ((x >= _vpW) || (y >= _vpH) || (!DMA_Enabled)) return;
int32_t dx = 0;
int32_t dy = 0;
int32_t dw = w;
int32_t dh = h;
if (x < _vpX) { dx = _vpX - x; dw -= dx; x = _vpX; }
if (y < _vpY) { dy = _vpY - y; dh -= dy; y = _vpY; }
if ((x + dw) > _vpW ) dw = _vpW - x;
if ((y + dh) > _vpH ) dh = _vpH - y;
if (dw < 1 || dh < 1) return;
uint32_t len = dw*dh;
if (buffer == nullptr) {
buffer = image;
dmaWait();
}
// If image is clipped, copy pixels into a contiguous block
if ( (dw != w) || (dh != h) ) {
if(_swapBytes) {
for (int32_t yb = 0; yb < dh; yb++) {
for (int32_t xb = 0; xb < dw; xb++) {
uint32_t src = xb + dx + w * (yb + dy);
(buffer[xb + yb * dw] = image[src] << 8 | image[src] >> 8);
}
}
}
else {
for (int32_t yb = 0; yb < dh; yb++) {
memcpy((uint8_t*) (buffer + yb * dw), (uint8_t*) (image + dx + w * (yb + dy)), dw << 1);
}
}
}
// else, if a buffer pointer has been provided copy whole image to the buffer
else if (buffer != image || _swapBytes) {
if(_swapBytes) {
for (uint32_t i = 0; i < len; i++) (buffer[i] = image[i] << 8 | image[i] >> 8);
}
else {
memcpy(buffer, image, len*2);
}
}
if (spiBusyCheck) dmaWait(); // In case we did not wait earlier
setAddrWindow(x, y, dw, dh);
// DMA byte count for transmit is 64Kbytes maximum, so to avoid this constraint
// small transfers are performed using a blocking call until DMA capacity is reached.
// User sketch can prevent blocking by managing pixel count and splitting into blocks
// of 32768 pixels maximum. (equivalent to an area of ~320 x 100 pixels)
while(len>0x4000) { // Transfer 16 bit pixels in blocks if len*2 over 65536 bytes
pushPixels(buffer, 0x400);
len -= 0x400; buffer+= 0x400; // Arbitrarily send 1K pixel blocks (2Kbytes)
}
esp_err_t ret;
static spi_transaction_t trans;
memset(&trans, 0, sizeof(spi_transaction_t));
trans.user = (void *)1;
trans.tx_buffer = buffer; //finally send the line data
trans.length = len * 16; //Data length, in bits
trans.flags = 0; //SPI_TRANS_USE_TXDATA flag
ret = spi_device_queue_trans(dmaHAL, &trans, portMAX_DELAY);
assert(ret == ESP_OK);
spiBusyCheck++;
}
////////////////////////////////////////////////////////////////////////////////////////
// Processor specific DMA initialisation
////////////////////////////////////////////////////////////////////////////////////////
// The DMA functions here work with SPI only (not parallel)
/***************************************************************************************
** Function name: dc_callback
** Description: Toggles DC line during transaction (not used)
***************************************************************************************/
extern "C" void dc_callback();
void IRAM_ATTR dc_callback(spi_transaction_t *spi_tx)
{
if ((bool)spi_tx->user) {DC_D;}
else {DC_C;}
}
/***************************************************************************************
** Function name: dma_end_callback
** Description: Clear DMA run flag to stop retransmission loop
***************************************************************************************/
extern "C" void dma_end_callback();
void IRAM_ATTR dma_end_callback(spi_transaction_t *spi_tx)
{
WRITE_PERI_REG(SPI_DMA_CONF_REG(spi_host), 0);
}
/***************************************************************************************
** Function name: initDMA
** Description: Initialise the DMA engine - returns true if init OK
***************************************************************************************/
bool TFT_eSPI::initDMA(bool ctrl_cs)
{
if (DMA_Enabled) return false;
esp_err_t ret;
spi_bus_config_t buscfg = {
.mosi_io_num = TFT_MOSI,
.miso_io_num = TFT_MISO,
.sclk_io_num = TFT_SCLK,
.quadwp_io_num = -1,
.quadhd_io_num = -1,
.max_transfer_sz = 65536, // ESP32 S3 max size is 64Kbytes
.flags = 0,
.intr_flags = 0
};
int8_t pin = -1;
if (ctrl_cs) pin = TFT_CS;
spi_device_interface_config_t devcfg = {
.command_bits = 0,
.address_bits = 0,
.dummy_bits = 0,
.mode = TFT_SPI_MODE,
.duty_cycle_pos = 0,
.cs_ena_pretrans = 0,
.cs_ena_posttrans = 0,
.clock_speed_hz = SPI_FREQUENCY,
.input_delay_ns = 0,
.spics_io_num = pin,
.flags = SPI_DEVICE_NO_DUMMY, //0,
.queue_size = 1, // Not using queues
.pre_cb = 0, //dc_callback, //Callback to handle D/C line (not used)
.post_cb = dma_end_callback //Callback to end transmission
};
ret = spi_bus_initialize(spi_host, &buscfg, DMA_CHANNEL);
ESP_ERROR_CHECK(ret);
ret = spi_bus_add_device(spi_host, &devcfg, &dmaHAL);
ESP_ERROR_CHECK(ret);
DMA_Enabled = true;
spiBusyCheck = 0;
return true;
}
/***************************************************************************************
** Function name: deInitDMA
** Description: Disconnect the DMA engine from SPI
***************************************************************************************/
void TFT_eSPI::deInitDMA(void)
{
if (!DMA_Enabled) return;
spi_bus_remove_device(dmaHAL);
spi_bus_free(spi_host);
DMA_Enabled = false;
}
////////////////////////////////////////////////////////////////////////////////////////
#endif // End of DMA FUNCTIONS
////////////////////////////////////////////////////////////////////////////////////////

View File

@ -1,640 +0,0 @@
////////////////////////////////////////////////////
// TFT_eSPI driver functions for ESP32 processors //
////////////////////////////////////////////////////
// Temporarily a separate file to TFT_eSPI_ESP32.h until board package low level API stabilises
#ifndef _TFT_eSPI_ESP32H_
#define _TFT_eSPI_ESP32H_
// Processor ID reported by getSetup()
#define PROCESSOR_ID 0x32
// Include processor specific header
#include "soc/spi_reg.h"
#include "driver/spi_master.h"
#if !defined(CONFIG_IDF_TARGET_ESP32S3) && !defined(CONFIG_IDF_TARGET_ESP32S2) && !defined(CONFIG_IDF_TARGET_ESP32)
#define CONFIG_IDF_TARGET_ESP32
#endif
#ifndef VSPI
#define VSPI FSPI
#endif
// Fix IDF problems with ESP32S3
// Note illogical enumerations: FSPI_HOST=SPI2_HOST=1 HSPI_HOST=SPI3_HOST=2
#if CONFIG_IDF_TARGET_ESP32S3
// Fix ESP32C3 IDF bug for missing definition (FSPI only tested at the moment)
#ifndef REG_SPI_BASE // HSPI FSPI/VSPI
#define REG_SPI_BASE(i) (((i)>1) ? (DR_REG_SPI3_BASE) : (DR_REG_SPI2_BASE))
#endif
// Fix ESP32S3 IDF bug for name change
#ifndef SPI_MOSI_DLEN_REG
#define SPI_MOSI_DLEN_REG(x) SPI_MS_DLEN_REG(x)
#endif
#endif
// SUPPORT_TRANSACTIONS is mandatory for ESP32 so the hal mutex is toggled
#if !defined (SUPPORT_TRANSACTIONS)
#define SUPPORT_TRANSACTIONS
#endif
/*
ESP32:
FSPI not defined
HSPI = 2, uses SPI2
VSPI = 3, uses SPI3
ESP32-S2:
FSPI = 1, uses SPI2
HSPI = 2, uses SPI3
VSPI not defined
ESP32 C3:
FSPI = 0, uses SPI2 ???? To be checked
HSPI = 1, uses SPI3 ???? To be checked
VSPI not defined
For ESP32/S2/C3/S3:
SPI1_HOST = 0
SPI2_HOST = 1
SPI3_HOST = 2
*/
// ESP32 specific SPI port selection
#ifdef USE_HSPI_PORT
#ifdef CONFIG_IDF_TARGET_ESP32
#define SPI_PORT HSPI //HSPI is port 2 on ESP32
#else
#define SPI_PORT 3 //HSPI is port 3 on ESP32 S2
#endif
#elif defined(USE_FSPI_PORT)
#define SPI_PORT 2 //FSPI(ESP32 S2)
#else
#ifdef CONFIG_IDF_TARGET_ESP32
#define SPI_PORT VSPI
#elif CONFIG_IDF_TARGET_ESP32S2
#define SPI_PORT 2 //FSPI(ESP32 S2)
#elif CONFIG_IDF_TARGET_ESP32S3
#define SPI_PORT FSPI
#endif
#endif
#ifdef RPI_DISPLAY_TYPE
#define CMD_BITS (16-1)
#else
#define CMD_BITS (8-1)
#endif
// Initialise processor specific SPI functions, used by init()
#define INIT_TFT_DATA_BUS // Not used
// Define a generic flag for 8 bit parallel
#if defined (ESP32_PARALLEL) // Specific to ESP32 for backwards compatibility
#if !defined (TFT_PARALLEL_8_BIT)
#define TFT_PARALLEL_8_BIT // Generic parallel flag
#endif
#endif
// Ensure ESP32 specific flag is defined for 8 bit parallel
#if defined (TFT_PARALLEL_8_BIT)
#if !defined (ESP32_PARALLEL)
#define ESP32_PARALLEL
#endif
#endif
#if !defined(DISABLE_ALL_LIBRARY_WARNINGS) && defined (ESP32_PARALLEL)
#warning >>>>------>> DMA is not supported in parallel mode
#endif
// Processor specific code used by SPI bus transaction startWrite and endWrite functions
#if !defined (ESP32_PARALLEL)
#define _spi_cmd (volatile uint32_t*)(SPI_CMD_REG(SPI_PORT))
#define _spi_user (volatile uint32_t*)(SPI_USER_REG(SPI_PORT))
#define _spi_mosi_dlen (volatile uint32_t*)(SPI_MOSI_DLEN_REG(SPI_PORT))
#define _spi_w (volatile uint32_t*)(SPI_W0_REG(SPI_PORT))
#if (TFT_SPI_MODE == SPI_MODE1) || (TFT_SPI_MODE == SPI_MODE2)
#define SET_BUS_WRITE_MODE *_spi_user = SPI_USR_MOSI | SPI_CK_OUT_EDGE
#define SET_BUS_READ_MODE *_spi_user = SPI_USR_MOSI | SPI_USR_MISO | SPI_DOUTDIN | SPI_CK_OUT_EDGE
#else
#define SET_BUS_WRITE_MODE *_spi_user = SPI_USR_MOSI
#define SET_BUS_READ_MODE *_spi_user = SPI_USR_MOSI | SPI_USR_MISO | SPI_DOUTDIN
#endif
#else
// Not applicable to parallel bus
#define SET_BUS_WRITE_MODE
#define SET_BUS_READ_MODE
#endif
// Code to check if DMA is busy, used by SPI bus transaction transaction and endWrite functions
#if !defined(TFT_PARALLEL_8_BIT) && !defined(SPI_18BIT_DRIVER)
#define ESP32_DMA
// Code to check if DMA is busy, used by SPI DMA + transaction + endWrite functions
#define DMA_BUSY_CHECK dmaWait()
#else
#define DMA_BUSY_CHECK
#endif
#if defined(TFT_PARALLEL_8_BIT)
#define SPI_BUSY_CHECK
#else
#define SPI_BUSY_CHECK while (*_spi_cmd&SPI_USR)
#endif
// If smooth font is used then it is likely SPIFFS will be needed
#ifdef SMOOTH_FONT
// Call up the SPIFFS (SPI FLASH Filing System) for the anti-aliased fonts
#define FS_NO_GLOBALS
#include <FS.h>
#include "SPIFFS.h" // ESP32 only
#define FONT_FS_AVAILABLE
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Define the DC (TFT Data/Command or Register Select (RS))pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#ifndef TFT_DC
#define DC_C // No macro allocated so it generates no code
#define DC_D // No macro allocated so it generates no code
#else
#if defined (TFT_PARALLEL_8_BIT)
// TFT_DC, by design, must be in range 0-31 for single register parallel write
#if (TFT_DC >= 0) && (TFT_DC < 32)
#define DC_C GPIO.out_w1tc = (1 << TFT_DC)
#define DC_D GPIO.out_w1ts = (1 << TFT_DC)
#elif (TFT_DC >= 32)
#define DC_C GPIO.out1_w1tc.val = (1 << (TFT_DC- 32))
#define DC_D GPIO.out1_w1ts.val = (1 << (TFT_DC- 32))
#else
#define DC_C
#define DC_D
#endif
#else
#if (TFT_DC >= 32)
#ifdef RPI_DISPLAY_TYPE // RPi displays need a slower DC change
#define DC_C GPIO.out1_w1ts.val = (1 << (TFT_DC - 32)); \
GPIO.out1_w1tc.val = (1 << (TFT_DC - 32))
#define DC_D GPIO.out1_w1tc.val = (1 << (TFT_DC - 32)); \
GPIO.out1_w1ts.val = (1 << (TFT_DC - 32))
#else
#define DC_C GPIO.out1_w1tc.val = (1 << (TFT_DC - 32))//;GPIO.out1_w1tc.val = (1 << (TFT_DC - 32))
#define DC_D GPIO.out1_w1ts.val = (1 << (TFT_DC - 32))//;GPIO.out1_w1ts.val = (1 << (TFT_DC - 32))
#endif
#elif (TFT_DC >= 0)
#if defined (RPI_DISPLAY_TYPE)
#if defined (ILI9486_DRIVER)
// RPi ILI9486 display needs a slower DC change
#define DC_C GPIO.out_w1tc = (1 << TFT_DC); \
GPIO.out_w1tc = (1 << TFT_DC)
#define DC_D GPIO.out_w1tc = (1 << TFT_DC); \
GPIO.out_w1ts = (1 << TFT_DC)
#else
// Other RPi displays need a slower C->D change
#define DC_C GPIO.out_w1tc = (1 << TFT_DC)
#define DC_D GPIO.out_w1tc = (1 << TFT_DC); \
GPIO.out_w1ts = (1 << TFT_DC)
#endif
#else
#define DC_C GPIO.out_w1tc = (1 << TFT_DC)//;GPIO.out_w1tc = (1 << TFT_DC)
#define DC_D GPIO.out_w1ts = (1 << TFT_DC)//;GPIO.out_w1ts = (1 << TFT_DC)
#endif
#else
#define DC_C
#define DC_D
#endif
#endif
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Define the CS (TFT chip select) pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#ifndef TFT_CS
#define TFT_CS -1 // Keep DMA code happy
#define CS_L // No macro allocated so it generates no code
#define CS_H // No macro allocated so it generates no code
#else
#if defined (TFT_PARALLEL_8_BIT)
#if TFT_CS >= 32
#define CS_L GPIO.out1_w1tc.val = (1 << (TFT_CS - 32))
#define CS_H GPIO.out1_w1ts.val = (1 << (TFT_CS - 32))
#elif TFT_CS >= 0
#define CS_L GPIO.out_w1tc = (1 << TFT_CS)
#define CS_H GPIO.out_w1ts = (1 << TFT_CS)
#else
#define CS_L
#define CS_H
#endif
#else
#if (TFT_CS >= 32)
#ifdef RPI_DISPLAY_TYPE // RPi display needs a slower CS change
#define CS_L GPIO.out1_w1ts.val = (1 << (TFT_CS - 32)); \
GPIO.out1_w1tc.val = (1 << (TFT_CS - 32))
#define CS_H GPIO.out1_w1tc.val = (1 << (TFT_CS - 32)); \
GPIO.out1_w1ts.val = (1 << (TFT_CS - 32))
#else
#define CS_L GPIO.out1_w1tc.val = (1 << (TFT_CS - 32)); GPIO.out1_w1tc.val = (1 << (TFT_CS - 32))
#define CS_H GPIO.out1_w1ts.val = (1 << (TFT_CS - 32))//;GPIO.out1_w1ts.val = (1 << (TFT_CS - 32))
#endif
#elif (TFT_CS >= 0)
#ifdef RPI_DISPLAY_TYPE // RPi display needs a slower CS change
#define CS_L GPIO.out_w1ts = (1 << TFT_CS); GPIO.out_w1tc = (1 << TFT_CS)
#define CS_H GPIO.out_w1tc = (1 << TFT_CS); GPIO.out_w1ts = (1 << TFT_CS)
#else
#define CS_L GPIO.out_w1tc = (1 << TFT_CS); GPIO.out_w1tc = (1 << TFT_CS)
#define CS_H GPIO.out_w1ts = (1 << TFT_CS)//;GPIO.out_w1ts = (1 << TFT_CS)
#endif
#else
#define CS_L
#define CS_H
#endif
#endif
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Define the WR (TFT Write) pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#if defined (TFT_WR)
#if (TFT_WR >= 32)
// Note: it will be ~1.25x faster if the TFT_WR pin uses a GPIO pin lower than 32
#define WR_L GPIO.out1_w1tc.val = (1 << (TFT_WR - 32))
#define WR_H GPIO.out1_w1ts.val = (1 << (TFT_WR - 32))
#elif (TFT_WR >= 0)
// TFT_WR, for best performance, should be in range 0-31 for single register parallel write
#define WR_L GPIO.out_w1tc = (1 << TFT_WR)
#define WR_H GPIO.out_w1ts = (1 << TFT_WR)
#else
#define WR_L
#define WR_H
#endif
#else
#define WR_L
#define WR_H
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Define the touch screen chip select pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#ifndef TOUCH_CS
#define T_CS_L // No macro allocated so it generates no code
#define T_CS_H // No macro allocated so it generates no code
#else // XPT2046 is slow, so use slower digitalWrite here
#define T_CS_L digitalWrite(TOUCH_CS, LOW)
#define T_CS_H digitalWrite(TOUCH_CS, HIGH)
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Make sure SPI default pins are assigned if not specified by user or set to -1
////////////////////////////////////////////////////////////////////////////////////////
#if !defined (TFT_PARALLEL_8_BIT)
#ifdef USE_HSPI_PORT
#ifndef TFT_MISO
#define TFT_MISO -1
#endif
#ifndef TFT_MOSI
#define TFT_MOSI 13
#endif
#if (TFT_MOSI == -1)
#undef TFT_MOSI
#define TFT_MOSI 13
#endif
#ifndef TFT_SCLK
#define TFT_SCLK 14
#endif
#if (TFT_SCLK == -1)
#undef TFT_SCLK
#define TFT_SCLK 14
#endif
#else // VSPI port
#ifndef TFT_MISO
#define TFT_MISO -1
#endif
#ifndef TFT_MOSI
#define TFT_MOSI 23
#endif
#if (TFT_MOSI == -1)
#undef TFT_MOSI
#define TFT_MOSI 23
#endif
#ifndef TFT_SCLK
#define TFT_SCLK 18
#endif
#if (TFT_SCLK == -1)
#undef TFT_SCLK
#define TFT_SCLK 18
#endif
#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32S2)
#if (TFT_MISO == -1)
#undef TFT_MISO
#define TFT_MISO TFT_MOSI
#endif
#endif
#endif
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Define the parallel bus interface chip pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#if defined (TFT_PARALLEL_8_BIT)
#if (TFT_D0 >= 32) // If D0 is a high GPIO assume all other data bits are high GPIO
#define MASK_OFFSET 32
#define GPIO_CLR_REG GPIO.out1_w1tc.val
#define GPIO_SET_REG GPIO.out1_w1ts.val
#else
#define MASK_OFFSET 0
#define GPIO_CLR_REG GPIO.out_w1tc
#define GPIO_SET_REG GPIO.out_w1ts
#endif
// Create a bit set lookup table for data bus - wastes 1kbyte of RAM but speeds things up dramatically
// can then use e.g. GPIO.out_w1ts = set_mask(0xFF); to set data bus to 0xFF
#define PARALLEL_INIT_TFT_DATA_BUS \
for (int32_t c = 0; c<256; c++) \
{ \
xset_mask[c] = 0; \
if ( c & 0x01 ) xset_mask[c] |= (1 << (TFT_D0-MASK_OFFSET)); \
if ( c & 0x02 ) xset_mask[c] |= (1 << (TFT_D1-MASK_OFFSET)); \
if ( c & 0x04 ) xset_mask[c] |= (1 << (TFT_D2-MASK_OFFSET)); \
if ( c & 0x08 ) xset_mask[c] |= (1 << (TFT_D3-MASK_OFFSET)); \
if ( c & 0x10 ) xset_mask[c] |= (1 << (TFT_D4-MASK_OFFSET)); \
if ( c & 0x20 ) xset_mask[c] |= (1 << (TFT_D5-MASK_OFFSET)); \
if ( c & 0x40 ) xset_mask[c] |= (1 << (TFT_D6-MASK_OFFSET)); \
if ( c & 0x80 ) xset_mask[c] |= (1 << (TFT_D7-MASK_OFFSET)); \
} \
// Mask for the 8 data bits to set pin directions
#define GPIO_DIR_MASK ((1 << (TFT_D0-MASK_OFFSET)) | (1 << (TFT_D1-MASK_OFFSET)) | (1 << (TFT_D2-MASK_OFFSET)) | (1 << (TFT_D3-MASK_OFFSET)) | (1 << (TFT_D4-MASK_OFFSET)) | (1 << (TFT_D5-MASK_OFFSET)) | (1 << (TFT_D6-MASK_OFFSET)) | (1 << (TFT_D7-MASK_OFFSET)))
#if (TFT_WR >= 32)
#if (TFT_D0 >= 32)
// Data bits and the write line are cleared to 0 in one step (1.25x faster)
#define GPIO_OUT_CLR_MASK (GPIO_DIR_MASK | (1 << (TFT_WR-32)))
#elif (TFT_D0 >= 0)
// Data bits and the write line are cleared sequentially
#define GPIO_OUT_CLR_MASK (GPIO_DIR_MASK); WR_L
#endif
#elif (TFT_WR >= 0)
#if (TFT_D0 >= 32)
// Data bits and the write line are cleared sequentially
#define GPIO_OUT_CLR_MASK (GPIO_DIR_MASK); WR_L
#elif (TFT_D0 >= 0)
// Data bits and the write line are cleared to 0 in one step (1.25x faster)
#define GPIO_OUT_CLR_MASK (GPIO_DIR_MASK | (1 << TFT_WR))
#endif
#else
#define GPIO_OUT_CLR_MASK
#endif
// A lookup table is used to set the different bit patterns, this uses 1kByte of RAM
#define set_mask(C) xset_mask[C] // 63fps Sprite rendering test 33% faster, graphicstest only 1.8% faster than shifting in real time
// Real-time shifting alternative to above to save 1KByte RAM, 47 fps Sprite rendering test
/*#define set_mask(C) (((C)&0x80)>>7)<<TFT_D7 | (((C)&0x40)>>6)<<TFT_D6 | (((C)&0x20)>>5)<<TFT_D5 | (((C)&0x10)>>4)<<TFT_D4 | \
(((C)&0x08)>>3)<<TFT_D3 | (((C)&0x04)>>2)<<TFT_D2 | (((C)&0x02)>>1)<<TFT_D1 | (((C)&0x01)>>0)<<TFT_D0
//*/
// Write 8 bits to TFT
#define tft_Write_8(C) GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t)(C)); WR_H
#if defined (SSD1963_DRIVER)
// Write 18 bit color to TFT
#define tft_Write_16(C) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0xF800)>> 8)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0x07E0)>> 3)); WR_H; \
GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) (((C) & 0x001F)<< 3)); WR_H
// 18 bit color write with swapped bytes
#define tft_Write_16S(C) Cswap = ((C) >>8 | (C) << 8); tft_Write_16(Cswap)
#else
#ifdef PSEUDO_16_BIT
// One write strobe for both bytes
#define tft_Write_16(C) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 0)); WR_H
#define tft_Write_16S(C) GPIO.out_w1tc = GPIO_OUT_CLR_MASK; GPIO.out_w1ts = set_mask((uint8_t) ((C) >> 8)); WR_H
#else
// Write 16 bits to TFT
#define tft_Write_16(C) GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 0)); WR_H
// 16 bit write with swapped bytes
#define tft_Write_16S(C) GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 8)); WR_H
#endif
#endif
// Write 32 bits to TFT
#define tft_Write_32(C) GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 24)); WR_H; \
GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 16)); WR_H; \
GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 0)); WR_H
// Write two concatenated 16 bit values to TFT
#define tft_Write_32C(C,D) GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((D) >> 8)); WR_H; \
GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((D) >> 0)); WR_H
// Write 16 bit value twice to TFT - used by drawPixel()
#define tft_Write_32D(C) GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 0)); WR_H; \
GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 8)); WR_H; \
GPIO_CLR_REG = GPIO_OUT_CLR_MASK; GPIO_SET_REG = set_mask((uint8_t) ((C) >> 0)); WR_H
// Read pin
#ifdef TFT_RD
#if (TFT_RD >= 32)
#define RD_L GPIO.out1_w1tc.val = (1 << (TFT_RD - 32))
#define RD_H GPIO.out1_w1ts.val = (1 << (TFT_RD - 32))
#elif (TFT_RD >= 0)
#define RD_L GPIO.out_w1tc = (1 << TFT_RD)
//#define RD_L digitalWrite(TFT_WR, LOW)
#define RD_H GPIO.out_w1ts = (1 << TFT_RD)
//#define RD_H digitalWrite(TFT_WR, HIGH)
#else
#define RD_L
#define RD_H
#endif
#else
#define TFT_RD -1
#define RD_L
#define RD_H
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Macros to write commands/pixel colour data to a SPI ILI948x TFT
////////////////////////////////////////////////////////////////////////////////////////
#elif defined (SPI_18BIT_DRIVER) // SPI 18 bit colour
// Write 8 bits to TFT
#define tft_Write_8(C) spi.transfer(C)
// Convert 16 bit colour to 18 bit and write in 3 bytes
#define tft_Write_16(C) spi.transfer(((C) & 0xF800)>>8); \
spi.transfer(((C) & 0x07E0)>>3); \
spi.transfer(((C) & 0x001F)<<3)
// Future option for transfer without wait
#define tft_Write_16N(C) tft_Write_16(C)
// Convert swapped byte 16 bit colour to 18 bit and write in 3 bytes
#define tft_Write_16S(C) spi.transfer((C) & 0xF8); \
spi.transfer(((C) & 0xE000)>>11 | ((C) & 0x07)<<5); \
spi.transfer(((C) & 0x1F00)>>5)
// Write 32 bits to TFT
#define tft_Write_32(C) spi.write32(C)
// Write two concatenated 16 bit values to TFT
#define tft_Write_32C(C,D) spi.write32((C)<<16 | (D))
// Write 16 bit value twice to TFT
#define tft_Write_32D(C) spi.write32((C)<<16 | (C))
////////////////////////////////////////////////////////////////////////////////////////
// Macros to write commands/pixel colour data to an Raspberry Pi TFT
////////////////////////////////////////////////////////////////////////////////////////
#elif defined (RPI_DISPLAY_TYPE)
// ESP32 low level SPI writes for 8, 16 and 32 bit values
// to avoid the function call overhead
#define TFT_WRITE_BITS(D, B) \
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), B-1); \
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), D); \
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR); \
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
// Write 8 bits
#define tft_Write_8(C) TFT_WRITE_BITS((C)<<8, 16)
// Write 16 bits with corrected endianness for 16 bit colours
#define tft_Write_16(C) TFT_WRITE_BITS((C)<<8 | (C)>>8, 16)
// Future option for transfer without wait
#define tft_Write_16N(C) tft_Write_16(C)
// Write 16 bits
#define tft_Write_16S(C) TFT_WRITE_BITS(C, 16)
// Write 32 bits
#define tft_Write_32(C) TFT_WRITE_BITS(C, 32)
// Write two address coordinates
#define tft_Write_32C(C,D) TFT_WRITE_BITS((C)<<24 | (C), 32); \
TFT_WRITE_BITS((D)<<24 | (D), 32)
// Write same value twice
#define tft_Write_32D(C) tft_Write_32C(C,C)
////////////////////////////////////////////////////////////////////////////////////////
// Macros for all other SPI displays
////////////////////////////////////////////////////////////////////////////////////////
#else
/* Old macros
// ESP32 low level SPI writes for 8, 16 and 32 bit values
// to avoid the function call overhead
#define TFT_WRITE_BITS(D, B) \
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), B-1); \
WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), D); \
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR); \
while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
// Write 8 bits
#define tft_Write_8(C) TFT_WRITE_BITS(C, 8)
// Write 16 bits with corrected endianness for 16 bit colours
#define tft_Write_16(C) TFT_WRITE_BITS((C)<<8 | (C)>>8, 16)
// Write 16 bits
#define tft_Write_16S(C) TFT_WRITE_BITS(C, 16)
// Write 32 bits
#define tft_Write_32(C) TFT_WRITE_BITS(C, 32)
// Write two address coordinates
#define tft_Write_32C(C,D) TFT_WRITE_BITS((uint16_t)((D)<<8 | (D)>>8)<<16 | (uint16_t)((C)<<8 | (C)>>8), 32)
// Write same value twice
#define tft_Write_32D(C) TFT_WRITE_BITS((uint16_t)((C)<<8 | (C)>>8)<<16 | (uint16_t)((C)<<8 | (C)>>8), 32)
//*/
//* Replacement slimmer macros
#if !defined(CONFIG_IDF_TARGET_ESP32S3)
#define TFT_WRITE_BITS(D, B) *_spi_mosi_dlen = B-1; \
*_spi_w = D; \
*_spi_cmd = SPI_USR; \
while (*_spi_cmd & SPI_USR);
#else
#define TFT_WRITE_BITS(D, B) *_spi_mosi_dlen = B-1; \
*_spi_w = D; \
*_spi_cmd = SPI_UPDATE; \
while (*_spi_cmd & SPI_UPDATE); \
*_spi_cmd = SPI_USR; \
while (*_spi_cmd & SPI_USR);
#endif
// Write 8 bits
#define tft_Write_8(C) TFT_WRITE_BITS(C, 8)
// Write 16 bits with corrected endianness for 16 bit colours
#define tft_Write_16(C) TFT_WRITE_BITS((C)<<8 | (C)>>8, 16)
// Future option for transfer without wait
#if !defined(CONFIG_IDF_TARGET_ESP32S3)
#define tft_Write_16N(C) *_spi_mosi_dlen = 16-1; \
*_spi_w = ((C)<<8 | (C)>>8); \
*_spi_cmd = SPI_USR;
#else
#define tft_Write_16N(C) *_spi_mosi_dlen = 16-1; \
*_spi_w = ((C)<<8 | (C)>>8); \
*_spi_cmd = SPI_UPDATE; \
while (*_spi_cmd & SPI_UPDATE); \
*_spi_cmd = SPI_USR;
#endif
// Write 16 bits
#define tft_Write_16S(C) TFT_WRITE_BITS(C, 16)
// Write 32 bits
#define tft_Write_32(C) TFT_WRITE_BITS(C, 32)
// Write two address coordinates
#define tft_Write_32C(C,D) TFT_WRITE_BITS((uint16_t)((D)<<8 | (D)>>8)<<16 | (uint16_t)((C)<<8 | (C)>>8), 32)
// Write same value twice
#define tft_Write_32D(C) TFT_WRITE_BITS((uint16_t)((C)<<8 | (C)>>8)<<16 | (uint16_t)((C)<<8 | (C)>>8), 32)
//*/
#endif
#ifndef tft_Write_16N
#define tft_Write_16N tft_Write_16
#endif
////////////////////////////////////////////////////////////////////////////////////////
// Macros to read from display using SPI or software SPI
////////////////////////////////////////////////////////////////////////////////////////
#if !defined (TFT_PARALLEL_8_BIT)
// Read from display using SPI or software SPI
// Use a SPI read transfer
#define tft_Read_8() spi.transfer(0)
#endif
// Concatenate a byte sequence A,B,C,D to CDAB, P is a uint8_t pointer
#define DAT8TO32(P) ( (uint32_t)P[0]<<8 | P[1] | P[2]<<24 | P[3]<<16 )
#endif // Header end

View File

@ -19,7 +19,7 @@
#define DMA_BUSY_CHECK // DMA not available, leave blank
// Initialise processor specific SPI functions, used by init()
#if (!defined (SUPPORT_TRANSACTIONS) && defined (ARDUINO_ARCH_ESP8266))
#if (!defined (SUPPORT_TRANSACTIONS) && defined (ESP8266))
#define INIT_TFT_DATA_BUS \
spi.setBitOrder(MSBFIRST); \
spi.setDataMode(TFT_SPI_MODE); \

View File

@ -28,17 +28,9 @@
// SPI PIO code for 16 bit colour transmit
#include "pio_SPI.pio.h"
#endif
#elif defined (TFT_PARALLEL_8_BIT)
#if defined (SSD1963_DRIVER)
// PIO code for 8 bit parallel interface (18 bit colour)
#include "pio_8bit_parallel_18bpp.pio.h"
#else
// PIO code for 8 bit parallel interface (16 bit colour)
#include "pio_8bit_parallel.pio.h"
#endif
#else // must be TFT_PARALLEL_16_BIT
// PIO code for 16 bit parallel interface (16 bit colour)
#include "pio_16bit_parallel.pio.h"
#else
// SPI PIO code for 8 bit parallel interface (16 bit colour)
#include "pio_8bit_parallel.pio.h"
#endif
// Board package specific differences
@ -197,7 +189,7 @@ void pioinit(uint32_t clock_freq) {
pio_instr_set_dc = pio_encode_set((pio_src_dest)0, 1);
pio_instr_clr_dc = pio_encode_set((pio_src_dest)0, 0);
}
#else // 8 or 16 bit parallel
#else
void pioinit(uint16_t clock_div, uint16_t fract_div) {
// Find a free SM on one of the PIO's
@ -220,27 +212,21 @@ void pioinit(uint16_t clock_div, uint16_t fract_div) {
}
}
*/
#if defined (TFT_PARALLEL_8_BIT)
uint8_t bits = 8;
#else // must be TFT_PARALLEL_16_BIT
uint8_t bits = 16;
#endif
// Load the PIO program
program_offset = pio_add_program(tft_pio, &tft_io_program);
// Associate pins with the PIO
pio_gpio_init(tft_pio, TFT_DC);
pio_gpio_init(tft_pio, TFT_WR);
for (int i = 0; i < bits; i++) {
for (int i = 0; i < 8; i++) {
pio_gpio_init(tft_pio, TFT_D0 + i);
}
// Configure the pins to be outputs
pio_sm_set_consecutive_pindirs(tft_pio, pio_sm, TFT_DC, 1, true);
pio_sm_set_consecutive_pindirs(tft_pio, pio_sm, TFT_WR, 1, true);
pio_sm_set_consecutive_pindirs(tft_pio, pio_sm, TFT_D0, bits, true);
pio_sm_set_consecutive_pindirs(tft_pio, pio_sm, TFT_D0, 8, true);
// Configure the state machine
pio_sm_config c = tft_io_program_get_default_config(program_offset);
@ -248,8 +234,8 @@ void pioinit(uint16_t clock_div, uint16_t fract_div) {
sm_config_set_set_pins(&c, TFT_DC, 1);
// Define the single side-set pin
sm_config_set_sideset_pins(&c, TFT_WR);
// Define the consecutive pins that are used for data output
sm_config_set_out_pins(&c, TFT_D0, bits);
// Define the 8 consecutive pins that are used for data output
sm_config_set_out_pins(&c, TFT_D0, 8);
// Set clock divider and fractional divider
sm_config_set_clkdiv_int_frac(&c, clock_div, fract_div);
// Make a single 8 words FIFO from the 4 words TX and RX FIFOs
@ -284,7 +270,7 @@ void pioinit(uint16_t clock_div, uint16_t fract_div) {
// PIO handles pixel block fill writes
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len)
{
#if defined (SPI_18BIT_DRIVER) || (defined (SSD1963_DRIVER) && defined (TFT_PARALLEL_8_BIT))
#if defined (SPI_18BIT_DRIVER)
uint32_t col = ((color & 0xF800)<<8) | ((color & 0x07E0)<<5) | ((color & 0x001F)<<3);
if (len) {
WAIT_FOR_STALL;
@ -332,7 +318,7 @@ void TFT_eSPI::pushBlock(uint16_t color, uint32_t len){
** Description: Write a sequence of pixels
***************************************************************************************/
void TFT_eSPI::pushPixels(const void* data_in, uint32_t len){
#if defined (SPI_18BIT_DRIVER) || (defined (SSD1963_DRIVER) && defined (TFT_PARALLEL_8_BIT))
#if defined (SPI_18BIT_DRIVER)
uint16_t *data = (uint16_t*)data_in;
if (_swapBytes) {
while ( len-- ) {
@ -582,7 +568,7 @@ void TFT_eSPI::pushPixels(const void* data_in, uint32_t len){
////////////////////////////////////////////////////////////////////////////////////////
#ifdef RP2040_DMA // DMA functions for 16 bit SPI and 8/16 bit parallel displays
#ifdef RP2040_DMA // DMA functions for 16 bit SPI and 8 bit parallel displays
////////////////////////////////////////////////////////////////////////////////////////
/*
These are created in header file:

View File

@ -30,7 +30,7 @@
// Include processor specific header
// None
#if defined (TFT_PARALLEL_8_BIT) || defined (TFT_PARALLEL_16_BIT) || defined (RP2040_PIO_SPI)
#if defined (TFT_PARALLEL_8_BIT) || defined (RP2040_PIO_SPI)
#define RP2040_PIO_INTERFACE
#define RP2040_PIO_PUSHBLOCK
#endif
@ -65,20 +65,9 @@
#define DMA_BUSY_CHECK
#endif
// Handle high performance MHS RPi display type
#if defined (MHS_DISPLAY_TYPE) && !defined (RPI_DISPLAY_TYPE)
#define RPI_DISPLAY_TYPE
#endif
#if !defined (RP2040_PIO_INTERFACE) // SPI
#if defined (MHS_DISPLAY_TYPE) // High speed RPi TFT type always needs 16 bit transfers
// This swaps to 16 bit mode, used for commands so wait avoids clash with DC timing
#define INIT_TFT_DATA_BUS hw_write_masked(&spi_get_hw(SPI_X)->cr0, (16 - 1) << SPI_SSPCR0_DSS_LSB, SPI_SSPCR0_DSS_BITS)
#else
// Initialise processor specific SPI functions, used by init()
#define INIT_TFT_DATA_BUS // Not used
#endif
// Initialise processor specific SPI functions, used by init()
#define INIT_TFT_DATA_BUS // Not used
// Wait for tx to end, flush rx FIFO, clear rx overrun
#define SPI_BUSY_CHECK while (spi_get_hw(SPI_X)->sr & SPI_SSPSR_BSY_BITS) {}; \
@ -91,37 +80,18 @@
#endif
#else
// Different controllers have different minimum write cycle periods, so the PIO clock is changed accordingly
// The PIO clock is a division of the CPU clock so scales when the processor is overclocked
// PIO write frequency = (CPU clock/(4 * RP2040_PIO_CLK_DIV))
// The write cycle periods below assume a 125MHz CPU clock speed
#if defined (TFT_PARALLEL_8_BIT) || defined (TFT_PARALLEL_16_BIT)
#if defined (RP2040_PIO_CLK_DIV)
#if (RP2040_PIO_CLK_DIV > 0)
#define DIV_UNITS RP2040_PIO_CLK_DIV
#define DIV_FRACT 0
#else
#define DIV_UNITS 3
#define DIV_FRACT 0
#endif
#elif defined (TFT_PARALLEL_16_BIT)
// Different display drivers have different minimum write cycle times
#if defined (HX8357C_DRIVER) || defined (SSD1963_DRIVER)
#define DIV_UNITS 1 // 32ns write cycle time SSD1963, HX8357C (maybe HX8357D?)
#elif defined (ILI9486_DRIVER) || defined (HX8357B_DRIVER) || defined (HX8357D_DRIVER)
#define DIV_UNITS 2 // 64ns write cycle time ILI9486, HX8357D, HX8357B
#else // ILI9481 needs a slower cycle time
#define DIV_UNITS 3 // 96ns write cycle time
#endif
#define DIV_FRACT 0
#else // 8 bit parallel mode default 64ns write cycle time
#define DIV_UNITS 2
#define DIV_FRACT 0 // Note: Fractional values done with clock period dithering
#endif
// ILI9481 needs a slower cycle time
// Byte rate = (CPU clock/(4 * divider))
#ifdef ILI9481_DRIVER
#define DIV_UNITS 1
#define DIV_FRACT 160
#else
#define DIV_UNITS 1
#define DIV_FRACT 0
#endif
// Initialise TFT data bus
#if defined (TFT_PARALLEL_8_BIT) || defined (TFT_PARALLEL_16_BIT)
#if defined (TFT_PARALLEL_8_BIT)
#define INIT_TFT_DATA_BUS pioinit(DIV_UNITS, DIV_FRACT);
#elif defined (RP2040_PIO_SPI)
#define INIT_TFT_DATA_BUS pioinit(SPI_FREQUENCY);
@ -152,7 +122,7 @@
#if !defined (RP2040_PIO_INTERFACE)// SPI
//#define DC_C sio_hw->gpio_clr = (1ul << TFT_DC)
//#define DC_D sio_hw->gpio_set = (1ul << TFT_DC)
#if defined (RPI_DISPLAY_TYPE) && !defined (MHS_DISPLAY_TYPE)
#if defined (RPI_DISPLAY_TYPE)
#define DC_C digitalWrite(TFT_DC, LOW);
#define DC_D digitalWrite(TFT_DC, HIGH);
#else
@ -178,7 +148,7 @@
#define CS_H // No macro allocated so it generates no code
#else
#if !defined (RP2040_PIO_INTERFACE) // SPI
#if defined (RPI_DISPLAY_TYPE) && !defined (MHS_DISPLAY_TYPE)
#if defined (RPI_DISPLAY_TYPE)
#define CS_L digitalWrite(TFT_CS, LOW);
#define CS_H digitalWrite(TFT_CS, HIGH);
#else
@ -214,7 +184,7 @@
////////////////////////////////////////////////////////////////////////////////////////
// Define the WR (TFT Write) pin drive code
////////////////////////////////////////////////////////////////////////////////////////
#if !defined (TFT_PARALLEL_8_BIT) && !defined (TFT_PARALLEL_16_BIT) // SPI
#if !defined (TFT_PARALLEL_8_BIT) // SPI
#ifdef TFT_WR
#define WR_L digitalWrite(TFT_WR, LOW)
#define WR_H digitalWrite(TFT_WR, HIGH)
@ -298,28 +268,7 @@
// Macros to write commands/pixel colour data to other displays
////////////////////////////////////////////////////////////////////////////////////////
#else
#if defined (MHS_DISPLAY_TYPE) // High speed RPi TFT type always needs 16 bit transfers
// This swaps to 16 bit mode, used for commands so wait avoids clash with DC timing
#define tft_Write_8(C) while (spi_get_hw(SPI_X)->sr & SPI_SSPSR_BSY_BITS) {}; \
hw_write_masked(&spi_get_hw(SPI_X)->cr0, (16 - 1) << SPI_SSPCR0_DSS_LSB, SPI_SSPCR0_DSS_BITS); \
spi_get_hw(SPI_X)->dr = (uint32_t)((C) | ((C)<<8)); \
while (spi_get_hw(SPI_X)->sr & SPI_SSPSR_BSY_BITS) {}; \
// Note: the following macros do not wait for the end of transmission
#define tft_Write_16(C) while (!spi_is_writable(SPI_X)){}; spi_get_hw(SPI_X)->dr = (uint32_t)(C)
#define tft_Write_16N(C) while (!spi_is_writable(SPI_X)){}; spi_get_hw(SPI_X)->dr = (uint32_t)(C)
#define tft_Write_16S(C) while (!spi_is_writable(SPI_X)){}; spi_get_hw(SPI_X)->dr = (uint32_t)(C)<<8 | (C)>>8
#define tft_Write_32(C) spi_get_hw(SPI_X)->dr = (uint32_t)((C)>>16); spi_get_hw(SPI_X)->dr = (uint32_t)(C)
#define tft_Write_32C(C,D) spi_get_hw(SPI_X)->dr = (uint32_t)(C); spi_get_hw(SPI_X)->dr = (uint32_t)(D)
#define tft_Write_32D(C) spi_get_hw(SPI_X)->dr = (uint32_t)(C); spi_get_hw(SPI_X)->dr = (uint32_t)(C)
#elif defined (RPI_DISPLAY_TYPE) // RPi TFT type always needs 16 bit transfers
#if defined (RPI_DISPLAY_TYPE) // RPi TFT type always needs 16 bit transfers
#define tft_Write_8(C) spi.transfer(C); spi.transfer(C)
#define tft_Write_16(C) spi.transfer((uint8_t)((C)>>8));spi.transfer((uint8_t)((C)>>0))
#define tft_Write_16N(C) spi.transfer((uint8_t)((C)>>8));spi.transfer((uint8_t)((C)>>0))
@ -406,9 +355,9 @@
#define TX_FIFO tft_pio->txf[pio_sm]
// Temporary - to be deleted
#define GPIO_DIR_MASK 0
#define dir_mask 0
#if defined (SPI_18BIT_DRIVER) || defined (SSD1963_DRIVER) // 18 bit colour (3 bytes)
#if defined (SPI_18BIT_DRIVER) // SPI 18 bit colour
// This writes 8 bits, then switches back to 16 bit mode automatically
// Have already waited for pio stalled (last data write complete) when DC switched to command mode
// The wait for stall allows DC to be changed immediately afterwards
@ -435,18 +384,13 @@
#define tft_Write_32D(C) WAIT_FOR_FIFO_FREE(2); TX_FIFO = (((C)<<8) | ((C)>>8)); tft_Write_8L(C)
#else // PIO interface, SPI or parallel
// This writes 8 bits, then switches back to 16 bit mode automatically
// Have already waited for pio stalled (last data write complete) when DC switched to command mode
// The wait for stall allows DC to be changed immediately afterwards
#if defined (TFT_PARALLEL_8_BIT) || defined (RP2040_PIO_SPI)
#else
// This writes 8 bits, then switches back to 16 bit mode automatically
// Have already waited for pio stalled (last data write complete) when DC switched to command mode
// The wait for stall allows DC to be changed immediately afterwards
#define tft_Write_8(C) tft_pio->sm[pio_sm].instr = pio_instr_jmp8; \
TX_FIFO = (C); \
WAIT_FOR_STALL
#else // For 16 bit parallel 16 bits are always sent
#define tft_Write_8(C) TX_FIFO = (C); \
WAIT_FOR_STALL
#endif
// Note: the following macros do not wait for the end of transmission

View File

@ -306,7 +306,7 @@
#if defined (TFT_PARALLEL_8_BIT)
// Mask for the 8 data bits to set pin directions (not used)
#define GPIO_DIR_MASK 0
#define dir_mask 0
#define PARALLEL_INIT_TFT_DATA_BUS // None

View File

@ -1,62 +0,0 @@
// -------------------------------------------------- //
// This file is autogenerated by pioasm; do not edit! //
// 16 bit parallel //
// -------------------------------------------------- //
#pragma once
#if !PICO_NO_HARDWARE
#include "hardware/pio.h"
#endif
// ------ //
// tft_io //
// ------ //
#define tft_io_wrap_target 7
#define tft_io_wrap 20
#define tft_io_offset_block_fill 0u
#define tft_io_offset_start_8 7u
#define tft_io_offset_start_tx 7u
#define tft_io_offset_set_addr_window 10u
static const uint16_t tft_io_program_instructions[] = {
0x98a0, // 0: pull block side 1
0xa027, // 1: mov x, osr
0x80a0, // 2: pull block
0xa047, // 3: mov y, osr
0xb8e1, // 4: mov osr, x side 1
0x7100, // 5: out pins, 32 side 0 [1]
0x1884, // 6: jmp y--, 4 side 1
// .wrap_target
0x98a0, // 7: pull block side 1
0x7100, // 8: out pins, 32 side 0 [1]
0x1807, // 9: jmp 7 side 1
0xf822, // 10: set x, 2 side 1
0xe000, // 11: set pins, 0
0x80a0, // 12: pull block
0x7000, // 13: out pins, 32 side 0
0x0033, // 14: jmp !x, 19
0x98a0, // 15: pull block side 1
0xe001, // 16: set pins, 1
0x7108, // 17: out pins, 8 side 0 [1]
0x19f1, // 18: jmp !osre, 17 side 1 [1]
0x184b, // 19: jmp x--, 11 side 1
0xe001, // 20: set pins, 1
// .wrap
};
#if !PICO_NO_HARDWARE
static const struct pio_program tft_io_program = {
.instructions = tft_io_program_instructions,
.length = 21,
.origin = -1,
};
static inline pio_sm_config tft_io_program_get_default_config(uint offset) {
pio_sm_config c = pio_get_default_sm_config();
sm_config_set_wrap(&c, offset + tft_io_wrap_target, offset + tft_io_wrap);
sm_config_set_sideset(&c, 2, true, false);
return c;
}
#endif

View File

@ -0,0 +1,92 @@
// Raspberry Pi Pico PIO program to output data to a TFT
// controller via a 8 bit 8080 style data path.
// Original sourced from:
// https://github.com/zapta/pio_tft
// Side set: 1 output pin, TFT_WR. Active low.
// Data set: 8 consecutive output pins, TFT_D0 .. TFT_D7
.program tft_io
.side_set 1 opt ; The TFT_WR output.
// The C++ code switches between the different SM routines
// by waiting for the SM to be idle and setting its PC.
// The default SM routine is a 16 bit transfer
// Do a block fill of N+1 pixels.
public block_fill:
// Fetch colour value.
pull side 1
// Move colour to x.
mov x, osr
// Fetch pixel count N (sends N+1 pixels).
pull
// Move pixel count to y.
mov y, osr
next:
// Copy colour value into osr, colour in LS 16 bits.
mov osr, x side 1
// Output colour 8 MS bits, unwanted top 16 bits shifted through.
out pins, 24 side 0 [1]
// Write first colour byte.
nop side 1 [1]
// Write second colour byte.
out pins, 8 side 0 [1]
// Decrement pixel count and loop.
jmp y--, next side 1
.wrap_target
// Transmit a 16 bit value (LS 16 bits of 32 bits).
public start_tx:
// Fetch the next 32 bit value from the TX FIFO and set TFT_WR high.
pull side 1
// Write the first byte (MSB) and set WR low. This also
// shifts the unused top 16 bits through.
out pins, 24 side 0 [1]
// Set WR high and delay to next byte.
nop side 1 [1]
// Output the second byte and set TFT_WRITE low.
out pins, 8 side 0 [1]
// Set WR high and jump back to start.
jmp start_tx side 1
// Transmit an 8 bit value (LS 8 bits of 32 bits).
public start_8:
// Fetch the next 32 bit value from the TX FIFO and set TFT_WR high.
pull side 1
// Write the first byte (LSB) and sets WR low. This also
// shifts the unused top 24 bits through.
out pins, 32 side 0 [1]
// Jump to start
jmp start_tx side 1
// Transmit a set window command sequence.
public set_addr_window:
// Loop count in x (to send caset, paset and ramwr commands).
set x, 2 side 1
pull_cmd:
// Set TFT_DC low.
set pins, 0
// Fetch caset, paset or ramwr.
pull
// Output LS byte (caset, paset or ramwr), discarding top 24 bits, set TFT_WR low.
out pins, 32 side 0
// Jump to end if 3rd cmd byte ramwr sent (x == 0)
jmp !x, end_set_addr
// pull next start and end coordinates, TFT_WR high.
pull side 1
// Set TFT_DC high.
set pins, 1
send_xy:
// Output byte, TFT_WR low.
out pins, 8 side 0 [1]
// Loop until 4 bytes sent, TFT_WR high.
jmp !osre, send_xy side 1 [1]
end_set_addr:
// Loop back for next command and write last command.
jmp x--, pull_cmd side 1
// Set DC high.
set pins, 1
// Auto-wrap back to start_tx.
.wrap

View File

@ -1,6 +1,5 @@
// -------------------------------------------------- //
// This file is autogenerated by pioasm; do not edit! //
// 8 bit parallel //
// -------------------------------------------------- //
#pragma once

View File

@ -1,73 +0,0 @@
// -------------------------------------------------- //
// This file is autogenerated by pioasm; do not edit! //
// -------------------------------------------------- //
#pragma once
#if !PICO_NO_HARDWARE
#include "hardware/pio.h"
#endif
// ------ //
// tft_io //
// ------ //
#define tft_io_wrap_target 11
#define tft_io_wrap 31
#define tft_io_offset_block_fill 0u
#define tft_io_offset_start_tx 11u
#define tft_io_offset_start_8 18u
#define tft_io_offset_set_addr_window 21u
static const uint16_t tft_io_program_instructions[] = {
0x98a0, // 0: pull block side 1
0xa027, // 1: mov x, osr
0x80a0, // 2: pull block
0xa047, // 3: mov y, osr
0xb8e1, // 4: mov osr, x side 1
0x7110, // 5: out pins, 16 side 0 [1]
0xb942, // 6: nop side 1 [1]
0x7108, // 7: out pins, 8 side 0 [1]
0xb942, // 8: nop side 1 [1]
0x7108, // 9: out pins, 8 side 0 [1]
0x1884, // 10: jmp y--, 4 side 1
// .wrap_target
0x98a0, // 11: pull block side 1
0x7110, // 12: out pins, 16 side 0 [1]
0xb942, // 13: nop side 1 [1]
0x7108, // 14: out pins, 8 side 0 [1]
0xb942, // 15: nop side 1 [1]
0x7108, // 16: out pins, 8 side 0 [1]
0x180b, // 17: jmp 11 side 1
0x98a0, // 18: pull block side 1
0x7100, // 19: out pins, 32 side 0 [1]
0x180b, // 20: jmp 11 side 1
0xf822, // 21: set x, 2 side 1
0xe000, // 22: set pins, 0
0x80a0, // 23: pull block
0x7000, // 24: out pins, 32 side 0
0x003e, // 25: jmp !x, 30
0x98a0, // 26: pull block side 1
0xe001, // 27: set pins, 1
0x7108, // 28: out pins, 8 side 0 [1]
0x19fc, // 29: jmp !osre, 28 side 1 [1]
0x1856, // 30: jmp x--, 22 side 1
0xe001, // 31: set pins, 1
// .wrap
};
#if !PICO_NO_HARDWARE
static const struct pio_program tft_io_program = {
.instructions = tft_io_program_instructions,
.length = 32,
.origin = -1,
};
static inline pio_sm_config tft_io_program_get_default_config(uint offset) {
pio_sm_config c = pio_get_default_sm_config();
sm_config_set_wrap(&c, offset + tft_io_wrap_target, offset + tft_io_wrap);
sm_config_set_sideset(&c, 2, true, false);
return c;
}
#endif

89
Processors/pio_SPI.pio Normal file
View File

@ -0,0 +1,89 @@
// Raspberry Pi Pico PIO program to output data to a TFT
// controller via a SPI output data path.
//"Set" set: 1 output pin, TFT_DC
// Side set: 1 output pin, TFT_SCLK
// Data set: 1 output pin, TFT_MOSI
.program tft_io
.side_set 1 opt ; The TFT_SCLK output.
// The C++ code switches between the 8 bits and 16 bits loops
// by waiting for the SM to be idle and setting its PC.
//
// 8 bit transfer
public start_8:
// Pull the next 32 bit value from the TX FIFO.
pull side 0
// Lose the top 24 bits, send 1st bit
out pins, 25
// Now send remaining bits
jmp spi_out side 1
public set_addr_window:
// Loop count in x for caset, paset and ramwr
set x, 2 side 0
pull_cmd:
// Set DC low
set pins, 0
// Fetch and output LS byte (caset, paset or ramwr), discarding top 24 bits, set WR low
pull side 0
out pins, 25
nop side 1
next_cmd_bit:
out pins, 1 side 0
jmp !osre, next_cmd_bit side 1
// Set DC high
set pins, 1 side 0
// Finish if 3rd cmd byte ramwr sent (x == 0)
jmp !x, start_tx
pull
next_xy:
// send 32 bit start and end coordinates
out pins, 1 side 0
jmp !osre, next_xy side 1
// Loop back for next command
jmp x--, pull_cmd side 0
// End
jmp start_tx
public block_fill:
// Fetch colour value
pull side 0
// Move colour to x
mov x, osr
// Fetch pixel count
pull
// Move pixel count to y
mov y, osr
next_16:
// Copy colour value back into osr
mov osr, x side 0
// Lose the top 16 bits, send 1st bit
out pins, 17 side 0
nop side 1
next_bit:
// Output next 15 colour bits
out pins, 1 side 0
// Set TFT_SCLK high and jump for next bit
jmp !osre, next_bit side 1
// Decrement count and loop
jmp y--, next_16 side 0
// Now drop back to 16 bit output
.wrap_target
public start_tx:
// Pull the next 32 bit value from the TX FIFO.
// Send the bottom 16 bits
pull side 0
// Drop the first 16 bits, write first bit
out pins, 17 side 0
nop side 1
spi_out:
// Output the next 15 bits
out pins, 1 side 0
// Set TFT_SCLK high and jump for next bit
jmp !osre, spi_out side 1
// Return to start
.wrap

View File

@ -1,6 +1,5 @@
// -------------------------------------------------- //
// This file is autogenerated by pioasm; do not edit! //
// 8 + 16 bit SPI - no auto colour conversion //
// -------------------------------------------------- //
#pragma once

View File

@ -0,0 +1,89 @@
// Raspberry Pi Pico PIO program to output 18 bit data to a TFT
// controller via a SPI output data path.
//"Set" set: 1 output pin, TFT_DC
// Side set: 1 output pin, TFT_SCLK
// Data set: 1 output pin, TFT_MOSI
.program tft_io
.side_set 1 opt ; The TFT_SCLK output.
// The C++ code switches between the 8 bits and 16 bits loops
// by waiting for the SM to be idle and setting its PC.
//
// 8 bit transfer
public start_8:
// Pull the next 32 bit value from the TX FIFO.
pull side 0
// Lose the top 24 bits, send 1st bit
out pins, 25
// Now send remaining bits
jmp spi_out side 1
public set_addr_window:
// Loop count in x for caset, paset and ramwr
set x, 2 side 0
pull_cmd:
// Set DC low
set pins, 0
// Fetch and output LS byte (caset, paset or ramwr), discarding top 24 bits, set WR low
pull side 0
out pins, 25
nop side 1
next_cmd_bit:
out pins, 1 side 0
jmp !osre, next_cmd_bit side 1
// Set DC high
set pins, 1 side 0
// Finish if 3rd cmd byte ramwr sent (x == 0)
jmp !x, start_tx
pull
next_xy:
// send 32 bit start and end coordinates
out pins, 1 side 0
jmp !osre, next_xy side 1
// Loop back for next command
jmp x--, pull_cmd side 0
// End
jmp start_tx
public block_fill:
// Fetch colour value
pull side 0
// Move colour to x
mov x, osr
// Fetch pixel count
pull
// Move pixel count to y
mov y, osr
next_16:
// Copy colour value back into osr
mov osr, x side 0
// Lose the top 8 bits, send 1st bit
out pins, 9 side 0
nop side 1
next_bit:
// Output next remaining bits
out pins, 1 side 0
// Set TFT_SCLK high and jump for next bit
jmp !osre, next_bit side 1
// Decrement count and loop
jmp y--, next_16 side 0
// Now drop back to 16 bit output
.wrap_target
public start_tx:
// Pull the next 32 bit value from the TX FIFO.
// Send the bottom 24 bits
pull side 0
// Drop the first 8 bits, write first bit
out pins, 9 side 0
nop side 1
spi_out:
// Output the remaining bits
out pins, 1 side 0
// Set TFT_SCLK high and jump for next bit
jmp !osre, spi_out side 1
// Return to start
.wrap

View File

@ -1,6 +1,5 @@
// -------------------------------------------------- //
// This file is autogenerated by pioasm; do not edit! //
// 8 + 18 bit SPI - no auto colour conversion //
// -------------------------------------------------- //
#pragma once

View File

@ -1,47 +1,12 @@
A ["Discussions"](https://github.com/Bodmer/TFT_eSPI/discussions) facility has been added for Q&A etc. Use the ["Issues"](https://github.com/Bodmer/TFT_eSPI/issues) tab only for problems with the library. Thanks!
# News
1. New functions have been added to draw smooth (antialiased) arcs, circles, and rounded rectangle outlines. New sketches are provided in the "Smooth Graphics" examples folder. Arcs can be drawn with or without anti-aliasing (which will then render faster). The arc ends can be straight or rounded. The arc drawing algorithm uses an optimised fixed point sqrt() function to improve performance on processors that do not have a hardware Floating Point Unit (e.g. RP2040). Here are two demo images, on the left smooth (anti-aliased) arcs with rounded ends, the image to the right is the same resolution (grabbed from the same 240x240 TFT) with the smoothing diasbled (no anti-aliasing):
1. New anti-aliased graphics functions to draw lines, wedge shaped lines, circles and rounded rectangles. [Examples are included](https://github.com/Bodmer/TFT_eSPI/tree/master/examples/Smooth%20Graphics). Examples have also been added to [display PNG compressed images](https://github.com/Bodmer/TFT_eSPI/tree/master/examples/PNG%20Images) (note: requires ~40kbytes RAM).
![arcs](https://github.com/Bodmer/Github-images/blob/main/aa_arc_240x240.png) ![pixelated_arcs](https://github.com/Bodmer/Github-images/blob/main/no_aa_arc_240x240.png)
2. Frank Boesing has created an extension library for TFT_eSPI that allows a large range of ready-built fonts to be used. Frank's library (adapted to permit rendering in sprites as well as TFT) can be [downloaded here](https://github.com/Bodmer/TFT_eSPI_ext). More than 3300 additional Fonts are [available here](https://github.com/FrankBoesing/fonts/tree/master/ofl). The TFT_eSPI_ext library contains examples that demonstrate the use of the fonts.
Here the smooth arcs have been used to create anti-aliased meter gauges on a 320x240 TFT:
![arcs](https://github.com/Bodmer/Github-images/blob/main/xarc_meters_320x240.png)
3. Users of PowerPoint experienced with running macros may be interested in the [pptm sketch generator here](https://github.com/Bodmer/PowerPoint_to_sketch), this converts graphics and tables drawn in PowerPoint slides into an Arduino sketch that renders the graphics on a 480x320 TFT. This is based on VB macros [created by Kris Kasprzak here](https://github.com/KrisKasprzak/Powerpoint-ILI9341_t3).
2. An excellent new compatible library is available which can render TrueType fonts on a TFT screen (or into a sprite). This has been developed by [takkaO](https://github.com/takkaO/OpenFontRender), I have created a branch with some bug fixes [here](https://github.com/Bodmer/OpenFontRender). The library provides access to compact font files, with fully scaleable anti-aliased glyphs. Left, middle and right justified text can also be printed to the screen. I have added TFT_eSPI specific examples to the OpenFontRender library and tested on RP2040 and ESP32 processors, the ESP8266 does not have sufficient RAM due to the glyph render complexity. Here is a demo screen where a single 12kbyte font file binary was used to render fully anti-aliased glyphs of gradually increasing size on a 320x480 TFT screen:
![ttf_font_demo](https://i.imgur.com/bKkilIb.png)
3. New GUI examples have been added for sliders, buttons, graphs and meters. These examples require a new support library here:
[TFT_eWidget](https://github.com/Bodmer/TFT_eWidget)
4. Support has been added in v2.4.70 for the RP2040 with 16 bit parallel displays. This has been tested and the screen update performance is very good (4ms to clear 320 x 480 screen with HC8357C). The use of the RP2040 PIO makes it easy to change the write cycle timing for different displays. DMA with 16 bit transfers is also supported.
5. Support for the ESP32-S2, ESP32-S3 and ESP32-C3 has been added (DMA only on ESP32 S3 at the moment). Tested with v2.0.3 RC1 of the ESP32 board package. Example setups:
[Setup70_ESP32_S2_ILI9341.h](https://github.com/Bodmer/TFT_eSPI/blob/master/User_Setups/Setup70_ESP32_S2_ILI9341.h)
[Setup70b_ESP32_S3_ILI9341.h](https://github.com/Bodmer/TFT_eSPI/blob/master/User_Setups/Setup70b_ESP32_S3_ILI9341.h)
[Setup70c_ESP32_C3_ILI9341.h](https://github.com/Bodmer/TFT_eSPI/blob/master/User_Setups/Setup70c_ESP32_C3_ILI9341.h)
[Setup70d_ILI9488_S3_Parallel.h](https://github.com/Bodmer/TFT_eSPI/blob/master/User_Setups/Setup70d_ILI9488_S3_Parallel.h)
6. Smooth fonts can now be rendered direct to the TFT with very little flicker for quickly changing values. This is achieved by a line-by-line and block-by-block update of the glyph area without drawing pixels twice. This is a "breaking" change for some sketches because a new true/false parameter is needed to render the background. The default is false if the parameter is missing, Examples:
tft.setTextColor(TFT_WHITE, TFT_BLUE, true);
spr.setTextColor(TFT_BLUE, TFT_BLACK, true);
Note: background rendering for Smooth fonts is also now available when using the print stream e.g. with: tft.println("Hello World");
7. New anti-aliased graphics functions to draw lines, wedge shaped lines, circles and rounded rectangles. [Examples are included](https://github.com/Bodmer/TFT_eSPI/tree/master/examples/Smooth%20Graphics). Examples have also been added to [display PNG compressed images](https://github.com/Bodmer/TFT_eSPI/tree/master/examples/PNG%20Images) (note: requires ~40kbytes RAM).
8. Frank Boesing has created an extension library for TFT_eSPI that allows a large range of ready-built fonts to be used. Frank's library (adapted to permit rendering in sprites as well as TFT) can be [downloaded here](https://github.com/Bodmer/TFT_eSPI_ext). More than 3300 additional Fonts are [available here](https://github.com/FrankBoesing/fonts/tree/master/ofl). The TFT_eSPI_ext library contains examples that demonstrate the use of the fonts.
9. Users of PowerPoint experienced with running macros may be interested in the [pptm sketch generator here](https://github.com/Bodmer/PowerPoint_to_sketch), this converts graphics and tables drawn in PowerPoint slides into an Arduino sketch that renders the graphics on a 480x320 TFT. This is based on VB macros [created by Kris Kasprzak here](https://github.com/KrisKasprzak/Powerpoint-ILI9341_t3).
10. The library contains two new functions for rectangles filled with a horizontal or vertical coloured gradient:
4. The library contains two new functions for rectangles filled with a horizontal or vertical coloured gradient:
tft.fillRectHGradient(x, y, w, h, color1, color2);
@ -49,61 +14,65 @@ Note: background rendering for Smooth fonts is also now available when using the
![Gradient](https://i.imgur.com/atR0DmP.png)
11. The RP2040 8 bit parallel interface uses the PIO. The PIO now manages the "setWindow" and "block fill" actions, releasing the processor for other tasks when areas of the screen are being filled with a colour. The PIO can optionally be used for SPI interface displays if #define RP2040_PIO_SPI is put in the setup file. Touch screens and pixel read operations are not supported when the PIO interface is used.
5. The RP2040 8 bit parallel interface uses the PIO. The PIO now manages the "setWindow" and "block fill" actions, releasing the processor for other tasks when areas of the screen are being filled with a colour. The PIO can optionally be used for SPI interface displays if #define RP2040_PIO_SPI is put in the setup file. Touch screens and pixel read operations are not supported when the PIO interface is used.
The RP2040 PIO features only work with [Earle Philhower's board package](https://github.com/earlephilhower/arduino-pico), NOT the Arduino Mbed version.
The use of PIO for SPI allows the RP2040 to be over-clocked (up to 250MHz works on my boards) in Earle's board package whilst still maintaining high SPI clock rates.
12. DMA can now be used with the Raspberry Pi Pico (RP2040) when used with 8/16 bit parallel and 16 bit colour SPI displays. See "Bouncy_Circles" sketch.
6. DMA can now be used with the Raspberry Pi Pico (RP2040) when used with both 8 bit parallel and 16 bit colour SPI displays. See "Bouncy_Circles" sketch.
["Bouncing circles"](https://www.youtube.com/watch?v=njFXIzCTQ_Q&lc=UgymaUIwOIuihvYh-Qt4AaABAg)
7. Support hase been added for the ESP32 S2 processor variant. A [new user setup](https://github.com/Bodmer/TFT_eSPI/blob/master/User_Setups/Setup70_ESP32_S2_ILI9341.h) file has been added as an example setup with an ILI9341 TFT.
8. The library now supports the Raspberry Pi Pico with both the [official Arduino board package](https://github.com/arduino/ArduinoCore-mbed) and the one provided by [Earle Philhower](https://github.com/earlephilhower/arduino-pico). The setup file "Setup60_RP2040_ILI9341.h" has been used for tests with an ILI9341 display. At the moment only SPI interface displays have been tested. SPI port 0 is the default but SPI port 1 can be specifed in the setup file if those SPI pins are used.
["Rotating cube demo"](https://www.youtube.com/watch?v=4fPxEN9ImVE)
9. The library now provides a "viewport" capability. See "Viewport_Demo" and "Viewport_graphicstest" examples. When a viewport is defined graphics will only appear within that window. The coordinate datum by default moves to the top left corner of the viewport, but can optionally remain at top left corner of TFT. The GUIslice library will make use of this feature to speed up the rendering of GUI objects ([see #769](https://github.com/Bodmer/TFT_eSPI/issues/769)).
10. The library now supports SSD1963 based screen, this has been tested on a [480x800 screen](https://www.buydisplay.com/7-tft-screen-touch-lcd-display-module-w-ssd1963-controller-board-mcu) with an ESP32. The interface is 8 bit parallel only as that controller does not support a SPI interface.
# TFT_eSPI
An Arduino IDE compatible graphics and fonts library for 32 bit processors. The library is targeted at 32 bit processors, it has been performance optimised for RP2040, STM32, ESP8266 and ESP32 types, other processors may be used but will use the slower generic Arduino interface calls. The library can be loaded using the Arduino IDE's Library Manager. Direct Memory Access (DMA) can be used with the ESP32, RP2040 and STM32 processors with SPI interface displays to improve rendering performance. DMA with a parallel interface (8 and 16 bit parallel) is only supported with the RP2040.
An Arduino IDE compatible graphics and fonts library for 32 bit processors. The library is targeted at 32 bit processors, it has been performance optimised for STM32, ESP8266 and ESP32 types. The library can be loaded using the Arduino IDE's Library Manager. Direct Memory Access (DMA) can be used with the ESP32, RP2040 and STM32 processors with SPI interface displays to improve rendering performance. DMA with a parallel interface is only supported with the RP2040.
Optimised drivers have been tested with the following processors:
Optimised drivers are incorporated for the following processors:
* RP2040, e.g. Raspberry Pi Pico
* ESP32 and ESP32-S2, ESP32-C3, ESP32-S3
* ESP32 and ESP32-S2 (ESP32C3 untested)
* ESP8266
* STM32F1xx, STM32F2xx, STM32F4xx, STM32F767 (higher RAM processors recommended)
For other processors only SPI interface displays are supported and the slower Arduino SPI library functions are used by the library. Higher clock speed processors such as used for the Teensy 3.x and 4.x boards will still provide a very good performance with the generic Arduino SPI functions.
Generic (non-optimised Arduino function calls) are used by the library for other processors.
"Four wire" SPI and 8 bit parallel interfaces are supported. Due to lack of GPIO pins the 8 bit parallel interface is NOT supported on the ESP8266. 8 bit parallel interface TFTs (e.g. UNO format mcufriend shields) can used with the STM32 Nucleo 64/144 range or the UNO format ESP32 (see below for ESP32).
Displays using the following controllers are supported:
* GC9A01
* ILI9163
* ILI9225
* ILI9341
* ILI9342
* ILI9481 (DMA not supported with SPI)
* ILI9486 (DMA not supported with SPI)
* ILI9488 (DMA not supported with SPI)
* HX8357B (16 bit parallel tested with RP2040)
* HX8357C (16 bit parallel tested with RP2040)
* HX8357D
* R61581
* RM68120 (support files added but untested)
* RM68140
* S6D02A1
* SSD1351
* SSD1963
* ST7735
* ST7789
* ST7796
* GC9A01
ILI9341 and ST7796 SPI based displays are recommended as starting point for experimenting with this library.
The library supports some TFT displays designed for the Raspberry Pi (RPi) that are based on a ILI9486 or ST7796 driver chip with a 480 x 320 pixel screen. The ILI9486 RPi display must be of the Waveshare design and use a 16 bit serial interface based on the 74HC04, 74HC4040 and 2 x 74HC4094 logic chips. Note that due to design variations between these displays not all RPi displays will work with this library, so purchasing a RPi display of these types solely for use with this library is NOT recommended.
The library supports some TFT displays designed for the Raspberry Pi (RPi) that are based on a ILI9486 or ST7796 driver chip with a 480 x 320 pixel screen. The ILI9486 RPi display must be of the Waveshare design and use a 16 bit serial interface based on the 74HC04, 74HC4040 and 2 x 74HC4094 logic chips. Note that due to design variations between these displays not all RPi displays will work with this library, so purchasing a RPi display of these types solely for use with this library is not recommended.
A "good" RPi display is the [MHS-4.0 inch Display-B type ST7796](http://www.lcdwiki.com/MHS-4.0inch_Display-B) which provides good performance. This has a dedicated controller and can be clocked at up to 80MHz with the ESP32 (125MHz with overclocked RP2040, 55MHz with STM32 and 40MHz with ESP8266). The [MHS-3.5 inch RPi ILI9486](http://www.lcdwiki.com/MHS-3.5inch_RPi_Display) based display is also supported, however the MHS ILI9341 based display of the same type does NOT work with this library.
A "good" RPi display is the [MHS-4.0 inch Display-B type ST7796](http://www.lcdwiki.com/MHS-4.0inch_Display-B) which provides good performance. This has a dedicated controller and can be clocked at up to 80MHz with the ESP32 (55MHz with STM32 and 40MHz with ESP8266). The [MHS-3.5 inch RPi ILI9486](http://www.lcdwiki.com/MHS-3.5inch_RPi_Display) based display is also supported.
Some displays permit the internal TFT screen RAM to be read, a few of the examples use this feature. The TFT_Screen_Capture example allows full screens to be captured and sent to a PC, this is handy to create program documentation.
Some displays permit the internal TFT screen RAM to be read, some of the examples use this feature. The TFT_Screen_Capture example allows full screens to be captured and sent to a PC, this is handy to create program documentation.
The library supports Waveshare 2 and 3 colour ePaper displays using full frame buffers. This addition is relatively immature and thus only one example has been provided.
@ -150,7 +119,7 @@ Configuration of the library font selections, pins used to interface with the TF
Anti-aliased (smooth) font files in "vlw" format are generated by the free [Processing IDE](https://processing.org/) using a sketch included in the library Tools folder. This sketch with the Processing IDE can be used to generate font files from your computer's font set or any TrueType (.ttf) font, the font file can include **any** combination of 16 bit Unicode characters. This means Greek, Japanese and any other UCS-2 glyphs can be used. Character arrays and Strings in UTF-8 format are supported.
The .vlw files must be uploaded to the processors FLASH filing system (SPIFFS, LittleFS or SD card) for use. Alternatively the .vlw files can be converted to C arrays (see "Smooth Font -> FLASH_Array" examples) and stored directly in FLASH as part of the compile process. The array based approach is convenient, provides performance improvements and is suitable where: either use of a filing system is undesirable, or the processor type (e.g. STM32) does not support a FLASH based filing system.
The .vlw files must be uploaded to the processors FLASH filing system (SPIFFS, LittleFS or SD card) for use. Alternatively the .vlw files can be converted to C arrays (see "Smooth Font -> FLASH_Array" examples) and stored directly in FLASH as part of the compile process. The array based approach is convenient, provides performance improvements and is suitable where: either use of a filing system is undesirable, or the processor type (e.g. STM32) does not support a FLASH based filing sytem.
Here is the Adafruit_GFX "FreeSans12pt" bitmap font compared to the same font drawn as anti-aliased:
@ -207,3 +176,10 @@ You can take this one step further and have your own setup select file and then
#include <../TFT_eSPI_Setups/my_setup_select.h>
```
To select a new setup you then edit your own my_setup_select.h file (which will not get overwritten during an upgrade).
# ePaper displays
The library was intended to support only TFT displays but using a Sprite as a 1 bit per pixel screen buffer permits support for the Waveshare 2 and 3 colour SPI ePaper displays. This addition to the library is experimental and only one example is provided. Further examples will be added.
![Example](https://i.imgur.com/L2tV129.jpg?1)

View File

@ -1,7 +1,7 @@
This is a stand-alone library that contains both graphics functions
and the TFT chip driver library. It supports the ESP8266, ESP32,
STM32 and RP2040 processors with performance optimised code. Other
Arduino IDE compatible boards are also supported but the library
then uses generic functions which will be slower. The library uses
32 bit variables extensively so this will affect performance on 8
and 16 bit processors.
and the TFT chip driver library. It supports the ESP8266, ESP32 and
STM32 processors with performance optimised code. Other Arduino IDE
compatible boards are also supported but the library then uses
generic functions which will be slower. The library uses 32 bit
variables extensively so this will affect performance on 8 and 16
bit processors.

View File

@ -1,52 +0,0 @@
// Change the width and height if required (defined in portrait mode)
// or use the constructor to over-ride defaults
#define TFT_WIDTH 320
#define TFT_HEIGHT 480
// Delay between some initialisation commands
#define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked
// Generic commands used by TFT_eSPar.cpp
#define TFT_NOP 0x00
#define TFT_SWRST 0x01
#define TFT_SLPIN 0x10
#define TFT_SLPOUT 0x11
#define TFT_INVOFF 0x20
#define TFT_INVON 0x21
#define TFT_DISPOFF 0x28
#define TFT_DISPON 0x29
#define TFT_CASET 0x2A
#define TFT_PASET 0x2B
#define TFT_RAMWR 0x2C
#define TFT_RAMRD 0x2E
#define TFT_MADCTL 0x36
#define TFT_MAD_MY 0x80
#define TFT_MAD_MX 0x40
#define TFT_MAD_MV 0x20
#define TFT_MAD_ML 0x10
#define TFT_MAD_RGB 0x00
#define TFT_MAD_BGR 0x08
#define TFT_MAD_MH 0x04
#define TFT_MAD_SS 0x02
#define TFT_MAD_GS 0x01
#ifdef TFT_RGB_ORDER
#if (TFT_RGB_ORDER == 1)
#define TFT_MAD_COLOR_ORDER TFT_MAD_RGB
#else
#define TFT_MAD_COLOR_ORDER TFT_MAD_BGR
#endif
#else
#define TFT_MAD_COLOR_ORDER TFT_MAD_BGR
#endif
#define TFT_IDXRD 0x00 // ILI9341 only, indexed control register read

View File

@ -1,76 +0,0 @@
// This is the command sequence that initialises the HX8357B driver
//
// This setup information uses simple 8 bit SPI writecommand() and writedata() functions
//
// See ST7735_Setup.h file for an alternative format
// Configure HX8357-B display
writecommand(0x11);
delay(20);
writecommand(0xD0);
writedata(0x07);
writedata(0x42);
writedata(0x18);
writecommand(0xD1);
writedata(0x00);
writedata(0x07);
writedata(0x10);
writecommand(0xD2);
writedata(0x01);
writedata(0x02);
writecommand(0xC0);
writedata(0x10);
writedata(0x3B);
writedata(0x00);
writedata(0x02);
writedata(0x11);
writecommand(0xC5);
writedata(0x08);
writecommand(0xC8);
writedata(0x00);
writedata(0x32);
writedata(0x36);
writedata(0x45);
writedata(0x06);
writedata(0x16);
writedata(0x37);
writedata(0x75);
writedata(0x77);
writedata(0x54);
writedata(0x0C);
writedata(0x00);
writecommand(0x36);
writedata(0x0a);
writecommand(0x3A);
writedata(0x55);
writecommand(0x2A);
writedata(0x00);
writedata(0x00);
writedata(0x01);
writedata(0x3F);
writecommand(0x2B);
writedata(0x00);
writedata(0x00);
writedata(0x01);
writedata(0xDF);
delay(120);
writecommand(0x29);
delay(25);
// End of HX8357B display configuration

View File

@ -1,47 +0,0 @@
// This is the command sequence that rotates the HX8357C driver coordinate frame
writecommand(TFT_MADCTL);
rotation = m % 8;
switch (rotation) {
case 0: // Portrait
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MX);
_width = _init_width;
_height = _init_height;
break;
case 1: // Landscape (Portrait + 90)
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MV);
_width = _init_height;
_height = _init_width;
break;
case 2: // Inverter portrait
writedata( TFT_MAD_COLOR_ORDER | TFT_MAD_MY);
_width = _init_width;
_height = _init_height;
break;
case 3: // Inverted landscape
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MV | TFT_MAD_MX | TFT_MAD_MY);
_width = _init_height;
_height = _init_width;
break;
case 4: // Portrait
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MX | TFT_MAD_MY);
_width = _init_width;
_height = _init_height;
break;
case 5: // Landscape (Portrait + 90)
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MV | TFT_MAD_MX);
_width = _init_height;
_height = _init_width;
break;
case 6: // Inverter portrait
writedata( TFT_MAD_COLOR_ORDER);
_width = _init_width;
_height = _init_height;
break;
case 7: // Inverted landscape
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MV | TFT_MAD_MY);
_width = _init_height;
_height = _init_width;
break;
}

View File

@ -1,52 +0,0 @@
// Change the width and height if required (defined in portrait mode)
// or use the constructor to over-ride defaults
#define TFT_WIDTH 320
#define TFT_HEIGHT 480
// Delay between some initialisation commands
#define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked
// Generic commands used by TFT_eSPar.cpp
#define TFT_NOP 0x00
#define TFT_SWRST 0x01
#define TFT_SLPIN 0x10
#define TFT_SLPOUT 0x11
#define TFT_INVOFF 0x20
#define TFT_INVON 0x21
#define TFT_DISPOFF 0x28
#define TFT_DISPON 0x29
#define TFT_CASET 0x2A
#define TFT_PASET 0x2B
#define TFT_RAMWR 0x2C
#define TFT_RAMRD 0x2E
#define TFT_MADCTL 0x36
#define TFT_MAD_MY 0x80
#define TFT_MAD_MX 0x40
#define TFT_MAD_MV 0x20
#define TFT_MAD_ML 0x10
#define TFT_MAD_RGB 0x00
#define TFT_MAD_BGR 0x08
#define TFT_MAD_MH 0x04
#define TFT_MAD_SS 0x02
#define TFT_MAD_GS 0x01
#ifdef TFT_RGB_ORDER
#if (TFT_RGB_ORDER == 1)
#define TFT_MAD_COLOR_ORDER TFT_MAD_RGB
#else
#define TFT_MAD_COLOR_ORDER TFT_MAD_BGR
#endif
#else
#define TFT_MAD_COLOR_ORDER TFT_MAD_BGR
#endif
#define TFT_IDXRD 0x00 // ILI9341 only, indexed control register read

View File

@ -1,116 +0,0 @@
// This is the command sequence that initialises the HX8357C driver
//
// This setup information uses simple 8 bit SPI writecommand() and writedata() functions
//
// See ST7735_Setup.h file for an alternative format
// Configure HX8357C display
writecommand(0xB9); // Enable extension command
writedata(0xFF);
writedata(0x83);
writedata(0x57);
delay(50);
writecommand(0xB6); //Set VCOM voltage
writedata(0x2C); //0x52 for HSD 3.0"
writecommand(0x11); // Sleep off
delay(200);
writecommand(0x35); // Tearing effect on
writedata(0x00); // Added parameter
writecommand(0x3A); // Interface pixel format
writedata(0x55); // 16 bits per pixel
//writecommand(0xCC); // Set panel characteristic
//writedata(0x09); // S960>S1, G1>G480, R-G-B, normally black
//writecommand(0xB3); // RGB interface
//writedata(0x43);
//writedata(0x00);
//writedata(0x06);
//writedata(0x06);
writecommand(0xB1); // Power control
writedata(0x00);
writedata(0x15);
writedata(0x0D);
writedata(0x0D);
writedata(0x83);
writedata(0x48);
writecommand(0xC0); // Does this do anything?
writedata(0x24);
writedata(0x24);
writedata(0x01);
writedata(0x3C);
writedata(0xC8);
writedata(0x08);
writecommand(0xB4); // Display cycle
writedata(0x02);
writedata(0x40);
writedata(0x00);
writedata(0x2A);
writedata(0x2A);
writedata(0x0D);
writedata(0x4F);
writecommand(0xE0); // Gamma curve
writedata(0x00);
writedata(0x15);
writedata(0x1D);
writedata(0x2A);
writedata(0x31);
writedata(0x42);
writedata(0x4C);
writedata(0x53);
writedata(0x45);
writedata(0x40);
writedata(0x3B);
writedata(0x32);
writedata(0x2E);
writedata(0x28);
writedata(0x24);
writedata(0x03);
writedata(0x00);
writedata(0x15);
writedata(0x1D);
writedata(0x2A);
writedata(0x31);
writedata(0x42);
writedata(0x4C);
writedata(0x53);
writedata(0x45);
writedata(0x40);
writedata(0x3B);
writedata(0x32);
writedata(0x2E);
writedata(0x28);
writedata(0x24);
writedata(0x03);
writedata(0x00);
writedata(0x01);
writecommand(0x36); // MADCTL Memory access control
writedata(0x48);
delay(20);
writecommand(0x21); //Display inversion on
delay(20);
writecommand(0x29); // Display on
delay(120);
// End of HX8357C display configuration

View File

@ -1,47 +0,0 @@
// This is the command sequence that rotates the HX8357C driver coordinate frame
writecommand(TFT_MADCTL);
rotation = m % 8;
switch (rotation) {
case 0: // Portrait
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MX);
_width = _init_width;
_height = _init_height;
break;
case 1: // Landscape (Portrait + 90)
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MV);
_width = _init_height;
_height = _init_width;
break;
case 2: // Inverter portrait
writedata( TFT_MAD_COLOR_ORDER | TFT_MAD_MY);
_width = _init_width;
_height = _init_height;
break;
case 3: // Inverted landscape
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MV | TFT_MAD_MX | TFT_MAD_MY);
_width = _init_height;
_height = _init_width;
break;
case 4: // Portrait
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MX | TFT_MAD_MY);
_width = _init_width;
_height = _init_height;
break;
case 5: // Landscape (Portrait + 90)
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MV | TFT_MAD_MX);
_width = _init_height;
_height = _init_width;
break;
case 6: // Inverter portrait
writedata( TFT_MAD_COLOR_ORDER);
_width = _init_width;
_height = _init_height;
break;
case 7: // Inverted landscape
writedata(TFT_MAD_COLOR_ORDER | TFT_MAD_MV | TFT_MAD_MY);
_width = _init_height;
_height = _init_width;
break;
}

View File

@ -15,20 +15,14 @@
delay(120);
writecommand(0x3A);
#if defined (TFT_PARALLEL_8_BIT) || defined (TFT_PARALLEL_16_BIT) || defined (RPI_DISPLAY_TYPE)
#if defined (TFT_PARALLEL_8_BIT) || defined (RPI_DISPLAY_TYPE)
writedata(0x55); // 16 bit colour interface
#else
writedata(0x66); // 18 bit colour interface
#endif
writecommand(0xC0); // 1100.0000 Power Control 1
writedata(0x0E); // 0001.0111 ... VRH1
writedata(0x0E); // 0001.0101 ... VRH2
writecommand(0xC1); // 1100.0001 Power Control 2
writedata(0x41); // 0100.0001 . SAP BT
writedata(0x00); // 0000.0000 ..... VC
writecommand(0xC2); // 1100.0010 Power Control 3
writedata(0x55); // nb. was 0x44 0101.0101 . DCA1 . DCA0
writecommand(0xC2);
writedata(0x44);
writecommand(0xC5);
writedata(0x00);
@ -70,7 +64,7 @@
writedata(0x20);
writedata(0x00);
#if defined (TFT_PARALLEL_8_BIT) || defined (TFT_PARALLEL_16_BIT) || defined (RPI_DISPLAY_TYPE)
#if defined (TFT_PARALLEL_8_BIT) || defined (RPI_DISPLAY_TYPE)
writecommand(TFT_INVOFF);
#else
writecommand(TFT_INVON);

View File

@ -58,7 +58,7 @@
writedata(0x48); // MX, BGR
writecommand(0x3A); // Pixel Interface Format
#if defined (TFT_PARALLEL_8_BIT) || defined (TFT_PARALLEL_16_BIT) || defined (RPI_DISPLAY_TYPE)
#if defined (TFT_PARALLEL_8_BIT) || defined (RPI_DISPLAY_TYPE)
writedata(0x55); // 16 bit colour for parallel
#else
writedata(0x66); // 18 bit colour for SPI

View File

@ -1,47 +0,0 @@
// Change the width and height if required (defined in portrait mode)
// or use the constructor to over-ride defaults
// RM68120_DRIVER
#define TFT_WIDTH 480
#define TFT_HEIGHT 800
//Set driver type common to all TBD initialisation options
#ifndef RM68120_DRIVER
#define RM68120_DRIVER
#endif
// Delay between some initialisation commands
#define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked
// Generic commands used by TFT_eSPI.cpp
#define TFT_NOP 0x0000
#define TFT_SWRST 0x0100
#define TFT_CASET 0x2A00
#define TFT_PASET 0x2B00
#define TFT_RAMWR 0x2C00
#define TFT_RAMRD 0x2E00
#define TFT_IDXRD 0xDD00 // ILI9341 only, indexed control register read
#define TFT_MADCTL 0x3600
#define TFT_MAD_MY 0x80
#define TFT_MAD_MX 0x40
#define TFT_MAD_MV 0x20
#define TFT_MAD_ML 0x10
#define TFT_MAD_BGR 0x08
#define TFT_MAD_MH 0x04
#define TFT_MAD_RGB 0x00
#ifdef TFT_RGB_ORDER
#if (TFT_RGB_ORDER == 1)
#define TFT_MAD_COLOR_ORDER TFT_MAD_RGB
#else
#define TFT_MAD_COLOR_ORDER TFT_MAD_BGR
#endif
#else
#define TFT_MAD_COLOR_ORDER TFT_MAD_RGB
#endif
#define TFT_INVOFF 0x2000
#define TFT_INVON 0x2100

View File

@ -1,429 +0,0 @@
writeRegister(0xF000, 0x55);
writeRegister(0xF001, 0xAA);
writeRegister(0xF002, 0x52);
writeRegister(0xF003, 0x08);
writeRegister(0xF004, 0x01);
//GAMMA SETING RED
writeRegister(0xD100, 0x00);
writeRegister(0xD101, 0x00);
writeRegister(0xD102, 0x1b);
writeRegister(0xD103, 0x44);
writeRegister(0xD104, 0x62);
writeRegister(0xD105, 0x00);
writeRegister(0xD106, 0x7b);
writeRegister(0xD107, 0xa1);
writeRegister(0xD108, 0xc0);
writeRegister(0xD109, 0xee);
writeRegister(0xD10A, 0x55);
writeRegister(0xD10B, 0x10);
writeRegister(0xD10C, 0x2c);
writeRegister(0xD10D, 0x43);
writeRegister(0xD10E, 0x57);
writeRegister(0xD10F, 0x55);
writeRegister(0xD110, 0x68);
writeRegister(0xD111, 0x78);
writeRegister(0xD112, 0x87);
writeRegister(0xD113, 0x94);
writeRegister(0xD114, 0x55);
writeRegister(0xD115, 0xa0);
writeRegister(0xD116, 0xac);
writeRegister(0xD117, 0xb6);
writeRegister(0xD118, 0xc1);
writeRegister(0xD119, 0x55);
writeRegister(0xD11A, 0xcb);
writeRegister(0xD11B, 0xcd);
writeRegister(0xD11C, 0xd6);
writeRegister(0xD11D, 0xdf);
writeRegister(0xD11E, 0x95);
writeRegister(0xD11F, 0xe8);
writeRegister(0xD120, 0xf1);
writeRegister(0xD121, 0xfa);
writeRegister(0xD122, 0x02);
writeRegister(0xD123, 0xaa);
writeRegister(0xD124, 0x0b);
writeRegister(0xD125, 0x13);
writeRegister(0xD126, 0x1d);
writeRegister(0xD127, 0x26);
writeRegister(0xD128, 0xaa);
writeRegister(0xD129, 0x30);
writeRegister(0xD12A, 0x3c);
writeRegister(0xD12B, 0x4A);
writeRegister(0xD12C, 0x63);
writeRegister(0xD12D, 0xea);
writeRegister(0xD12E, 0x79);
writeRegister(0xD12F, 0xa6);
writeRegister(0xD130, 0xd0);
writeRegister(0xD131, 0x20);
writeRegister(0xD132, 0x0f);
writeRegister(0xD133, 0x8e);
writeRegister(0xD134, 0xff);
//GAMMA SETING GREEN
writeRegister(0xD200, 0x00);
writeRegister(0xD201, 0x00);
writeRegister(0xD202, 0x1b);
writeRegister(0xD203, 0x44);
writeRegister(0xD204, 0x62);
writeRegister(0xD205, 0x00);
writeRegister(0xD206, 0x7b);
writeRegister(0xD207, 0xa1);
writeRegister(0xD208, 0xc0);
writeRegister(0xD209, 0xee);
writeRegister(0xD20A, 0x55);
writeRegister(0xD20B, 0x10);
writeRegister(0xD20C, 0x2c);
writeRegister(0xD20D, 0x43);
writeRegister(0xD20E, 0x57);
writeRegister(0xD20F, 0x55);
writeRegister(0xD210, 0x68);
writeRegister(0xD211, 0x78);
writeRegister(0xD212, 0x87);
writeRegister(0xD213, 0x94);
writeRegister(0xD214, 0x55);
writeRegister(0xD215, 0xa0);
writeRegister(0xD216, 0xac);
writeRegister(0xD217, 0xb6);
writeRegister(0xD218, 0xc1);
writeRegister(0xD219, 0x55);
writeRegister(0xD21A, 0xcb);
writeRegister(0xD21B, 0xcd);
writeRegister(0xD21C, 0xd6);
writeRegister(0xD21D, 0xdf);
writeRegister(0xD21E, 0x95);
writeRegister(0xD21F, 0xe8);
writeRegister(0xD220, 0xf1);
writeRegister(0xD221, 0xfa);
writeRegister(0xD222, 0x02);
writeRegister(0xD223, 0xaa);
writeRegister(0xD224, 0x0b);
writeRegister(0xD225, 0x13);
writeRegister(0xD226, 0x1d);
writeRegister(0xD227, 0x26);
writeRegister(0xD228, 0xaa);
writeRegister(0xD229, 0x30);
writeRegister(0xD22A, 0x3c);
writeRegister(0xD22B, 0x4a);
writeRegister(0xD22C, 0x63);
writeRegister(0xD22D, 0xea);
writeRegister(0xD22E, 0x79);
writeRegister(0xD22F, 0xa6);
writeRegister(0xD230, 0xd0);
writeRegister(0xD231, 0x20);
writeRegister(0xD232, 0x0f);
writeRegister(0xD233, 0x8e);
writeRegister(0xD234, 0xff);
//GAMMA SETING BLUE
writeRegister(0xD300, 0x00);
writeRegister(0xD301, 0x00);
writeRegister(0xD302, 0x1b);
writeRegister(0xD303, 0x44);
writeRegister(0xD304, 0x62);
writeRegister(0xD305, 0x00);
writeRegister(0xD306, 0x7b);
writeRegister(0xD307, 0xa1);
writeRegister(0xD308, 0xc0);
writeRegister(0xD309, 0xee);
writeRegister(0xD30A, 0x55);
writeRegister(0xD30B, 0x10);
writeRegister(0xD30C, 0x2c);
writeRegister(0xD30D, 0x43);
writeRegister(0xD30E, 0x57);
writeRegister(0xD30F, 0x55);
writeRegister(0xD310, 0x68);
writeRegister(0xD311, 0x78);
writeRegister(0xD312, 0x87);
writeRegister(0xD313, 0x94);
writeRegister(0xD314, 0x55);
writeRegister(0xD315, 0xa0);
writeRegister(0xD316, 0xac);
writeRegister(0xD317, 0xb6);
writeRegister(0xD318, 0xc1);
writeRegister(0xD319, 0x55);
writeRegister(0xD31A, 0xcb);
writeRegister(0xD31B, 0xcd);
writeRegister(0xD31C, 0xd6);
writeRegister(0xD31D, 0xdf);
writeRegister(0xD31E, 0x95);
writeRegister(0xD31F, 0xe8);
writeRegister(0xD320, 0xf1);
writeRegister(0xD321, 0xfa);
writeRegister(0xD322, 0x02);
writeRegister(0xD323, 0xaa);
writeRegister(0xD324, 0x0b);
writeRegister(0xD325, 0x13);
writeRegister(0xD326, 0x1d);
writeRegister(0xD327, 0x26);
writeRegister(0xD328, 0xaa);
writeRegister(0xD329, 0x30);
writeRegister(0xD32A, 0x3c);
writeRegister(0xD32B, 0x4A);
writeRegister(0xD32C, 0x63);
writeRegister(0xD32D, 0xea);
writeRegister(0xD32E, 0x79);
writeRegister(0xD32F, 0xa6);
writeRegister(0xD330, 0xd0);
writeRegister(0xD331, 0x20);
writeRegister(0xD332, 0x0f);
writeRegister(0xD333, 0x8e);
writeRegister(0xD334, 0xff);
//GAMMA SETING RED
writeRegister(0xD400, 0x00);
writeRegister(0xD401, 0x00);
writeRegister(0xD402, 0x1b);
writeRegister(0xD403, 0x44);
writeRegister(0xD404, 0x62);
writeRegister(0xD405, 0x00);
writeRegister(0xD406, 0x7b);
writeRegister(0xD407, 0xa1);
writeRegister(0xD408, 0xc0);
writeRegister(0xD409, 0xee);
writeRegister(0xD40A, 0x55);
writeRegister(0xD40B, 0x10);
writeRegister(0xD40C, 0x2c);
writeRegister(0xD40D, 0x43);
writeRegister(0xD40E, 0x57);
writeRegister(0xD40F, 0x55);
writeRegister(0xD410, 0x68);
writeRegister(0xD411, 0x78);
writeRegister(0xD412, 0x87);
writeRegister(0xD413, 0x94);
writeRegister(0xD414, 0x55);
writeRegister(0xD415, 0xa0);
writeRegister(0xD416, 0xac);
writeRegister(0xD417, 0xb6);
writeRegister(0xD418, 0xc1);
writeRegister(0xD419, 0x55);
writeRegister(0xD41A, 0xcb);
writeRegister(0xD41B, 0xcd);
writeRegister(0xD41C, 0xd6);
writeRegister(0xD41D, 0xdf);
writeRegister(0xD41E, 0x95);
writeRegister(0xD41F, 0xe8);
writeRegister(0xD420, 0xf1);
writeRegister(0xD421, 0xfa);
writeRegister(0xD422, 0x02);
writeRegister(0xD423, 0xaa);
writeRegister(0xD424, 0x0b);
writeRegister(0xD425, 0x13);
writeRegister(0xD426, 0x1d);
writeRegister(0xD427, 0x26);
writeRegister(0xD428, 0xaa);
writeRegister(0xD429, 0x30);
writeRegister(0xD42A, 0x3c);
writeRegister(0xD42B, 0x4A);
writeRegister(0xD42C, 0x63);
writeRegister(0xD42D, 0xea);
writeRegister(0xD42E, 0x79);
writeRegister(0xD42F, 0xa6);
writeRegister(0xD430, 0xd0);
writeRegister(0xD431, 0x20);
writeRegister(0xD432, 0x0f);
writeRegister(0xD433, 0x8e);
writeRegister(0xD434, 0xff);
//GAMMA SETING GREEN
writeRegister(0xD500, 0x00);
writeRegister(0xD501, 0x00);
writeRegister(0xD502, 0x1b);
writeRegister(0xD503, 0x44);
writeRegister(0xD504, 0x62);
writeRegister(0xD505, 0x00);
writeRegister(0xD506, 0x7b);
writeRegister(0xD507, 0xa1);
writeRegister(0xD508, 0xc0);
writeRegister(0xD509, 0xee);
writeRegister(0xD50A, 0x55);
writeRegister(0xD50B, 0x10);
writeRegister(0xD50C, 0x2c);
writeRegister(0xD50D, 0x43);
writeRegister(0xD50E, 0x57);
writeRegister(0xD50F, 0x55);
writeRegister(0xD510, 0x68);
writeRegister(0xD511, 0x78);
writeRegister(0xD512, 0x87);
writeRegister(0xD513, 0x94);
writeRegister(0xD514, 0x55);
writeRegister(0xD515, 0xa0);
writeRegister(0xD516, 0xac);
writeRegister(0xD517, 0xb6);
writeRegister(0xD518, 0xc1);
writeRegister(0xD519, 0x55);
writeRegister(0xD51A, 0xcb);
writeRegister(0xD51B, 0xcd);
writeRegister(0xD51C, 0xd6);
writeRegister(0xD51D, 0xdf);
writeRegister(0xD51E, 0x95);
writeRegister(0xD51F, 0xe8);
writeRegister(0xD520, 0xf1);
writeRegister(0xD521, 0xfa);
writeRegister(0xD522, 0x02);
writeRegister(0xD523, 0xaa);
writeRegister(0xD524, 0x0b);
writeRegister(0xD525, 0x13);
writeRegister(0xD526, 0x1d);
writeRegister(0xD527, 0x26);
writeRegister(0xD528, 0xaa);
writeRegister(0xD529, 0x30);
writeRegister(0xD52A, 0x3c);
writeRegister(0xD52B, 0x4a);
writeRegister(0xD52C, 0x63);
writeRegister(0xD52D, 0xea);
writeRegister(0xD52E, 0x79);
writeRegister(0xD52F, 0xa6);
writeRegister(0xD530, 0xd0);
writeRegister(0xD531, 0x20);
writeRegister(0xD532, 0x0f);
writeRegister(0xD533, 0x8e);
writeRegister(0xD534, 0xff);
//GAMMA SETING BLUE
writeRegister(0xD600, 0x00);
writeRegister(0xD601, 0x00);
writeRegister(0xD602, 0x1b);
writeRegister(0xD603, 0x44);
writeRegister(0xD604, 0x62);
writeRegister(0xD605, 0x00);
writeRegister(0xD606, 0x7b);
writeRegister(0xD607, 0xa1);
writeRegister(0xD608, 0xc0);
writeRegister(0xD609, 0xee);
writeRegister(0xD60A, 0x55);
writeRegister(0xD60B, 0x10);
writeRegister(0xD60C, 0x2c);
writeRegister(0xD60D, 0x43);
writeRegister(0xD60E, 0x57);
writeRegister(0xD60F, 0x55);
writeRegister(0xD610, 0x68);
writeRegister(0xD611, 0x78);
writeRegister(0xD612, 0x87);
writeRegister(0xD613, 0x94);
writeRegister(0xD614, 0x55);
writeRegister(0xD615, 0xa0);
writeRegister(0xD616, 0xac);
writeRegister(0xD617, 0xb6);
writeRegister(0xD618, 0xc1);
writeRegister(0xD619, 0x55);
writeRegister(0xD61A, 0xcb);
writeRegister(0xD61B, 0xcd);
writeRegister(0xD61C, 0xd6);
writeRegister(0xD61D, 0xdf);
writeRegister(0xD61E, 0x95);
writeRegister(0xD61F, 0xe8);
writeRegister(0xD620, 0xf1);
writeRegister(0xD621, 0xfa);
writeRegister(0xD622, 0x02);
writeRegister(0xD623, 0xaa);
writeRegister(0xD624, 0x0b);
writeRegister(0xD625, 0x13);
writeRegister(0xD626, 0x1d);
writeRegister(0xD627, 0x26);
writeRegister(0xD628, 0xaa);
writeRegister(0xD629, 0x30);
writeRegister(0xD62A, 0x3c);
writeRegister(0xD62B, 0x4A);
writeRegister(0xD62C, 0x63);
writeRegister(0xD62D, 0xea);
writeRegister(0xD62E, 0x79);
writeRegister(0xD62F, 0xa6);
writeRegister(0xD630, 0xd0);
writeRegister(0xD631, 0x20);
writeRegister(0xD632, 0x0f);
writeRegister(0xD633, 0x8e);
writeRegister(0xD634, 0xff);
//AVDD VOLTAGE SETTING
writeRegister(0xB000, 0x05);
writeRegister(0xB001, 0x05);
writeRegister(0xB002, 0x05);
//AVEE VOLTAGE SETTING
writeRegister(0xB100, 0x05);
writeRegister(0xB101, 0x05);
writeRegister(0xB102, 0x05);
//AVDD Boosting
writeRegister(0xB600, 0x34);
writeRegister(0xB601, 0x34);
writeRegister(0xB603, 0x34);
//AVEE Boosting
writeRegister(0xB700, 0x24);
writeRegister(0xB701, 0x24);
writeRegister(0xB702, 0x24);
//VCL Boosting
writeRegister(0xB800, 0x24);
writeRegister(0xB801, 0x24);
writeRegister(0xB802, 0x24);
//VGLX VOLTAGE SETTING
writeRegister(0xBA00, 0x14);
writeRegister(0xBA01, 0x14);
writeRegister(0xBA02, 0x14);
//VCL Boosting
writeRegister(0xB900, 0x24);
writeRegister(0xB901, 0x24);
writeRegister(0xB902, 0x24);
//Gamma Voltage
writeRegister(0xBc00, 0x00);
writeRegister(0xBc01, 0xa0);//vgmp=5.0
writeRegister(0xBc02, 0x00);
writeRegister(0xBd00, 0x00);
writeRegister(0xBd01, 0xa0);//vgmn=5.0
writeRegister(0xBd02, 0x00);
//VCOM Setting
writeRegister(0xBe01, 0x3d);//3
//ENABLE PAGE 0
writeRegister(0xF000, 0x55);
writeRegister(0xF001, 0xAA);
writeRegister(0xF002, 0x52);
writeRegister(0xF003, 0x08);
writeRegister(0xF004, 0x00);
//Vivid Color Function Control
writeRegister(0xB400, 0x10);
//Z-INVERSION
writeRegister(0xBC00, 0x05);
writeRegister(0xBC01, 0x05);
writeRegister(0xBC02, 0x05);
//*************** add on 20111021**********************//
writeRegister(0xB700, 0x22);//GATE EQ CONTROL
writeRegister(0xB701, 0x22);//GATE EQ CONTROL
writeRegister(0xC80B, 0x2A);//DISPLAY TIMING CONTROL
writeRegister(0xC80C, 0x2A);//DISPLAY TIMING CONTROL
writeRegister(0xC80F, 0x2A);//DISPLAY TIMING CONTROL
writeRegister(0xC810, 0x2A);//DISPLAY TIMING CONTROL
//*************** add on 20111021**********************//
//PWM_ENH_OE =1
writeRegister(0xd000, 0x01);
//DM_SEL =1
writeRegister(0xb300, 0x10);
//VBPDA=07h
writeRegister(0xBd02, 0x07);
//VBPDb=07h
writeRegister(0xBe02, 0x07);
//VBPDc=07h
writeRegister(0xBf02, 0x07);
//ENABLE PAGE 2
writeRegister(0xF000, 0x55);
writeRegister(0xF001, 0xAA);
writeRegister(0xF002, 0x52);
writeRegister(0xF003, 0x08);
writeRegister(0xF004, 0x02);
//SDREG0 =0
writeRegister(0xc301, 0xa9);
//DS=14
writeRegister(0xfe01, 0x94);
//OSC =60h
writeRegister(0xf600, 0x60);
//TE ON
writeRegister(0x3500, 0x00);
//SLEEP OUT
writecommand(0x1100);
delay(100);
//DISPLY ON
writecommand(0x2900);
delay(100);
writeRegister(0x3A00, 0x55);
writeRegister(0x3600, 0xA3);

View File

@ -1,29 +0,0 @@
// This is the command sequence that rotates the RM68120 driver coordinate frame
rotation = m % 4; // Limit the range of values to 0-3
writecommand(TFT_MADCTL);
switch (rotation) {
case 0:
writedata(TFT_MAD_COLOR_ORDER);
_width = _init_width;
_height = _init_height;
break;
case 1:
writedata(TFT_MAD_MV | TFT_MAD_MX | TFT_MAD_COLOR_ORDER);
_width = _init_height;
_height = _init_width;
break;
case 2:
writedata(TFT_MAD_MX | TFT_MAD_MY | TFT_MAD_COLOR_ORDER);
_width = _init_width;
_height = _init_height;
break;
case 3:
writedata(TFT_MAD_MV | TFT_MAD_MY | TFT_MAD_COLOR_ORDER);
_width = _init_height;
_height = _init_width;
break;
}

View File

@ -17,7 +17,6 @@
#define INITR_GREENTAB128 0x5 // Use if you only get part of 128x128 screen in rotation 0 & 1
#define INITR_GREENTAB160x80 0x6 // Use if you only get part of 128x128 screen in rotation 0 & 1
#define INITR_REDTAB160x80 0x7 // Added for https://www.aliexpress.com/item/ShengYang-1pcs-IPS-0-96-inch-7P-SPI-HD-65K-Full-Color-OLED-Module-ST7735-Drive/32918394604.html
#define INITR_ROBOTLCD 0x8
#define INITB 0xB
@ -45,10 +44,6 @@
#define TAB_COLOUR INITR_GREENTAB160x80
#define CGRAM_OFFSET
#elif defined (ST7735_ROBOTLCD)
#define TAB_COLOUR INITR_ROBOTLCD
#define CGRAM_OFFSET
#elif defined (ST7735_REDTAB160x80)
#define TAB_COLOUR INITR_REDTAB160x80
#define CGRAM_OFFSET
@ -112,7 +107,7 @@
#define TFT_MAD_RGB 0x00
#ifndef TFT_RGB_ORDER
#if defined(ST7735_BLACKTAB) || defined(ST7735_GREENTAB2) || defined(ST7735_INITB)
#if defined(INITR_BLACKTAB) || defined(INITR_GREENTAB2) || defined(INITB)
#define TFT_MAD_COLOR_ORDER TFT_MAD_RGB
#else
#define TFT_MAD_COLOR_ORDER TFT_MAD_BGR

View File

@ -123,17 +123,6 @@
0x00, 0x00, // XSTART = 0
0x00, 0x9F }, // XEND = 159
// Frame control init for RobotLCD, taken from https://github.com/arduino-libraries/TFT, Adafruit_ST7735.cpp l. 263, commit 61b8a7e
Rcmd3RobotLCD[] = {
3,
ST7735_FRMCTR1, 2 , // 1: Frame rate ctrl - normal mode, 2 args
0x0B, 0x14,
ST7735_FRMCTR2, 2 , // 2: Frame rate ctrl - idle mode, 2 args
0x0B, 0x14,
ST7735_FRMCTR3, 4 , // 3: Frame rate ctrl - partial mode, 4 args
0x0B, 0x14,
0x0B, 0x14 },
Rcmd3[] = { // Init for 7735R, part 3 (red or green tab)
4, // 4 commands in list:
ST7735_GMCTRP1, 16 , // 1: 16 args, no delay:
@ -192,11 +181,6 @@
colstart = 26;
rowstart = 1;
}
else if (tabcolor == INITR_ROBOTLCD)
{
commandList(Rcmd2green);
commandList(Rcmd3RobotLCD);
}
else if (tabcolor == INITR_REDTAB160x80)
{
commandList(Rcmd2green);

View File

@ -20,32 +20,6 @@
#endif
#endif
// Adafruit 1.69 round corner TFT support
#if (TFT_HEIGHT == 280) && (TFT_WIDTH == 240)
#ifndef CGRAM_OFFSET
#define CGRAM_OFFSET
#endif
#endif
// 1.47" 172x320 Round Rectangle Color IPS TFT Display
#if (TFT_HEIGHT == 320) && (TFT_WIDTH == 172)
#ifndef CGRAM_OFFSET
#define CGRAM_OFFSET
#endif
#endif
#if (TFT_HEIGHT == 320) && (TFT_WIDTH == 170)
#ifndef CGRAM_OFFSET
#define CGRAM_OFFSET
#endif
#endif
#if (TFT_HEIGHT == 300) && (TFT_WIDTH == 240)
#ifndef CGRAM_OFFSET
#define CGRAM_OFFSET
#endif
#endif
// Delay between some initialisation commands
#define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked

View File

@ -10,21 +10,6 @@
colstart = 52;
rowstart = 40;
}
else if(_init_height == 280)
{
colstart = 0;
rowstart = 20;
}
else if(_init_width == 172)
{
colstart = 34;
rowstart = 0;
}
else if(_init_width == 170)
{
colstart = 35;
rowstart = 0;
}
else
{
colstart = 0;
@ -44,21 +29,6 @@
colstart = 40;
rowstart = 53;
}
else if(_init_height == 280)
{
colstart = 20;
rowstart = 0;
}
else if(_init_width == 172)
{
colstart = 0;
rowstart = 34;
}
else if(_init_width == 170)
{
colstart = 0;
rowstart = 35;
}
else
{
colstart = 0;
@ -71,28 +41,13 @@
_height = _init_width;
break;
case 2: // Inverter portrait
case 2: // Inverter portrait
#ifdef CGRAM_OFFSET
if (_init_width == 135)
{
colstart = 53;
rowstart = 40;
}
else if(_init_height == 280)
{
colstart = 0;
rowstart = 20;
}
else if(_init_width == 172)
{
colstart = 34;
rowstart = 0;
}
else if(_init_width == 170)
{
colstart = 35;
rowstart = 0;
}
else
{
colstart = 0;
@ -111,21 +66,6 @@
colstart = 40;
rowstart = 52;
}
else if(_init_height == 280)
{
colstart = 20;
rowstart = 0;
}
else if(_init_width == 172)
{
colstart = 0;
rowstart = 34;
}
else if(_init_width == 170)
{
colstart = 0;
rowstart = 35;
}
else
{
colstart = 80;

View File

@ -20,13 +20,6 @@
#endif
#endif
// Adafruit 1.69 round corner TFT support
#if (TFT_HEIGHT == 280) && (TFT_WIDTH == 240)
#ifndef CGRAM_OFFSET
#define CGRAM_OFFSET
#endif
#endif
// 1.47" 172x320 Round Rectangle Color IPS TFT Display
#if (TFT_HEIGHT == 320) && (TFT_WIDTH == 172)
#ifndef CGRAM_OFFSET
@ -34,18 +27,6 @@
#endif
#endif
#if (TFT_HEIGHT == 320) && (TFT_WIDTH == 170)
#ifndef CGRAM_OFFSET
#define CGRAM_OFFSET
#endif
#endif
#if (TFT_HEIGHT == 300) && (TFT_WIDTH == 240)
#ifndef CGRAM_OFFSET
#define CGRAM_OFFSET
#endif
#endif
// Delay between some initialisation commands
#define TFT_INIT_DELAY 0x80 // Not used unless commandlist invoked

View File

@ -5,7 +5,6 @@
//
// See ST7735_Setup.h file for an alternative format
#ifndef INIT_SEQUENCE_3
{
writecommand(ST7789_SLPOUT); // Sleep out
delay(120);
@ -104,7 +103,7 @@
writedata(0x00);
writedata(0x00);
writedata(0x00);
writedata(0xEF); // 239
writedata(0xE5); // 239
writecommand(ST7789_RASET); // Row address set
writedata(0x00);
@ -127,111 +126,3 @@
pinMode(TFT_BL, OUTPUT);
#endif
}
#else
// TTGO ESP32 S3 T-Display
{
writecommand(ST7789_SLPOUT); // Sleep out
delay(120);
writecommand(ST7789_NORON); // Normal display mode on
//------------------------------display and color format setting--------------------------------//
writecommand(ST7789_MADCTL);
writedata(TFT_MAD_COLOR_ORDER);
// writecommand(ST7789_RAMCTRL);
// writedata(0x00);
// writedata(0xE0); // 5 to 6 bit conversion: r0 = r5, b0 = b5
writecommand(ST7789_COLMOD);
writedata(0x55);
delay(10);
//--------------------------------ST7789V Frame rate setting----------------------------------//
writecommand(ST7789_PORCTRL);
writedata(0x0b);
writedata(0x0b);
writedata(0x00);
writedata(0x33);
writedata(0x33);
writecommand(ST7789_GCTRL); // Voltages: VGH / VGL
writedata(0x75);
//---------------------------------ST7789V Power setting--------------------------------------//
writecommand(ST7789_VCOMS);
writedata(0x28); // JLX240 display datasheet
writecommand(ST7789_LCMCTRL);
writedata(0x2C);
writecommand(ST7789_VDVVRHEN);
writedata(0x01);
writecommand(ST7789_VRHS); // voltage VRHS
writedata(0x1F);
writecommand(ST7789_FRCTR2);
writedata(0x13);
writecommand(ST7789_PWCTRL1);
writedata(0xa7);
writecommand(ST7789_PWCTRL1);
writedata(0xa4);
writedata(0xa1);
writecommand(0xD6);
writedata(0xa1);
//--------------------------------ST7789V gamma setting---------------------------------------//
writecommand(ST7789_PVGAMCTRL);
writedata(0xf0);
writedata(0x05);
writedata(0x0a);
writedata(0x06);
writedata(0x06);
writedata(0x03);
writedata(0x2b);
writedata(0x32);
writedata(0x43);
writedata(0x36);
writedata(0x11);
writedata(0x10);
writedata(0x2b);
writedata(0x32);
writecommand(ST7789_NVGAMCTRL);
writedata(0xf0);
writedata(0x08);
writedata(0x0c);
writedata(0x0b);
writedata(0x09);
writedata(0x24);
writedata(0x2b);
writedata(0x22);
writedata(0x43);
writedata(0x38);
writedata(0x15);
writedata(0x16);
writedata(0x2f);
writedata(0x37);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
end_tft_write();
delay(120);
begin_tft_write();
writecommand(ST7789_DISPON); //Display on
delay(120);
#ifdef TFT_BL
// Turn on the back-light LED
digitalWrite(TFT_BL, HIGH);
pinMode(TFT_BL, OUTPUT);
#endif
}
#endif

View File

@ -20,11 +20,6 @@
colstart = 34;
rowstart = 0;
}
else if(_init_width == 170)
{
colstart = 35;
rowstart = 0;
}
else
{
colstart = 0;
@ -54,11 +49,6 @@
colstart = 0;
rowstart = 34;
}
else if(_init_width == 170)
{
colstart = 0;
rowstart = 35;
}
else
{
colstart = 0;
@ -88,11 +78,6 @@
colstart = 34;
rowstart = 0;
}
else if(_init_width == 170)
{
colstart = 35;
rowstart = 0;
}
else
{
colstart = 0;
@ -121,11 +106,6 @@
colstart = 0;
rowstart = 34;
}
else if(_init_width == 170)
{
colstart = 0;
rowstart = 35;
}
else
{
colstart = 80;

View File

@ -78,7 +78,7 @@
#define TFT_RGB_ORDER TFT_RGB
#endif
#ifdef CONFIG_TFT_BGR_ORDER
#ifdef CONFIG_TFT_RGB_ORDER
#define TFT_RGB_ORDER TFT_BGR
#endif
@ -223,11 +223,9 @@
// SPI BUS
#else
#if CONFIG_TFT_HSPI_PORT
#define USE_HSPI_PORT
#endif
#if CONFIG_TFT_MISO != -1
#if CONFIG_TFT_MISO == -1
#error "Invalid MISO pin. Check TFT_eSPI configuration"
#else
#define TFT_MISO CONFIG_TFT_MISO
#endif

File diff suppressed because it is too large Load Diff

View File

@ -16,7 +16,7 @@
#ifndef _TFT_eSPIH_
#define _TFT_eSPIH_
#define TFT_ESPI_VERSION "2.5.21"
#define TFT_ESPI_VERSION "2.4.51"
// Bit level feature flags
// Bit 0 set: viewport capability
@ -37,34 +37,8 @@
// 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"
#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
@ -83,22 +57,16 @@
})
#elif defined(__AVR__)
#include <avr/pgmspace.h>
#elif defined(ARDUINO_ARCH_ESP8266) || defined(ESP32)
#elif defined(ESP8266) || defined(ESP32)
#include <pgmspace.h>
#else
#ifndef PROGMEM
#define PROGMEM
#endif
#define PROGMEM
#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)
#if defined (ESP32)
#include "Processors/TFT_eSPI_ESP32.h"
#elif defined (ARDUINO_ARCH_ESP8266)
#elif defined (ESP8266)
#include "Processors/TFT_eSPI_ESP8266.h"
#elif defined (STM32)
#include "Processors/TFT_eSPI_STM32.h"
@ -126,7 +94,7 @@
#endif
// Some ST7789 boards do not work with Mode 0
#ifndef TFT_SPI_MODE
#ifndef TFT_SPI_MODE
#if defined(ST7789_DRIVER) || defined(ST7789_2_DRIVER)
#define TFT_SPI_MODE SPI_MODE3
#else
@ -143,17 +111,6 @@
#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
***************************************************************************************/
@ -318,7 +275,7 @@ const PROGMEM fontinfo fontdata [] = {
#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_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 */
@ -415,6 +372,9 @@ int16_t tch_spi_freq;// Touch controller read/write SPI frequency
/***************************************************************************************
** Section 8: Class member and support functions
***************************************************************************************/
// Swap any type
template <typename T> static inline void
swap_coord(T& a, T& b) { T t = a; a = b; b = t; }
// Callback prototype for smooth font pixel colour read
typedef uint16_t (*getColorCallback)(uint16_t x, uint16_t y);
@ -444,7 +404,7 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
height(void),
width(void);
// Read the colour of a pixel at x,y and return value in 565 format
// 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
@ -459,12 +419,6 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
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
@ -507,7 +461,6 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
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),
@ -517,6 +470,28 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
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);
// Draw a pixel blended with the pixel colour on the TFT or sprite, return blended colour
// If bg_color is not included 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 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 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);
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 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);
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),
@ -529,53 +504,6 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
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);
@ -614,20 +542,15 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
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
@ -645,21 +568,20 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
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
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
@ -686,14 +608,13 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
// 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);
// 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
#ifndef RM68120_DRIVER
@ -727,15 +648,14 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
// 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);
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
// DMA support functions - these are currently just for SPI writes when using the ESP32 or STM32 processors
// 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".
@ -764,16 +684,11 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
// 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.
//
// If swapping colour bytes is defined, and the double buffer option is NOT used, then the bytes
// in the original data image will be swapped by the function 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);
@ -866,9 +781,6 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
// 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);
@ -930,7 +842,7 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
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)
@ -940,7 +852,7 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
bool _fillbg; // Fill background flag (just for for smooth fonts at the moment)
#if defined (SSD1963_DRIVER)
#if defined (SSD1963_DRIVER)
uint16_t Cswap; // Swap buffer for SSD1963
uint8_t r6, g6, b6; // RGB buffer for SSD1963
#endif
@ -955,16 +867,12 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
// 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
#error >>>>------>> Touch functions not supported in 8 bit parallel mode or with RP2040 PIO.
#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
#warning >>>>------>> TOUCH_CS pin not defined, TFT_eSPI touch functions will not be available!
#endif
// Load the Anti-aliased font extension
@ -974,10 +882,6 @@ class TFT_eSPI : public Print { friend class TFT_eSprite; // Sprite class has ac
}; // 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
***************************************************************************************/

View File

@ -11,9 +11,6 @@
// User defined information reported by "Read_User_Setup" test & diagnostics example
#define USER_SETUP_INFO "User_Setup"
// Define to disable all #warnings in library (can be put in User_Setup_Select.h)
//#define DISABLE_ALL_LIBRARY_WARNINGS
// ##################################################################################
//
// Section 1. Call up the right driver file and any options for it
@ -34,9 +31,8 @@
//#define STM_PORTA_DATA_BUS
//#define STM_PORTB_DATA_BUS
// Tell the library to use parallel mode (otherwise SPI is assumed)
// Tell the library to use 8 bit parallel mode (otherwise SPI is assumed)
//#define TFT_PARALLEL_8_BIT
//#defined TFT_PARALLEL_16_BIT // **** 16 bit parallel ONLY for RP2040 processor ****
// Display type - only define if RPi display
//#define RPI_DISPLAY_TYPE // 20MHz maximum SPI
@ -104,7 +100,6 @@
// #define ST7735_GREENTAB3
// #define ST7735_GREENTAB128 // For 128 x 128 display
// #define ST7735_GREENTAB160x80 // For 160 x 80 display (BGR, inverted, 26 offset)
// #define ST7735_ROBOTLCD // For some RobotLCD arduino shields (128x160, BGR, https://docs.arduino.cc/retired/getting-started-guides/TFT)
// #define ST7735_REDTAB
// #define ST7735_BLACKTAB
// #define ST7735_REDTAB160x80 // For 160 x 80 display with 24 pixel offset
@ -324,20 +319,6 @@
// For RP2040 processor and SPI displays, uncomment the following line to use the PIO interface.
//#define RP2040_PIO_SPI // Leave commented out to use standard RP2040 SPI port interface
// For RP2040 processor and 8 or 16 bit parallel displays:
// The parallel interface write cycle period is derived from a division of the CPU clock
// speed so scales with the processor clock. This means that the divider ratio may need
// to be increased when overclocking. I may also need to be adjusted dependant on the
// display controller type (ILI94341, HX8357C etc). If RP2040_PIO_CLK_DIV is not defined
// the library will set default values which may not suit your display.
// The display controller data sheet will specify the minimum write cycle period. The
// controllers often work reliably for shorter periods, however if the period is too short
// the display may not initialise or graphics will become corrupted.
// PIO write cycle frequency = (CPU clock/(4 * RP2040_PIO_CLK_DIV))
//#define RP2040_PIO_CLK_DIV 1 // 32ns write cycle at 125MHz CPU clock
//#define RP2040_PIO_CLK_DIV 2 // 64ns write cycle at 125MHz CPU clock
//#define RP2040_PIO_CLK_DIV 3 // 96ns write cycle at 125MHz CPU clock
// For the RP2040 processor define the SPI port channel used (default 0 if undefined)
//#define TFT_SPI_PORT 1 // Set to 0 if SPI0 pins are used, or 1 if spi1 pins used

View File

@ -1,53 +1,45 @@
// This header file contains a list of user setup files and defines which one the
// compiler uses when the IDE performs a Verify/Compile or Upload.
//
// Users can create configurations for different boards and TFT displays.
// Users can create configurations for different Espressif boards and TFT displays.
// This makes selecting between hardware setups easy by "uncommenting" one line.
// The advantage of this hardware configuration method is that the examples provided
// with the library should work with immediately without any other changes being
// needed. It also improves the portability of users sketches to other hardware
// configurations and compatible libraries.
// with the library should work with different setups immediately without any other
// changes being needed. It also improves the portability of users sketches to other
// hardware configurations and compatible libraries.
//
// Create a shortcut to this file on your desktop to permit quick access for editing.
// Re-compile and upload after making and saving any changes to this file.
// Customised User_Setup files are stored in the "User_Setups" folder.
// It is also possible for the user tft settings to be included with the sketch, see
// the "Sketch_with_tft_setup" generic example. This may be more convenient for
// multiple projects.
#ifndef USER_SETUP_LOADED // Lets PlatformIO users define settings in
// platformio.ini, see notes in "Tools" folder.
///////////////////////////////////////////////////////
// User configuration selection lines are below //
///////////////////////////////////////////////////////
// Only ONE line below should be uncommented to define your setup. Add extra lines and files as needed.
// Only ONE line below should be uncommented. Add extra lines and files as needed.
#include <User_Setup.h> // Default setup is root library folder
//#include <User_Setups/Setup1_ILI9341.h> // Setup file for ESP8266 configured for my ILI9341
//#include <User_Setups/Setup2_ST7735.h> // Setup file for ESP8266 configured for my ST7735
//#include <User_Setups/Setup3_ILI9163.h> // Setup file for ESP8266 configured for my ILI9163
//#include <User_Setups/Setup4_S6D02A1.h> // Setup file for ESP8266 configured for my S6D02A1
//#include <User_Setups/Setup5_RPi_ILI9486.h> // Setup file for ESP8266 configured for my stock RPi TFT
//#include <User_Setups/Setup6_RPi_Wr_ILI9486.h> // Setup file for ESP8266 configured for my modified RPi TFT
//#include <User_Setups/Setup7_ST7735_128x128.h> // Setup file for ESP8266 configured for my ST7735 128x128 display
//#include <User_Setups/Setup8_ILI9163_128x128.h> // Setup file for ESP8266 configured for my ILI9163 128x128 display
//#include <User_Setups/Setup9_ST7735_Overlap.h> // Setup file for ESP8266 configured for my ST7735
//#include <User_Setups/Setup10_RPi_touch_ILI9486.h> // Setup file for ESP8266 configured for ESP8266 and RPi TFT with touch
//#include <User_Setups/Setup1_ILI9341.h> // Setup file configured for my ILI9341
//#include <User_Setups/Setup2_ST7735.h> // Setup file configured for my ST7735
//#include <User_Setups/Setup3_ILI9163.h> // Setup file configured for my ILI9163
//#include <User_Setups/Setup4_S6D02A1.h> // Setup file configured for my S6D02A1
//#include <User_Setups/Setup5_RPi_ILI9486.h> // Setup file configured for my stock RPi TFT
//#include <User_Setups/Setup6_RPi_Wr_ILI9486.h> // Setup file configured for my modified RPi TFT
//#include <User_Setups/Setup7_ST7735_128x128.h> // Setup file configured for my ST7735 128x128 display
//#include <User_Setups/Setup8_ILI9163_128x128.h> // Setup file configured for my ILI9163 128x128 display
//#include <User_Setups/Setup9_ST7735_Overlap.h> // Setup file configured for my ST7735
//#include <User_Setups/Setup10_RPi_touch_ILI9486.h> // Setup file configured for ESP8266 and RPi TFT with touch
//#include <User_Setups/Setup11_RPi_touch_ILI9486.h> // Setup file configured for ESP32 and RPi TFT with touch
//#include <User_Setups/Setup12_M5Stack_Basic_Core.h>// Setup file for the ESP32 based M5Stack (Basic Core only)
//#include <User_Setups/Setup12_M5Stack.h> // Setup file for the ESP32 based M5Stack
//#include <User_Setups/Setup13_ILI9481_Parallel.h> // Setup file for the ESP32 with parallel bus TFT
//#include <User_Setups/Setup14_ILI9341_Parallel.h> // Setup file for the ESP32 with parallel bus TFT
//#include <User_Setups/Setup15_HX8357D.h> // Setup file for ESP8266 configured for HX8357D
//#include <User_Setups/Setup15_HX8357D.h> // Setup file configured for HX8357D (untested)
//#include <User_Setups/Setup16_ILI9488_Parallel.h> // Setup file for the ESP32 with parallel bus TFT
//#include <User_Setups/Setup17_ePaper.h> // Setup file for ESP8266 and any Waveshare ePaper display
//#include <User_Setups/Setup18_ST7789.h> // Setup file for ESP8266 configured for ST7789
//#include <User_Setups/Setup17_ePaper.h> // Setup file for any Waveshare ePaper display
//#include <User_Setups/Setup18_ST7789.h> // Setup file configured for ST7789
//#include <User_Setups/Setup19_RM68140_Parallel.h> // Setup file configured for RM68140 with parallel bus
@ -57,7 +49,7 @@
//#include <User_Setups/Setup22_TTGO_T4.h> // Setup file for ESP32 and TTGO T4 version 1.2
//#include <User_Setups/Setup22_TTGO_T4_v1.3.h> // Setup file for ESP32 and TTGO T4 version 1.3
//#include <User_Setups/Setup23_TTGO_TM.h> // Setup file for ESP32 and TTGO TM ST7789 SPI bus TFT
//#include <User_Setups/Setup24_ST7789.h> // Setup file for DSTIKE/ESP32/ESP8266 configured for ST7789 240 x 240
//#include <User_Setups/Setup24_ST7789.h> // Setup file configured for ST7789 240 x 240
//#include <User_Setups/Setup25_TTGO_T_Display.h> // Setup file for ESP32 and TTGO T-Display ST7789V SPI bus TFT
//#include <User_Setups/Setup26_TTGO_T_Wristband.h> // Setup file for ESP32 and TTGO T-Wristband ST7735 SPI bus TFT
@ -76,13 +68,11 @@
//#include <User_Setups/Setup36_RPi_touch_ST7796.h> // Setup file configured for ESP32 and RPi ST7796 TFT with touch
//#include <User_Setups/Setup42_ILI9341_ESP32.h> // Setup file for ESP32 and SPI ILI9341 240x320
//#include <User_Setups/Setup43_ST7735.h> // Setup file for ESP8266 & ESP32 configured for my ST7735S 80x160
//#include <User_Setups/Setup43_ST7735.h> // Setup file configured for my ST7735S 80x160
//#include <User_Setups/Setup44_TTGO_CameraPlus.h> // Setup file for ESP32 and TTGO T-CameraPlus ST7789 SPI bus TFT 240x240
//#include <User_Setups/Setup45_TTGO_T_Watch.h> // Setup file for ESP32 and TTGO T-Watch ST7789 SPI bus TFT 240x240
//#include <User_Setups/Setup46_GC9A01_ESP32.h> // Setup file for ESP32 and GC9A01 SPI bus TFT 240x240
//#include <User_Setups/Setup47_ST7735.h> // Setup file for ESP32 configured for ST7735 128 x 128 animated eyes
//#include <User_Setups/Setup47_ST7735.h> // Setup file configured for ST7735 128 x 128 animated eyes
//#include <User_Setups/Setup50_SSD1963_Parallel.h> // Setup file for ESP32 and SSD1963 TFT display
@ -93,23 +83,17 @@
//#include <User_Setups/Setup61_RP2040_ILI9341_PIO_SPI.h> // Setup file for RP2040 with PIO SPI ILI9341
//#include <User_Setups/Setup62_RP2040_Nano_Connect_ILI9341.h> // Setup file for RP2040 with SPI ILI9341
//#include <User_Setups/Setup70_ESP32_S2_ILI9341.h> // Setup file for ESP32 S2 with SPI ILI9341
//#include <User_Setups/Setup70b_ESP32_S3_ILI9341.h> // Setup file for ESP32 S3 with SPI ILI9341
//#include <User_Setups/Setup70c_ESP32_C3_ILI9341.h> // Setup file for ESP32 C3 with SPI ILI9341
//#include <User_Setups/Setup70d_ILI9488_S3_Parallel.h> // Setup file for ESP32 S3 with SPI ILI9488
//#include <User_Setups/Setup70_ESP32_S2_ILI9341.h> // Setup file for ESP32 S2 with SPI ILI9341
//#include <User_Setups/Setup71_ESP32_S2_ST7789.h> // Setup file for ESP32 S2 with ST7789
//#include <User_Setups/Setup72_ESP32_ST7789_172x320.h> // Setup file for ESP32 with ST7789 1.47" 172x320
//#include <User_Setups/Setup100_RP2040_ILI9488_parallel.h> // Setup file for Pico/RP2040 with 8 bit parallel ILI9488
//#include <User_Setups/Setup101_RP2040_ILI9481_parallel.h> // Setup file for Pico/RP2040 with 8 bit parallel ILI9481
//#include <User_Setups/Setup102_RP2040_ILI9341_parallel.h> // Setup file for Pico/RP2040 with 8 bit parallel ILI9341
//#include <User_Setups/Setup103_RP2040_ILI9486_parallel.h> // Setup file for Pico/RP2040 with 8 bit parallel ILI9486
//#include <User_Setups/Setup104_RP2040_ST7796_parallel.h> // Setup file for Pico/RP2040 with 8 bit parallel ST7796
//#include <User_Setups/Setup105_RP2040_ST7796_16bit_parallel.h> // Setup file for RP2040 16 bit parallel display
//#include <User_Setups/Setup106_RP2040_ILI9481_16bit_parallel.h> // Setup file for RP2040 16 bit parallel display
//#include <User_Setups/Setup107_RP2040_ILI9341_16bit_parallel.h> // Setup file for RP2040 16 bit parallel display
//#include <User_Setups/Setup100_RP2040_ILI9488_parallel.h>
//#include <User_Setups/Setup101_RP2040_ILI9481_parallel.h>
//#include <User_Setups/Setup102_RP2040_ILI9341_parallel.h>
//#include <User_Setups/Setup103_RP2040_ILI9486_parallel.h>
//#include <User_Setups/Setup104_RP2040_ST7796_parallel.h>
//#include <User_Setups/Setup105_RP2040_ILI9341_PIO_SPI.h> // Setup file for Raspberry Pi Pico with SPI PIO interface and ILI9341
//#include <User_Setups/Setup135_ST7789.h> // Setup file for ESP8266 and ST7789 135 x 240 TFT
@ -124,27 +108,8 @@
//#include <User_Setups/Setup203_ST7789.h> // Setup file for ESP32/ESP8266 based ST7789 240X280 1.69inch TFT
//#include <User_Setups/Setup204_ESP32_TouchDown.h> // Setup file for the ESP32 TouchDown based on ILI9488 480 x 320 TFT
//#include <User_Setups/SetupX_Template.h>
//#include <User_Setups/Setup205_ESP32_TouchDown_S3.h> // Setup file for the ESP32 TouchDown S3 based on ILI9488 480 x 320 TFT
//#include <User_Setups/Setup206_LilyGo_T_Display_S3.h>
//#include <User_Setups/Setup207_LilyGo_T_HMI.h>
//#include <User_Setups/Setup301_BW16_ST7735.h> // Setup file for Bw16-based boards with ST7735 160 x 80 TFT
//#include <User_Setups/SetupX_Template.h> // Template file for a setup
//#include <User_Setups/Dustin_ILI9488.h> // Setup file for Dustin Watts PCB with ILI9488
//#include <User_Setups/Dustin_ST7796.h> // Setup file for Dustin Watts PCB with ST7796
//#include <User_Setups/Dustin_ILI9488_Pico.h> // Setup file for Dustin Watts Pico PCB with ST7796
//#include <User_Setups/Dustin_ST7789_Pico.h> // Setup file for Dustin Watts PCB with ST7789 240 x 240 on 3.3V adapter board
//#include <User_Setups/Dustin_GC9A01_Pico.h> // Setup file for Dustin Watts PCB with GC9A01 240 x 240 on 3.3V adapter board
//#include <User_Setups/Dustin_GC9A01_ESP32.h> // Setup file for Dustin Watts PCB with GC9A01 240 x 240 on 3.3V adapter board
//#include <User_Setups/Dustin_STT7789_ESP32.h> // Setup file for Dustin Watts PCB with ST7789 240 x 240 on 3.3V adapter board
//#include <User_Setups/Dustin_ILI9341_ESP32.h> // Setup file for Dustin Watts PCB with ILI9341
//#include <User_Setups/ILI9225.h>
#endif // USER_SETUP_LOADED
@ -181,7 +146,7 @@
#endif
// Invoke 18 bit colour for selected displays
#if !defined (RPI_DISPLAY_TYPE) && !defined (TFT_PARALLEL_8_BIT) && !defined (TFT_PARALLEL_16_BIT) && !defined (ESP32_PARALLEL)
#if !defined (RPI_DISPLAY_TYPE) && !defined (TFT_PARALLEL_8_BIT) && !defined (ESP32_PARALLEL)
#if defined (ILI9481_DRIVER) || defined (ILI9486_DRIVER) || defined (ILI9488_DRIVER)
#define SPI_18BIT_DRIVER
#endif
@ -254,13 +219,6 @@
#elif defined (RM68120_DRIVER)
#include "TFT_Drivers/RM68120_Defines.h"
#define TFT_DRIVER 0x6812
#elif defined (HX8357B_DRIVER)
#include "TFT_Drivers/HX8357B_Defines.h"
#define TFT_DRIVER 0x835B
#elif defined (HX8357C_DRIVER)
#include "TFT_Drivers/HX8357C_Defines.h"
#define TFT_DRIVER 0x835C
// <<<<<<<<<<<<<<<<<<<<<<<< ADD NEW DRIVER HERE
// XYZZY_init.h and XYZZY_rotation.h must also be added in TFT_eSPI.cpp
#elif defined (XYZZY_DRIVER)

View File

@ -1,60 +0,0 @@
// This setup is for the RP2040 processor only when used with 8 bit parallel displays
// See SetupX_Template.h for all options available
#define USER_SETUP_ID 105
////////////////////////////////////////////////////////////////////////////////////////////
// Interface
////////////////////////////////////////////////////////////////////////////////////////////
#define TFT_PARALLEL_16_BIT
////////////////////////////////////////////////////////////////////////////////////////////
// Display driver type
////////////////////////////////////////////////////////////////////////////////////////////
#define ST7796_DRIVER
////////////////////////////////////////////////////////////////////////////////////////////
// RP2040 pins used
////////////////////////////////////////////////////////////////////////////////////////////
//#define TFT_CS -1 // Do not define, chip select control pin permanently connected to 0V
// These pins can be moved and are controlled directly by the library software
#define TFT_DC 3 // Data Command control pin
#define TFT_RST 2 // Reset pin
//#define TFT_RD -1 // Do not define, read pin must be permanently connected to 3V3
#define TFT_WR 4
// PIO requires these to be sequentially increasing GPIO with no gaps
#define TFT_D0 6
#define TFT_D1 7
#define TFT_D2 8
#define TFT_D3 9
#define TFT_D4 10
#define TFT_D5 11
#define TFT_D6 12
#define TFT_D7 13
#define TFT_D8 14
#define TFT_D9 15
#define TFT_D10 16
#define TFT_D11 17
#define TFT_D12 18
#define TFT_D13 19
#define TFT_D14 20
#define TFT_D15 21
////////////////////////////////////////////////////////////////////////////////////////////
// Fonts to be available
////////////////////////////////////////////////////////////////////////////////////////////
#define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:.
#define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
#define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts
#define SMOOTH_FONT
////////////////////////////////////////////////////////////////////////////////////////////

View File

@ -1,64 +0,0 @@
// This setup is for the RP2040 processor when used with 8 bit parallel displays
// See SetupX_Template.h for all options available
#define USER_SETUP_ID 106
////////////////////////////////////////////////////////////////////////////////////////////
// Interface
////////////////////////////////////////////////////////////////////////////////////////////
//#define TFT_PARALLEL_8_BIT
#define TFT_PARALLEL_16_BIT
////////////////////////////////////////////////////////////////////////////////////////////
// Display driver type
////////////////////////////////////////////////////////////////////////////////////////////
#define ILI9481_DRIVER
//#define HX8357B_DRIVER
//#define HX8357C_DRIVER
////////////////////////////////////////////////////////////////////////////////////////////
// RP2040 pins used
////////////////////////////////////////////////////////////////////////////////////////////
// These pins can be moved and are controlled directly by the library software
#define TFT_RST 18 // Reset pin
#define TFT_CS 19 // Do not define if chip select control pin permanently connected to 0V
//#define TFT_RD -1 // Do not define, read pin must be permanently connected to 3V3
// Note: All the following pins are PIO hardware configured and driven
#define TFT_WR 16 // Write strobe pin
#define TFT_DC 17 // Data Command control pin
// PIO requires these to be sequentially increasing
#define TFT_D0 0
#define TFT_D1 1
#define TFT_D2 2
#define TFT_D3 3
#define TFT_D4 4
#define TFT_D5 5
#define TFT_D6 6
#define TFT_D7 7
#define TFT_D8 8
#define TFT_D9 9
#define TFT_D10 10
#define TFT_D11 11
#define TFT_D12 12
#define TFT_D13 13
#define TFT_D14 14
#define TFT_D15 15
//*/
////////////////////////////////////////////////////////////////////////////////////////////
// Fonts to be available
////////////////////////////////////////////////////////////////////////////////////////////
#define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:.
#define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
#define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts
#define SMOOTH_FONT
////////////////////////////////////////////////////////////////////////////////////////////

View File

@ -1,65 +0,0 @@
// This setup is for the RP2040 processor only when used with 8 bit parallel displays
// See SetupX_Template.h for all options available
#define USER_SETUP_ID 107
////////////////////////////////////////////////////////////////////////////////////////////
// Interface
////////////////////////////////////////////////////////////////////////////////////////////
//#define TFT_PARALLEL_8_BIT
#define TFT_PARALLEL_16_BIT
////////////////////////////////////////////////////////////////////////////////////////////
// Display driver type
////////////////////////////////////////////////////////////////////////////////////////////
#define ILI9341_DRIVER
//#define ILI9481_DRIVER // Tested
//#define HX8357B_DRIVER // Tested
//#define HX8357C_DRIVER // Tested
//#define SSD1963_800_DRIVER
////////////////////////////////////////////////////////////////////////////////////////////
// RP2040 pins used
////////////////////////////////////////////////////////////////////////////////////////////
// These pins can be moved and are controlled directly by the library software
#define TFT_RST 18 // Reset pin
#define TFT_CS 19 // Do not define if chip select control pin permanently connected to 0V
//#define TFT_RD -1 // Do not define, read pin must be permanently connected to 3V3
// Note: All the following pins are PIO hardware configured and driven
#define TFT_WR 16 // Write strobe pin
#define TFT_DC 17 // Data Command control pin
// PIO requires these to be sequentially increasing
#define TFT_D0 0
#define TFT_D1 1
#define TFT_D2 2
#define TFT_D3 3
#define TFT_D4 4
#define TFT_D5 5
#define TFT_D6 6
#define TFT_D7 7
#define TFT_D8 8
#define TFT_D9 9
#define TFT_D10 10
#define TFT_D11 11
#define TFT_D12 12
#define TFT_D13 13
#define TFT_D14 14
#define TFT_D15 15
//*/
////////////////////////////////////////////////////////////////////////////////////////////
// Fonts to be available
////////////////////////////////////////////////////////////////////////////////////////////
#define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:.
#define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
#define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts
#define SMOOTH_FONT
////////////////////////////////////////////////////////////////////////////////////////////

View File

@ -1,32 +0,0 @@
// User Setup for the ESP32 TouchDown V1.0 and V1.1
// ILI9488 using 4-wire SPI and using an FT6206 touch controller
#define USER_SETUP_ID 204
#define ILI9488_DRIVER
#define TFT_BL 32
#define TFT_BACKLIGHT_ON HIGH
#define TFT_MISO 19
#define TFT_MOSI 23
#define TFT_SCLK 18
#define TFT_CS 15
#define TFT_DC 2
#define TFT_RST 4
#define TOUCH_CS 21
#define LOAD_GLCD
#define LOAD_FONT2
#define LOAD_FONT4
#define LOAD_FONT6
#define LOAD_FONT7
#define LOAD_FONT8
#define LOAD_GFXFF
#define SMOOTH_FONT
#define SPI_FREQUENCY 27000000
#define SPI_READ_FREQUENCY 20000000
#define SPI_TOUCH_FREQUENCY 2500000

View File

@ -1,36 +0,0 @@
// User Setup for the ESP32 TouchDown S3 V1.1
// ILI9488 using 8-bit Parallel and using an FT6206 touch controller
#define USER_SETUP_ID 205
#define ESP32_PARALLEL
#define ILI9488_DRIVER
#define TFT_DC 5
#define TFT_RST 46
#define TFT_WR 7
#define TFT_RD 6
#define TFT_D0 21
#define TFT_D1 14
#define TFT_D2 13
#define TFT_D3 12
#define TFT_D4 11
#define TFT_D5 10
#define TFT_D6 9
#define TFT_D7 8
#define TFT_BL 48
#define TFT_BACKLIGHT_ON HIGH
#define LOAD_GLCD
#define LOAD_FONT2
#define LOAD_FONT4
#define LOAD_FONT6
#define LOAD_FONT7
#define LOAD_FONT8
#define LOAD_GFXFF
#define SMOOTH_FONT

View File

@ -1,46 +0,0 @@
// ST7789 using 8-bit Parallel
#define USER_SETUP_ID 206
#define ST7789_DRIVER
#define INIT_SEQUENCE_3 // Using this initialisation sequence improves the display image
#define CGRAM_OFFSET
#define TFT_RGB_ORDER TFT_RGB // Colour order Red-Green-Blue
//#define TFT_RGB_ORDER TFT_BGR // Colour order Blue-Green-Red
#define TFT_INVERSION_ON
// #define TFT_INVERSION_OFF
#define TFT_PARALLEL_8_BIT
#define TFT_WIDTH 170
#define TFT_HEIGHT 320
#define TFT_DC 7
#define TFT_RST 5
#define TFT_WR 8
#define TFT_RD 9
#define TFT_D0 39
#define TFT_D1 40
#define TFT_D2 41
#define TFT_D3 42
#define TFT_D4 45
#define TFT_D5 46
#define TFT_D6 47
#define TFT_D7 48
#define TFT_BL 38
#define TFT_BACKLIGHT_ON HIGH
#define LOAD_GLCD
#define LOAD_FONT2
#define LOAD_FONT4
#define LOAD_FONT6
#define LOAD_FONT7
#define LOAD_FONT8
#define LOAD_GFXFF
#define SMOOTH_FONT

View File

@ -1,48 +0,0 @@
// ST7789 240 x 240 display with no chip select line
#define USER_SETUP_ID 207
#define ST7789_DRIVER // Configure all registers
// #define TFT_RGB_ORDER TFT_BGR // Colour order Blue-Green-Red
#define TFT_WIDTH 240
#define TFT_HEIGHT 320
#define CGRAM_OFFSET
// #define TFT_RGB_ORDER TFT_RGB // Colour order Red-Green-Blue
#define TFT_RGB_ORDER TFT_BGR // Colour order Blue-Green-Red
// #define TFT_INVERSION_ON
#define TFT_INVERSION_OFF
#define TFT_PARALLEL_8_BIT
// The ESP32 and TFT the pins used for testing are:
#define TFT_CS 6 // Chip select control pin (library pulls permanently low
#define TFT_DC 7 // Data Command control pin
#define TFT_RST -1 // Reset pin, toggles on startup
#define TFT_WR 8 // Write strobe control pin
#define TFT_RD -1 // Read strobe control pin
#define TFT_D0 48 // Must use pins in the range 0-31 or alternatively 32-48
#define TFT_D1 47 // so a single register write sets/clears all bits.
#define TFT_D2 39 // Pins can be randomly assigned, this does not affect
#define TFT_D3 40 // TFT screen update performance.
#define TFT_D4 41
#define TFT_D5 42
#define TFT_D6 45
#define TFT_D7 46
#define TFT_BL 38 // LED back-light
#define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:.
#define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
//#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT
#define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts
#define SMOOTH_FONT

View File

@ -19,6 +19,8 @@
#define TFT_DC 16
#define TFT_RST 23
#define TOUCH_CS -1
#define TFT_BL 4 // Display backlight control pin
#define TFT_BACKLIGHT_ON HIGH // HIGH or LOW are options

View File

@ -1,47 +0,0 @@
#include "itoa.h"
#include <avr/dtostrf.h>
// Setup for BW16 and ST7735 80 x 160 TFT
#define USER_SETUP_ID 301
// See SetupX_Template.h for all options available
#define ST7735_DRIVER
#define TFT_WIDTH 80
#define TFT_HEIGHT 160
#define ST7735_GREENTAB160x80
// For ST7735, ST7789 and ILI9341 ONLY, define the colour order IF the blue and red are swapped on your display
// Try ONE option at a time to find the correct colour order for your display
// #define TFT_RGB_ORDER TFT_RGB // Colour order Red-Green-Blue
// #define TFT_RGB_ORDER TFT_BGR // Colour order Blue-Green-Red
// Pin Mappings for BW16 board
#define TFT_MISO 11
#define TFT_MOSI 12
#define TFT_SCLK 10
#define TFT_CS 9 // Chip select control pin
#define TFT_DC 8 // Data Command control pin
#define TFT_RST 6 // Reset pin (could connect to RST pin)
#define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:.
#define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
//#define LOAD_FONT8N // Font 8. Alternative to Font 8 above, slightly narrower, so 3 digits fit a 160 pixel TFT
#define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts
#define SMOOTH_FONT
#define SPI_FREQUENCY 20000000
//#define SPI_FREQUENCY 27000000 // Actually sets it to 26.67MHz = 80/3

View File

@ -1,36 +0,0 @@
// See SetupX_Template.h for all options available
#define USER_SETUP_ID 42
#define ILI9341_DRIVER
#define TFT_MISO 19 // (leave TFT SDO disconnected if other SPI devices share MISO)
#define TFT_MOSI 23
#define TFT_SCLK 18
#define TFT_CS 15 // Chip select control pin
#define TFT_DC 2 // Data Command control pin
#define TFT_RST 4 // Reset pin (could connect to RST pin)
// Optional touch screen chip select
//#define TOUCH_CS 5 // Chip select pin (T_CS) of touch screen
#define LOAD_GLCD // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2 // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4 // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6 // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7 // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:.
#define LOAD_FONT8 // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
#define LOAD_GFXFF // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts
#define SMOOTH_FONT
// TFT SPI clock frequency
// #define SPI_FREQUENCY 20000000
// #define SPI_FREQUENCY 27000000
#define SPI_FREQUENCY 40000000
// #define SPI_FREQUENCY 80000000
// Optional reduced SPI frequency for reading TFT
#define SPI_READ_FREQUENCY 16000000
// SPI clock frequency for touch controller
#define SPI_TOUCH_FREQUENCY 2500000

View File

@ -1,4 +1,3 @@
// See SetupX_Template.h for all options available
#define USER_SETUP_ID 46
#define GC9A01_DRIVER

View File

@ -1,37 +0,0 @@
// Setup for the ESP32 S3 with ILI9341 display
// Note SPI DMA with ESP32 S3 is not currently supported
#define USER_SETUP_ID 70
// See SetupX_Template.h for all options available
#define ILI9341_DRIVER
// Typical board default pins - change to match your board
#define TFT_CS 34 // 10 or 34 (FSPI CS0)
#define TFT_MOSI 35 // 11 or 35 (FSPI D)
#define TFT_SCLK 36 // 12 or 36 (FSPI CLK)
#define TFT_MISO 37 // 13 or 37 (FSPI Q)
// Use pins in range 0-31
#define TFT_DC 7
#define TFT_RST 6
//#define TOUCH_CS 16 // Optional for touch screen
#define LOAD_GLCD
#define LOAD_FONT2
#define LOAD_FONT4
#define LOAD_FONT6
#define LOAD_FONT7
#define LOAD_FONT8
#define LOAD_GFXFF
#define SMOOTH_FONT
// FSPI (or VSPI) port (SPI2) used unless following defined. HSPI port is (SPI3) on S3.
//#define USE_HSPI_PORT
//#define SPI_FREQUENCY 27000000
#define SPI_FREQUENCY 40000000 // Maximum for ILI9341
#define SPI_READ_FREQUENCY 6000000 // 6 MHz is the maximum SPI read speed for the ST7789V
#define SPI_TOUCH_FREQUENCY 2500000

View File

@ -1,56 +0,0 @@
// Setup for the ESP32 C3 with ILI9341 display
// Note SPI DMA with ESP32 C3 is not currently supported
#define USER_SETUP_ID 70
// See SetupX_Template.h for all options available
#define ILI9341_DRIVER
//#define ST7796_DRIVER
//#define ILI9488_DRIVER
// Adafruit qtpy default
//TFT_CS 6
//TFT_MOSI 7
//TFT_MISO 8
//TFT_SCLK 10
// Lolin C3 mini default
//TFT_CS 5
//TFT_MOSI 4
//TFT_MISO 3
//TFT_SCLK 2
//ESP32 C3 generic default
//TFT_CS 7
//TFT_MOSI 6
//TFT_MISO 5
//TFT_SCLK 4
#define TFT_CS 7
#define TFT_MOSI 6
#define TFT_MISO 5
#define TFT_SCLK 4
#define TFT_DC 8
#define TFT_RST 10
//#define TOUCH_CS 1 // Optional for touch screen
#define LOAD_GLCD
#define LOAD_FONT2
#define LOAD_FONT4
#define LOAD_FONT6
#define LOAD_FONT7
#define LOAD_FONT8
#define LOAD_GFXFF
#define SMOOTH_FONT
//#define SPI_FREQUENCY 27000000
#define SPI_FREQUENCY 40000000 // Maximum for ILI9341
#define SPI_READ_FREQUENCY 6000000 // 6 MHz is the maximum SPI read speed for the ST7789V
#define SPI_TOUCH_FREQUENCY 2500000

View File

@ -1,36 +0,0 @@
#define USER_SETUP_ID 146
#define TFT_PARALLEL_8_BIT
//#define ILI9341_DRIVER
//#define ST7796_DRIVER
#define ILI9488_DRIVER
// ESP32 S3 pins used for the parallel interface TFT
#define TFT_CS 9
#define TFT_DC 8 // Data Command control pin - must use a GPIO in the range 0-31
#define TFT_RST 34
#define TFT_WR 7 // Write strobe control pin - must use a GPIO in the range 0-31
#define TFT_RD 6
#define TFT_D0 12 // Must use GPIO in the range 0-31 for the data bus
#define TFT_D1 13 // so a single register write sets/clears all bits
#define TFT_D2 14
#define TFT_D3 15
#define TFT_D4 16
#define TFT_D5 21
#define TFT_D6 5
#define TFT_D7 4
#define LOAD_GLCD
#define LOAD_FONT2
#define LOAD_FONT4
#define LOAD_FONT6
#define LOAD_FONT7
#define LOAD_FONT8
#define LOAD_GFXFF
#define SMOOTH_FONT

View File

@ -1,44 +0,0 @@
// Setup for the ESP32 S2 with ST7735 80x160 display
// See SetupX_Template.h for all options available
#define USER_SETUP_ID 70
#define ST7735_DRIVER
#define TFT_SDA_READ // Display has a bidirectional SDA pin (no MISO)
#define TFT_WIDTH 80
#define TFT_HEIGHT 160
#define ST7735_GREENTAB160x80
//#define ST7735_REDTAB160x80
//#define TFT_RGB_ORDER TFT_RGB // Colour order Red-Green-Blue
#define TFT_RGB_ORDER TFT_BGR // Colour order Blue-Green-Red
#define TFT_INVERSION_ON
// #define TFT_INVERSION_OFF
// Typical board default pins
#define TFT_CS 10 // 10 or 34
#define TFT_MOSI 11 // 11 or 35
#define TFT_SCLK 12 // 12 or 36
#define TFT_DC 14
#define TFT_RST 15
#define LOAD_GLCD
#define LOAD_FONT2
#define LOAD_FONT4
#define LOAD_FONT6
#define LOAD_FONT7
#define LOAD_FONT8
#define LOAD_GFXFF
#define SMOOTH_FONT
// FSPI port must be used for SDA reads. Do not use #define USE_HSPI_PORT
#define SPI_FREQUENCY 27000000
#define SPI_READ_FREQUENCY 16000000

View File

@ -10,9 +10,6 @@
#define USER_SETUP_ID 0xFFFFFFFF
// Define to disable all #warnings in library (can be put in User_Setup_Select.h)
//#define DISABLE_ALL_LIBRARY_WARNINGS
// ##################################################################################
//
// Section 1. Call up the right driver file and any options for it
@ -35,21 +32,17 @@
// Tell the library to use 8 bit parallel mode (otherwise SPI is assumed)
//#define TFT_PARALLEL_8_BIT
//#define TFT_PARALLEL_16_BIT // **** 16 bit parallel ONLY with RP2040 processor ****
// Display type - only define if RPi display
//#define RPI_DISPLAY_TYPE // 20MHz maximum SPI
// Only define one driver, the other ones must be commented out
#define ILI9341_DRIVER // Generic driver for common displays
//#define ILI9341_2_DRIVER // Alternative ILI9341 driver, see https://github.com/Bodmer/TFT_eSPI/issues/1172
//#define ILI9342_DRIVER // Landscape default orientation variant of ILI9341
//#define ILI9341_2_DRIVER // Alternative ILI9341 driver, see https://github.com/Bodmer/TFT_eSPI/issues/1172
//#define ST7735_DRIVER // Define additional parameters below for this display
//#define ILI9163_DRIVER // Define additional parameters below for this display
//#define S6D02A1_DRIVER
//#define RPI_ILI9486_DRIVER // 20MHz maximum SPI
//#define HX8357B_DRIVER
//#define HX8357C_DRIVER
//#define HX8357D_DRIVER
//#define ILI9481_DRIVER
//#define ILI9486_DRIVER
@ -57,7 +50,6 @@
//#define ST7789_DRIVER // Full configuration option, define additional parameters below for this display
//#define ST7789_2_DRIVER // Minimal configuration option, define additional parameters below for this display
//#define R61581_DRIVER
//#define RM68120_DRIVER // Untested
//#define RM68140_DRIVER
//#define ST7796_DRIVER
//#define SSD1351_DRIVER

View File

@ -1,70 +0,0 @@
The TFT_eSPI library has been updated by a user (dracir9) in pull request #1770 to enable
use with the ESP-IDF.
https://github.com/Bodmer/TFT_eSPI/pull/1770
The library author (Bodmer) does not use the ESP-IDF so will not be able to provide support!
There are two ways to configure the library either:
manually enter the setup in menuconfig
OR
delete the KConfig file, select your LCD/board in the User_Setup_Select.h file, and run "idf.py reconfigure"
The following menuconfig instructions were posted by dracir9 as part of the pull request #1770:
https://github.com/Bodmer/TFT_eSPI/pull/1770#issuecomment-1096478997
In the above link the instructions include useful hyperlinks. The bare text of the
instructions is included below.
Steps to use:
1. Install ESP-IDF toolchain. The easiest way is to use VS Code and the ESP-IDF extension
which handles most of the work automatically. Make sure to install version V4.4. From
now on I'll assume that VS Code is being used.
2. Once ESP-IDF is installed open VS Code and press F1. Type ESP-IDF: New Project. Hit enter.
3. Enter your project name, directory and board (if not sure choose ESP32 chip (via ESP-PROG)).
If your board is connected choose serial port. Leave ESP-IDF component directory blank and
press Choose Template.
4. In the dropdown choose Extension and select Arduino-as-component. (This is not mandatory.
You can try other templates if you want). This will create a blank project with a simple
main source file in the "main" folder.
5. Now we have to add Arduino to your project. You can find the complete documentation here:
https://github.com/espressif/arduino-esp32
and here:
https://docs.espressif.com/projects/arduino-esp32/en/latest/esp-idf_component.html
I'll list two methods that I use most of the time:
5.1. Press F1 and type ESP-IDF: Add Arduino ESP32 as ESP-IDF Component. This will
automatically download and install the latest code from the arduino esp-32 repository.
This is the easiest method but as it uses the latest code it may introduce compilation errors.
5.2. Go to the Arduino esp-32 repository release page. Choose a version and find its "Assets"
section. Download the source code file into "project directory/components". Extract the
compressed file. This will create a folder called arduino-esp32-2.x.x. Rename it to arduino.
This method is slightly more complex but ensures you choose a stable version.
6. Download the TFT_eSPI library into the components folder
7. Now open VS Code and load your project folder. Press F1 and type ESP-IDF: SDK Configuration
editor (menuconfig). Alternatively press Ctrl+E, G or press the gear button in the bottom left
corner.
8. This will open the project configuration menu. Navigate to the TFT_eSPI section and configure
the library (TFT driver, pins, fonts, etc.).
9. Press F1 and type ESP-IDF: Build your project. Alternatively press Ctrl+E, B or click the
build button in the bottom left corner.
10. Choose your port by typing ESP-IDF: Select port to use or with the button in the bottom left.
11. Upload your code with the lightning button in the bottom toolbar.
12. Enjoy!

View File

@ -1,191 +0,0 @@
// Button widget demo, requires SPI display with touch screen
// Requires widget library here:
// https://github.com/Bodmer/TFT_eWidget
#include <FS.h>
#include "Free_Fonts.h" // Include the header file attached to this sketch
#include <TFT_eSPI.h> // Hardware-specific library
#include <TFT_eWidget.h> // Widget library
TFT_eSPI tft = TFT_eSPI(); // Invoke custom library
#define CALIBRATION_FILE "/TouchCalData1"
#define REPEAT_CAL false
ButtonWidget btnL = ButtonWidget(&tft);
ButtonWidget btnR = ButtonWidget(&tft);
#define BUTTON_W 100
#define BUTTON_H 50
// Create an array of button instances to use in for() loops
// This is more useful where large numbers of buttons are employed
ButtonWidget* btn[] = {&btnL , &btnR};;
uint8_t buttonCount = sizeof(btn) / sizeof(btn[0]);
void btnL_pressAction(void)
{
if (btnL.justPressed()) {
Serial.println("Left button just pressed");
btnL.drawSmoothButton(true);
}
}
void btnL_releaseAction(void)
{
static uint32_t waitTime = 1000;
if (btnL.justReleased()) {
Serial.println("Left button just released");
btnL.drawSmoothButton(false);
btnL.setReleaseTime(millis());
waitTime = 10000;
}
else {
if (millis() - btnL.getReleaseTime() >= waitTime) {
waitTime = 1000;
btnL.setReleaseTime(millis());
btnL.drawSmoothButton(!btnL.getState());
}
}
}
void btnR_pressAction(void)
{
if (btnR.justPressed()) {
btnR.drawSmoothButton(!btnR.getState(), 3, TFT_BLACK, btnR.getState() ? "OFF" : "ON");
Serial.print("Button toggled: ");
if (btnR.getState()) Serial.println("ON");
else Serial.println("OFF");
btnR.setPressTime(millis());
}
// if button pressed for more than 1 sec...
if (millis() - btnR.getPressTime() >= 1000) {
Serial.println("Stop pressing my buttton.......");
}
else Serial.println("Right button is being pressed");
}
void btnR_releaseAction(void)
{
// Not action
}
void initButtons() {
uint16_t x = (tft.width() - BUTTON_W) / 2;
uint16_t y = tft.height() / 2 - BUTTON_H - 10;
btnL.initButtonUL(x, y, BUTTON_W, BUTTON_H, TFT_WHITE, TFT_RED, TFT_BLACK, "Button", 1);
btnL.setPressAction(btnL_pressAction);
btnL.setReleaseAction(btnL_releaseAction);
btnL.drawSmoothButton(false, 3, TFT_BLACK); // 3 is outline width, TFT_BLACK is the surrounding background colour for anti-aliasing
y = tft.height() / 2 + 10;
btnR.initButtonUL(x, y, BUTTON_W, BUTTON_H, TFT_WHITE, TFT_BLACK, TFT_GREEN, "OFF", 1);
btnR.setPressAction(btnR_pressAction);
//btnR.setReleaseAction(btnR_releaseAction);
btnR.drawSmoothButton(false, 3, TFT_BLACK); // 3 is outline width, TFT_BLACK is the surrounding background colour for anti-aliasing
}
void setup() {
Serial.begin(115200);
tft.begin();
tft.setRotation(0);
tft.fillScreen(TFT_BLACK);
tft.setFreeFont(FF18);
// Calibrate the touch screen and retrieve the scaling factors
touch_calibrate();
initButtons();
}
void loop() {
static uint32_t scanTime = millis();
uint16_t t_x = 9999, t_y = 9999; // To store the touch coordinates
// Scan keys every 50ms at most
if (millis() - scanTime >= 50) {
// Pressed will be set true if there is a valid touch on the screen
bool pressed = tft.getTouch(&t_x, &t_y);
scanTime = millis();
for (uint8_t b = 0; b < buttonCount; b++) {
if (pressed) {
if (btn[b]->contains(t_x, t_y)) {
btn[b]->press(true);
btn[b]->pressAction();
}
}
else {
btn[b]->press(false);
btn[b]->releaseAction();
}
}
}
}
void touch_calibrate()
{
uint16_t calData[5];
uint8_t calDataOK = 0;
// check file system exists
if (!LittleFS.begin()) {
Serial.println("Formating file system");
LittleFS.format();
LittleFS.begin();
}
// check if calibration file exists and size is correct
if (LittleFS.exists(CALIBRATION_FILE)) {
if (REPEAT_CAL)
{
// Delete if we want to re-calibrate
LittleFS.remove(CALIBRATION_FILE);
}
else
{
File f = LittleFS.open(CALIBRATION_FILE, "r");
if (f) {
if (f.readBytes((char *)calData, 14) == 14)
calDataOK = 1;
f.close();
}
}
}
if (calDataOK && !REPEAT_CAL) {
// calibration data valid
tft.setTouch(calData);
} else {
// data not valid so recalibrate
tft.fillScreen(TFT_BLACK);
tft.setCursor(20, 0);
tft.setTextFont(2);
tft.setTextSize(1);
tft.setTextColor(TFT_WHITE, TFT_BLACK);
tft.println("Touch corners as indicated");
tft.setTextFont(1);
tft.println();
if (REPEAT_CAL) {
tft.setTextColor(TFT_RED, TFT_BLACK);
tft.println("Set REPEAT_CAL to false to stop this running again!");
}
tft.calibrateTouch(calData, TFT_MAGENTA, TFT_BLACK, 15);
tft.setTextColor(TFT_GREEN, TFT_BLACK);
tft.println("Calibration complete!");
// store data
File f = LittleFS.open(CALIBRATION_FILE, "w");
if (f) {
f.write((const unsigned char *)calData, 14);
f.close();
}
}
}

View File

@ -1,377 +0,0 @@
// Attach this header file to your sketch to use the GFX Free Fonts. You can write
// sketches without it, but it makes referencing them easier.
// This calls up ALL the fonts but they only get loaded if you actually
// use them in your sketch.
//
// No changes are needed to this header file unless new fonts are added to the
// library "Fonts/GFXFF" folder.
//
// To save a lot of typing long names, each font can easily be referenced in the
// sketch in three ways, either with:
//
// 1. Font file name with the & in front such as &FreeSansBoldOblique24pt7b
// an example being:
//
// tft.setFreeFont(&FreeSansBoldOblique24pt7b);
//
// 2. FF# where # is a number determined by looking at the list below
// an example being:
//
// tft.setFreeFont(FF32);
//
// 3. An abbreviation of the file name. Look at the list below to see
// the abbreviations used, for example:
//
// tft.setFreeFont(FSSBO24)
//
// Where the letters mean:
// F = Free font
// M = Mono
// SS = Sans Serif (double S to distinguish is form serif fonts)
// S = Serif
// B = Bold
// O = Oblique (letter O not zero)
// I = Italic
// # = point size, either 9, 12, 18 or 24
//
// Setting the font to NULL will select the GLCD font:
//
// tft.setFreeFont(NULL); // Set font to GLCD
#define LOAD_tftFF
#ifdef LOAD_tftFF // Only include the fonts if LOAD_tftFF is defined in User_Setup.h
// Use these when printing or drawing text in GLCD and high rendering speed fonts
#define GFXFF 1
#define GLCD 0
#define FONT2 2
#define FONT4 4
#define FONT6 6
#define FONT7 7
#define FONT8 8
// Use the following when calling setFont()
//
// Reserved for GLCD font // FF0
//
#define TT1 &TomThumb
#define FM9 &FreeMono9pt7b
#define FM12 &FreeMono12pt7b
#define FM18 &FreeMono18pt7b
#define FM24 &FreeMono24pt7b
#define FMB9 &FreeMonoBold9pt7b
#define FMB12 &FreeMonoBold12pt7b
#define FMB18 &FreeMonoBold18pt7b
#define FMB24 &FreeMonoBold24pt7b
#define FMO9 &FreeMonoOblique9pt7b
#define FMO12 &FreeMonoOblique12pt7b
#define FMO18 &FreeMonoOblique18pt7b
#define FMO24 &FreeMonoOblique24pt7b
#define FMBO9 &FreeMonoBoldOblique9pt7b
#define FMBO12 &FreeMonoBoldOblique12pt7b
#define FMBO18 &FreeMonoBoldOblique18pt7b
#define FMBO24 &FreeMonoBoldOblique24pt7b
#define FSS9 &FreeSans9pt7b
#define FSS12 &FreeSans12pt7b
#define FSS18 &FreeSans18pt7b
#define FSS24 &FreeSans24pt7b
#define FSSB9 &FreeSansBold9pt7b
#define FSSB12 &FreeSansBold12pt7b
#define FSSB18 &FreeSansBold18pt7b
#define FSSB24 &FreeSansBold24pt7b
#define FSSO9 &FreeSansOblique9pt7b
#define FSSO12 &FreeSansOblique12pt7b
#define FSSO18 &FreeSansOblique18pt7b
#define FSSO24 &FreeSansOblique24pt7b
#define FSSBO9 &FreeSansBoldOblique9pt7b
#define FSSBO12 &FreeSansBoldOblique12pt7b
#define FSSBO18 &FreeSansBoldOblique18pt7b
#define FSSBO24 &FreeSansBoldOblique24pt7b
#define FS9 &FreeSerif9pt7b
#define FS12 &FreeSerif12pt7b
#define FS18 &FreeSerif18pt7b
#define FS24 &FreeSerif24pt7b
#define FSI9 &FreeSerifItalic9pt7b
#define FSI12 &FreeSerifItalic12pt7b
#define FSI19 &FreeSerifItalic18pt7b
#define FSI24 &FreeSerifItalic24pt7b
#define FSB9 &FreeSerifBold9pt7b
#define FSB12 &FreeSerifBold12pt7b
#define FSB18 &FreeSerifBold18pt7b
#define FSB24 &FreeSerifBold24pt7b
#define FSBI9 &FreeSerifBoldItalic9pt7b
#define FSBI12 &FreeSerifBoldItalic12pt7b
#define FSBI18 &FreeSerifBoldItalic18pt7b
#define FSBI24 &FreeSerifBoldItalic24pt7b
#define FF0 NULL //ff0 reserved for GLCD
#define FF1 &FreeMono9pt7b
#define FF2 &FreeMono12pt7b
#define FF3 &FreeMono18pt7b
#define FF4 &FreeMono24pt7b
#define FF5 &FreeMonoBold9pt7b
#define FF6 &FreeMonoBold12pt7b
#define FF7 &FreeMonoBold18pt7b
#define FF8 &FreeMonoBold24pt7b
#define FF9 &FreeMonoOblique9pt7b
#define FF10 &FreeMonoOblique12pt7b
#define FF11 &FreeMonoOblique18pt7b
#define FF12 &FreeMonoOblique24pt7b
#define FF13 &FreeMonoBoldOblique9pt7b
#define FF14 &FreeMonoBoldOblique12pt7b
#define FF15 &FreeMonoBoldOblique18pt7b
#define FF16 &FreeMonoBoldOblique24pt7b
#define FF17 &FreeSans9pt7b
#define FF18 &FreeSans12pt7b
#define FF19 &FreeSans18pt7b
#define FF20 &FreeSans24pt7b
#define FF21 &FreeSansBold9pt7b
#define FF22 &FreeSansBold12pt7b
#define FF23 &FreeSansBold18pt7b
#define FF24 &FreeSansBold24pt7b
#define FF25 &FreeSansOblique9pt7b
#define FF26 &FreeSansOblique12pt7b
#define FF27 &FreeSansOblique18pt7b
#define FF28 &FreeSansOblique24pt7b
#define FF29 &FreeSansBoldOblique9pt7b
#define FF30 &FreeSansBoldOblique12pt7b
#define FF31 &FreeSansBoldOblique18pt7b
#define FF32 &FreeSansBoldOblique24pt7b
#define FF33 &FreeSerif9pt7b
#define FF34 &FreeSerif12pt7b
#define FF35 &FreeSerif18pt7b
#define FF36 &FreeSerif24pt7b
#define FF37 &FreeSerifItalic9pt7b
#define FF38 &FreeSerifItalic12pt7b
#define FF39 &FreeSerifItalic18pt7b
#define FF40 &FreeSerifItalic24pt7b
#define FF41 &FreeSerifBold9pt7b
#define FF42 &FreeSerifBold12pt7b
#define FF43 &FreeSerifBold18pt7b
#define FF44 &FreeSerifBold24pt7b
#define FF45 &FreeSerifBoldItalic9pt7b
#define FF46 &FreeSerifBoldItalic12pt7b
#define FF47 &FreeSerifBoldItalic18pt7b
#define FF48 &FreeSerifBoldItalic24pt7b
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// Now we define "s"tring versions for easy printing of the font name so:
// tft.println(sFF5);
// will print
// Mono bold 9
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#define sFF0 "GLCD"
#define sTT1 "Tom Thumb"
#define sFF1 "Mono 9"
#define sFF2 "Mono 12"
#define sFF3 "Mono 18"
#define sFF4 "Mono 24"
#define sFF5 "Mono bold 9"
#define sFF6 "Mono bold 12"
#define sFF7 "Mono bold 18"
#define sFF8 "Mono bold 24"
#define sFF9 "Mono oblique 9"
#define sFF10 "Mono oblique 12"
#define sFF11 "Mono oblique 18"
#define sFF12 "Mono oblique 24"
#define sFF13 "Mono bold oblique 9"
#define sFF14 "Mono bold oblique 12"
#define sFF15 "Mono bold oblique 18"
#define sFF16 "Mono bold oblique 24" // Full text line is too big for 480 pixel wide screen
#define sFF17 "Sans 9"
#define sFF18 "Sans 12"
#define sFF19 "Sans 18"
#define sFF20 "Sans 24"
#define sFF21 "Sans bold 9"
#define sFF22 "Sans bold 12"
#define sFF23 "Sans bold 18"
#define sFF24 "Sans bold 24"
#define sFF25 "Sans oblique 9"
#define sFF26 "Sans oblique 12"
#define sFF27 "Sans oblique 18"
#define sFF28 "Sans oblique 24"
#define sFF29 "Sans bold oblique 9"
#define sFF30 "Sans bold oblique 12"
#define sFF31 "Sans bold oblique 18"
#define sFF32 "Sans bold oblique 24"
#define sFF33 "Serif 9"
#define sFF34 "Serif 12"
#define sFF35 "Serif 18"
#define sFF36 "Serif 24"
#define sFF37 "Serif italic 9"
#define sFF38 "Serif italic 12"
#define sFF39 "Serif italic 18"
#define sFF40 "Serif italic 24"
#define sFF41 "Serif bold 9"
#define sFF42 "Serif bold 12"
#define sFF43 "Serif bold 18"
#define sFF44 "Serif bold 24"
#define sFF45 "Serif bold italic 9"
#define sFF46 "Serif bold italic 12"
#define sFF47 "Serif bold italic 18"
#define sFF48 "Serif bold italic 24"
#else // LOAD_tftFF not defined so setup defaults to prevent error messages
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// Free fonts are not loaded in User_Setup.h so we must define all as font 1
// to prevent compile error messages
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#define GFXFF 1
#define GLCD 1
#define FONT2 2
#define FONT4 4
#define FONT6 6
#define FONT7 7
#define FONT8 8
#define FF0 1
#define FF1 1
#define FF2 1
#define FF3 1
#define FF4 1
#define FF5 1
#define FF6 1
#define FF7 1
#define FF8 1
#define FF9 1
#define FF10 1
#define FF11 1
#define FF12 1
#define FF13 1
#define FF14 1
#define FF15 1
#define FF16 1
#define FF17 1
#define FF18 1
#define FF19 1
#define FF20 1
#define FF21 1
#define FF22 1
#define FF23 1
#define FF24 1
#define FF25 1
#define FF26 1
#define FF27 1
#define FF28 1
#define FF29 1
#define FF30 1
#define FF31 1
#define FF32 1
#define FF33 1
#define FF34 1
#define FF35 1
#define FF36 1
#define FF37 1
#define FF38 1
#define FF39 1
#define FF40 1
#define FF41 1
#define FF42 1
#define FF43 1
#define FF44 1
#define FF45 1
#define FF46 1
#define FF47 1
#define FF48 1
#define FM9 1
#define FM12 1
#define FM18 1
#define FM24 1
#define FMB9 1
#define FMB12 1
#define FMB18 1
#define FMB24 1
#define FMO9 1
#define FMO12 1
#define FMO18 1
#define FMO24 1
#define FMBO9 1
#define FMBO12 1
#define FMBO18 1
#define FMBO24 1
#define FSS9 1
#define FSS12 1
#define FSS18 1
#define FSS24 1
#define FSSB9 1
#define FSSB12 1
#define FSSB18 1
#define FSSB24 1
#define FSSO9 1
#define FSSO12 1
#define FSSO18 1
#define FSSO24 1
#define FSSBO9 1
#define FSSBO12 1
#define FSSBO18 1
#define FSSBO24 1
#define FS9 1
#define FS12 1
#define FS18 1
#define FS24 1
#define FSI9 1
#define FSI12 1
#define FSI19 1
#define FSI24 1
#define FSB9 1
#define FSB12 1
#define FSB18 1
#define FSB24 1
#define FSBI9 1
#define FSBI12 1
#define FSBI18 1
#define FSBI24 1
#endif // LOAD_tftFF

View File

@ -1,80 +0,0 @@
// Demonstrate graph widget functions with a single trace instance
// One trace can be drawn at a time with one trace instance
// Requires widget library here:
// https://github.com/Bodmer/TFT_eWidget
#include <TFT_eSPI.h>
TFT_eSPI tft = TFT_eSPI();
#include <TFT_eWidget.h> // Widget library
GraphWidget gr = GraphWidget(&tft); // Graph widget gr instance with pointer to tft
TraceWidget tr = TraceWidget(&gr); // Graph trace tr with pointer to gr
const float gxLow = 0.0;
const float gxHigh = 100.0;
const float gyLow = -512.0;
const float gyHigh = 512.0;
void setup() {
Serial.begin(115200);
tft.begin();
tft.setRotation(3);
tft.fillScreen(TFT_BLACK);
// Graph area is 200 pixels wide, 150 pixels high, dark grey background
gr.createGraph(200, 150, tft.color565(5, 5, 5));
// x scale units is from 0 to 100, y scale units is -512 to 512
gr.setGraphScale(gxLow, gxHigh, gyLow, gyHigh);
// X grid starts at 0 with lines every 20 x-scale units
// Y grid starts at -512 with lines every 64 y-scale units
// blue grid
gr.setGraphGrid(gxLow, 20.0, gyLow, 64.0, TFT_BLUE);
// Draw empty graph, top left corner at pixel coordinate 40,10 on TFT
gr.drawGraph(40, 10);
// Start a trace with using red, trace points are in x and y scale units
// In this example a horizontal line is drawn
tr.startTrace(TFT_RED);
// Add a trace point at 0.0,0.0 on graph
tr.addPoint(0.0, 0.0);
// Add another point at 100.0, 0.0 this will be joined via line to the last point added
tr.addPoint(100.0, 0.0);
// Start a new trace with using white
tr.startTrace(TFT_WHITE);
}
void loop() {
static uint32_t plotTime = millis();
static float gx = 0.0, gy = 0.0;
static float delta = 10.0;
// Create a new plot point every 100ms
if (millis() - plotTime >= 100) {
plotTime = millis();
// Add a plot, first point in a trace will be a single pixel (if within graph area)
tr.addPoint(gx, gy);
gx += 1.0;
if (gy > 500.0) delta = -10.0;
if (gy < -500.0) delta = 10.0;
gy += delta;
// If the end of the graph x ais is reached start a new trace at 0.0,0.0
if (gx > gxHigh) {
gx = 0.0;
gy = 0.0;
// Draw empty graph at 40,10 on display to clear old one
gr.drawGraph(40, 10);
// Start new trace
tr.startTrace(TFT_GREEN);
}
}
}

View File

@ -1,105 +0,0 @@
// Demonstrate graph widget functions with two independant trace instances
// Multiple traces can be drawn at a time with multiple trace instances
// Note: Traces are automatically clipped at graph boundaries by widget library
// Requires widget library here:
// https://github.com/Bodmer/TFT_eWidget
#include <TFT_eSPI.h>
TFT_eSPI tft = TFT_eSPI();
#include <TFT_eWidget.h> // Widget library
GraphWidget gr = GraphWidget(&tft); // Graph widget
// Traces are drawn on tft using graph instance
TraceWidget tr1 = TraceWidget(&gr); // Graph trace 1
TraceWidget tr2 = TraceWidget(&gr); // Graph trace 2
void setup() {
Serial.begin(115200);
delay(5000);
tft.begin();
tft.setRotation(3);
tft.fillScreen(TFT_BLACK);
// Graph area is 200 pixels wide, 150 high, dark grey background
gr.createGraph(200, 150, tft.color565(5, 5, 5));
// x scale units is from 0 to 100, y scale units is -50 to 50
gr.setGraphScale(0.0, 100.0, -50.0, 50.0);
// X grid starts at 0 with lines every 10 x-scale units
// Y grid starts at -50 with lines every 25 y-scale units
// blue grid
gr.setGraphGrid(0.0, 10.0, -50.0, 25.0, TFT_BLUE);
// Draw empty graph, top left corner at 40,10 on TFT
gr.drawGraph(40, 10);
// Start a trace with using red and another with green
tr1.startTrace(TFT_RED);
tr2.startTrace(TFT_GREEN);
// Add points on graph to trace 1 using graph scale factors
tr1.addPoint(0.0, 0.0);
tr1.addPoint(100.0, 0.0);
// Add points on graph to trace 2 using graph scale factors
// Points are off graph so the plotted line is clipped to graph area
tr2.addPoint(0.0, -100.0);
tr2.addPoint(100.0, 100.0);
// Get x,y pixel coordinates of any scaled point on graph
// and ring that point.
tft.drawCircle(gr.getPointX(50.0), gr.getPointY(0.0), 5, TFT_MAGENTA);
// Draw the x axis scale
tft.setTextDatum(TC_DATUM); // Top centre text datum
tft.drawNumber(0, gr.getPointX(0.0), gr.getPointY(-50.0) + 3);
tft.drawNumber(50, gr.getPointX(50.0), gr.getPointY(-50.0) + 3);
tft.drawNumber(100, gr.getPointX(100.0), gr.getPointY(-50.0) + 3);
// Draw the y axis scale
tft.setTextDatum(MR_DATUM); // Middle right text datum
tft.drawNumber(-50, gr.getPointX(0.0), gr.getPointY(-50.0));
tft.drawNumber(0, gr.getPointX(0.0), gr.getPointY(0.0));
tft.drawNumber(50, gr.getPointX(0.0), gr.getPointY(50.0));
// Restart traces with new colours
tr1.startTrace(TFT_WHITE);
tr2.startTrace(TFT_YELLOW);
}
void loop() {
static uint32_t plotTime = millis();
static float gx = 0.0, gy = 0.0;
static float delta = 7.0;
// Sample periodically
if (millis() - plotTime >= 100) {
plotTime = millis();
// Add a new point on each trace
tr1.addPoint(gx, gy);
tr2.addPoint(gx, gy/2.0); // half y amplitude
// Create next plot point
gx += 1.0;
gy += delta;
if (gy > 70.0) { delta = -7.0; gy = 70.0; }
if (gy < -70.0) { delta = 7.0; gy = -70.0; }
// If the end of the graph is reached start 2 new traces
if (gx > 100.0) {
gx = 0.0;
gy = 0.0;
// Draw empty graph at 40,10 on display
gr.drawGraph(40, 10);
// Start new trace
tr1.startTrace(TFT_GREEN);
tr2.startTrace(TFT_YELLOW);
}
}
}

View File

@ -1,87 +0,0 @@
/*
Example animated analogue meters
Needs Font 2 (also Font 4 if using large scale label)
Make sure all the display driver and pin connections are correct by
editing the User_Setup.h file in the TFT_eSPI library folder.
#########################################################################
###### DON'T FORGET TO UPDATE THE User_Setup.h FILE IN THE LIBRARY ######
#########################################################################
Requires widget library here:
https://github.com/Bodmer/TFT_eWidget
*/
#include <TFT_eSPI.h> // Hardware-specific library
#include <TFT_eWidget.h> // Widget library
TFT_eSPI tft = TFT_eSPI(); // Invoke custom library
MeterWidget amps = MeterWidget(&tft);
MeterWidget volts = MeterWidget(&tft);
MeterWidget ohms = MeterWidget(&tft);
#define LOOP_PERIOD 35 // Display updates every 35 ms
void setup(void)
{
tft.init();
tft.setRotation(0);
Serial.begin(115200); // For debug
// Colour zones are set as a start and end percentage of full scale (0-100)
// If start and end of a colour zone are the same then that colour is not used
// --Red-- -Org- -Yell- -Grn-
amps.setZones(75, 100, 50, 75, 25, 50, 0, 25); // Example here red starts at 75% and ends at 100% of full scale
// Meter is 239 pixels wide and 126 pixels high
amps.analogMeter(0, 0, 2.0, "mA", "0", "0.5", "1.0", "1.5", "2.0"); // Draw analogue meter at 0, 0
// Colour draw order is red, orange, yellow, green. So red can be full scale with green drawn
// last on top to indicate a "safe" zone.
// -Red- -Org- -Yell- -Grn-
volts.setZones(0, 100, 25, 75, 0, 0, 40, 60);
volts.analogMeter(0, 128, 10.0, "V", "0", "2.5", "5", "7.5", "10"); // Draw analogue meter at 0, 128
// No coloured zones if not defined
ohms.analogMeter(0, 256, 100, "R", "0", "", "50", "", "100"); // Draw analogue meter at 0, 128
}
void loop()
{
static int d = 0;
static uint32_t updateTime = 0;
if (millis() - updateTime >= LOOP_PERIOD)
{
updateTime = millis();
d += 4; if (d > 360) d = 0;
// Create a Sine wave for testing, value is in range 0 - 100
float value = 50.0 + 50.0 * sin((d + 0) * 0.0174532925);
float current;
current = mapValue(value, (float)0.0, (float)100.0, (float)0.0, (float)2.0);
//Serial.print("I = "); Serial.print(current);
amps.updateNeedle(current, 0);
float voltage;
voltage = mapValue(value, (float)0.0, (float)100.0, (float)0.0, (float)10.0);
//Serial.print(", V = "); Serial.println(voltage);
volts.updateNeedle(voltage, 0);
float resistance;
resistance = mapValue(value, (float)0.0, (float)100.0, (float)0.0, (float)100.0);
//Serial.print(", R = "); Serial.println(resistance);
ohms.updateNeedle(resistance, 0);
}
}
float mapValue(float ip, float ipmin, float ipmax, float tomin, float tomax)
{
return tomin + (((tomax - tomin) * (ip - ipmin))/ (ipmax - ipmin));
}

View File

@ -1,377 +0,0 @@
// Attach this header file to your sketch to use the GFX Free Fonts. You can write
// sketches without it, but it makes referencing them easier.
// This calls up ALL the fonts but they only get loaded if you actually
// use them in your sketch.
//
// No changes are needed to this header file unless new fonts are added to the
// library "Fonts/GFXFF" folder.
//
// To save a lot of typing long names, each font can easily be referenced in the
// sketch in three ways, either with:
//
// 1. Font file name with the & in front such as &FreeSansBoldOblique24pt7b
// an example being:
//
// tft.setFreeFont(&FreeSansBoldOblique24pt7b);
//
// 2. FF# where # is a number determined by looking at the list below
// an example being:
//
// tft.setFreeFont(FF32);
//
// 3. An abbreviation of the file name. Look at the list below to see
// the abbreviations used, for example:
//
// tft.setFreeFont(FSSBO24)
//
// Where the letters mean:
// F = Free font
// M = Mono
// SS = Sans Serif (double S to distinguish is form serif fonts)
// S = Serif
// B = Bold
// O = Oblique (letter O not zero)
// I = Italic
// # = point size, either 9, 12, 18 or 24
//
// Setting the font to NULL will select the GLCD font:
//
// tft.setFreeFont(NULL); // Set font to GLCD
#define LOAD_tftFF
#ifdef LOAD_tftFF // Only include the fonts if LOAD_tftFF is defined in User_Setup.h
// Use these when printing or drawing text in GLCD and high rendering speed fonts
#define GFXFF 1
#define GLCD 0
#define FONT2 2
#define FONT4 4
#define FONT6 6
#define FONT7 7
#define FONT8 8
// Use the following when calling setFont()
//
// Reserved for GLCD font // FF0
//
#define TT1 &TomThumb
#define FM9 &FreeMono9pt7b
#define FM12 &FreeMono12pt7b
#define FM18 &FreeMono18pt7b
#define FM24 &FreeMono24pt7b
#define FMB9 &FreeMonoBold9pt7b
#define FMB12 &FreeMonoBold12pt7b
#define FMB18 &FreeMonoBold18pt7b
#define FMB24 &FreeMonoBold24pt7b
#define FMO9 &FreeMonoOblique9pt7b
#define FMO12 &FreeMonoOblique12pt7b
#define FMO18 &FreeMonoOblique18pt7b
#define FMO24 &FreeMonoOblique24pt7b
#define FMBO9 &FreeMonoBoldOblique9pt7b
#define FMBO12 &FreeMonoBoldOblique12pt7b
#define FMBO18 &FreeMonoBoldOblique18pt7b
#define FMBO24 &FreeMonoBoldOblique24pt7b
#define FSS9 &FreeSans9pt7b
#define FSS12 &FreeSans12pt7b
#define FSS18 &FreeSans18pt7b
#define FSS24 &FreeSans24pt7b
#define FSSB9 &FreeSansBold9pt7b
#define FSSB12 &FreeSansBold12pt7b
#define FSSB18 &FreeSansBold18pt7b
#define FSSB24 &FreeSansBold24pt7b
#define FSSO9 &FreeSansOblique9pt7b
#define FSSO12 &FreeSansOblique12pt7b
#define FSSO18 &FreeSansOblique18pt7b
#define FSSO24 &FreeSansOblique24pt7b
#define FSSBO9 &FreeSansBoldOblique9pt7b
#define FSSBO12 &FreeSansBoldOblique12pt7b
#define FSSBO18 &FreeSansBoldOblique18pt7b
#define FSSBO24 &FreeSansBoldOblique24pt7b
#define FS9 &FreeSerif9pt7b
#define FS12 &FreeSerif12pt7b
#define FS18 &FreeSerif18pt7b
#define FS24 &FreeSerif24pt7b
#define FSI9 &FreeSerifItalic9pt7b
#define FSI12 &FreeSerifItalic12pt7b
#define FSI19 &FreeSerifItalic18pt7b
#define FSI24 &FreeSerifItalic24pt7b
#define FSB9 &FreeSerifBold9pt7b
#define FSB12 &FreeSerifBold12pt7b
#define FSB18 &FreeSerifBold18pt7b
#define FSB24 &FreeSerifBold24pt7b
#define FSBI9 &FreeSerifBoldItalic9pt7b
#define FSBI12 &FreeSerifBoldItalic12pt7b
#define FSBI18 &FreeSerifBoldItalic18pt7b
#define FSBI24 &FreeSerifBoldItalic24pt7b
#define FF0 NULL //ff0 reserved for GLCD
#define FF1 &FreeMono9pt7b
#define FF2 &FreeMono12pt7b
#define FF3 &FreeMono18pt7b
#define FF4 &FreeMono24pt7b
#define FF5 &FreeMonoBold9pt7b
#define FF6 &FreeMonoBold12pt7b
#define FF7 &FreeMonoBold18pt7b
#define FF8 &FreeMonoBold24pt7b
#define FF9 &FreeMonoOblique9pt7b
#define FF10 &FreeMonoOblique12pt7b
#define FF11 &FreeMonoOblique18pt7b
#define FF12 &FreeMonoOblique24pt7b
#define FF13 &FreeMonoBoldOblique9pt7b
#define FF14 &FreeMonoBoldOblique12pt7b
#define FF15 &FreeMonoBoldOblique18pt7b
#define FF16 &FreeMonoBoldOblique24pt7b
#define FF17 &FreeSans9pt7b
#define FF18 &FreeSans12pt7b
#define FF19 &FreeSans18pt7b
#define FF20 &FreeSans24pt7b
#define FF21 &FreeSansBold9pt7b
#define FF22 &FreeSansBold12pt7b
#define FF23 &FreeSansBold18pt7b
#define FF24 &FreeSansBold24pt7b
#define FF25 &FreeSansOblique9pt7b
#define FF26 &FreeSansOblique12pt7b
#define FF27 &FreeSansOblique18pt7b
#define FF28 &FreeSansOblique24pt7b
#define FF29 &FreeSansBoldOblique9pt7b
#define FF30 &FreeSansBoldOblique12pt7b
#define FF31 &FreeSansBoldOblique18pt7b
#define FF32 &FreeSansBoldOblique24pt7b
#define FF33 &FreeSerif9pt7b
#define FF34 &FreeSerif12pt7b
#define FF35 &FreeSerif18pt7b
#define FF36 &FreeSerif24pt7b
#define FF37 &FreeSerifItalic9pt7b
#define FF38 &FreeSerifItalic12pt7b
#define FF39 &FreeSerifItalic18pt7b
#define FF40 &FreeSerifItalic24pt7b
#define FF41 &FreeSerifBold9pt7b
#define FF42 &FreeSerifBold12pt7b
#define FF43 &FreeSerifBold18pt7b
#define FF44 &FreeSerifBold24pt7b
#define FF45 &FreeSerifBoldItalic9pt7b
#define FF46 &FreeSerifBoldItalic12pt7b
#define FF47 &FreeSerifBoldItalic18pt7b
#define FF48 &FreeSerifBoldItalic24pt7b
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// Now we define "s"tring versions for easy printing of the font name so:
// tft.println(sFF5);
// will print
// Mono bold 9
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#define sFF0 "GLCD"
#define sTT1 "Tom Thumb"
#define sFF1 "Mono 9"
#define sFF2 "Mono 12"
#define sFF3 "Mono 18"
#define sFF4 "Mono 24"
#define sFF5 "Mono bold 9"
#define sFF6 "Mono bold 12"
#define sFF7 "Mono bold 18"
#define sFF8 "Mono bold 24"
#define sFF9 "Mono oblique 9"
#define sFF10 "Mono oblique 12"
#define sFF11 "Mono oblique 18"
#define sFF12 "Mono oblique 24"
#define sFF13 "Mono bold oblique 9"
#define sFF14 "Mono bold oblique 12"
#define sFF15 "Mono bold oblique 18"
#define sFF16 "Mono bold oblique 24" // Full text line is too big for 480 pixel wide screen
#define sFF17 "Sans 9"
#define sFF18 "Sans 12"
#define sFF19 "Sans 18"
#define sFF20 "Sans 24"
#define sFF21 "Sans bold 9"
#define sFF22 "Sans bold 12"
#define sFF23 "Sans bold 18"
#define sFF24 "Sans bold 24"
#define sFF25 "Sans oblique 9"
#define sFF26 "Sans oblique 12"
#define sFF27 "Sans oblique 18"
#define sFF28 "Sans oblique 24"
#define sFF29 "Sans bold oblique 9"
#define sFF30 "Sans bold oblique 12"
#define sFF31 "Sans bold oblique 18"
#define sFF32 "Sans bold oblique 24"
#define sFF33 "Serif 9"
#define sFF34 "Serif 12"
#define sFF35 "Serif 18"
#define sFF36 "Serif 24"
#define sFF37 "Serif italic 9"
#define sFF38 "Serif italic 12"
#define sFF39 "Serif italic 18"
#define sFF40 "Serif italic 24"
#define sFF41 "Serif bold 9"
#define sFF42 "Serif bold 12"
#define sFF43 "Serif bold 18"
#define sFF44 "Serif bold 24"
#define sFF45 "Serif bold italic 9"
#define sFF46 "Serif bold italic 12"
#define sFF47 "Serif bold italic 18"
#define sFF48 "Serif bold italic 24"
#else // LOAD_tftFF not defined so setup defaults to prevent error messages
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// Free fonts are not loaded in User_Setup.h so we must define all as font 1
// to prevent compile error messages
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#define GFXFF 1
#define GLCD 1
#define FONT2 2
#define FONT4 4
#define FONT6 6
#define FONT7 7
#define FONT8 8
#define FF0 1
#define FF1 1
#define FF2 1
#define FF3 1
#define FF4 1
#define FF5 1
#define FF6 1
#define FF7 1
#define FF8 1
#define FF9 1
#define FF10 1
#define FF11 1
#define FF12 1
#define FF13 1
#define FF14 1
#define FF15 1
#define FF16 1
#define FF17 1
#define FF18 1
#define FF19 1
#define FF20 1
#define FF21 1
#define FF22 1
#define FF23 1
#define FF24 1
#define FF25 1
#define FF26 1
#define FF27 1
#define FF28 1
#define FF29 1
#define FF30 1
#define FF31 1
#define FF32 1
#define FF33 1
#define FF34 1
#define FF35 1
#define FF36 1
#define FF37 1
#define FF38 1
#define FF39 1
#define FF40 1
#define FF41 1
#define FF42 1
#define FF43 1
#define FF44 1
#define FF45 1
#define FF46 1
#define FF47 1
#define FF48 1
#define FM9 1
#define FM12 1
#define FM18 1
#define FM24 1
#define FMB9 1
#define FMB12 1
#define FMB18 1
#define FMB24 1
#define FMO9 1
#define FMO12 1
#define FMO18 1
#define FMO24 1
#define FMBO9 1
#define FMBO12 1
#define FMBO18 1
#define FMBO24 1
#define FSS9 1
#define FSS12 1
#define FSS18 1
#define FSS24 1
#define FSSB9 1
#define FSSB12 1
#define FSSB18 1
#define FSSB24 1
#define FSSO9 1
#define FSSO12 1
#define FSSO18 1
#define FSSO24 1
#define FSSBO9 1
#define FSSBO12 1
#define FSSBO18 1
#define FSSBO24 1
#define FS9 1
#define FS12 1
#define FS18 1
#define FS24 1
#define FSI9 1
#define FSI12 1
#define FSI19 1
#define FSI24 1
#define FSB9 1
#define FSB12 1
#define FSB18 1
#define FSB24 1
#define FSBI9 1
#define FSBI12 1
#define FSBI18 1
#define FSBI24 1
#endif // LOAD_tftFF

View File

@ -1,201 +0,0 @@
// Slider widget demo, requires display with touch screen
// Requires widget library here:
// https://github.com/Bodmer/TFT_eWidget
#include "FS.h"
#include "Free_Fonts.h" // Include the header file attached to this sketch
#include <TFT_eSPI.h>
#include <TFT_eWidget.h> // Widget library
TFT_eSPI tft = TFT_eSPI();
TFT_eSprite knob = TFT_eSprite(&tft); // Sprite for the slide knob
#define CALIBRATION_FILE "/TouchCalData1"
#define REPEAT_CAL false
SliderWidget s1 = SliderWidget(&tft, &knob); // Slider 1 widget
SliderWidget s2 = SliderWidget(&tft, &knob); // Slider 2 widget
void setup() {
Serial.begin(115200);
tft.begin();
tft.setRotation(0);
tft.fillScreen(TFT_BLACK);
tft.setFreeFont(FF18);
// Calibrate the touch screen and retrieve the scaling factors
if (REPEAT_CAL) {
touch_calibrate();
tft.fillScreen(TFT_BLACK);
}
// Create a parameter set for the slider
slider_t param;
// Slider slot parameters
param.slotWidth = 9; // Note: ends of slot will be rounded and anti-aliased
param.slotLength = 200; // Length includes rounded ends
param.slotColor = TFT_BLUE; // Slot colour
param.slotBgColor = TFT_BLACK; // Slot background colour for anti-aliasing
param.orientation = H_SLIDER; // sets it "true" for horizontal
// Slider control knob parameters (smooth rounded rectangle)
param.knobWidth = 15; // Always along x axis
param.knobHeight = 25; // Always along y axis
param.knobRadius = 5; // Corner radius
param.knobColor = TFT_WHITE; // Anti-aliased with slot backgound colour
param.knobLineColor = TFT_RED; // Colour of marker line (set to same as knobColor for no line)
// Slider range and movement speed
param.sliderLT = 0; // Left side for horizontal, top for vertical slider
param.sliderRB = 100; // Right side for horizontal, bottom for vertical slider
param.startPosition = 50; // Start position for control knob
param.sliderDelay = 0; // Microseconds per pixel movement delay (0 = no delay)
// Create slider using parameters and plot at 0,0
s1.drawSlider(0, 0, param);
// Show bounding box (1 pixel outside slider working area)
int16_t x, y; // x and y can be negative
uint16_t w, h; // Width and height
s1.getBoundingRect(&x, &y, &w, &h); // Update x,y,w,h with bounding box
tft.drawRect(x, y, w, h, TFT_DARKGREY); // Draw rectangle outline
/*
// Alternative discrete fns to create/modify same slider - but fn sequence is important...
s1.createSlider(9, 200, TFT_BLUE, TFT_BLACK, H_SLIDER);
s1.createKnob(15, 25, 5, TFT_WHITE, TFT_RED);
s1.setSliderScale(0, 100);
s1.drawSlider(0, 0);
*/
delay(1000);
s1.setSliderPosition(50);
delay(1000);
s1.setSliderPosition(100);
// Update any parameters that are different for slider 2
param.slotWidth = 4;
param.orientation = V_SLIDER; // sets it "false" for vertical
param.knobWidth = 19;
param.knobHeight = 19;
param.knobRadius = 19/2; // Half w and h so creates a circle
param.sliderLT = 200; // Top for vertical slider
param.sliderRB = 0; // Bottom for vertical slider
param.sliderDelay = 2000; // 2ms per pixel movement delay (movement is blocking until complete)
s2.drawSlider(0, 50, param);
s2.getBoundingRect(&x, &y, &w, &h);
tft.drawRect(x, y, w, h, TFT_DARKGREY);
/*
// Alternative discrete fns to create/modify same slider - but fn sequence is important...
s2.createSlider(4, 200, TFT_BLUE, TFT_BLACK, V_SLIDER);
s2.createKnob(19, 19, 9, TFT_WHITE, TFT_RED);
s2.setSliderScale(200, 0, 2000);
s2.drawSlider(0, 50);
*/
// Move slider under software control
delay(1000);
s2.setSliderPosition(50);
delay(1000);
s2.setSliderPosition(100);
}
void loop() {
static uint32_t scanTime = millis();
uint16_t t_x = 9999, t_y = 9999; // To store the touch coordinates
// Scan for touch every 50ms
if (millis() - scanTime >= 20) {
// Pressed will be set true if there is a valid touch on the screen
if( tft.getTouch(&t_x, &t_y, 250) ) {
if (s1.checkTouch(t_x, t_y)) {
Serial.print("Slider 1 = "); Serial.println(s1.getSliderPosition());
}
if (s2.checkTouch(t_x, t_y)) {
Serial.print("Slider 2 = "); Serial.println(s2.getSliderPosition());
}
}
scanTime = millis();
}
//s1.moveTo(random(101));
//delay(250);
//s2.moveTo(random(101));
//delay(250);
}
void touch_calibrate()
{
uint16_t calData[5];
uint8_t calDataOK = 0;
// check file system exists
if (!LittleFS.begin()) {
Serial.println("Formating file system");
LittleFS.format();
LittleFS.begin();
}
// check if calibration file exists and size is correct
if (LittleFS.exists(CALIBRATION_FILE)) {
if (REPEAT_CAL)
{
// Delete if we want to re-calibrate
LittleFS.remove(CALIBRATION_FILE);
}
else
{
File f = LittleFS.open(CALIBRATION_FILE, "r");
if (f) {
if (f.readBytes((char *)calData, 14) == 14)
calDataOK = 1;
f.close();
}
}
}
if (calDataOK && !REPEAT_CAL) {
// calibration data valid
tft.setTouch(calData);
} else {
// data not valid so recalibrate
tft.fillScreen(TFT_BLACK);
tft.setCursor(20, 0);
tft.setTextFont(2);
tft.setTextSize(1);
tft.setTextColor(TFT_WHITE, TFT_BLACK);
tft.println("Touch corners as indicated");
tft.setTextFont(1);
tft.println();
if (REPEAT_CAL) {
tft.setTextColor(TFT_RED, TFT_BLACK);
tft.println("Set REPEAT_CAL to false to stop this running again!");
}
tft.calibrateTouch(calData, TFT_MAGENTA, TFT_BLACK, 15);
tft.setTextColor(TFT_GREEN, TFT_BLACK);
tft.println("Calibration complete!");
// store data
File f = LittleFS.open(CALIBRATION_FILE, "w");
if (f) {
f.write((const unsigned char *)calData, 14);
f.close();
}
}
}

View File

@ -2,19 +2,9 @@
// This example renders a png file that is stored in a FLASH array
// using the PNGdec library (available via library manager).
// Image files can be converted to arrays using the tool here:
// https://notisrac.github.io/FileToCArray/
// To use this tool:
// 1. Drag and drop file on "Browse..." button
// 2. Tick box "Treat as binary"
// 3. Click "Convert"
// 4. Click "Save as file" and move the header file to sketch folder
// 5. Open the sketch in IDE
// 6. Include the header file containing the array (panda.h in this example)
// Include the PNG decoder library
#include <PNGdec.h>
#include "panda.h" // Image is stored here in an 8 bit array
#include "panda_png.h" // Image is stored here in an 8 bit array
PNG png; // PNG decoder inatance
@ -48,7 +38,7 @@ void setup()
//====================================================================================
void loop()
{
int16_t rc = png.openFLASH((uint8_t *)panda, sizeof(panda), pngDraw);
int16_t rc = png.openFLASH((uint8_t *)panda_png, sizeof(panda_png), pngDraw);
if (rc == PNG_SUCCESS) {
Serial.println("Successfully png file");
Serial.printf("image specs: (%d x %d), %d bpp, pixel type: %d\n", png.getWidth(), png.getHeight(), png.getBpp(), png.getPixelType());

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,86 +0,0 @@
// This example renders a png file that is stored in a FLASH array
// using the PNGdec library (available via library manager).
// The example png is encoded as ARGB 8 bits per pixel with indexed colour
// It was created using GIMP and has a transparent background area.
// Image files can be converted to arrays using the tool here:
// https://notisrac.github.io/FileToCArray/
// To use this tool:
// 1. Drag and drop PNG image file on "Browse..." button
// 2. Tick box "Treat as binary"
// 3. Click "Convert"
// 4. Click "Save as file" and move the header file to sketch folder
// (alternatively use the "Copy to clipboard" and paste into a new tab)
// 5. Open the sketch in IDE
// 6. Include the header file containing the array (SpongeBob.h in this example)
// Include the PNG decoder library, available via the IDE library manager
#include <PNGdec.h>
// Include image array
#include "SpongeBob.h"
PNG png; // PNG decoder instance
#define MAX_IMAGE_WDITH 240 // Sets rendering line buffer lengths, adjust for your images
// Include the TFT library - see https://github.com/Bodmer/TFT_eSPI for library information
#include "SPI.h"
#include <TFT_eSPI.h> // Hardware-specific library
TFT_eSPI tft = TFT_eSPI(); // Invoke custom library
// Position variables must be global (PNGdec does not handle position coordinates)
int16_t xpos = 0;
int16_t ypos = 0;
//====================================================================================
// Setup
//====================================================================================
void setup()
{
Serial.begin(115200);
Serial.println("\n\n Using the PNGdec library");
// Initialise the TFT
tft.begin();
tft.fillScreen(TFT_BLACK);
Serial.println("\r\nInitialisation done.");
}
//====================================================================================
// Loop
//====================================================================================
void loop()
{
uint16_t pngw = 0, pngh = 0; // To store width and height of image
int16_t rc = png.openFLASH((uint8_t *)bob, sizeof(bob), pngDraw);
if (rc == PNG_SUCCESS) {
Serial.println("Successfully png file");
pngw = png.getWidth();
pngh = png.getHeight();
Serial.printf("Image metrics: (%d x %d), %d bpp, pixel type: %d\n", pngw, pngh, png.getBpp(), png.getPixelType());
tft.startWrite();
uint32_t dt = millis();
rc = png.decode(NULL, 0);
tft.endWrite();
Serial.print(millis() - dt); Serial.println("ms");
tft.endWrite();
// png.close(); // Required for files, not needed for FLASH arrays
}
delay(250);
// Randomly change position
xpos = random(tft.width() - pngw);
ypos = random(tft.height() - pngh);
// Fill screen with a random colour at random intervals
if (random(100) < 20) tft.fillScreen(random(0x10000));
}

File diff suppressed because it is too large Load Diff

View File

@ -1,18 +0,0 @@
// PNGdec support functions
//=========================================v==========================================
// pngDraw: Callback function to draw pixels to the display
//====================================================================================
// This function will be called during decoding of the png file to render each image
// line to the TFT. PNGdec generates the image line and a 1bpp mask.
void pngDraw(PNGDRAW *pDraw) {
uint16_t lineBuffer[MAX_IMAGE_WDITH]; // Line buffer for rendering
uint8_t maskBuffer[1 + MAX_IMAGE_WDITH / 8]; // Mask buffer
png.getLineAsRGB565(pDraw, lineBuffer, PNG_RGB565_BIG_ENDIAN, 0xffffffff);
if (png.getAlphaMask(pDraw, maskBuffer, 255)) {
tft.pushMaskedImage(xpos, ypos + pDraw->y, pDraw->iWidth, 1, lineBuffer, maskBuffer);
}
}

View File

@ -129,7 +129,7 @@ static void renderFace(float t) {
face.setTextDatum(MC_DATUM);
// The background colour will be read during the character rendering
face.setTextColor(CLOCK_FG, CLOCK_BG);
face.setTextColor(CLOCK_FG);
// Text offset adjustment
constexpr uint32_t dialOffset = CLOCK_R - 10;
@ -143,7 +143,7 @@ static void renderFace(float t) {
}
// Add text (could be digital time...)
face.setTextColor(LABEL_FG, CLOCK_BG);
face.setTextColor(LABEL_FG);
face.drawString("TFT_eSPI", CLOCK_R, CLOCK_R * 0.75);
// Draw minute hand

View File

@ -11,10 +11,10 @@
#include <Timezone.h>
// Choose library to load
#ifdef ARDUINO_ARCH_ESP8266
#ifdef ESP8266
// ESP8266
#include <ESP8266WiFi.h>
#elif (defined(ARDUINO_ARCH_MBED) || defined(ARDUINO_ARCH_RP2040)) && !defined(ARDUINO_RASPBERRY_PI_PICO_W)
#elif defined(ARDUINO_ARCH_MBED) || defined(ARDUINO_ARCH_RP2040)
// RP2040 Nano Connect
#include <WiFiNINA.h>
#else

View File

@ -1,208 +0,0 @@
// This is a test sketch being developed for a new arc based meter widget
// The meter grahic is fully anti-aliased to avoid jaggy pixelated edges
// For this demo randomly sized meters are drawn, cycled and redrawn a random size.
// The meter is ramped up and down 0-100 and 100-0, then pauses before a new
// random sized meter is drawn
// If the radius is > 25 then the value is drawn in the middle
// The outer ring of the meter uses the drawSmoothCircle function (which draws
// a narrow full circle smooth arc)
// Uncomment to draw meter digits and label text
//#define DRAW_DIGITS
// If DRAW_DIGITS is defined the OpenFontRender library must be loaded since
// the sketch uses a scaleable TrueType font for the text and numerals.
// https://github.com/Bodmer/OpenFontRender
#define LOOP_DELAY 0 // This controls how frequently the meter is updated
// for test purposes this is set to 0
#include <SPI.h>
#include <TFT_eSPI.h> // Hardware-specific library
#ifdef DRAW_DIGITS
#include "NotoSans_Bold.h"
#include "OpenFontRender.h"
#define TTF_FONT NotoSans_Bold
#endif
TFT_eSPI tft = TFT_eSPI(); // Invoke custom library with default width and height
TFT_eSprite spr = TFT_eSprite(&tft); // Declare Sprite object "spr" with pointer to "tft" object
#ifdef DRAW_DIGITS
OpenFontRender ofr;
#endif
#define DARKER_GREY 0x18E3
uint32_t runTime = 0; // time for next update
int reading = 0; // Value to be displayed
int d = 0; // Variable used for the sinewave test waveform
bool range_error = 0;
int8_t ramp = 1;
bool initMeter = true;
void setup(void) {
Serial.begin(115200);
tft.begin();
tft.setRotation(1);
tft.fillScreen(TFT_NAVY);
//tft.setViewport(0, 0, 240, 320);
}
void loop() {
static uint16_t maxRadius = 0;
int8_t ramp = 1;
static uint8_t radius = 0;
static int16_t xpos = tft.width() / 2;
static int16_t ypos = tft.height() / 2;
bool newMeter = false;
if (maxRadius == 0) {
maxRadius = tft.width();
if (tft.height() < maxRadius) maxRadius = tft.height();
maxRadius = (0.6 * maxRadius) / 2;
radius = maxRadius;
}
// Choose a random meter radius for test purposes and draw for one range cycle
// Clear old meter first
tft.fillCircle(xpos, ypos, radius + 1, TFT_NAVY);
radius = random(20, maxRadius); // Random radius
initMeter = true;
#ifdef DRAW_DIGITS
// Loading a font takes a few milliseconds, so for test purposes it is done outside the test loop
if (ofr.loadFont(TTF_FONT, sizeof(TTF_FONT))) {
Serial.println("Render initialize error");
return;
}
#endif
initMeter = true;
reading = 0;
ramp = 1;
while (!newMeter) {
if (millis() - runTime >= LOOP_DELAY) {
runTime = millis();
reading += ramp;
ringMeter(xpos, ypos, radius, reading, "Watts"); // Draw analogue meter
if (reading > 99) ramp = -1;
if (reading <= 0) ramp = 1;
if (reading > 99) delay(1000);
if (reading <= 0) {
delay(1000);
newMeter = true;
}
}
}
#ifdef DRAW_DIGITS
ofr.unloadFont(); // Recover space used by font metrics etc
#endif
}
// #########################################################################
// Draw the meter on the screen, returns x coord of righthand side
// #########################################################################
// x,y is centre of meter, r the radius, val a number in range 0-100
// units is the meter scale label
void ringMeter(int x, int y, int r, int val, const char *units)
{
static uint16_t last_angle = 30;
if (initMeter) {
initMeter = false;
last_angle = 30;
tft.fillCircle(x, y, r, DARKER_GREY);
tft.drawSmoothCircle(x, y, r, TFT_SILVER, DARKER_GREY);
uint16_t tmp = r - 3;
tft.drawArc(x, y, tmp, tmp - tmp / 5, last_angle, 330, TFT_BLACK, DARKER_GREY);
}
r -= 3;
// Range here is 0-100 so value is scaled to an angle 30-330
int val_angle = map(val, 0, 100, 30, 330);
if (last_angle != val_angle) {
// Could load the required font here
//if (ofr.loadFont(TTF_FONT, sizeof(TTF_FONT))) {
// Serial.println("Render initialize error");
// return;
//}
#ifdef DRAW_DIGITS
ofr.setDrawer(spr); // Link renderer to sprite (font will be rendered in sprite spr)
// Add value in centre if radius is a reasonable size
if ( r >= 25 ) {
// This code gets the font dimensions in pixels to determine the required the sprite size
ofr.setFontSize((6 * r) / 4);
ofr.setFontColor(TFT_WHITE, DARKER_GREY);
// The OpenFontRender library only has simple print functions...
// Digit jiggle for chaging values often happens with proportional fonts because
// digit glyph width varies ( 1 narrower that 4 for example). This code prints up to
// 3 digits with even spacing.
// A few experiemntal fudge factors are used here to position the
// digits in the sprite...
// Create a sprite to draw the digits into
uint8_t w = ofr.getTextWidth("444");
uint8_t h = ofr.getTextHeight("4") + 4;
spr.createSprite(w, h + 2);
spr.fillSprite(DARKER_GREY); // (TFT_BLUE); // (DARKER_GREY);
char str_buf[8]; // Buffed for string
itoa (val, str_buf, 10); // Convert value to string (null terminated)
uint8_t ptr = 0; // Pointer to a digit character
uint8_t dx = 4; // x offfset for cursor position
if (val < 100) dx = ofr.getTextWidth("4") / 2; // Adjust cursor x for 2 digits
if (val < 10) dx = ofr.getTextWidth("4"); // Adjust cursor x for 1 digit
while ((uint8_t)str_buf[ptr] != 0) ptr++; // Count the characters
while (ptr) {
ofr.setCursor(w - dx - w / 20, -h / 2.5); // Offset cursor position in sprtie
ofr.rprintf(str_buf + ptr - 1); // Draw a character
str_buf[ptr - 1] = 0; // Replace character with a null
dx += 1 + w / 3; // Adjust cursor for next character
ptr--; // Decrement character pointer
}
spr.pushSprite(x - w / 2, y - h / 2); // Push sprite containing the val number
spr.deleteSprite(); // Recover used memory
// Make the TFT the print destination, print the units label direct to the TFT
ofr.setDrawer(tft);
ofr.setFontColor(TFT_GOLD, DARKER_GREY);
ofr.setFontSize(r / 2.0);
ofr.setCursor(x, y + (r * 0.4));
ofr.cprintf("Watts");
}
#endif
//ofr.unloadFont(); // Recover space used by font metrics etc
// Allocate a value to the arc thickness dependant of radius
uint8_t thickness = r / 5;
if ( r < 25 ) thickness = r / 3;
// Update the arc, only the zone between last_angle and new val_angle is updated
if (val_angle > last_angle) {
tft.drawArc(x, y, r, r - thickness, last_angle, val_angle, TFT_SKYBLUE, TFT_BLACK); // TFT_SKYBLUE random(0x10000)
}
else {
tft.drawArc(x, y, r, r - thickness, val_angle, last_angle, TFT_BLACK, DARKER_GREY);
}
last_angle = val_angle; // Store meter arc position for next redraw
}
}

View File

@ -1,732 +0,0 @@
// This font is a subset of the full font to reduce array size, ONLY these characters are present:
// !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
// array size is 11592
const unsigned char NotoSans_Bold[] PROGMEM = {
0x00, 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x80, 0x00, 0x03, 0x00, 0x30, 0x63, 0x6d, 0x61, 0x70,
0xe1, 0x4c, 0xf1, 0x46, 0x00, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x0b, 0x6e, 0x67, 0x6c, 0x79, 0x66,
0xab, 0x85, 0x48, 0xd5, 0x00, 0x00, 0x0c, 0x2c, 0x00, 0x00, 0x1b, 0xa0, 0x68, 0x65, 0x61, 0x64,
0x26, 0x95, 0xb4, 0xa1, 0x00, 0x00, 0x27, 0xcc, 0x00, 0x00, 0x00, 0x36, 0x68, 0x68, 0x65, 0x61,
0x03, 0x7f, 0x04, 0x08, 0x00, 0x00, 0x28, 0x04, 0x00, 0x00, 0x00, 0x24, 0x68, 0x6d, 0x74, 0x78,
0xd0, 0xa7, 0x10, 0x76, 0x00, 0x00, 0x28, 0x28, 0x00, 0x00, 0x01, 0x7c, 0x6c, 0x6f, 0x63, 0x61,
0x00, 0x05, 0x33, 0xed, 0x00, 0x00, 0x29, 0xa4, 0x00, 0x00, 0x01, 0x80, 0x6d, 0x61, 0x78, 0x70,
0x07, 0x5d, 0x11, 0x1f, 0x00, 0x00, 0x2b, 0x24, 0x00, 0x00, 0x00, 0x20, 0x6e, 0x61, 0x6d, 0x65,
0x1a, 0x56, 0x03, 0x30, 0x00, 0x00, 0x2b, 0x44, 0x00, 0x00, 0x01, 0x7a, 0x4f, 0x53, 0x2f, 0x32,
0x0f, 0x8e, 0x89, 0xf7, 0x00, 0x00, 0x2c, 0xc0, 0x00, 0x00, 0x00, 0x60, 0x70, 0x6f, 0x73, 0x74,
0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x20, 0x00, 0x00, 0x00, 0x20, 0x70, 0x72, 0x65, 0x70,
0x68, 0x06, 0x8c, 0x85, 0x00, 0x00, 0x2d, 0x40, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x03,
0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0xe2,
0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x07, 0xa8, 0x00, 0x04, 0x03, 0xc6, 0x00, 0x00, 0x00, 0xbe,
0x00, 0x80, 0x00, 0x06, 0x00, 0x3e, 0x00, 0x21, 0x00, 0x22, 0x00, 0x23, 0x00, 0x24, 0x00, 0x25,
0x00, 0x26, 0x00, 0x27, 0x00, 0x28, 0x00, 0x29, 0x00, 0x2a, 0x00, 0x2b, 0x00, 0x2c, 0x00, 0x2d,
0x00, 0x2e, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x35,
0x00, 0x36, 0x00, 0x37, 0x00, 0x38, 0x00, 0x39, 0x00, 0x3a, 0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d,
0x00, 0x3e, 0x00, 0x3f, 0x00, 0x40, 0x00, 0x41, 0x00, 0x42, 0x00, 0x43, 0x00, 0x44, 0x00, 0x45,
0x00, 0x46, 0x00, 0x47, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4a, 0x00, 0x4b, 0x00, 0x4c, 0x00, 0x4d,
0x00, 0x4e, 0x00, 0x4f, 0x00, 0x50, 0x00, 0x51, 0x00, 0x52, 0x00, 0x53, 0x00, 0x54, 0x00, 0x55,
0x00, 0x56, 0x00, 0x57, 0x00, 0x58, 0x00, 0x59, 0x00, 0x5a, 0x00, 0x5b, 0x00, 0x5c, 0x00, 0x5d,
0x00, 0x5e, 0x00, 0x5f, 0x00, 0x60, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x64, 0x00, 0x65,
0x00, 0x66, 0x00, 0x67, 0x00, 0x68, 0x00, 0x69, 0x00, 0x6a, 0x00, 0x6b, 0x00, 0x6c, 0x00, 0x6d,
0x00, 0x6e, 0x00, 0x6f, 0x00, 0x70, 0x00, 0x71, 0x00, 0x72, 0x00, 0x73, 0x00, 0x74, 0x00, 0x75,
0x00, 0x76, 0x00, 0x77, 0x00, 0x78, 0x00, 0x79, 0x00, 0x7a, 0x00, 0x7b, 0x00, 0x7c, 0x00, 0x7d,
0x00, 0x7e, 0xff, 0xff, 0x00, 0x00, 0x00, 0x21, 0x00, 0x22, 0x00, 0x23, 0x00, 0x24, 0x00, 0x25,
0x00, 0x26, 0x00, 0x27, 0x00, 0x28, 0x00, 0x29, 0x00, 0x2a, 0x00, 0x2b, 0x00, 0x2c, 0x00, 0x2d,
0x00, 0x2e, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x35,
0x00, 0x36, 0x00, 0x37, 0x00, 0x38, 0x00, 0x39, 0x00, 0x3a, 0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d,
0x00, 0x3e, 0x00, 0x3f, 0x00, 0x40, 0x00, 0x41, 0x00, 0x42, 0x00, 0x43, 0x00, 0x44, 0x00, 0x45,
0x00, 0x46, 0x00, 0x47, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4a, 0x00, 0x4b, 0x00, 0x4c, 0x00, 0x4d,
0x00, 0x4e, 0x00, 0x4f, 0x00, 0x50, 0x00, 0x51, 0x00, 0x52, 0x00, 0x53, 0x00, 0x54, 0x00, 0x55,
0x00, 0x56, 0x00, 0x57, 0x00, 0x58, 0x00, 0x59, 0x00, 0x5a, 0x00, 0x5b, 0x00, 0x5c, 0x00, 0x5d,
0x00, 0x5e, 0x00, 0x5f, 0x00, 0x60, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x64, 0x00, 0x65,
0x00, 0x66, 0x00, 0x67, 0x00, 0x68, 0x00, 0x69, 0x00, 0x6a, 0x00, 0x6b, 0x00, 0x6c, 0x00, 0x6d,
0x00, 0x6e, 0x00, 0x6f, 0x00, 0x70, 0x00, 0x71, 0x00, 0x72, 0x00, 0x73, 0x00, 0x74, 0x00, 0x75,
0x00, 0x76, 0x00, 0x77, 0x00, 0x78, 0x00, 0x79, 0x00, 0x7a, 0x00, 0x7b, 0x00, 0x7c, 0x00, 0x7d,
0x00, 0x7e, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, 0x00, 0x08,
0x00, 0x09, 0x00, 0x0a, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x0d, 0x00, 0x0e, 0x00, 0x0f, 0x00, 0x10,
0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 0x18,
0x00, 0x19, 0x00, 0x1a, 0x00, 0x1b, 0x00, 0x1c, 0x00, 0x1d, 0x00, 0x1e, 0x00, 0x1f, 0x00, 0x20,
0x00, 0x21, 0x00, 0x22, 0x00, 0x23, 0x00, 0x24, 0x00, 0x25, 0x00, 0x26, 0x00, 0x27, 0x00, 0x28,
0x00, 0x29, 0x00, 0x2a, 0x00, 0x2b, 0x00, 0x2c, 0x00, 0x2d, 0x00, 0x2e, 0x00, 0x2f, 0x00, 0x30,
0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37, 0x00, 0x38,
0x00, 0x39, 0x00, 0x3a, 0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d, 0x00, 0x3e, 0x00, 0x3f, 0x00, 0x40,
0x00, 0x41, 0x00, 0x42, 0x00, 0x43, 0x00, 0x44, 0x00, 0x45, 0x00, 0x46, 0x00, 0x47, 0x00, 0x48,
0x00, 0x49, 0x00, 0x4a, 0x00, 0x4b, 0x00, 0x4c, 0x00, 0x4d, 0x00, 0x4e, 0x00, 0x4f, 0x00, 0x50,
0x00, 0x51, 0x00, 0x52, 0x00, 0x53, 0x00, 0x54, 0x00, 0x55, 0x00, 0x56, 0x00, 0x57, 0x00, 0x58,
0x00, 0x59, 0x00, 0x5a, 0x00, 0x5b, 0x00, 0x5c, 0x00, 0x5d, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x04,
0x03, 0xc6, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x80, 0x00, 0x06, 0x00, 0x3e, 0x00, 0x21, 0x00, 0x22,
0x00, 0x23, 0x00, 0x24, 0x00, 0x25, 0x00, 0x26, 0x00, 0x27, 0x00, 0x28, 0x00, 0x29, 0x00, 0x2a,
0x00, 0x2b, 0x00, 0x2c, 0x00, 0x2d, 0x00, 0x2e, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x31, 0x00, 0x32,
0x00, 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37, 0x00, 0x38, 0x00, 0x39, 0x00, 0x3a,
0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d, 0x00, 0x3e, 0x00, 0x3f, 0x00, 0x40, 0x00, 0x41, 0x00, 0x42,
0x00, 0x43, 0x00, 0x44, 0x00, 0x45, 0x00, 0x46, 0x00, 0x47, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4a,
0x00, 0x4b, 0x00, 0x4c, 0x00, 0x4d, 0x00, 0x4e, 0x00, 0x4f, 0x00, 0x50, 0x00, 0x51, 0x00, 0x52,
0x00, 0x53, 0x00, 0x54, 0x00, 0x55, 0x00, 0x56, 0x00, 0x57, 0x00, 0x58, 0x00, 0x59, 0x00, 0x5a,
0x00, 0x5b, 0x00, 0x5c, 0x00, 0x5d, 0x00, 0x5e, 0x00, 0x5f, 0x00, 0x60, 0x00, 0x61, 0x00, 0x62,
0x00, 0x63, 0x00, 0x64, 0x00, 0x65, 0x00, 0x66, 0x00, 0x67, 0x00, 0x68, 0x00, 0x69, 0x00, 0x6a,
0x00, 0x6b, 0x00, 0x6c, 0x00, 0x6d, 0x00, 0x6e, 0x00, 0x6f, 0x00, 0x70, 0x00, 0x71, 0x00, 0x72,
0x00, 0x73, 0x00, 0x74, 0x00, 0x75, 0x00, 0x76, 0x00, 0x77, 0x00, 0x78, 0x00, 0x79, 0x00, 0x7a,
0x00, 0x7b, 0x00, 0x7c, 0x00, 0x7d, 0x00, 0x7e, 0xff, 0xff, 0x00, 0x00, 0x00, 0x21, 0x00, 0x22,
0x00, 0x23, 0x00, 0x24, 0x00, 0x25, 0x00, 0x26, 0x00, 0x27, 0x00, 0x28, 0x00, 0x29, 0x00, 0x2a,
0x00, 0x2b, 0x00, 0x2c, 0x00, 0x2d, 0x00, 0x2e, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x31, 0x00, 0x32,
0x00, 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37, 0x00, 0x38, 0x00, 0x39, 0x00, 0x3a,
0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d, 0x00, 0x3e, 0x00, 0x3f, 0x00, 0x40, 0x00, 0x41, 0x00, 0x42,
0x00, 0x43, 0x00, 0x44, 0x00, 0x45, 0x00, 0x46, 0x00, 0x47, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4a,
0x00, 0x4b, 0x00, 0x4c, 0x00, 0x4d, 0x00, 0x4e, 0x00, 0x4f, 0x00, 0x50, 0x00, 0x51, 0x00, 0x52,
0x00, 0x53, 0x00, 0x54, 0x00, 0x55, 0x00, 0x56, 0x00, 0x57, 0x00, 0x58, 0x00, 0x59, 0x00, 0x5a,
0x00, 0x5b, 0x00, 0x5c, 0x00, 0x5d, 0x00, 0x5e, 0x00, 0x5f, 0x00, 0x60, 0x00, 0x61, 0x00, 0x62,
0x00, 0x63, 0x00, 0x64, 0x00, 0x65, 0x00, 0x66, 0x00, 0x67, 0x00, 0x68, 0x00, 0x69, 0x00, 0x6a,
0x00, 0x6b, 0x00, 0x6c, 0x00, 0x6d, 0x00, 0x6e, 0x00, 0x6f, 0x00, 0x70, 0x00, 0x71, 0x00, 0x72,
0x00, 0x73, 0x00, 0x74, 0x00, 0x75, 0x00, 0x76, 0x00, 0x77, 0x00, 0x78, 0x00, 0x79, 0x00, 0x7a,
0x00, 0x7b, 0x00, 0x7c, 0x00, 0x7d, 0x00, 0x7e, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05,
0x00, 0x06, 0x00, 0x07, 0x00, 0x08, 0x00, 0x09, 0x00, 0x0a, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x0d,
0x00, 0x0e, 0x00, 0x0f, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, 0x00, 0x13, 0x00, 0x14, 0x00, 0x15,
0x00, 0x16, 0x00, 0x17, 0x00, 0x18, 0x00, 0x19, 0x00, 0x1a, 0x00, 0x1b, 0x00, 0x1c, 0x00, 0x1d,
0x00, 0x1e, 0x00, 0x1f, 0x00, 0x20, 0x00, 0x21, 0x00, 0x22, 0x00, 0x23, 0x00, 0x24, 0x00, 0x25,
0x00, 0x26, 0x00, 0x27, 0x00, 0x28, 0x00, 0x29, 0x00, 0x2a, 0x00, 0x2b, 0x00, 0x2c, 0x00, 0x2d,
0x00, 0x2e, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x35,
0x00, 0x36, 0x00, 0x37, 0x00, 0x38, 0x00, 0x39, 0x00, 0x3a, 0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d,
0x00, 0x3e, 0x00, 0x3f, 0x00, 0x40, 0x00, 0x41, 0x00, 0x42, 0x00, 0x43, 0x00, 0x44, 0x00, 0x45,
0x00, 0x46, 0x00, 0x47, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4a, 0x00, 0x4b, 0x00, 0x4c, 0x00, 0x4d,
0x00, 0x4e, 0x00, 0x4f, 0x00, 0x50, 0x00, 0x51, 0x00, 0x52, 0x00, 0x53, 0x00, 0x54, 0x00, 0x55,
0x00, 0x56, 0x00, 0x57, 0x00, 0x58, 0x00, 0x59, 0x00, 0x5a, 0x00, 0x5b, 0x00, 0x5c, 0x00, 0x5d,
0x00, 0x5e, 0x00, 0x00, 0x00, 0x04, 0x03, 0xc6, 0x00, 0x00, 0x00, 0xbe, 0x00, 0x80, 0x00, 0x06,
0x00, 0x3e, 0x00, 0x21, 0x00, 0x22, 0x00, 0x23, 0x00, 0x24, 0x00, 0x25, 0x00, 0x26, 0x00, 0x27,
0x00, 0x28, 0x00, 0x29, 0x00, 0x2a, 0x00, 0x2b, 0x00, 0x2c, 0x00, 0x2d, 0x00, 0x2e, 0x00, 0x2f,
0x00, 0x30, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37,
0x00, 0x38, 0x00, 0x39, 0x00, 0x3a, 0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d, 0x00, 0x3e, 0x00, 0x3f,
0x00, 0x40, 0x00, 0x41, 0x00, 0x42, 0x00, 0x43, 0x00, 0x44, 0x00, 0x45, 0x00, 0x46, 0x00, 0x47,
0x00, 0x48, 0x00, 0x49, 0x00, 0x4a, 0x00, 0x4b, 0x00, 0x4c, 0x00, 0x4d, 0x00, 0x4e, 0x00, 0x4f,
0x00, 0x50, 0x00, 0x51, 0x00, 0x52, 0x00, 0x53, 0x00, 0x54, 0x00, 0x55, 0x00, 0x56, 0x00, 0x57,
0x00, 0x58, 0x00, 0x59, 0x00, 0x5a, 0x00, 0x5b, 0x00, 0x5c, 0x00, 0x5d, 0x00, 0x5e, 0x00, 0x5f,
0x00, 0x60, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x64, 0x00, 0x65, 0x00, 0x66, 0x00, 0x67,
0x00, 0x68, 0x00, 0x69, 0x00, 0x6a, 0x00, 0x6b, 0x00, 0x6c, 0x00, 0x6d, 0x00, 0x6e, 0x00, 0x6f,
0x00, 0x70, 0x00, 0x71, 0x00, 0x72, 0x00, 0x73, 0x00, 0x74, 0x00, 0x75, 0x00, 0x76, 0x00, 0x77,
0x00, 0x78, 0x00, 0x79, 0x00, 0x7a, 0x00, 0x7b, 0x00, 0x7c, 0x00, 0x7d, 0x00, 0x7e, 0xff, 0xff,
0x00, 0x00, 0x00, 0x21, 0x00, 0x22, 0x00, 0x23, 0x00, 0x24, 0x00, 0x25, 0x00, 0x26, 0x00, 0x27,
0x00, 0x28, 0x00, 0x29, 0x00, 0x2a, 0x00, 0x2b, 0x00, 0x2c, 0x00, 0x2d, 0x00, 0x2e, 0x00, 0x2f,
0x00, 0x30, 0x00, 0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37,
0x00, 0x38, 0x00, 0x39, 0x00, 0x3a, 0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d, 0x00, 0x3e, 0x00, 0x3f,
0x00, 0x40, 0x00, 0x41, 0x00, 0x42, 0x00, 0x43, 0x00, 0x44, 0x00, 0x45, 0x00, 0x46, 0x00, 0x47,
0x00, 0x48, 0x00, 0x49, 0x00, 0x4a, 0x00, 0x4b, 0x00, 0x4c, 0x00, 0x4d, 0x00, 0x4e, 0x00, 0x4f,
0x00, 0x50, 0x00, 0x51, 0x00, 0x52, 0x00, 0x53, 0x00, 0x54, 0x00, 0x55, 0x00, 0x56, 0x00, 0x57,
0x00, 0x58, 0x00, 0x59, 0x00, 0x5a, 0x00, 0x5b, 0x00, 0x5c, 0x00, 0x5d, 0x00, 0x5e, 0x00, 0x5f,
0x00, 0x60, 0x00, 0x61, 0x00, 0x62, 0x00, 0x63, 0x00, 0x64, 0x00, 0x65, 0x00, 0x66, 0x00, 0x67,
0x00, 0x68, 0x00, 0x69, 0x00, 0x6a, 0x00, 0x6b, 0x00, 0x6c, 0x00, 0x6d, 0x00, 0x6e, 0x00, 0x6f,
0x00, 0x70, 0x00, 0x71, 0x00, 0x72, 0x00, 0x73, 0x00, 0x74, 0x00, 0x75, 0x00, 0x76, 0x00, 0x77,
0x00, 0x78, 0x00, 0x79, 0x00, 0x7a, 0x00, 0x7b, 0x00, 0x7c, 0x00, 0x7d, 0x00, 0x7e, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe,
0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0xbe, 0x00, 0x01, 0x00, 0x02,
0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, 0x00, 0x08, 0x00, 0x09, 0x00, 0x0a,
0x00, 0x0b, 0x00, 0x0c, 0x00, 0x0d, 0x00, 0x0e, 0x00, 0x0f, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12,
0x00, 0x13, 0x00, 0x14, 0x00, 0x15, 0x00, 0x16, 0x00, 0x17, 0x00, 0x18, 0x00, 0x19, 0x00, 0x1a,
0x00, 0x1b, 0x00, 0x1c, 0x00, 0x1d, 0x00, 0x1e, 0x00, 0x1f, 0x00, 0x20, 0x00, 0x21, 0x00, 0x22,
0x00, 0x23, 0x00, 0x24, 0x00, 0x25, 0x00, 0x26, 0x00, 0x27, 0x00, 0x28, 0x00, 0x29, 0x00, 0x2a,
0x00, 0x2b, 0x00, 0x2c, 0x00, 0x2d, 0x00, 0x2e, 0x00, 0x2f, 0x00, 0x30, 0x00, 0x31, 0x00, 0x32,
0x00, 0x33, 0x00, 0x34, 0x00, 0x35, 0x00, 0x36, 0x00, 0x37, 0x00, 0x38, 0x00, 0x39, 0x00, 0x3a,
0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d, 0x00, 0x3e, 0x00, 0x3f, 0x00, 0x40, 0x00, 0x41, 0x00, 0x42,
0x00, 0x43, 0x00, 0x44, 0x00, 0x45, 0x00, 0x46, 0x00, 0x47, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4a,
0x00, 0x4b, 0x00, 0x4c, 0x00, 0x4d, 0x00, 0x4e, 0x00, 0x4f, 0x00, 0x50, 0x00, 0x51, 0x00, 0x52,
0x00, 0x53, 0x00, 0x54, 0x00, 0x55, 0x00, 0x56, 0x00, 0x57, 0x00, 0x58, 0x00, 0x59, 0x00, 0x5a,
0x00, 0x5b, 0x00, 0x5c, 0x00, 0x5d, 0x00, 0x5e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
0x00, 0x00, 0x02, 0x58, 0x08, 0x00, 0x00, 0x03, 0x00, 0x07, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x58, 0x00, 0x00, 0xfd, 0xad, 0x02, 0x4e,
0x00, 0x00, 0xfd, 0xb2, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x05, 0x00, 0x00,
0x07, 0xf6, 0x00, 0x00, 0x00, 0x02, 0x00, 0x39, 0xff, 0xf3, 0x00, 0xe4, 0x02, 0xca, 0x00, 0x03,
0x00, 0x0f, 0x00, 0x00, 0x37, 0x23, 0x03, 0x33, 0x03, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14,
0x06, 0x23, 0x22, 0x26, 0xcb, 0x77, 0x19, 0xa9, 0xab, 0x32, 0x24, 0x23, 0x32, 0x32, 0x23, 0x24,
0x32, 0xed, 0x01, 0xdd, 0xfd, 0x7c, 0x2e, 0x25, 0x25, 0x2e, 0x2c, 0x27, 0x27, 0x00, 0x02, 0x00,
0x41, 0x01, 0xc8, 0x01, 0x97, 0x02, 0xca, 0x00, 0x03, 0x00, 0x07, 0x00, 0x00, 0x13, 0x03, 0x23,
0x03, 0x21, 0x03, 0x23, 0x03, 0xc9, 0x14, 0x60, 0x14, 0x01, 0x56, 0x14, 0x60, 0x14, 0x02, 0xca,
0xfe, 0xfe, 0x01, 0x02, 0xfe, 0xfe, 0x01, 0x02, 0x00, 0x02, 0x00, 0x16, 0x00, 0x00, 0x02, 0x70,
0x02, 0xc9, 0x00, 0x1b, 0x00, 0x1f, 0x00, 0x00, 0x01, 0x07, 0x33, 0x15, 0x23, 0x07, 0x23, 0x37,
0x23, 0x07, 0x23, 0x37, 0x23, 0x35, 0x33, 0x37, 0x23, 0x35, 0x33, 0x37, 0x33, 0x07, 0x33, 0x37,
0x33, 0x07, 0x33, 0x15, 0x05, 0x33, 0x37, 0x23, 0x01, 0xe8, 0x17, 0x7e, 0x91, 0x26, 0x6b, 0x26,
0x5f, 0x25, 0x69, 0x24, 0x74, 0x87, 0x17, 0x7b, 0x8d, 0x26, 0x6b, 0x26, 0x61, 0x26, 0x69, 0x26,
0x75, 0xfe, 0x97, 0x60, 0x17, 0x60, 0x01, 0x9c, 0x71, 0x65, 0xc6, 0xc6, 0xc6, 0xc6, 0x65, 0x71,
0x66, 0xc7, 0xc7, 0xc7, 0xc7, 0x66, 0x71, 0x71, 0x00, 0x03, 0x00, 0x2b, 0xff, 0xc6, 0x02, 0x15,
0x02, 0xf7, 0x00, 0x22, 0x00, 0x28, 0x00, 0x2e, 0x00, 0x00, 0x37, 0x26, 0x26, 0x27, 0x35, 0x16,
0x16, 0x17, 0x35, 0x2e, 0x02, 0x35, 0x34, 0x36, 0x37, 0x35, 0x33, 0x15, 0x16, 0x17, 0x07, 0x26,
0x26, 0x27, 0x15, 0x1e, 0x02, 0x15, 0x14, 0x06, 0x07, 0x15, 0x23, 0x11, 0x06, 0x15, 0x14, 0x16,
0x17, 0x13, 0x36, 0x35, 0x34, 0x26, 0x27, 0xfd, 0x41, 0x66, 0x2a, 0x29, 0x74, 0x34, 0x4d, 0x5d,
0x28, 0x75, 0x5d, 0x43, 0x6f, 0x5b, 0x2e, 0x28, 0x51, 0x23, 0x36, 0x62, 0x3d, 0x6a, 0x6b, 0x43,
0x3f, 0x1e, 0x21, 0x43, 0x42, 0x21, 0x21, 0x28, 0x02, 0x15, 0x13, 0x81, 0x14, 0x21, 0x03, 0x97,
0x1e, 0x39, 0x46, 0x31, 0x4b, 0x59, 0x08, 0x4b, 0x49, 0x04, 0x29, 0x72, 0x11, 0x12, 0x03, 0x90,
0x14, 0x2f, 0x48, 0x3b, 0x49, 0x62, 0x0a, 0x64, 0x02, 0x6d, 0x09, 0x2a, 0x15, 0x1c, 0x0f, 0xfe,
0xde, 0x0c, 0x2e, 0x14, 0x1d, 0x0f, 0x00, 0x05, 0x00, 0x1f, 0xff, 0xf7, 0x03, 0x66, 0x02, 0xd4,
0x00, 0x0b, 0x00, 0x0f, 0x00, 0x17, 0x00, 0x23, 0x00, 0x2b, 0x00, 0x00, 0x13, 0x32, 0x16, 0x15,
0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x05, 0x01, 0x23, 0x01, 0x05, 0x22, 0x15, 0x14,
0x33, 0x32, 0x35, 0x34, 0x05, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36,
0x17, 0x22, 0x15, 0x14, 0x33, 0x32, 0x35, 0x34, 0xc7, 0x54, 0x57, 0x52, 0x59, 0x52, 0x56, 0x50,
0x02, 0x53, 0xfe, 0x74, 0x75, 0x01, 0x8c, 0xfe, 0x7b, 0x2e, 0x2e, 0x2f, 0x01, 0xc4, 0x54, 0x57,
0x52, 0x59, 0x52, 0x56, 0x50, 0x59, 0x2e, 0x2e, 0x2f, 0x02, 0xd4, 0x75, 0x6a, 0x6a, 0x77, 0x77,
0x6a, 0x6a, 0x75, 0x0a, 0xfd, 0x36, 0x02, 0xca, 0x5c, 0x7a, 0x7b, 0x7b, 0x7a, 0xb7, 0x75, 0x6a,
0x6a, 0x77, 0x77, 0x6a, 0x6a, 0x75, 0x66, 0x7a, 0x7b, 0x7b, 0x7a, 0x00, 0x03, 0x00, 0x28, 0xff,
0xf6, 0x02, 0xee, 0x02, 0xd4, 0x00, 0x21, 0x00, 0x2d, 0x00, 0x37, 0x00, 0x00, 0x01, 0x32, 0x16,
0x16, 0x15, 0x14, 0x06, 0x07, 0x17, 0x36, 0x36, 0x37, 0x33, 0x06, 0x06, 0x07, 0x17, 0x23, 0x27,
0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x37, 0x26, 0x26, 0x35, 0x34, 0x36, 0x36, 0x17,
0x22, 0x06, 0x15, 0x14, 0x16, 0x17, 0x36, 0x36, 0x35, 0x34, 0x26, 0x03, 0x06, 0x06, 0x15, 0x14,
0x16, 0x33, 0x32, 0x36, 0x37, 0x01, 0x36, 0x3a, 0x5a, 0x34, 0x52, 0x3d, 0x8b, 0x14, 0x1e, 0x0a,
0x9b, 0x0f, 0x3a, 0x2d, 0x93, 0xb8, 0x38, 0x2b, 0x6a, 0x3e, 0x7a, 0x89, 0x46, 0x3d, 0x27, 0x1f,
0x35, 0x5f, 0x3c, 0x19, 0x2d, 0x19, 0x15, 0x2a, 0x2d, 0x28, 0x4a, 0x1c, 0x21, 0x40, 0x30, 0x20,
0x38, 0x17, 0x02, 0xd4, 0x24, 0x45, 0x32, 0x45, 0x5e, 0x23, 0x87, 0x22, 0x4b, 0x26, 0x38, 0x80,
0x38, 0x8f, 0x37, 0x1e, 0x23, 0x70, 0x5b, 0x4c, 0x5b, 0x23, 0x2d, 0x4c, 0x2b, 0x33, 0x4a, 0x28,
0x73, 0x19, 0x23, 0x19, 0x2e, 0x18, 0x17, 0x2e, 0x1e, 0x1e, 0x1a, 0xfe, 0xd1, 0x15, 0x2f, 0x1f,
0x2b, 0x31, 0x10, 0x0e, 0x00, 0x01, 0x00, 0x41, 0x01, 0xc8, 0x00, 0xc9, 0x02, 0xca, 0x00, 0x03,
0x00, 0x00, 0x13, 0x03, 0x23, 0x03, 0xc9, 0x14, 0x60, 0x14, 0x02, 0xca, 0xfe, 0xfe, 0x01, 0x02,
0x00, 0x01, 0x00, 0x28, 0xff, 0x62, 0x01, 0x35, 0x02, 0xca, 0x00, 0x0d, 0x00, 0x00, 0x13, 0x34,
0x36, 0x37, 0x33, 0x06, 0x06, 0x15, 0x14, 0x16, 0x17, 0x23, 0x26, 0x26, 0x28, 0x47, 0x4c, 0x7a,
0x44, 0x47, 0x47, 0x43, 0x79, 0x4c, 0x47, 0x01, 0x12, 0x7a, 0xe3, 0x5b, 0x5e, 0xe2, 0x77, 0x74,
0xe1, 0x5c, 0x58, 0xdf, 0x00, 0x01, 0x00, 0x1e, 0xff, 0x62, 0x01, 0x2b, 0x02, 0xca, 0x00, 0x0d,
0x00, 0x00, 0x01, 0x14, 0x06, 0x07, 0x23, 0x36, 0x36, 0x35, 0x34, 0x26, 0x27, 0x33, 0x16, 0x16,
0x01, 0x2b, 0x47, 0x4c, 0x79, 0x44, 0x46, 0x47, 0x44, 0x7a, 0x4c, 0x47, 0x01, 0x12, 0x79, 0xdf,
0x58, 0x5c, 0xe1, 0x74, 0x77, 0xe2, 0x5e, 0x5b, 0xe3, 0x00, 0x01, 0x00, 0x1f, 0x01, 0x24, 0x02,
0x02, 0x02, 0xf8, 0x00, 0x0e, 0x00, 0x00, 0x01, 0x07, 0x37, 0x17, 0x07, 0x17, 0x07, 0x27, 0x07,
0x27, 0x37, 0x27, 0x37, 0x17, 0x27, 0x01, 0x50, 0x14, 0xb6, 0x10, 0xa6, 0x6d, 0x6f, 0x4c, 0x43,
0x73, 0x6c, 0xa5, 0x13, 0xb2, 0x14, 0x02, 0xf8, 0xb4, 0x33, 0x7b, 0x0c, 0x91, 0x3b, 0x99, 0x98,
0x3a, 0x91, 0x0d, 0x7a, 0x33, 0xb4, 0x00, 0x01, 0x00, 0x2b, 0x00, 0x6f, 0x02, 0x10, 0x02, 0x54,
0x00, 0x0b, 0x00, 0x00, 0x01, 0x33, 0x15, 0x23, 0x15, 0x23, 0x35, 0x23, 0x35, 0x33, 0x35, 0x33,
0x01, 0x53, 0xbd, 0xbd, 0x6b, 0xbd, 0xbd, 0x6b, 0x01, 0x96, 0x6b, 0xbc, 0xbc, 0x6b, 0xbe, 0x00,
0x01, 0x00, 0x1f, 0xff, 0x7f, 0x00, 0xe0, 0x00, 0x74, 0x00, 0x08, 0x00, 0x00, 0x37, 0x06, 0x06,
0x07, 0x23, 0x36, 0x36, 0x37, 0x33, 0xe0, 0x0d, 0x30, 0x19, 0x6b, 0x0e, 0x1c, 0x07, 0x89, 0x69,
0x35, 0x7e, 0x37, 0x3b, 0x86, 0x34, 0x00, 0x01, 0x00, 0x1e, 0x00, 0xcf, 0x01, 0x24, 0x01, 0x49,
0x00, 0x03, 0x00, 0x00, 0x37, 0x35, 0x21, 0x15, 0x1e, 0x01, 0x06, 0xcf, 0x7a, 0x7a, 0x00, 0x01,
0x00, 0x39, 0xff, 0xf3, 0x00, 0xe4, 0x00, 0x99, 0x00, 0x0b, 0x00, 0x00, 0x37, 0x34, 0x36, 0x33,
0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x39, 0x32, 0x24, 0x23, 0x32, 0x32, 0x23, 0x24,
0x32, 0x46, 0x2e, 0x25, 0x25, 0x2e, 0x2c, 0x27, 0x27, 0x00, 0x01, 0x00, 0x07, 0x00, 0x00, 0x01,
0x98, 0x02, 0xca, 0x00, 0x03, 0x00, 0x00, 0x01, 0x01, 0x23, 0x01, 0x01, 0x98, 0xfe, 0xf6, 0x87,
0x01, 0x0a, 0x02, 0xca, 0xfd, 0x36, 0x02, 0xca, 0x00, 0x02, 0x00, 0x24, 0xff, 0xf6, 0x02, 0x17,
0x02, 0xd5, 0x00, 0x0d, 0x00, 0x19, 0x00, 0x00, 0x01, 0x14, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35,
0x34, 0x36, 0x36, 0x33, 0x32, 0x16, 0x05, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23,
0x22, 0x06, 0x02, 0x17, 0x31, 0x6d, 0x5c, 0x81, 0x78, 0x30, 0x6e, 0x5b, 0x80, 0x7a, 0xfe, 0xa3,
0x2a, 0x39, 0x38, 0x2c, 0x2c, 0x38, 0x39, 0x2a, 0x01, 0x65, 0x73, 0xa4, 0x58, 0xc3, 0xac, 0x74,
0xa4, 0x58, 0xc2, 0xae, 0x7a, 0x7b, 0x7a, 0x7b, 0x7a, 0x7c, 0x7c, 0x00, 0x01, 0x00, 0x3b, 0x00,
0x00, 0x01, 0x9d, 0x02, 0xca, 0x00, 0x0c, 0x00, 0x00, 0x21, 0x23, 0x11, 0x34, 0x36, 0x37, 0x06,
0x06, 0x07, 0x07, 0x27, 0x37, 0x33, 0x01, 0x9d, 0x97, 0x03, 0x01, 0x05, 0x21, 0x0e, 0x52, 0x49,
0xe6, 0x7c, 0x01, 0x9d, 0x1a, 0x54, 0x20, 0x06, 0x1f, 0x0c, 0x42, 0x5b, 0xb7, 0x00, 0x01, 0x00,
0x26, 0x00, 0x00, 0x02, 0x1b, 0x02, 0xd4, 0x00, 0x1d, 0x00, 0x00, 0x21, 0x21, 0x35, 0x37, 0x3e,
0x02, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x27, 0x3e, 0x02, 0x33, 0x32, 0x16, 0x16, 0x15,
0x14, 0x06, 0x06, 0x07, 0x07, 0x15, 0x21, 0x02, 0x1b, 0xfe, 0x0d, 0xb3, 0x36, 0x42, 0x1e, 0x2f,
0x28, 0x29, 0x4e, 0x2b, 0x52, 0x1f, 0x45, 0x5b, 0x40, 0x46, 0x65, 0x37, 0x2f, 0x59, 0x3f, 0x5c,
0x01, 0x37, 0x69, 0xb5, 0x38, 0x4b, 0x3d, 0x23, 0x2b, 0x2a, 0x26, 0x23, 0x61, 0x1b, 0x2e, 0x1d,
0x33, 0x57, 0x37, 0x3b, 0x62, 0x60, 0x3a, 0x56, 0x07, 0x00, 0x01, 0x00, 0x26, 0xff, 0xf6, 0x02,
0x14, 0x02, 0xd4, 0x00, 0x2b, 0x00, 0x00, 0x01, 0x14, 0x06, 0x07, 0x15, 0x16, 0x16, 0x15, 0x14,
0x06, 0x06, 0x23, 0x22, 0x27, 0x35, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x26, 0x23,
0x23, 0x35, 0x33, 0x32, 0x36, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x27, 0x36, 0x36,
0x33, 0x32, 0x16, 0x01, 0xff, 0x59, 0x41, 0x56, 0x59, 0x3d, 0x7f, 0x64, 0x74, 0x5a, 0x2e, 0x65,
0x2b, 0x51, 0x41, 0x1e, 0x4b, 0x43, 0x36, 0x37, 0x42, 0x45, 0x19, 0x2f, 0x37, 0x33, 0x4b, 0x1a,
0x46, 0x2a, 0x71, 0x4e, 0x6e, 0x81, 0x02, 0x2a, 0x4a, 0x58, 0x10, 0x03, 0x0a, 0x54, 0x47, 0x3e,
0x63, 0x39, 0x27, 0x80, 0x17, 0x18, 0x38, 0x33, 0x1e, 0x29, 0x15, 0x74, 0x19, 0x2b, 0x1c, 0x26,
0x2b, 0x23, 0x11, 0x68, 0x1e, 0x28, 0x59, 0x00, 0x02, 0x00, 0x11, 0x00, 0x00, 0x02, 0x2b, 0x02,
0xca, 0x00, 0x0a, 0x00, 0x15, 0x00, 0x00, 0x25, 0x23, 0x15, 0x23, 0x35, 0x21, 0x35, 0x01, 0x33,
0x11, 0x33, 0x27, 0x34, 0x36, 0x36, 0x37, 0x23, 0x06, 0x06, 0x07, 0x07, 0x33, 0x02, 0x2b, 0x56,
0x93, 0xfe, 0xcf, 0x01, 0x39, 0x8b, 0x56, 0xe9, 0x02, 0x03, 0x01, 0x04, 0x09, 0x14, 0x0e, 0x83,
0xac, 0x94, 0x94, 0x94, 0x69, 0x01, 0xcd, 0xfe, 0x3f, 0x79, 0x17, 0x42, 0x39, 0x09, 0x14, 0x26,
0x14, 0xc6, 0x00, 0x01, 0x00, 0x31, 0xff, 0xf6, 0x02, 0x0e, 0x02, 0xca, 0x00, 0x1e, 0x00, 0x00,
0x01, 0x32, 0x16, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x35, 0x16, 0x16, 0x33, 0x32,
0x36, 0x35, 0x34, 0x23, 0x22, 0x06, 0x07, 0x27, 0x13, 0x21, 0x15, 0x23, 0x07, 0x36, 0x36, 0x01,
0x2c, 0x41, 0x66, 0x3b, 0x90, 0x8d, 0x38, 0x63, 0x25, 0x25, 0x68, 0x2e, 0x43, 0x47, 0x8f, 0x1c,
0x3c, 0x14, 0x3c, 0x1b, 0x01, 0x83, 0xff, 0x0d, 0x11, 0x27, 0x01, 0xc8, 0x32, 0x60, 0x47, 0x74,
0x85, 0x14, 0x13, 0x82, 0x13, 0x1b, 0x37, 0x3a, 0x6c, 0x0b, 0x05, 0x20, 0x01, 0x6c, 0x80, 0x8c,
0x03, 0x07, 0x00, 0x02, 0x00, 0x23, 0xff, 0xf6, 0x02, 0x1b, 0x02, 0xd2, 0x00, 0x1e, 0x00, 0x2c,
0x00, 0x00, 0x13, 0x34, 0x3e, 0x03, 0x33, 0x32, 0x16, 0x17, 0x15, 0x26, 0x26, 0x23, 0x22, 0x06,
0x06, 0x07, 0x33, 0x36, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x26, 0x05,
0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x06, 0x15, 0x14, 0x16, 0x16, 0x23, 0x12, 0x2d,
0x51, 0x7d, 0x59, 0x15, 0x38, 0x13, 0x13, 0x2d, 0x16, 0x59, 0x61, 0x28, 0x03, 0x06, 0x14, 0x4b,
0x3c, 0x5e, 0x6e, 0x83, 0x70, 0x49, 0x76, 0x46, 0x01, 0x02, 0x2c, 0x38, 0x30, 0x31, 0x21, 0x32,
0x1c, 0x18, 0x31, 0x01, 0x2f, 0x3e, 0x78, 0x6b, 0x53, 0x2f, 0x03, 0x04, 0x79, 0x05, 0x05, 0x38,
0x65, 0x42, 0x23, 0x30, 0x76, 0x6c, 0x74, 0x84, 0x43, 0x8b, 0x55, 0x3d, 0x40, 0x34, 0x3c, 0x1d,
0x2e, 0x18, 0x21, 0x3f, 0x2a, 0x00, 0x01, 0x00, 0x1b, 0x00, 0x00, 0x02, 0x1b, 0x02, 0xca, 0x00,
0x06, 0x00, 0x00, 0x33, 0x01, 0x21, 0x35, 0x21, 0x15, 0x01, 0x6f, 0x01, 0x0c, 0xfe, 0xa0, 0x02,
0x00, 0xfe, 0xf2, 0x02, 0x4b, 0x7f, 0x5f, 0xfd, 0x95, 0x00, 0x03, 0x00, 0x23, 0xff, 0xf6, 0x02,
0x18, 0x02, 0xd3, 0x00, 0x1b, 0x00, 0x27, 0x00, 0x35, 0x00, 0x00, 0x01, 0x32, 0x16, 0x16, 0x15,
0x14, 0x06, 0x07, 0x1e, 0x02, 0x15, 0x14, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x37,
0x26, 0x26, 0x35, 0x34, 0x36, 0x36, 0x17, 0x22, 0x06, 0x15, 0x14, 0x16, 0x17, 0x36, 0x36, 0x35,
0x34, 0x26, 0x03, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x26, 0x27, 0x27, 0x06, 0x06,
0x01, 0x1e, 0x3e, 0x67, 0x3f, 0x49, 0x37, 0x26, 0x45, 0x2b, 0x3f, 0x71, 0x4a, 0x78, 0x83, 0x50,
0x39, 0x30, 0x43, 0x40, 0x69, 0x3b, 0x25, 0x31, 0x34, 0x23, 0x22, 0x34, 0x31, 0x94, 0x37, 0x36,
0x38, 0x38, 0x20, 0x2f, 0x19, 0x0d, 0x2e, 0x3a, 0x02, 0xd3, 0x26, 0x4c, 0x3a, 0x40, 0x53, 0x1b,
0x14, 0x35, 0x47, 0x30, 0x3b, 0x58, 0x30, 0x66, 0x59, 0x4a, 0x5a, 0x1c, 0x1e, 0x55, 0x40, 0x39,
0x4c, 0x26, 0x6e, 0x26, 0x23, 0x25, 0x2e, 0x11, 0x10, 0x2d, 0x27, 0x23, 0x26, 0xfe, 0x59, 0x27,
0x32, 0x30, 0x28, 0x1b, 0x29, 0x21, 0x0e, 0x07, 0x16, 0x3a, 0x00, 0x02, 0x00, 0x20, 0xff, 0xf6,
0x02, 0x18, 0x02, 0xd2, 0x00, 0x1e, 0x00, 0x2c, 0x00, 0x00, 0x01, 0x14, 0x0e, 0x03, 0x23, 0x22,
0x26, 0x27, 0x35, 0x16, 0x16, 0x33, 0x32, 0x36, 0x36, 0x37, 0x23, 0x06, 0x06, 0x23, 0x22, 0x26,
0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x16, 0x25, 0x22, 0x06, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36,
0x36, 0x35, 0x34, 0x26, 0x26, 0x02, 0x18, 0x12, 0x2d, 0x51, 0x7d, 0x59, 0x15, 0x38, 0x13, 0x14,
0x2c, 0x16, 0x59, 0x61, 0x28, 0x03, 0x06, 0x15, 0x45, 0x44, 0x5b, 0x6e, 0x83, 0x70, 0x49, 0x76,
0x46, 0xfe, 0xfe, 0x2c, 0x38, 0x30, 0x31, 0x22, 0x31, 0x1c, 0x18, 0x30, 0x01, 0x99, 0x3d, 0x79,
0x6b, 0x53, 0x2f, 0x03, 0x04, 0x79, 0x04, 0x06, 0x39, 0x64, 0x42, 0x23, 0x30, 0x76, 0x6c, 0x74,
0x84, 0x43, 0x8b, 0x55, 0x3c, 0x41, 0x34, 0x3c, 0x1e, 0x2d, 0x18, 0x21, 0x40, 0x29, 0x00, 0x02,
0x00, 0x39, 0xff, 0xf3, 0x00, 0xe4, 0x02, 0x2c, 0x00, 0x0b, 0x00, 0x17, 0x00, 0x00, 0x13, 0x34,
0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x11, 0x34, 0x36, 0x33, 0x32, 0x16,
0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x39, 0x32, 0x24, 0x23, 0x32, 0x32, 0x23, 0x24, 0x32, 0x32,
0x24, 0x23, 0x32, 0x32, 0x23, 0x24, 0x32, 0x01, 0xd9, 0x2e, 0x25, 0x25, 0x2e, 0x2c, 0x27, 0x27,
0xfe, 0x99, 0x2e, 0x25, 0x25, 0x2e, 0x2c, 0x27, 0x27, 0x00, 0x02, 0x00, 0x1f, 0xff, 0x7f, 0x00,
0xe4, 0x02, 0x2c, 0x00, 0x0b, 0x00, 0x14, 0x00, 0x00, 0x13, 0x34, 0x36, 0x33, 0x32, 0x16, 0x15,
0x14, 0x06, 0x23, 0x22, 0x26, 0x13, 0x06, 0x06, 0x07, 0x23, 0x36, 0x36, 0x37, 0x33, 0x39, 0x32,
0x24, 0x23, 0x32, 0x32, 0x23, 0x24, 0x32, 0xa7, 0x0d, 0x30, 0x19, 0x6b, 0x0e, 0x1c, 0x07, 0x89,
0x01, 0xd9, 0x2e, 0x25, 0x25, 0x2e, 0x2c, 0x27, 0x27, 0xfe, 0xbc, 0x35, 0x7e, 0x37, 0x3b, 0x86,
0x34, 0x00, 0x01, 0x00, 0x2b, 0x00, 0x63, 0x02, 0x10, 0x02, 0x71, 0x00, 0x06, 0x00, 0x00, 0x25,
0x25, 0x35, 0x25, 0x15, 0x05, 0x05, 0x02, 0x10, 0xfe, 0x1b, 0x01, 0xe5, 0xfe, 0xb2, 0x01, 0x4e,
0x63, 0xd6, 0x46, 0xf2, 0x75, 0x9b, 0x89, 0x00, 0x02, 0x00, 0x2b, 0x00, 0xcc, 0x02, 0x10, 0x01,
0xf4, 0x00, 0x03, 0x00, 0x07, 0x00, 0x00, 0x13, 0x35, 0x21, 0x15, 0x05, 0x35, 0x21, 0x15, 0x2b,
0x01, 0xe5, 0xfe, 0x1b, 0x01, 0xe5, 0x01, 0x8a, 0x6a, 0x6a, 0xbe, 0x6b, 0x6b, 0x00, 0x01, 0x00,
0x2b, 0x00, 0x63, 0x02, 0x10, 0x02, 0x71, 0x00, 0x06, 0x00, 0x00, 0x37, 0x25, 0x25, 0x35, 0x05,
0x15, 0x05, 0x2b, 0x01, 0x4e, 0xfe, 0xb2, 0x01, 0xe5, 0xfe, 0x1b, 0xd8, 0x89, 0x9b, 0x75, 0xf2,
0x46, 0xd6, 0x00, 0x02, 0x00, 0x03, 0xff, 0xf3, 0x01, 0xc5, 0x02, 0xd4, 0x00, 0x1d, 0x00, 0x29,
0x00, 0x00, 0x13, 0x34, 0x36, 0x37, 0x36, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x27,
0x36, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x06, 0x07, 0x0e, 0x02, 0x15, 0x15, 0x23, 0x07,
0x34, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x87, 0x2a, 0x33, 0x2d, 0x27,
0x2f, 0x2a, 0x2a, 0x52, 0x2b, 0x35, 0x31, 0x72, 0x44, 0x68, 0x73, 0x1a, 0x34, 0x27, 0x1d, 0x20,
0x0b, 0x81, 0x10, 0x32, 0x24, 0x23, 0x32, 0x32, 0x23, 0x24, 0x32, 0x01, 0x11, 0x32, 0x44, 0x25,
0x20, 0x2f, 0x20, 0x20, 0x21, 0x1a, 0x16, 0x6b, 0x1b, 0x22, 0x64, 0x4d, 0x29, 0x3c, 0x33, 0x1d,
0x15, 0x1e, 0x1c, 0x15, 0x1d, 0xa7, 0x2e, 0x25, 0x25, 0x2e, 0x2c, 0x27, 0x27, 0x00, 0x02, 0x00,
0x32, 0xff, 0xac, 0x03, 0x4f, 0x02, 0xca, 0x00, 0x3f, 0x00, 0x4d, 0x00, 0x00, 0x01, 0x14, 0x0e,
0x02, 0x23, 0x22, 0x26, 0x27, 0x23, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x36, 0x33,
0x32, 0x16, 0x17, 0x07, 0x06, 0x14, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x36, 0x35, 0x34, 0x26,
0x26, 0x23, 0x22, 0x06, 0x06, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x37, 0x15, 0x06, 0x06, 0x23,
0x22, 0x26, 0x26, 0x35, 0x34, 0x3e, 0x02, 0x33, 0x32, 0x16, 0x16, 0x05, 0x14, 0x16, 0x33, 0x32,
0x36, 0x37, 0x37, 0x26, 0x26, 0x23, 0x22, 0x06, 0x06, 0x03, 0x4f, 0x16, 0x2d, 0x44, 0x2e, 0x25,
0x38, 0x0b, 0x08, 0x14, 0x43, 0x2f, 0x59, 0x61, 0x3a, 0x6a, 0x48, 0x2f, 0x65, 0x1c, 0x0a, 0x01,
0x17, 0x0e, 0x17, 0x1e, 0x0f, 0x44, 0x75, 0x4b, 0x69, 0x8f, 0x4a, 0x91, 0x88, 0x3a, 0x7e, 0x34,
0x30, 0x76, 0x42, 0x7c, 0xb0, 0x5d, 0x3c, 0x71, 0x9e, 0x62, 0x6b, 0xa6, 0x5f, 0xfe, 0x0c, 0x2e,
0x26, 0x32, 0x29, 0x04, 0x06, 0x0b, 0x1c, 0x11, 0x2f, 0x39, 0x19, 0x01, 0x66, 0x2e, 0x5a, 0x4a,
0x2b, 0x23, 0x1c, 0x19, 0x26, 0x6b, 0x57, 0x43, 0x67, 0x3b, 0x11, 0x0a, 0xcd, 0x0a, 0x15, 0x03,
0x29, 0x1b, 0x2d, 0x4b, 0x2d, 0x54, 0x75, 0x3e, 0x57, 0x96, 0x61, 0x87, 0x90, 0x1a, 0x13, 0x5e,
0x14, 0x18, 0x58, 0xa5, 0x74, 0x5b, 0x9c, 0x75, 0x41, 0x56, 0xa0, 0xab, 0x37, 0x30, 0x49, 0x3b,
0x6c, 0x02, 0x03, 0x29, 0x41, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x02, 0xb2, 0x02, 0xcd, 0x00,
0x07, 0x00, 0x12, 0x00, 0x00, 0x21, 0x27, 0x21, 0x07, 0x23, 0x13, 0x33, 0x13, 0x01, 0x2e, 0x02,
0x27, 0x0e, 0x02, 0x07, 0x07, 0x33, 0x02, 0x0f, 0x34, 0xfe, 0xfc, 0x34, 0xa3, 0xfc, 0xb9, 0xfd,
0xfe, 0xd1, 0x05, 0x10, 0x10, 0x05, 0x05, 0x11, 0x0f, 0x04, 0x33, 0xba, 0xaa, 0xaa, 0x02, 0xcd,
0xfd, 0x33, 0x01, 0xcf, 0x11, 0x34, 0x36, 0x14, 0x14, 0x3b, 0x35, 0x0b, 0xa6, 0x00, 0x03, 0x00,
0x5a, 0x00, 0x00, 0x02, 0x6b, 0x02, 0xca, 0x00, 0x10, 0x00, 0x19, 0x00, 0x22, 0x00, 0x00, 0x01,
0x32, 0x16, 0x15, 0x14, 0x06, 0x07, 0x15, 0x1e, 0x02, 0x15, 0x14, 0x06, 0x23, 0x21, 0x11, 0x13,
0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x23, 0x1d, 0x02, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23,
0x01, 0x38, 0x8f, 0x92, 0x39, 0x35, 0x24, 0x3a, 0x22, 0x8c, 0x7a, 0xfe, 0xf5, 0xef, 0x42, 0x33,
0x3c, 0x41, 0x50, 0x63, 0x44, 0x36, 0x37, 0x48, 0x02, 0xca, 0x50, 0x65, 0x3d, 0x54, 0x09, 0x05,
0x07, 0x24, 0x44, 0x38, 0x61, 0x6e, 0x02, 0xca, 0xfe, 0xe5, 0x2a, 0x28, 0x29, 0x24, 0x9f, 0x78,
0xba, 0x35, 0x2c, 0x28, 0x31, 0x00, 0x01, 0x00, 0x3a, 0xff, 0xf6, 0x02, 0x5a, 0x02, 0xd4, 0x00,
0x1b, 0x00, 0x00, 0x01, 0x22, 0x06, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x37, 0x15, 0x06, 0x06,
0x23, 0x22, 0x26, 0x26, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, 0x16, 0x17, 0x07, 0x26, 0x26, 0x01,
0x89, 0x57, 0x5c, 0x55, 0x5e, 0x2c, 0x57, 0x33, 0x2f, 0x5c, 0x39, 0x6e, 0x8f, 0x44, 0x4e, 0x95,
0x6c, 0x35, 0x6b, 0x31, 0x31, 0x28, 0x51, 0x02, 0x56, 0x82, 0x71, 0x72, 0x7d, 0x14, 0x12, 0x7f,
0x13, 0x12, 0x5b, 0xa5, 0x6e, 0x6c, 0xa6, 0x5e, 0x1b, 0x17, 0x7b, 0x13, 0x1c, 0x00, 0x02, 0x00,
0x5a, 0x00, 0x00, 0x02, 0xaa, 0x02, 0xca, 0x00, 0x09, 0x00, 0x11, 0x00, 0x00, 0x01, 0x14, 0x06,
0x23, 0x23, 0x11, 0x33, 0x32, 0x16, 0x16, 0x07, 0x34, 0x26, 0x23, 0x23, 0x11, 0x33, 0x32, 0x02,
0xaa, 0xcd, 0xb9, 0xca, 0xe0, 0x70, 0xa5, 0x5b, 0x9d, 0x68, 0x63, 0x51, 0x41, 0xdb, 0x01, 0x6c,
0xb5, 0xb7, 0x02, 0xca, 0x50, 0x9b, 0x77, 0x77, 0x6f, 0xfe, 0x2f, 0x00, 0x01, 0x00, 0x5a, 0x00,
0x00, 0x01, 0xf5, 0x02, 0xca, 0x00, 0x0b, 0x00, 0x00, 0x21, 0x21, 0x11, 0x21, 0x15, 0x21, 0x15,
0x33, 0x15, 0x23, 0x15, 0x21, 0x01, 0xf5, 0xfe, 0x65, 0x01, 0x9b, 0xfe, 0xfc, 0xf2, 0xf2, 0x01,
0x04, 0x02, 0xca, 0x7c, 0x9d, 0x7c, 0xb8, 0x00, 0x01, 0x00, 0x5a, 0x00, 0x00, 0x01, 0xf3, 0x02,
0xca, 0x00, 0x09, 0x00, 0x00, 0x33, 0x23, 0x11, 0x21, 0x15, 0x21, 0x15, 0x33, 0x15, 0x23, 0xef,
0x95, 0x01, 0x99, 0xfe, 0xfc, 0xf2, 0xf2, 0x02, 0xca, 0x7c, 0xb8, 0x7c, 0x00, 0x01, 0x00, 0x3a,
0xff, 0xf6, 0x02, 0x84, 0x02, 0xd4, 0x00, 0x20, 0x00, 0x00, 0x01, 0x21, 0x11, 0x06, 0x06, 0x23,
0x22, 0x26, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, 0x16, 0x17, 0x07, 0x26, 0x26, 0x23, 0x22, 0x06,
0x06, 0x15, 0x14, 0x16, 0x16, 0x33, 0x32, 0x36, 0x37, 0x35, 0x23, 0x01, 0x69, 0x01, 0x1b, 0x38,
0x79, 0x4d, 0xa0, 0xac, 0x57, 0xa6, 0x78, 0x39, 0x6e, 0x2d, 0x32, 0x21, 0x54, 0x2e, 0x42, 0x61,
0x35, 0x26, 0x52, 0x42, 0x20, 0x2d, 0x13, 0x87, 0x01, 0x91, 0xfe, 0x8e, 0x13, 0x16, 0xbc, 0xb4,
0x70, 0xa4, 0x5a, 0x18, 0x14, 0x79, 0x11, 0x16, 0x3c, 0x6d, 0x4a, 0x46, 0x6c, 0x3d, 0x06, 0x04,
0x95, 0x00, 0x01, 0x00, 0x5a, 0x00, 0x00, 0x02, 0xa3, 0x02, 0xca, 0x00, 0x0b, 0x00, 0x00, 0x21,
0x23, 0x11, 0x21, 0x11, 0x23, 0x11, 0x33, 0x11, 0x21, 0x11, 0x33, 0x02, 0xa3, 0x97, 0xfe, 0xe5,
0x97, 0x97, 0x01, 0x1b, 0x97, 0x01, 0x34, 0xfe, 0xcc, 0x02, 0xca, 0xfe, 0xe8, 0x01, 0x18, 0x00,
0x01, 0x00, 0x20, 0x00, 0x00, 0x01, 0x65, 0x02, 0xca, 0x00, 0x0b, 0x00, 0x00, 0x21, 0x21, 0x35,
0x37, 0x11, 0x27, 0x35, 0x21, 0x15, 0x07, 0x11, 0x17, 0x01, 0x65, 0xfe, 0xbb, 0x57, 0x57, 0x01,
0x45, 0x57, 0x57, 0x56, 0x28, 0x01, 0xce, 0x28, 0x56, 0x56, 0x28, 0xfe, 0x32, 0x28, 0x00, 0x01,
0xff, 0xb6, 0xff, 0x2e, 0x00, 0xf1, 0x02, 0xca, 0x00, 0x11, 0x00, 0x00, 0x17, 0x22, 0x26, 0x27,
0x35, 0x16, 0x16, 0x33, 0x32, 0x36, 0x36, 0x35, 0x11, 0x33, 0x11, 0x14, 0x06, 0x06, 0x0f, 0x1d,
0x2c, 0x10, 0x10, 0x23, 0x14, 0x1a, 0x2b, 0x18, 0x97, 0x39, 0x66, 0xd2, 0x07, 0x04, 0x7e, 0x04,
0x06, 0x14, 0x38, 0x34, 0x02, 0x9d, 0xfd, 0x64, 0x5c, 0x71, 0x33, 0x00, 0x01, 0x00, 0x5a, 0x00,
0x00, 0x02, 0x98, 0x02, 0xca, 0x00, 0x0e, 0x00, 0x00, 0x21, 0x23, 0x03, 0x07, 0x15, 0x23, 0x11,
0x33, 0x11, 0x36, 0x36, 0x37, 0x37, 0x33, 0x03, 0x02, 0x98, 0xac, 0xbb, 0x40, 0x97, 0x97, 0x0f,
0x1e, 0x0f, 0xc1, 0xa8, 0xf9, 0x01, 0x2d, 0x2e, 0xff, 0x02, 0xca, 0xfe, 0xb9, 0x15, 0x2a, 0x15,
0xf3, 0xfe, 0xc4, 0x00, 0x01, 0x00, 0x5a, 0x00, 0x00, 0x02, 0x13, 0x02, 0xca, 0x00, 0x05, 0x00,
0x00, 0x33, 0x11, 0x33, 0x11, 0x21, 0x15, 0x5a, 0x97, 0x01, 0x22, 0x02, 0xca, 0xfd, 0xb3, 0x7d,
0x00, 0x01, 0x00, 0x5a, 0x00, 0x00, 0x03, 0x55, 0x02, 0xca, 0x00, 0x17, 0x00, 0x00, 0x21, 0x03,
0x23, 0x1e, 0x02, 0x15, 0x11, 0x23, 0x11, 0x33, 0x13, 0x33, 0x13, 0x33, 0x11, 0x23, 0x11, 0x34,
0x36, 0x36, 0x37, 0x23, 0x03, 0x01, 0x88, 0xac, 0x04, 0x01, 0x04, 0x04, 0x87, 0xce, 0xa9, 0x03,
0xb3, 0xce, 0x8d, 0x03, 0x03, 0x01, 0x04, 0xb8, 0x02, 0x30, 0x14, 0x50, 0x5b, 0x25, 0xfe, 0xb4,
0x02, 0xca, 0xfd, 0xde, 0x02, 0x22, 0xfd, 0x36, 0x01, 0x52, 0x22, 0x58, 0x4f, 0x14, 0xfd, 0xd1,
0x00, 0x01, 0x00, 0x5a, 0x00, 0x00, 0x02, 0xd3, 0x02, 0xca, 0x00, 0x11, 0x00, 0x00, 0x21, 0x23,
0x01, 0x23, 0x16, 0x16, 0x17, 0x11, 0x23, 0x11, 0x33, 0x01, 0x33, 0x26, 0x26, 0x27, 0x11, 0x33,
0x02, 0xd3, 0xc0, 0xfe, 0xc9, 0x04, 0x02, 0x05, 0x02, 0x87, 0xbf, 0x01, 0x36, 0x03, 0x01, 0x04,
0x02, 0x88, 0x02, 0x1c, 0x33, 0x66, 0x33, 0xfe, 0xb0, 0x02, 0xca, 0xfd, 0xe9, 0x32, 0x62, 0x31,
0x01, 0x52, 0x00, 0x02, 0x00, 0x3a, 0xff, 0xf6, 0x02, 0xe2, 0x02, 0xd5, 0x00, 0x0f, 0x00, 0x1b,
0x00, 0x00, 0x01, 0x14, 0x06, 0x06, 0x23, 0x22, 0x26, 0x26, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32,
0x16, 0x16, 0x05, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x02, 0xe2,
0x49, 0x96, 0x75, 0x74, 0x97, 0x49, 0x49, 0x97, 0x75, 0x74, 0x96, 0x49, 0xfd, 0xf7, 0x56, 0x5f,
0x61, 0x54, 0x54, 0x60, 0x60, 0x56, 0x01, 0x66, 0x6f, 0xa5, 0x5c, 0x5c, 0xa6, 0x6f, 0x6f, 0xa4,
0x5b, 0x5b, 0xa5, 0x6f, 0x70, 0x81, 0x81, 0x70, 0x71, 0x80, 0x80, 0x00, 0x02, 0x00, 0x5a, 0x00,
0x00, 0x02, 0x47, 0x02, 0xca, 0x00, 0x0b, 0x00, 0x13, 0x00, 0x00, 0x01, 0x32, 0x16, 0x15, 0x14,
0x06, 0x06, 0x23, 0x23, 0x15, 0x23, 0x11, 0x17, 0x23, 0x15, 0x33, 0x32, 0x36, 0x35, 0x34, 0x01,
0x3e, 0x8a, 0x7f, 0x34, 0x79, 0x68, 0x41, 0x97, 0xdc, 0x45, 0x32, 0x40, 0x4b, 0x02, 0xca, 0x77,
0x68, 0x3e, 0x6d, 0x42, 0xfe, 0x02, 0xca, 0x7c, 0xd4, 0x33, 0x39, 0x68, 0x00, 0x02, 0x00, 0x3a,
0xff, 0x56, 0x02, 0xe2, 0x02, 0xd5, 0x00, 0x12, 0x00, 0x1e, 0x00, 0x00, 0x01, 0x14, 0x06, 0x07,
0x17, 0x23, 0x27, 0x23, 0x22, 0x26, 0x26, 0x35, 0x34, 0x36, 0x36, 0x33, 0x32, 0x16, 0x16, 0x05,
0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x02, 0xe2, 0x56, 0x5a, 0xac,
0xc2, 0x83, 0x0b, 0x74, 0x97, 0x49, 0x49, 0x97, 0x75, 0x74, 0x96, 0x49, 0xfd, 0xf7, 0x56, 0x5f,
0x61, 0x54, 0x54, 0x60, 0x60, 0x56, 0x01, 0x66, 0x78, 0xaf, 0x29, 0xc0, 0xa0, 0x5c, 0xa6, 0x6f,
0x6f, 0xa4, 0x5b, 0x5b, 0xa5, 0x6f, 0x70, 0x81, 0x81, 0x70, 0x71, 0x80, 0x80, 0x00, 0x02, 0x00,
0x5a, 0x00, 0x00, 0x02, 0x94, 0x02, 0xca, 0x00, 0x0e, 0x00, 0x17, 0x00, 0x00, 0x01, 0x32, 0x16,
0x15, 0x14, 0x06, 0x06, 0x07, 0x13, 0x23, 0x03, 0x23, 0x11, 0x23, 0x11, 0x17, 0x23, 0x15, 0x33,
0x32, 0x36, 0x35, 0x34, 0x26, 0x01, 0x2a, 0x92, 0x8b, 0x25, 0x3d, 0x23, 0xd2, 0xa8, 0xaa, 0x51,
0x97, 0xc5, 0x2e, 0x31, 0x4b, 0x41, 0x45, 0x02, 0xca, 0x6a, 0x6c, 0x31, 0x49, 0x33, 0x10, 0xfe,
0xc9, 0x01, 0x12, 0xfe, 0xee, 0x02, 0xca, 0x7c, 0xc1, 0x32, 0x31, 0x33, 0x2b, 0x00, 0x01, 0x00,
0x2e, 0xff, 0xf6, 0x01, 0xff, 0x02, 0xd4, 0x00, 0x28, 0x00, 0x00, 0x25, 0x14, 0x06, 0x23, 0x22,
0x27, 0x35, 0x16, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x26, 0x27, 0x2e, 0x03, 0x35, 0x34,
0x36, 0x33, 0x32, 0x16, 0x17, 0x07, 0x26, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14, 0x16, 0x17, 0x1e,
0x02, 0x01, 0xff, 0x89, 0x7e, 0x71, 0x59, 0x33, 0x6d, 0x36, 0x38, 0x2f, 0x25, 0x3e, 0x28, 0x19,
0x3a, 0x35, 0x22, 0x82, 0x70, 0x38, 0x65, 0x37, 0x31, 0x31, 0x4e, 0x29, 0x2b, 0x2e, 0x44, 0x43,
0x37, 0x4d, 0x2a, 0xc6, 0x5f, 0x71, 0x2b, 0x8d, 0x16, 0x25, 0x2b, 0x21, 0x1b, 0x26, 0x21, 0x13,
0x0c, 0x21, 0x31, 0x46, 0x31, 0x60, 0x6b, 0x1a, 0x18, 0x76, 0x14, 0x16, 0x28, 0x20, 0x26, 0x2c,
0x20, 0x1a, 0x38, 0x4c, 0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x02, 0x2f, 0x02, 0xca, 0x00, 0x07,
0x00, 0x00, 0x21, 0x23, 0x11, 0x23, 0x35, 0x21, 0x15, 0x23, 0x01, 0x6d, 0x97, 0xc2, 0x02, 0x1b,
0xc2, 0x02, 0x4c, 0x7e, 0x7e, 0x00, 0x01, 0x00, 0x55, 0xff, 0xf6, 0x02, 0x9f, 0x02, 0xca, 0x00,
0x12, 0x00, 0x00, 0x25, 0x14, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x11, 0x33, 0x11, 0x14, 0x16,
0x33, 0x32, 0x36, 0x35, 0x11, 0x33, 0x02, 0x9f, 0x41, 0x83, 0x64, 0x8e, 0x94, 0x97, 0x48, 0x47,
0x4a, 0x43, 0x97, 0xfc, 0x4a, 0x77, 0x45, 0x91, 0x77, 0x01, 0xcc, 0xfe, 0x4b, 0x58, 0x48, 0x4e,
0x53, 0x01, 0xb4, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x8a, 0x02, 0xca, 0x00, 0x0e, 0x00,
0x00, 0x01, 0x03, 0x23, 0x03, 0x33, 0x13, 0x1e, 0x02, 0x17, 0x3e, 0x02, 0x37, 0x13, 0x02, 0x8a,
0xf3, 0xa5, 0xf2, 0x99, 0x86, 0x04, 0x0f, 0x10, 0x03, 0x03, 0x0f, 0x10, 0x03, 0x87, 0x02, 0xca,
0xfd, 0x36, 0x02, 0xca, 0xfe, 0x57, 0x0b, 0x3b, 0x41, 0x16, 0x16, 0x41, 0x3b, 0x0b, 0x01, 0xa9,
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc7, 0x02, 0xca, 0x00, 0x26, 0x00, 0x00, 0x01, 0x03,
0x23, 0x03, 0x2e, 0x03, 0x27, 0x0e, 0x03, 0x07, 0x03, 0x23, 0x03, 0x33, 0x13, 0x1e, 0x02, 0x17,
0x3e, 0x02, 0x37, 0x13, 0x33, 0x13, 0x1e, 0x02, 0x17, 0x3e, 0x02, 0x37, 0x13, 0x03, 0xc7, 0xb6,
0xac, 0x61, 0x03, 0x09, 0x0b, 0x08, 0x02, 0x01, 0x09, 0x0a, 0x0a, 0x03, 0x60, 0xac, 0xb6, 0x95,
0x5b, 0x06, 0x0e, 0x0c, 0x03, 0x03, 0x0c, 0x0d, 0x05, 0x68, 0x8f, 0x68, 0x05, 0x0d, 0x0c, 0x03,
0x03, 0x0c, 0x0f, 0x05, 0x5b, 0x02, 0xca, 0xfd, 0x36, 0x01, 0x77, 0x0b, 0x2c, 0x34, 0x2f, 0x0d,
0x0d, 0x2f, 0x33, 0x2d, 0x0c, 0xfe, 0x8a, 0x02, 0xca, 0xfe, 0x7a, 0x17, 0x46, 0x46, 0x18, 0x19,
0x45, 0x41, 0x12, 0x01, 0x90, 0xfe, 0x70, 0x11, 0x42, 0x46, 0x18, 0x19, 0x45, 0x46, 0x17, 0x01,
0x86, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x9b, 0x02, 0xca, 0x00, 0x0b, 0x00, 0x00, 0x21,
0x23, 0x03, 0x03, 0x23, 0x13, 0x03, 0x33, 0x13, 0x13, 0x33, 0x03, 0x02, 0x9b, 0xad, 0xa6, 0xa6,
0xa2, 0xed, 0xde, 0xa7, 0x9a, 0x97, 0xa3, 0xe0, 0x01, 0x0e, 0xfe, 0xf2, 0x01, 0x70, 0x01, 0x5a,
0xfe, 0xff, 0x01, 0x01, 0xfe, 0x9e, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x70, 0x02, 0xca,
0x00, 0x08, 0x00, 0x00, 0x01, 0x13, 0x33, 0x03, 0x11, 0x23, 0x11, 0x03, 0x33, 0x01, 0x38, 0x95,
0xa3, 0xed, 0x96, 0xed, 0xa4, 0x01, 0xa4, 0x01, 0x26, 0xfe, 0x4c, 0xfe, 0xea, 0x01, 0x11, 0x01,
0xb9, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x02, 0x2b, 0x02, 0xca, 0x00, 0x09, 0x00, 0x00, 0x21,
0x21, 0x35, 0x01, 0x21, 0x35, 0x21, 0x15, 0x01, 0x21, 0x02, 0x2b, 0xfd, 0xed, 0x01, 0x56, 0xfe,
0xb3, 0x02, 0x01, 0xfe, 0xaa, 0x01, 0x5f, 0x62, 0x01, 0xeb, 0x7d, 0x62, 0xfe, 0x15, 0x00, 0x01,
0x00, 0x46, 0xff, 0x62, 0x01, 0x32, 0x02, 0xca, 0x00, 0x07, 0x00, 0x00, 0x05, 0x23, 0x11, 0x33,
0x15, 0x23, 0x11, 0x33, 0x01, 0x32, 0xec, 0xec, 0x6d, 0x6d, 0x9e, 0x03, 0x68, 0x67, 0xfd, 0x66,
0x00, 0x01, 0x00, 0x06, 0x00, 0x00, 0x01, 0x97, 0x02, 0xca, 0x00, 0x03, 0x00, 0x00, 0x13, 0x01,
0x23, 0x01, 0x8d, 0x01, 0x0a, 0x87, 0xfe, 0xf6, 0x02, 0xca, 0xfd, 0x36, 0x02, 0xca, 0x00, 0x01,
0x00, 0x19, 0xff, 0x62, 0x01, 0x05, 0x02, 0xca, 0x00, 0x07, 0x00, 0x00, 0x17, 0x33, 0x11, 0x23,
0x35, 0x33, 0x11, 0x23, 0x19, 0x6d, 0x6d, 0xec, 0xec, 0x37, 0x02, 0x9a, 0x67, 0xfc, 0x98, 0x00,
0x01, 0x00, 0x17, 0x00, 0xfe, 0x02, 0x25, 0x02, 0xce, 0x00, 0x06, 0x00, 0x00, 0x37, 0x13, 0x33,
0x13, 0x23, 0x03, 0x03, 0x17, 0xd6, 0x46, 0xf2, 0x75, 0x9d, 0x89, 0xfe, 0x01, 0xd0, 0xfe, 0x30,
0x01, 0x3a, 0xfe, 0xc6, 0x00, 0x01, 0xff, 0xfe, 0xff, 0x62, 0x01, 0x9d, 0xff, 0xa6, 0x00, 0x03,
0x00, 0x00, 0x05, 0x21, 0x35, 0x21, 0x01, 0x9d, 0xfe, 0x61, 0x01, 0x9f, 0x9e, 0x44, 0x00, 0x01,
0x00, 0x28, 0x02, 0x5e, 0x01, 0x42, 0x02, 0xfe, 0x00, 0x0c, 0x00, 0x00, 0x13, 0x1e, 0x02, 0x17,
0x15, 0x23, 0x2e, 0x03, 0x27, 0x35, 0xcf, 0x0f, 0x29, 0x2b, 0x10, 0x63, 0x13, 0x33, 0x35, 0x2e,
0x0e, 0x02, 0xfe, 0x16, 0x37, 0x33, 0x13, 0x0d, 0x0d, 0x27, 0x2c, 0x28, 0x0e, 0x0a, 0x00, 0x02,
0x00, 0x2a, 0xff, 0xf6, 0x02, 0x11, 0x02, 0x2d, 0x00, 0x1b, 0x00, 0x26, 0x00, 0x00, 0x01, 0x32,
0x16, 0x15, 0x11, 0x23, 0x27, 0x23, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x37, 0x37,
0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x07, 0x27, 0x36, 0x36, 0x13, 0x06, 0x06, 0x15, 0x14, 0x16,
0x33, 0x32, 0x36, 0x35, 0x35, 0x01, 0x2e, 0x6e, 0x75, 0x68, 0x1d, 0x04, 0x23, 0x4e, 0x44, 0x49,
0x60, 0x7a, 0x7a, 0x5f, 0x2d, 0x28, 0x28, 0x4c, 0x26, 0x31, 0x2c, 0x6b, 0x4f, 0x48, 0x38, 0x28,
0x20, 0x30, 0x42, 0x02, 0x2d, 0x5f, 0x62, 0xfe, 0x94, 0x4a, 0x2c, 0x28, 0x55, 0x58, 0x57, 0x53,
0x04, 0x03, 0x18, 0x2b, 0x28, 0x17, 0x11, 0x65, 0x17, 0x1a, 0xfe, 0xce, 0x02, 0x30, 0x27, 0x22,
0x1d, 0x39, 0x34, 0x2d, 0x00, 0x02, 0x00, 0x4e, 0xff, 0xf6, 0x02, 0x4c, 0x02, 0xf8, 0x00, 0x15,
0x00, 0x22, 0x00, 0x00, 0x13, 0x14, 0x06, 0x07, 0x33, 0x36, 0x36, 0x33, 0x32, 0x16, 0x15, 0x14,
0x06, 0x23, 0x22, 0x26, 0x27, 0x23, 0x07, 0x23, 0x11, 0x33, 0x13, 0x22, 0x06, 0x07, 0x15, 0x14,
0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0xe3, 0x04, 0x02, 0x06, 0x16, 0x4a, 0x3b, 0x5c, 0x72,
0x74, 0x5e, 0x3c, 0x45, 0x16, 0x0a, 0x19, 0x72, 0x95, 0x6b, 0x3a, 0x2f, 0x02, 0x2f, 0x3e, 0x2e,
0x36, 0x37, 0x02, 0x47, 0x1f, 0x3c, 0x11, 0x22, 0x2f, 0x8f, 0x8b, 0x8c, 0x90, 0x2b, 0x1b, 0x3c,
0x02, 0xf8, 0xfe, 0xbd, 0x48, 0x4a, 0x10, 0x4f, 0x55, 0x55, 0x50, 0x50, 0x51, 0x00, 0x01, 0x00,
0x2d, 0xff, 0xf6, 0x01, 0xe3, 0x02, 0x2c, 0x00, 0x19, 0x00, 0x00, 0x05, 0x22, 0x26, 0x35, 0x34,
0x36, 0x36, 0x33, 0x32, 0x16, 0x17, 0x07, 0x26, 0x26, 0x23, 0x22, 0x15, 0x14, 0x16, 0x33, 0x32,
0x36, 0x37, 0x15, 0x06, 0x06, 0x01, 0x2c, 0x7a, 0x85, 0x44, 0x79, 0x4f, 0x38, 0x53, 0x1f, 0x2c,
0x23, 0x3d, 0x1e, 0x74, 0x3d, 0x37, 0x2f, 0x48, 0x22, 0x22, 0x4b, 0x0a, 0x87, 0x91, 0x64, 0x7e,
0x3c, 0x16, 0x0f, 0x73, 0x0e, 0x12, 0xa5, 0x52, 0x4e, 0x19, 0x16, 0x7f, 0x16, 0x13, 0x00, 0x02,
0x00, 0x2d, 0xff, 0xf6, 0x02, 0x2b, 0x02, 0xf8, 0x00, 0x15, 0x00, 0x22, 0x00, 0x00, 0x17, 0x22,
0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x17, 0x33, 0x26, 0x26, 0x35, 0x35, 0x33, 0x11, 0x23,
0x27, 0x23, 0x06, 0x06, 0x27, 0x32, 0x36, 0x37, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15, 0x14,
0x16, 0xfb, 0x5b, 0x73, 0x74, 0x5e, 0x3b, 0x4c, 0x16, 0x05, 0x03, 0x08, 0x95, 0x72, 0x1d, 0x06,
0x16, 0x4a, 0x07, 0x3e, 0x32, 0x01, 0x31, 0x42, 0x31, 0x38, 0x38, 0x0a, 0x8f, 0x8b, 0x8c, 0x90,
0x2e, 0x22, 0x10, 0x3d, 0x20, 0xaf, 0xfd, 0x08, 0x47, 0x22, 0x2f, 0x77, 0x49, 0x49, 0x10, 0x50,
0x54, 0x55, 0x50, 0x50, 0x51, 0x00, 0x02, 0x00, 0x2d, 0xff, 0xf6, 0x02, 0x24, 0x02, 0x2c, 0x00,
0x16, 0x00, 0x1d, 0x00, 0x00, 0x01, 0x32, 0x16, 0x15, 0x15, 0x21, 0x16, 0x16, 0x33, 0x32, 0x36,
0x37, 0x15, 0x06, 0x06, 0x23, 0x22, 0x26, 0x26, 0x35, 0x34, 0x36, 0x36, 0x17, 0x22, 0x06, 0x07,
0x33, 0x26, 0x26, 0x01, 0x2f, 0x71, 0x84, 0xfe, 0xa0, 0x02, 0x47, 0x3f, 0x35, 0x56, 0x2e, 0x28,
0x59, 0x3f, 0x52, 0x7e, 0x48, 0x41, 0x74, 0x4e, 0x2b, 0x39, 0x05, 0xd1, 0x01, 0x32, 0x02, 0x2c,
0x81, 0x77, 0x48, 0x3f, 0x48, 0x15, 0x16, 0x73, 0x14, 0x13, 0x3d, 0x7c, 0x5e, 0x60, 0x7f, 0x40,
0x6a, 0x38, 0x3b, 0x32, 0x41, 0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x01, 0xb0, 0x02, 0xfd, 0x00,
0x18, 0x00, 0x00, 0x01, 0x23, 0x11, 0x23, 0x11, 0x23, 0x35, 0x37, 0x35, 0x34, 0x36, 0x36, 0x33,
0x32, 0x16, 0x17, 0x07, 0x26, 0x26, 0x23, 0x22, 0x06, 0x15, 0x15, 0x33, 0x01, 0x7c, 0x81, 0x95,
0x52, 0x52, 0x2f, 0x57, 0x3b, 0x2c, 0x47, 0x16, 0x26, 0x11, 0x28, 0x1a, 0x1f, 0x1d, 0x81, 0x01,
0xb2, 0xfe, 0x4e, 0x01, 0xb2, 0x48, 0x28, 0x28, 0x46, 0x4d, 0x20, 0x0e, 0x09, 0x6d, 0x05, 0x09,
0x26, 0x1d, 0x22, 0x00, 0x02, 0x00, 0x2d, 0xff, 0x10, 0x02, 0x2b, 0x02, 0x2c, 0x00, 0x1e, 0x00,
0x29, 0x00, 0x00, 0x13, 0x32, 0x17, 0x33, 0x37, 0x33, 0x11, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27,
0x35, 0x16, 0x33, 0x32, 0x35, 0x35, 0x34, 0x36, 0x37, 0x23, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35,
0x34, 0x36, 0x17, 0x22, 0x15, 0x14, 0x33, 0x32, 0x36, 0x35, 0x35, 0x34, 0x26, 0xff, 0x65, 0x39,
0x04, 0x0c, 0x7e, 0x8a, 0x87, 0x3a, 0x63, 0x2f, 0x65, 0x70, 0x73, 0x03, 0x01, 0x04, 0x1c, 0x4e,
0x31, 0x61, 0x6d, 0x70, 0x91, 0x69, 0x6b, 0x39, 0x37, 0x36, 0x02, 0x2c, 0x50, 0x46, 0xfd, 0xdd,
0x75, 0x7a, 0x0e, 0x12, 0x77, 0x2a, 0x7c, 0x0b, 0x11, 0x24, 0x0e, 0x2b, 0x26, 0x95, 0x85, 0x86,
0x96, 0x79, 0xa5, 0xa3, 0x41, 0x51, 0x12, 0x58, 0x4c, 0x00, 0x01, 0x00, 0x4e, 0x00, 0x00, 0x02,
0x46, 0x02, 0xf8, 0x00, 0x16, 0x00, 0x00, 0x13, 0x14, 0x06, 0x07, 0x33, 0x36, 0x36, 0x33, 0x32,
0x16, 0x15, 0x11, 0x23, 0x11, 0x34, 0x23, 0x22, 0x06, 0x15, 0x11, 0x23, 0x11, 0x33, 0xe3, 0x05,
0x02, 0x08, 0x1a, 0x52, 0x32, 0x59, 0x6b, 0x95, 0x58, 0x43, 0x33, 0x95, 0x95, 0x02, 0x5d, 0x28,
0x4a, 0x0f, 0x2a, 0x26, 0x5f, 0x69, 0xfe, 0x9c, 0x01, 0x3f, 0x76, 0x5d, 0x57, 0xfe, 0xff, 0x02,
0xf8, 0x00, 0x02, 0x00, 0x48, 0x00, 0x00, 0x00, 0xea, 0x02, 0xf8, 0x00, 0x0b, 0x00, 0x0f, 0x00,
0x00, 0x13, 0x32, 0x16, 0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x17, 0x11, 0x23,
0x11, 0x99, 0x21, 0x30, 0x30, 0x21, 0x22, 0x2f, 0x2f, 0x6c, 0x95, 0x02, 0xf8, 0x1f, 0x2a, 0x29,
0x20, 0x20, 0x29, 0x2a, 0x1f, 0xd6, 0xfd, 0xde, 0x02, 0x22, 0x00, 0x02, 0xff, 0xc0, 0xff, 0x10,
0x00, 0xea, 0x02, 0xf8, 0x00, 0x0b, 0x00, 0x1c, 0x00, 0x00, 0x13, 0x34, 0x36, 0x33, 0x32, 0x16,
0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x03, 0x22, 0x26, 0x27, 0x35, 0x16, 0x16, 0x33, 0x32, 0x36,
0x35, 0x11, 0x33, 0x11, 0x14, 0x06, 0x06, 0x48, 0x2f, 0x22, 0x21, 0x30, 0x30, 0x21, 0x22, 0x2f,
0x26, 0x19, 0x37, 0x12, 0x12, 0x20, 0x14, 0x1e, 0x2a, 0x95, 0x26, 0x55, 0x02, 0xaf, 0x2a, 0x1f,
0x1f, 0x2a, 0x29, 0x20, 0x20, 0xfc, 0x8a, 0x07, 0x05, 0x75, 0x04, 0x05, 0x22, 0x31, 0x02, 0x47,
0xfd, 0xa3, 0x32, 0x52, 0x31, 0x00, 0x01, 0x00, 0x4e, 0x00, 0x00, 0x02, 0x6c, 0x02, 0xf8, 0x00,
0x12, 0x00, 0x00, 0x13, 0x14, 0x06, 0x07, 0x33, 0x36, 0x36, 0x37, 0x37, 0x33, 0x07, 0x13, 0x23,
0x27, 0x07, 0x15, 0x23, 0x11, 0x33, 0xe3, 0x05, 0x03, 0x02, 0x0f, 0x20, 0x12, 0x99, 0xa8, 0xd9,
0xe6, 0xac, 0x9d, 0x40, 0x95, 0x95, 0x01, 0xa4, 0x1f, 0x3d, 0x1f, 0x15, 0x2b, 0x13, 0xa6, 0xed,
0xfe, 0xcb, 0xdd, 0x33, 0xaa, 0x02, 0xf8, 0x00, 0x01, 0x00, 0x4e, 0x00, 0x00, 0x00, 0xe3, 0x02,
0xf8, 0x00, 0x03, 0x00, 0x00, 0x33, 0x23, 0x11, 0x33, 0xe3, 0x95, 0x95, 0x02, 0xf8, 0x00, 0x01,
0x00, 0x4e, 0x00, 0x00, 0x03, 0x8b, 0x02, 0x2c, 0x00, 0x22, 0x00, 0x00, 0x01, 0x32, 0x16, 0x15,
0x11, 0x23, 0x11, 0x34, 0x23, 0x22, 0x06, 0x15, 0x11, 0x23, 0x11, 0x34, 0x23, 0x22, 0x06, 0x15,
0x11, 0x23, 0x11, 0x33, 0x17, 0x33, 0x36, 0x36, 0x33, 0x32, 0x16, 0x17, 0x33, 0x36, 0x36, 0x02,
0xcf, 0x5d, 0x5f, 0x95, 0x52, 0x3b, 0x32, 0x95, 0x52, 0x3e, 0x2f, 0x95, 0x72, 0x14, 0x08, 0x19,
0x57, 0x2f, 0x3c, 0x54, 0x16, 0x0d, 0x19, 0x59, 0x02, 0x2c, 0x5f, 0x69, 0xfe, 0x9c, 0x01, 0x3f,
0x76, 0x54, 0x4f, 0xfe, 0xee, 0x01, 0x3f, 0x76, 0x5d, 0x57, 0xfe, 0xff, 0x02, 0x22, 0x46, 0x2a,
0x26, 0x27, 0x29, 0x2a, 0x26, 0x00, 0x01, 0x00, 0x4e, 0x00, 0x00, 0x02, 0x46, 0x02, 0x2c, 0x00,
0x14, 0x00, 0x00, 0x01, 0x32, 0x16, 0x15, 0x11, 0x23, 0x11, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15,
0x11, 0x23, 0x11, 0x33, 0x17, 0x33, 0x36, 0x36, 0x01, 0x84, 0x58, 0x6a, 0x95, 0x2a, 0x2e, 0x44,
0x32, 0x95, 0x72, 0x14, 0x08, 0x1a, 0x5b, 0x02, 0x2c, 0x5f, 0x69, 0xfe, 0x9c, 0x01, 0x3f, 0x3b,
0x3b, 0x5d, 0x57, 0xfe, 0xff, 0x02, 0x22, 0x46, 0x2a, 0x26, 0x00, 0x02, 0x00, 0x2d, 0xff, 0xf6,
0x02, 0x3e, 0x02, 0x2c, 0x00, 0x0d, 0x00, 0x19, 0x00, 0x00, 0x01, 0x14, 0x06, 0x23, 0x22, 0x26,
0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x16, 0x05, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34,
0x26, 0x23, 0x22, 0x06, 0x02, 0x3e, 0x8f, 0x7b, 0x4c, 0x77, 0x44, 0x8e, 0x7c, 0x4d, 0x76, 0x44,
0xfe, 0x87, 0x35, 0x3c, 0x3b, 0x35, 0x35, 0x3c, 0x3b, 0x35, 0x01, 0x12, 0x88, 0x94, 0x42, 0x7f,
0x5b, 0x88, 0x92, 0x42, 0x7d, 0x5b, 0x51, 0x53, 0x53, 0x51, 0x51, 0x51, 0x51, 0x00, 0x02, 0x00,
0x4e, 0xff, 0x10, 0x02, 0x4c, 0x02, 0x2c, 0x00, 0x14, 0x00, 0x20, 0x00, 0x00, 0x01, 0x32, 0x16,
0x15, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x23, 0x16, 0x15, 0x15, 0x23, 0x11, 0x33, 0x17, 0x33,
0x36, 0x36, 0x17, 0x22, 0x06, 0x07, 0x15, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x34, 0x01, 0x7e,
0x5c, 0x72, 0x76, 0x5c, 0x3b, 0x46, 0x16, 0x08, 0x08, 0x95, 0x79, 0x15, 0x07, 0x16, 0x4a, 0x0b,
0x3a, 0x2f, 0x02, 0x2f, 0x3e, 0x33, 0x31, 0x02, 0x2c, 0x8f, 0x8b, 0x8b, 0x91, 0x2b, 0x1b, 0x2a,
0x26, 0xdc, 0x03, 0x12, 0x47, 0x21, 0x30, 0x77, 0x48, 0x4a, 0x10, 0x4f, 0x55, 0x55, 0x50, 0xa1,
0x00, 0x02, 0x00, 0x2d, 0xff, 0x10, 0x02, 0x2b, 0x02, 0x2c, 0x00, 0x14, 0x00, 0x20, 0x00, 0x00,
0x05, 0x34, 0x37, 0x23, 0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16, 0x17,
0x33, 0x37, 0x33, 0x11, 0x23, 0x03, 0x32, 0x36, 0x37, 0x35, 0x34, 0x26, 0x23, 0x22, 0x06, 0x15,
0x14, 0x01, 0x96, 0x06, 0x06, 0x15, 0x4a, 0x3c, 0x5c, 0x72, 0x74, 0x5d, 0x3c, 0x4b, 0x17, 0x04,
0x0d, 0x7e, 0x95, 0x66, 0x3e, 0x31, 0x01, 0x31, 0x41, 0x35, 0x34, 0x0b, 0x2a, 0x28, 0x22, 0x2f,
0x8f, 0x8b, 0x8c, 0x90, 0x2e, 0x22, 0x46, 0xfc, 0xee, 0x01, 0x5b, 0x49, 0x49, 0x12, 0x50, 0x54,
0x55, 0x50, 0xa3, 0x00, 0x01, 0x00, 0x4e, 0x00, 0x00, 0x01, 0xb1, 0x02, 0x2c, 0x00, 0x13, 0x00,
0x00, 0x01, 0x32, 0x16, 0x17, 0x07, 0x26, 0x26, 0x23, 0x22, 0x06, 0x06, 0x15, 0x11, 0x23, 0x11,
0x33, 0x17, 0x33, 0x36, 0x36, 0x01, 0x7f, 0x0b, 0x1e, 0x09, 0x0b, 0x07, 0x1b, 0x0a, 0x26, 0x46,
0x2b, 0x95, 0x71, 0x16, 0x07, 0x18, 0x54, 0x02, 0x2c, 0x02, 0x02, 0x8c, 0x02, 0x03, 0x1b, 0x3c,
0x34, 0xfe, 0xea, 0x02, 0x22, 0x5c, 0x2a, 0x3c, 0x00, 0x01, 0x00, 0x2d, 0xff, 0xf6, 0x01, 0xcb,
0x02, 0x2c, 0x00, 0x28, 0x00, 0x00, 0x25, 0x14, 0x06, 0x23, 0x22, 0x26, 0x27, 0x35, 0x16, 0x16,
0x33, 0x32, 0x36, 0x35, 0x34, 0x26, 0x26, 0x27, 0x2e, 0x02, 0x35, 0x34, 0x36, 0x33, 0x32, 0x16,
0x17, 0x07, 0x26, 0x26, 0x23, 0x22, 0x15, 0x14, 0x16, 0x16, 0x17, 0x1e, 0x02, 0x01, 0xcb, 0x75,
0x74, 0x39, 0x52, 0x29, 0x2c, 0x66, 0x27, 0x2c, 0x25, 0x0f, 0x32, 0x35, 0x33, 0x42, 0x20, 0x76,
0x62, 0x33, 0x5c, 0x31, 0x2d, 0x28, 0x48, 0x25, 0x42, 0x11, 0x31, 0x30, 0x2f, 0x44, 0x25, 0xa2,
0x53, 0x59, 0x0f, 0x11, 0x7b, 0x14, 0x1a, 0x1a, 0x15, 0x0e, 0x16, 0x1c, 0x16, 0x16, 0x2b, 0x3d,
0x2e, 0x4c, 0x4c, 0x14, 0x17, 0x6b, 0x11, 0x17, 0x24, 0x0d, 0x15, 0x18, 0x14, 0x13, 0x29, 0x3d,
0x00, 0x01, 0x00, 0x17, 0xff, 0xf6, 0x01, 0x92, 0x02, 0x96, 0x00, 0x18, 0x00, 0x00, 0x25, 0x32,
0x36, 0x37, 0x15, 0x06, 0x06, 0x23, 0x22, 0x26, 0x26, 0x35, 0x11, 0x23, 0x35, 0x37, 0x37, 0x33,
0x15, 0x33, 0x15, 0x23, 0x11, 0x14, 0x16, 0x01, 0x34, 0x19, 0x2e, 0x17, 0x18, 0x47, 0x2a, 0x31,
0x4d, 0x2d, 0x47, 0x52, 0x2b, 0x5f, 0x99, 0x99, 0x24, 0x6d, 0x0a, 0x07, 0x6f, 0x0a, 0x0f, 0x20,
0x4f, 0x46, 0x01, 0x07, 0x3f, 0x32, 0x73, 0x74, 0x70, 0xfe, 0xf9, 0x1f, 0x1f, 0x00, 0x01, 0x00,
0x4b, 0xff, 0xf6, 0x02, 0x43, 0x02, 0x22, 0x00, 0x14, 0x00, 0x00, 0x01, 0x11, 0x23, 0x27, 0x23,
0x06, 0x06, 0x23, 0x22, 0x26, 0x35, 0x11, 0x33, 0x11, 0x14, 0x16, 0x33, 0x32, 0x36, 0x35, 0x11,
0x02, 0x43, 0x72, 0x14, 0x08, 0x1a, 0x5b, 0x33, 0x58, 0x6a, 0x95, 0x2a, 0x2e, 0x44, 0x32, 0x02,
0x22, 0xfd, 0xde, 0x46, 0x2a, 0x26, 0x5f, 0x69, 0x01, 0x64, 0xfe, 0xc1, 0x3a, 0x3c, 0x5d, 0x57,
0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x39, 0x02, 0x22, 0x00, 0x0c, 0x00, 0x00,
0x33, 0x03, 0x33, 0x13, 0x16, 0x16, 0x17, 0x33, 0x36, 0x37, 0x13, 0x33, 0x03, 0xd0, 0xd0, 0x9c,
0x69, 0x09, 0x0b, 0x01, 0x04, 0x03, 0x13, 0x69, 0x9c, 0xd0, 0x02, 0x22, 0xfe, 0xc9, 0x1c, 0x3c,
0x18, 0x36, 0x3a, 0x01, 0x37, 0xfd, 0xde, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x03, 0x4e, 0x02,
0x22, 0x00, 0x2a, 0x00, 0x00, 0x25, 0x2e, 0x03, 0x27, 0x23, 0x0e, 0x03, 0x07, 0x07, 0x23, 0x03,
0x33, 0x17, 0x1e, 0x02, 0x17, 0x33, 0x3e, 0x03, 0x37, 0x13, 0x33, 0x13, 0x1e, 0x02, 0x15, 0x33,
0x3e, 0x02, 0x37, 0x37, 0x33, 0x03, 0x23, 0x01, 0xe5, 0x04, 0x0f, 0x12, 0x10, 0x03, 0x04, 0x03,
0x0f, 0x12, 0x10, 0x04, 0x2c, 0xa0, 0x9b, 0x94, 0x3f, 0x07, 0x0b, 0x0a, 0x02, 0x04, 0x01, 0x06,
0x09, 0x07, 0x02, 0x43, 0xa4, 0x40, 0x04, 0x0b, 0x09, 0x04, 0x02, 0x0a, 0x0d, 0x07, 0x41, 0x92,
0x9d, 0xa2, 0xbf, 0x11, 0x43, 0x4d, 0x41, 0x0f, 0x0f, 0x41, 0x4d, 0x44, 0x12, 0xbd, 0x02, 0x22,
0xf2, 0x19, 0x46, 0x41, 0x13, 0x0e, 0x2f, 0x32, 0x29, 0x07, 0x01, 0x06, 0xfe, 0xfa, 0x0e, 0x3e,
0x40, 0x13, 0x11, 0x41, 0x48, 0x19, 0xf2, 0xfd, 0xde, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x02,
0x3d, 0x02, 0x22, 0x00, 0x0b, 0x00, 0x00, 0x13, 0x03, 0x33, 0x17, 0x37, 0x33, 0x03, 0x13, 0x23,
0x27, 0x07, 0x23, 0xbe, 0xb0, 0xa9, 0x6a, 0x6b, 0xa9, 0xb2, 0xba, 0xa9, 0x73, 0x73, 0xa9, 0x01,
0x17, 0x01, 0x0b, 0xae, 0xae, 0xfe, 0xf5, 0xfe, 0xe9, 0xbb, 0xbb, 0x00, 0x01, 0x00, 0x00, 0xff,
0x10, 0x02, 0x39, 0x02, 0x22, 0x00, 0x1a, 0x00, 0x00, 0x11, 0x33, 0x13, 0x16, 0x16, 0x17, 0x33,
0x36, 0x36, 0x37, 0x13, 0x33, 0x03, 0x06, 0x06, 0x23, 0x22, 0x26, 0x27, 0x35, 0x16, 0x16, 0x33,
0x32, 0x36, 0x37, 0x37, 0xa3, 0x67, 0x08, 0x08, 0x02, 0x03, 0x03, 0x0b, 0x07, 0x65, 0xa0, 0xe7,
0x1f, 0x77, 0x4e, 0x19, 0x25, 0x0e, 0x0b, 0x1f, 0x11, 0x2f, 0x37, 0x0d, 0x09, 0x02, 0x22, 0xfe,
0xcd, 0x16, 0x2f, 0x1a, 0x1a, 0x2f, 0x16, 0x01, 0x33, 0xfd, 0x98, 0x55, 0x55, 0x05, 0x03, 0x76,
0x02, 0x04, 0x39, 0x28, 0x1b, 0x00, 0x01, 0x00, 0x1b, 0x00, 0x00, 0x01, 0xca, 0x02, 0x22, 0x00,
0x09, 0x00, 0x00, 0x21, 0x21, 0x35, 0x13, 0x23, 0x35, 0x21, 0x15, 0x03, 0x33, 0x01, 0xca, 0xfe,
0x51, 0xfd, 0xee, 0x01, 0x97, 0xf6, 0xff, 0x58, 0x01, 0x58, 0x72, 0x61, 0xfe, 0xb1, 0x00, 0x01,
0x00, 0x0f, 0xff, 0x62, 0x01, 0x62, 0x02, 0xca, 0x00, 0x1f, 0x00, 0x00, 0x05, 0x22, 0x26, 0x26,
0x35, 0x35, 0x34, 0x26, 0x23, 0x35, 0x32, 0x36, 0x35, 0x35, 0x34, 0x36, 0x36, 0x33, 0x15, 0x06,
0x06, 0x15, 0x15, 0x14, 0x07, 0x15, 0x16, 0x15, 0x15, 0x14, 0x16, 0x17, 0x01, 0x62, 0x55, 0x5d,
0x24, 0x40, 0x3d, 0x3d, 0x40, 0x24, 0x5d, 0x55, 0x27, 0x2e, 0x72, 0x72, 0x2e, 0x27, 0x9e, 0x1c,
0x3c, 0x30, 0x9a, 0x2f, 0x28, 0x75, 0x28, 0x2f, 0x9b, 0x30, 0x3c, 0x1c, 0x6e, 0x01, 0x1a, 0x2a,
0x92, 0x5b, 0x11, 0x06, 0x11, 0x5b, 0x92, 0x2a, 0x1a, 0x01, 0x00, 0x01, 0x00, 0xde, 0xff, 0x1d,
0x01, 0x49, 0x02, 0xf5, 0x00, 0x03, 0x00, 0x00, 0x13, 0x33, 0x11, 0x23, 0xde, 0x6b, 0x6b, 0x02,
0xf5, 0xfc, 0x28, 0x00, 0x01, 0x00, 0x28, 0xff, 0x62, 0x01, 0x7b, 0x02, 0xca, 0x00, 0x1f, 0x00,
0x00, 0x17, 0x36, 0x36, 0x35, 0x35, 0x34, 0x37, 0x35, 0x26, 0x35, 0x35, 0x34, 0x26, 0x27, 0x35,
0x32, 0x16, 0x16, 0x15, 0x15, 0x14, 0x16, 0x33, 0x15, 0x22, 0x06, 0x15, 0x15, 0x14, 0x06, 0x06,
0x23, 0x28, 0x27, 0x2e, 0x72, 0x72, 0x2e, 0x27, 0x56, 0x5c, 0x24, 0x40, 0x3d, 0x3d, 0x40, 0x24,
0x5c, 0x56, 0x30, 0x01, 0x1a, 0x2a, 0x92, 0x5b, 0x11, 0x06, 0x11, 0x5b, 0x92, 0x2a, 0x1a, 0x01,
0x6e, 0x1c, 0x3c, 0x30, 0x9b, 0x2f, 0x28, 0x75, 0x28, 0x2f, 0x9a, 0x30, 0x3c, 0x1c, 0x00, 0x01,
0x00, 0x2b, 0x01, 0x0d, 0x02, 0x10, 0x01, 0xb4, 0x00, 0x17, 0x00, 0x00, 0x01, 0x26, 0x26, 0x23,
0x22, 0x06, 0x07, 0x35, 0x36, 0x33, 0x32, 0x16, 0x17, 0x16, 0x16, 0x33, 0x32, 0x36, 0x37, 0x15,
0x06, 0x23, 0x22, 0x26, 0x01, 0x0c, 0x25, 0x33, 0x17, 0x1c, 0x3d, 0x19, 0x32, 0x4b, 0x1d, 0x3b,
0x2f, 0x25, 0x34, 0x16, 0x1d, 0x3c, 0x19, 0x32, 0x4b, 0x1d, 0x3b, 0x01, 0x2d, 0x10, 0x0b, 0x22,
0x19, 0x71, 0x35, 0x0b, 0x14, 0x10, 0x0b, 0x22, 0x19, 0x71, 0x35, 0x0c, 0x00, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xf3, 0x66, 0xcb, 0x35, 0x5f, 0x0f, 0x3c, 0xf5, 0x00, 0x03, 0x08, 0x00,
0x00, 0x00, 0x00, 0x00, 0xdf, 0x93, 0x35, 0xf6, 0x00, 0x00, 0x00, 0x00, 0xdf, 0x93, 0x35, 0xf6,
0xfd, 0x68, 0xfe, 0x76, 0x0a, 0xf0, 0x05, 0x43, 0x00, 0x01, 0x00, 0x06, 0x00, 0x02, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xd6,
0xff, 0xb6, 0xff, 0xd3, 0x03, 0xc7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5f, 0x02, 0x58, 0x00, 0x00, 0x01, 0x1e, 0x00, 0x39,
0x01, 0xd8, 0x00, 0x41, 0x02, 0x86, 0x00, 0x16, 0x02, 0x3c, 0x00, 0x2b, 0x03, 0x85, 0x00, 0x1f,
0x02, 0xee, 0x00, 0x28, 0x01, 0x0a, 0x00, 0x41, 0x01, 0x53, 0x00, 0x28, 0x01, 0x53, 0x00, 0x1e,
0x02, 0x21, 0x00, 0x1f, 0x02, 0x3c, 0x00, 0x2b, 0x01, 0x1d, 0x00, 0x1f, 0x01, 0x42, 0x00, 0x1e,
0x01, 0x1d, 0x00, 0x39, 0x01, 0x9d, 0x00, 0x07, 0x02, 0x3c, 0x00, 0x24, 0x02, 0x3c, 0x00, 0x3b,
0x02, 0x3c, 0x00, 0x26, 0x02, 0x3c, 0x00, 0x26, 0x02, 0x3c, 0x00, 0x11, 0x02, 0x3c, 0x00, 0x31,
0x02, 0x3c, 0x00, 0x23, 0x02, 0x3c, 0x00, 0x1b, 0x02, 0x3c, 0x00, 0x23, 0x02, 0x3c, 0x00, 0x20,
0x01, 0x1d, 0x00, 0x39, 0x01, 0x1d, 0x00, 0x1f, 0x02, 0x3c, 0x00, 0x2b, 0x02, 0x3c, 0x00, 0x2b,
0x02, 0x3c, 0x00, 0x2b, 0x01, 0xdd, 0x00, 0x03, 0x03, 0x81, 0x00, 0x32, 0x02, 0xb2, 0x00, 0x00,
0x02, 0xa0, 0x00, 0x5a, 0x02, 0x7d, 0x00, 0x3a, 0x02, 0xe4, 0x00, 0x5a, 0x02, 0x30, 0x00, 0x5a,
0x02, 0x25, 0x00, 0x5a, 0x02, 0xd4, 0x00, 0x3a, 0x02, 0xfd, 0x00, 0x5a, 0x01, 0x85, 0x00, 0x20,
0x01, 0x4b, 0xff, 0xb6, 0x02, 0x98, 0x00, 0x5a, 0x02, 0x35, 0x00, 0x5a, 0x03, 0xaf, 0x00, 0x5a,
0x03, 0x2d, 0x00, 0x5a, 0x03, 0x1c, 0x00, 0x3a, 0x02, 0x74, 0x00, 0x5a, 0x03, 0x1c, 0x00, 0x3a,
0x02, 0x94, 0x00, 0x5a, 0x02, 0x27, 0x00, 0x2e, 0x02, 0x43, 0x00, 0x14, 0x02, 0xf4, 0x00, 0x55,
0x02, 0x8a, 0x00, 0x00, 0x03, 0xc7, 0x00, 0x00, 0x02, 0x9b, 0x00, 0x00, 0x02, 0x70, 0x00, 0x00,
0x02, 0x43, 0x00, 0x18, 0x01, 0x4b, 0x00, 0x46, 0x01, 0x9d, 0x00, 0x06, 0x01, 0x4b, 0x00, 0x19,
0x02, 0x3c, 0x00, 0x17, 0x01, 0x9b, 0xff, 0xfe, 0x01, 0x6a, 0x00, 0x28, 0x02, 0x5c, 0x00, 0x2a,
0x02, 0x79, 0x00, 0x4e, 0x02, 0x02, 0x00, 0x2d, 0x02, 0x79, 0x00, 0x2d, 0x02, 0x4f, 0x00, 0x2d,
0x01, 0x83, 0x00, 0x14, 0x02, 0x79, 0x00, 0x2d, 0x02, 0x91, 0x00, 0x4e, 0x01, 0x31, 0x00, 0x48,
0x01, 0x31, 0xff, 0xc0, 0x02, 0x6c, 0x00, 0x4e, 0x01, 0x31, 0x00, 0x4e, 0x03, 0xd6, 0x00, 0x4e,
0x02, 0x91, 0x00, 0x4e, 0x02, 0x6b, 0x00, 0x2d, 0x02, 0x79, 0x00, 0x4e, 0x02, 0x79, 0x00, 0x2d,
0x01, 0xc6, 0x00, 0x4e, 0x01, 0xf1, 0x00, 0x2d, 0x01, 0xb2, 0x00, 0x17, 0x02, 0x91, 0x00, 0x4b,
0x02, 0x39, 0x00, 0x00, 0x03, 0x58, 0x00, 0x0a, 0x02, 0x42, 0x00, 0x05, 0x02, 0x39, 0x00, 0x00,
0x01, 0xe8, 0x00, 0x1b, 0x01, 0x8a, 0x00, 0x0f, 0x02, 0x27, 0x00, 0xde, 0x01, 0x8a, 0x00, 0x28,
0x02, 0x3c, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x71,
0x00, 0x00, 0x00, 0x9c, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x01, 0x8a, 0x00, 0x00, 0x02, 0x0f,
0x00, 0x00, 0x02, 0xb8, 0x00, 0x00, 0x02, 0xd4, 0x00, 0x00, 0x03, 0x08, 0x00, 0x00, 0x03, 0x3d,
0x00, 0x00, 0x03, 0x7a, 0x00, 0x00, 0x03, 0xa3, 0x00, 0x00, 0x03, 0xca, 0x00, 0x00, 0x03, 0xe2,
0x00, 0x00, 0x04, 0x0d, 0x00, 0x00, 0x04, 0x2c, 0x00, 0x00, 0x04, 0x7f, 0x00, 0x00, 0x04, 0xb1,
0x00, 0x00, 0x05, 0x0d, 0x00, 0x00, 0x05, 0x8b, 0x00, 0x00, 0x05, 0xd6, 0x00, 0x00, 0x06, 0x36,
0x00, 0x00, 0x06, 0xb9, 0x00, 0x00, 0x06, 0xdd, 0x00, 0x00, 0x07, 0x7e, 0x00, 0x00, 0x08, 0x02,
0x00, 0x00, 0x08, 0x4d, 0x00, 0x00, 0x08, 0x95, 0x00, 0x00, 0x08, 0xbb, 0x00, 0x00, 0x08, 0xe1,
0x00, 0x00, 0x09, 0x06, 0x00, 0x00, 0x09, 0x81, 0x00, 0x00, 0x0a, 0x59, 0x00, 0x00, 0x0a, 0xa1,
0x00, 0x00, 0x0b, 0x09, 0x00, 0x00, 0x0b, 0x61, 0x00, 0x00, 0x0b, 0x9f, 0x00, 0x00, 0x0b, 0xcb,
0x00, 0x00, 0x0b, 0xf0, 0x00, 0x00, 0x0c, 0x55, 0x00, 0x00, 0x0c, 0x83, 0x00, 0x00, 0x0c, 0xb2,
0x00, 0x00, 0x0c, 0xef, 0x00, 0x00, 0x0d, 0x27, 0x00, 0x00, 0x0d, 0x44, 0x00, 0x00, 0x0d, 0x94,
0x00, 0x00, 0x0d, 0xd6, 0x00, 0x00, 0x0e, 0x2f, 0x00, 0x00, 0x0e, 0x70, 0x00, 0x00, 0x0e, 0xd1,
0x00, 0x00, 0x0f, 0x21, 0x00, 0x00, 0x0f, 0x98, 0x00, 0x00, 0x0f, 0xb9, 0x00, 0x00, 0x0f, 0xf7,
0x00, 0x00, 0x10, 0x34, 0x00, 0x00, 0x10, 0xb5, 0x00, 0x00, 0x10, 0xea, 0x00, 0x00, 0x11, 0x15,
0x00, 0x00, 0x11, 0x42, 0x00, 0x00, 0x11, 0x64, 0x00, 0x00, 0x11, 0x82, 0x00, 0x00, 0x11, 0xa3,
0x00, 0x00, 0x11, 0xc8, 0x00, 0x00, 0x11, 0xe2, 0x00, 0x00, 0x12, 0x12, 0x00, 0x00, 0x12, 0x88,
0x00, 0x00, 0x12, 0xf1, 0x00, 0x00, 0x13, 0x42, 0x00, 0x00, 0x13, 0xa9, 0x00, 0x00, 0x14, 0x09,
0x00, 0x00, 0x14, 0x57, 0x00, 0x00, 0x14, 0xcd, 0x00, 0x00, 0x15, 0x15, 0x00, 0x00, 0x15, 0x4e,
0x00, 0x00, 0x15, 0xa9, 0x00, 0x00, 0x15, 0xeb, 0x00, 0x00, 0x16, 0x02, 0x00, 0x00, 0x16, 0x69,
0x00, 0x00, 0x16, 0xae, 0x00, 0x00, 0x17, 0x01, 0x00, 0x00, 0x17, 0x64, 0x00, 0x00, 0x17, 0xc7,
0x00, 0x00, 0x18, 0x0c, 0x00, 0x00, 0x18, 0x84, 0x00, 0x00, 0x18, 0xd1, 0x00, 0x00, 0x19, 0x16,
0x00, 0x00, 0x19, 0x4b, 0x00, 0x00, 0x19, 0xcd, 0x00, 0x00, 0x19, 0xff, 0x00, 0x00, 0x1a, 0x59,
0x00, 0x00, 0x1a, 0x82, 0x00, 0x00, 0x1a, 0xde, 0x00, 0x00, 0x1a, 0xf7, 0x00, 0x00, 0x1b, 0x52,
0x00, 0x00, 0x1b, 0xa0, 0x00, 0x01, 0x00, 0x00, 0x00, 0x5f, 0x10, 0x00, 0x04, 0x00, 0x00, 0xff,
0x00, 0xff, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xff, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x96, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x04,
0x00, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x1e, 0x00, 0x11, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x0d, 0x00, 0x2f, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x05, 0x00, 0x03, 0x00, 0x3c, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x0d,
0x00, 0x3f, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x01, 0x00, 0x1a, 0x00, 0x4c, 0x00, 0x03,
0x00, 0x01, 0x04, 0x09, 0x00, 0x02, 0x00, 0x08, 0x00, 0x66, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09,
0x00, 0x03, 0x00, 0x3c, 0x00, 0x6e, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x04, 0x00, 0x1a,
0x00, 0xaa, 0x00, 0x03, 0x00, 0x01, 0x04, 0x09, 0x00, 0x05, 0x00, 0x06, 0x00, 0xc4, 0x00, 0x03,
0x00, 0x01, 0x04, 0x09, 0x00, 0x06, 0x00, 0x1a, 0x00, 0xca, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61,
0x74, 0x65, 0x64, 0x46, 0x6f, 0x6e, 0x74, 0x42, 0x6f, 0x6c, 0x64, 0x47, 0x65, 0x6e, 0x65, 0x72,
0x61, 0x74, 0x65, 0x64, 0x46, 0x6f, 0x6e, 0x74, 0x20, 0x42, 0x6f, 0x6c, 0x64, 0x3a, 0x56, 0x65,
0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x31, 0x2e, 0x30, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
0x65, 0x64, 0x46, 0x6f, 0x6e, 0x74, 0x31, 0x2e, 0x30, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74,
0x65, 0x64, 0x46, 0x6f, 0x6e, 0x74, 0x00, 0x47, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x72,
0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x46, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x74,
0x00, 0x42, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x64, 0x00, 0x47, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x65,
0x00, 0x72, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x46, 0x00, 0x6f, 0x00, 0x6e,
0x00, 0x74, 0x00, 0x20, 0x00, 0x42, 0x00, 0x6f, 0x00, 0x6c, 0x00, 0x64, 0x00, 0x3a, 0x00, 0x56,
0x00, 0x65, 0x00, 0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x20, 0x00, 0x31,
0x00, 0x2e, 0x00, 0x30, 0x00, 0x47, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x72, 0x00, 0x61,
0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x46, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x31,
0x00, 0x2e, 0x00, 0x30, 0x00, 0x47, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x72, 0x00, 0x61,
0x00, 0x74, 0x00, 0x65, 0x00, 0x64, 0x00, 0x46, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x00,
0x00, 0x03, 0x02, 0x68, 0x02, 0xbc, 0x00, 0x05, 0x00, 0x08, 0x02, 0x8a, 0x02, 0x58, 0x00, 0x00,
0x00, 0x4b, 0x02, 0x8a, 0x02, 0x58, 0x00, 0x00, 0x01, 0x5e, 0x00, 0x32, 0x01, 0x48, 0x00, 0x00,
0x02, 0x0b, 0x08, 0x02, 0x04, 0x05, 0x04, 0x02, 0x02, 0x04, 0xe0, 0x00, 0x82, 0xff, 0x40, 0x00,
0x20, 0x5f, 0x08, 0x00, 0x00, 0x29, 0x00, 0x10, 0x00, 0x00, 0x47, 0x4f, 0x4f, 0x47, 0x00, 0xa0,
0x00, 0x00, 0xff, 0xfd, 0x04, 0x2d, 0xfe, 0xdb, 0x00, 0x00, 0x05, 0x43, 0x01, 0x8b, 0x00, 0x00,
0x01, 0x9f, 0x00, 0x00, 0x00, 0x00, 0x02, 0x22, 0x02, 0xca, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04,
0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xb8, 0x01, 0xff, 0x85, 0xb0, 0x04, 0x8d, 0x00
};

View File

@ -1,47 +0,0 @@
// Arc drawing example - draw a colour wheel
#include <TFT_eSPI.h> // Include the graphics library
TFT_eSPI tft = TFT_eSPI(); // Create object "tft"
uint16_t colors[12];
// -------------------------------------------------------------------------
// Setup
// -------------------------------------------------------------------------
void setup(void) {
Serial.begin(115200);
tft.init();
tft.fillScreen(TFT_BLACK);
// Create the outer ring colours
for (uint8_t c = 0; c < 2; c++) {
colors[c + 10] = tft.alphaBlend(128 + c * 127, TFT_RED, TFT_MAGENTA);
colors[c + 8] = tft.alphaBlend(128 + c * 127, TFT_MAGENTA, TFT_BLUE);
colors[c + 6] = tft.alphaBlend(128 + c * 127, TFT_BLUE, TFT_GREEN);
colors[c + 4] = tft.alphaBlend(128 + c * 127, TFT_GREEN, TFT_YELLOW);
colors[c + 2] = tft.alphaBlend(128 + c * 127, TFT_YELLOW, TFT_ORANGE);
colors[c + 0] = tft.alphaBlend(128 + c * 127, TFT_ORANGE, TFT_RED);
}
}
// -------------------------------------------------------------------------
// Main loop
// -------------------------------------------------------------------------
void loop() {
uint16_t rDelta = (tft.width() - 1) / 10;
uint16_t x = tft.width() / 2;
uint16_t y = tft.height() / 2;
bool smooth = true;
// Draw rings as a series of arcs, increasingly blend colour with white towards middle
for (uint16_t i = 5; i > 0; i--) {
for (uint16_t angle = 0; angle <= 330; angle += 30) {
uint16_t radius = i * rDelta;
uint16_t wheelColor = tft.alphaBlend((i * 255.0)/5.0, colors[angle / 30], TFT_WHITE);
tft.drawArc(x, y, radius, radius - rDelta, angle, angle + 30, wheelColor, TFT_BLACK, smooth);
}
smooth = false; // Only outer ring is smooth
}
while (1) delay(100);
}

View File

@ -1,53 +0,0 @@
// Example for drawArc function. This is intended for arc based meters.
// (See arcMeter example)
// Draws arcs without smooth ends, suitable for dynamically changing arc
// angles to avoid residual anti-alias pixels at the arc segment joints.
// The sides of the arc can optionally be smooth or not. Smooth arcs have
// a much better appearance, especially at small sizes.
#include <TFT_eSPI.h> // Include the graphics library
TFT_eSPI tft = TFT_eSPI(); // Create object "tft"
// -------------------------------------------------------------------------
// Setup
// -------------------------------------------------------------------------
void setup(void) {
Serial.begin(115200);
tft.init();
tft.setRotation(1);
tft.fillScreen(TFT_BLACK);
}
// -------------------------------------------------------------------------
// Main loop
// -------------------------------------------------------------------------
void loop()
{
static uint32_t count = 0;
uint16_t fg_color = random(0x10000);
uint16_t bg_color = TFT_BLACK; // This is the background colour used for smoothing (anti-aliasing)
uint16_t x = random(tft.width()); // Position of centre of arc
uint16_t y = random(tft.height());
uint8_t radius = random(20, tft.width() / 4); // Outer arc radius
uint8_t thickness = random(1, radius / 4); // Thickness
uint8_t inner_radius = radius - thickness; // Calculate inner radius (can be 0 for circle segment)
// 0 degrees is at 6 o'clock position
// Arcs are drawn clockwise from start_angle to end_angle
// Start angle can be greater than end angle, the arc will then be drawn through 0 degrees
uint16_t start_angle = random(361); // Start angle must be in range 0 to 360
uint16_t end_angle = random(361); // End angle must be in range 0 to 360
bool smooth = random(2); // true = smooth sides, false = no smooth sides
tft.drawArc(x, y, radius, inner_radius, start_angle, end_angle, fg_color, bg_color, smooth);
count++;
if (count < 30) delay(500); // After 15s draw as fast as possible!
}

View File

@ -1,98 +0,0 @@
// Example for drawSmoothCircle function. Which draws anti-aliased circles
// The circle periphery has a "thickness" of ~3 pixles to minimise the
// "braiding" effect present in narrow anti-aliased lines.
// For thicker or thinner circle outlines use the drawArc function.
#include <TFT_eSPI.h> // Include the graphics library
TFT_eSPI tft = TFT_eSPI(); // Create object "tft"
// -------------------------------------------------------------------------
// Setup
// -------------------------------------------------------------------------
void setup(void) {
Serial.begin(115200);
tft.init();
tft.fillScreen(TFT_BLACK);
}
// -------------------------------------------------------------------------
// Main loop
// -------------------------------------------------------------------------
void loop()
{
static uint32_t radius = 2;
static uint32_t index = 0;
uint16_t fg_color = rainbow(index);
uint16_t bg_color = TFT_BLACK; // This is the background colour used for smoothing (anti-aliasing)
uint16_t x = tft.width() / 2; // Position of centre of arc
uint16_t y = tft.height() / 2;
tft.drawSmoothCircle(x, y, radius, fg_color, bg_color);
radius += 11;
index += 5;
index = index%192;
if (radius > tft.height()/2) {
delay (1000);
radius = 2;
}
}
// -------------------------------------------------------------------------
// Return a 16 bit rainbow colour
// -------------------------------------------------------------------------
unsigned int rainbow(byte value)
{
// If 'value' is in the range 0-159 it is converted to a spectrum colour
// from 0 = red through to 127 = blue to 159 = violet
// Extending the range to 0-191 adds a further violet to red band
value = value%192;
byte red = 0; // Red is the top 5 bits of a 16 bit colour value
byte green = 0; // Green is the middle 6 bits, but only top 5 bits used here
byte blue = 0; // Blue is the bottom 5 bits
byte sector = value >> 5;
byte amplit = value & 0x1F;
switch (sector)
{
case 0:
red = 0x1F;
green = amplit; // Green ramps up
blue = 0;
break;
case 1:
red = 0x1F - amplit; // Red ramps down
green = 0x1F;
blue = 0;
break;
case 2:
red = 0;
green = 0x1F;
blue = amplit; // Blue ramps up
break;
case 3:
red = 0;
green = 0x1F - amplit; // Green ramps down
blue = 0x1F;
break;
case 4:
red = amplit; // Red ramps up
green = 0;
blue = 0x1F;
break;
case 5:
red = 0x1F;
green = 0;
blue = 0x1F - amplit; // Blue ramps down
break;
}
return red << 11 | green << 6 | blue;
}

View File

@ -1,46 +0,0 @@
// Example for drawSmoothArc function.
// Draws smooth arcs with rounded or square smooth ends
#include <TFT_eSPI.h> // Include the graphics library
TFT_eSPI tft = TFT_eSPI(); // Create object "tft"
// -------------------------------------------------------------------------
// Setup
// -------------------------------------------------------------------------
void setup(void) {
Serial.begin(115200);
tft.init();
tft.setRotation(1);
tft.fillScreen(TFT_BLACK);
}
// -------------------------------------------------------------------------
// Main loop
// -------------------------------------------------------------------------
void loop()
{
static uint32_t count = 0;
uint16_t fg_color = random(0x10000);
uint16_t bg_color = TFT_BLACK; // This is the background colour used for smoothing (anti-aliasing)
uint16_t x = random(tft.width()); // Position of centre of arc
uint16_t y = random(tft.height());
uint8_t radius = random(20, tft.width()/4); // Outer arc radius
uint8_t thickness = random(1, radius / 4); // Thickness
uint8_t inner_radius = radius - thickness; // Calculate inner radius (can be 0 for circle segment)
// 0 degrees is at 6 o'clock position
// Arcs are drawn clockwise from start_angle to end_angle
uint16_t start_angle = random(361); // Start angle must be in range 0 to 360
uint16_t end_angle = random(361); // End angle must be in range 0 to 360
bool arc_end = random(2); // true = round ends, false = square ends (arc_end parameter can be omitted, ends will then be square)
tft.drawSmoothArc(x, y, radius, inner_radius, start_angle, end_angle, fg_color, bg_color, arc_end);
count++;
if (count < 30) delay(500); // After 15s draw as fast as possible!
}

View File

@ -1,50 +0,0 @@
// Draw random coloured smooth (anti-aliased) rounded rectangles on the TFT
#include <TFT_eSPI.h>
TFT_eSPI tft = TFT_eSPI();
void setup(void) {
tft.init();
tft.fillScreen(TFT_BLACK); // Background is black
}
void loop() {
tft.fillScreen(TFT_BLACK);
tft.setCursor(0, 0);
// Draw some random smooth rounded rectangles
for (int i = 0; i < 20; i++)
{
int radius = random(60);
int w = random(2 * radius, 160);
int h = random(2 * radius, 160);
int t = random(1, radius / 3);
int x = random(tft.width() - w);
int y = random(tft.height() - h);
// Random colour is anti-aliased (blended) with background colour (black in this case)
tft.drawSmoothRoundRect(x, y, radius, radius - t, w, h, random(0x10000), TFT_BLACK);
}
tft.print("Variable thickness");
delay(2000);
tft.fillScreen(TFT_BLACK);
tft.setCursor(0, 0);
// Draw some random minimum thickness smooth rounded rectangles
for (int i = 0; i < 20; i++)
{
int radius = random(60);
int w = random(2 * radius, 160);
int h = random(2 * radius, 160);
int t = 0;
int x = random(tft.width() - w);
int y = random(tft.height() - h);
// Random colour is anti-aliased (blended) with background colour (black in this case)
tft.drawSmoothRoundRect(x, y, radius, radius - t, w, h, random(0x10000), TFT_BLACK);
}
tft.print("Minimum thickness");
delay(2000);
}

View File

@ -44,7 +44,7 @@ TFT_eSprite spr = TFT_eSprite(&tft); // Sprite for meter reading
uint16_t* tft_buffer;
bool buffer_loaded = false;
uint16_t spr_width = 0;
uint16_t bg_color =0;
// =======================================================================================
// This function will be called during decoding of the jpeg file
// =======================================================================================
@ -82,11 +82,11 @@ void setup() {
// Load the font and create the Sprite for reporting the value
spr.loadFont(AA_FONT_LARGE);
spr_width = spr.textWidth("777"); // 7 is widest numeral in this font
spr_width = spr.textWidth("277");
spr.createSprite(spr_width, spr.fontHeight());
bg_color = tft.readPixel(120, 120); // Get colour from dial centre
uint16_t bg_color = tft.readPixel(120, 120); // Get colour from dial centre
spr.fillSprite(bg_color);
spr.setTextColor(TFT_WHITE, bg_color, true);
spr.setTextColor(TFT_WHITE, bg_color);
spr.setTextDatum(MC_DATUM);
spr.setTextPadding(spr_width);
spr.drawNumber(0, spr_width/2, spr.fontHeight()/2);
@ -203,7 +203,6 @@ void plotNeedle(int16_t angle, uint16_t ms_delay)
}
// Update the number at the centre of the dial
spr.setTextColor(TFT_WHITE, bg_color, true);
spr.drawNumber(old_angle+120, spr_width/2, spr.fontHeight()/2);
spr.pushSprite(120 - spr_width / 2, 120 - spr.fontHeight() / 2);

View File

@ -19,7 +19,7 @@
TFT_eSPI tft = TFT_eSPI(); // Invoke library
#ifdef ARDUINO_ARCH_ESP8266
#ifdef ESP8266
ADC_MODE(ADC_VCC); // Read the supply voltage
#endif
@ -45,15 +45,15 @@ Serial.print("\n[code]\n");
Serial.print ("TFT_eSPI ver = "); Serial.println(user.version);
printProcessorName();
#if defined (ESP32) || defined (ARDUINO_ARCH_ESP8266)
#if defined (ESP32) || defined (ESP8266)
if (user.esp < 0x32F000 || user.esp > 0x32FFFF) { Serial.print("Frequency = "); Serial.print(ESP.getCpuFreqMHz());Serial.println("MHz"); }
#endif
#ifdef ARDUINO_ARCH_ESP8266
#ifdef ESP8266
Serial.print("Voltage = "); Serial.print(ESP.getVcc() / 918.0); Serial.println("V"); // 918 empirically determined
#endif
Serial.print("Transactions = "); Serial.println((user.trans == 1) ? "Yes" : "No");
Serial.print("Interface = "); Serial.println((user.serial == 1) ? "SPI" : "Parallel");
#ifdef ARDUINO_ARCH_ESP8266
#ifdef ESP8266
if (user.serial == 1){ Serial.print("SPI overlap = "); Serial.println((user.overlap == 1) ? "Yes\n" : "No\n"); }
#endif
if (user.tft_driver != 0xE9D) // For ePaper displays the size is defined in the sketch
@ -78,7 +78,7 @@ if (user.pin_tft_mosi != -1) { Serial.print("MOSI = "); Serial.print("GPIO ")
if (user.pin_tft_miso != -1) { Serial.print("MISO = "); Serial.print("GPIO "); Serial.println(getPinName(user.pin_tft_miso)); }
if (user.pin_tft_clk != -1) { Serial.print("SCK = "); Serial.print("GPIO "); Serial.println(getPinName(user.pin_tft_clk)); }
#ifdef ARDUINO_ARCH_ESP8266
#ifdef ESP8266
if (user.overlap == true)
{
Serial.println("Overlap selected, following pins MUST be used:");
@ -92,7 +92,7 @@ if (user.overlap == true)
}
#endif
String pinNameRef = "GPIO ";
#ifdef ARDUINO_ARCH_ESP8266
#ifdef ESP8266
pinNameRef = "PIN_D";
#endif

View File

@ -18,9 +18,6 @@ pushColor KEYWORD2
setRotation KEYWORD2
getRotation KEYWORD2
setOrigin KEYWORD2
getOriginX KEYWORD2
getOriginY KEYWORD2
invertDisplay KEYWORD2
setAddrWindow KEYWORD2
@ -47,8 +44,6 @@ end_SDA_Read KEYWORD2
fillScreen KEYWORD2
drawRect KEYWORD2
fillRectHGradient KEYWORD2
fillRectVGradient KEYWORD2
drawRoundRect KEYWORD2
fillRoundRect KEYWORD2
@ -74,7 +69,6 @@ getPivotY KEYWORD2
readRect KEYWORD2
pushRect KEYWORD2
pushImage KEYWORD2
pushMaskedImage KEYWORD2
readRectRGB KEYWORD2
drawNumber KEYWORD2
@ -146,12 +140,10 @@ calibrateTouch KEYWORD2
setTouch KEYWORD2
# Smooth (anti-aliased) graphics functions
drawSmoothCircle KEYWORD2
fillRectHGradient KEYWORD2
fillRectVGradient KEYWORD2
fillSmoothCircle KEYWORD2
drawSmoothRoundRect KEYWORD2
fillSmoothRoundRect KEYWORD2
drawSmoothArc KEYWORD2
drawArc KEYWORD2
drawSpot KEYWORD2
drawWideLine KEYWORD2
drawWedgeLine KEYWORD2

View File

@ -1,8 +1,8 @@
{
"name": "TFT_eSPI",
"version": "2.5.21",
"version": "2.4.51",
"keywords": "Arduino, tft, display, ttgo, LilyPi, WT32-SC01, ePaper, display, Pico, RP2040 Nano Connect, RP2040, STM32, ESP8266, NodeMCU, ESP32, M5Stack, ILI9341, ST7735, ILI9163, S6D02A1, ILI9481, ILI9486, ILI9488, ST7789, ST7796, RM68140, SSD1351, SSD1963, ILI9225, HX8357D, GC9A01, R61581",
"description": "A TFT and ePaper (SPI or parallel interface) graphics library with optimisation for Raspberry Pi Pico, RP2040, ESP8266, ESP32 and STM32 processors",
"description": "A TFT and ePaper SPI graphics library with optimisation for Raspberry Pi Pico, RP2040, ESP8266, ESP32 and STM32",
"repository":
{
"type": "git",
@ -17,6 +17,6 @@
}
],
"frameworks": "arduino",
"platforms": "raspberrypi, espressif8266, espressif32, ststm32",
"platforms": "rp2040, espressif8266, espressif32, ststm32",
"headers": "TFT_eSPI.h"
}

View File

@ -1,9 +1,9 @@
name=TFT_eSPI
version=2.5.21
version=2.4.51
author=Bodmer
maintainer=Bodmer
sentence=TFT graphics library for Arduino processors with performance optimisation for RP2040, STM32, ESP8266 and ESP32
paragraph=Supports TFT displays using drivers (ILI9341 etc) that operate with hardware SPI or 8/16 bit parallel.
paragraph=Supports TFT displays using drivers (ILI9341 etc) that operate with hardware SPI or 8 bit parallel.
category=Display
url=https://github.com/Bodmer/TFT_eSPI
architectures=*