Bodmer/TFT_eSPI
1
0
Fork 1
mirror of https://github.com/Bodmer/TFT_eSPI.git synced 2025-08-02 20:24:41 +02:00
Code Issues Packages Projects Releases Wiki Activity

Add ESP32 VSPI or HSPI port option + others

Browse Source 
If the VSPI port is in use and pins are not accessible (e.g. TTGO
T-Beam)
then add or uncomment the following line in the setup header file:
//#define USE_HSPI_PORT

Minor performance tweaks for ESP32 to minimise the occurence of the slow
transaction overhead.

setAddrWindow now takes xstart, ystart, width and height as inputs

Multi-sample raw touch x and y for noisy displays

Example update for setAddrWindow change compatibility
This commit is contained in:
Bodmer
2019-01-22 18:41:31 +00:00
parent 0fdd25186a
commit 054a824eb8
16 changed files with 355 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Extensions/Smooth_font.cpp
View File

@@ -441,6 +441,8 @@ void TFT_eSPI::drawGlyph(uint16_t code)
int16_t cy = cursor_y + gFont.maxAscent - gdY[gNum]; int16_t cy = cursor_y + gFont.maxAscent - gdY[gNum];
int16_t cx = cursor_x + gdX[gNum]; int16_t cx = cursor_x + gdX[gNum];
startWrite(); // Avoid slow ESP32 transaction overhead for every pixel
for (int y = 0; y < gHeight[gNum]; y++) for (int y = 0; y < gHeight[gNum]; y++)
{ {
fontFile.read(pbuffer, gWidth[gNum]); //<// fontFile.read(pbuffer, gWidth[gNum]); //<//
@@ -481,6 +483,7 @@ void TFT_eSPI::drawGlyph(uint16_t code)
cursor_x += gFont.spaceWidth + 1; cursor_x += gFont.spaceWidth + 1;
} }
endWrite();
} }
/*************************************************************************************** /***************************************************************************************

24
Extensions/Sprite.cpp
View File

@@ -301,7 +301,8 @@ bool TFT_eSprite::pushRotated(int16_t angle, int32_t transp)
if (max_x > _tft->width()) max_x = _tft->width(); if (max_x > _tft->width()) max_x = _tft->width();
if (max_y > _tft->height()) max_y = _tft->height(); if (max_y > _tft->height()) max_y = _tft->height();
_tft->startWrite(); _tft->startWrite(); // ESP32: avoid transaction overhead for every tft pixel
// Scan destination bounding box and fetch transformed pixels from source Sprite // Scan destination bounding box and fetch transformed pixels from source Sprite
for (int32_t x = min_x; x <= max_x; x++) { for (int32_t x = min_x; x <= max_x; x++) {
int32_t xt = x - _tft->_xpivot; int32_t xt = x - _tft->_xpivot;
@@ -325,7 +326,8 @@ bool TFT_eSprite::pushRotated(int16_t angle, int32_t transp)
else if (column_drawn) y = max_y; // Skip remaining column pixels else if (column_drawn) y = max_y; // Skip remaining column pixels
} }
} }
_tft->endWrite();
_tft->endWrite(); // ESP32: end transaction
return true; return true;
} }
@@ -465,7 +467,6 @@ void TFT_eSprite::pushSprite(int32_t x, int32_t y)
if (_bpp == 16) _tft->pushImage(x, y, _iwidth, _iheight, _img ); if (_bpp == 16) _tft->pushImage(x, y, _iwidth, _iheight, _img );
else _tft->pushImage(x, y, _dwidth, _dheight, _img8, (bool)(_bpp == 8)); else _tft->pushImage(x, y, _dwidth, _dheight, _img8, (bool)(_bpp == 8));
} }
@@ -562,7 +563,7 @@ void TFT_eSprite::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, uint1
if (xs + w >= _iwidth) ws = _iwidth - xs; if (xs + w >= _iwidth) ws = _iwidth - xs;
if (ys + h >= _iheight) hs = _iheight - ys; if (ys + h >= _iheight) hs = _iheight - ys;
if (_bpp == 16) if (_bpp == 16) // Plot a 16 bpp image into a 16 bpp Sprite
{ {
for (uint32_t yp = yo; yp < yo + hs; yp++) for (uint32_t yp = yo; yp < yo + hs; yp++)
{ {
@@ -577,7 +578,7 @@ void TFT_eSprite::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, uint1
ys++; ys++;
} }
} }
else if (_bpp == 8) else if (_bpp == 8) // Plot a 16 bpp image into a 8 bpp Sprite
{ {
for (uint32_t yp = yo; yp < yo + hs; yp++) for (uint32_t yp = yo; yp < yo + hs; yp++)
{ {
@@ -613,7 +614,7 @@ void TFT_eSprite::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, uint1
x = y; x = y;
y = _dheight - tx - 1; y = _dheight - tx - 1;
} }
// Plot a 1bpp image into a 1bpp Sprite
uint8_t* pdata = (uint8_t* ) data; uint8_t* pdata = (uint8_t* ) data;
uint32_t ww = (w+7) & 0xFFF8; uint32_t ww = (w+7) & 0xFFF8;
for (int32_t yp = 0; yp<h; yp++) for (int32_t yp = 0; yp<h; yp++)
@@ -636,6 +637,10 @@ void TFT_eSprite::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, uint1
*************************************************************************************x*/ *************************************************************************************x*/
void TFT_eSprite::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uint16_t *data) void TFT_eSprite::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uint16_t *data)
{ {
#ifdef ESP32
pushImage(x, y, w, h, (uint16_t*) data);
#else
// Partitioned memory FLASH processor
if ((x >= _iwidth) || (y >= _iheight) || (w == 0) || (h == 0) || !_created) return; if ((x >= _iwidth) || (y >= _iheight) || (w == 0) || (h == 0) || !_created) return;
if ((x + (int32_t)w < 0) || (y + (int32_t)h < 0)) return; if ((x + (int32_t)w < 0) || (y + (int32_t)h < 0)) return;
@@ -654,7 +659,7 @@ void TFT_eSprite::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const
if (xs + w >= _iwidth) ws = _iwidth - xs; if (xs + w >= _iwidth) ws = _iwidth - xs;
if (ys + h >= _iheight) hs = _iheight - ys; if (ys + h >= _iheight) hs = _iheight - ys;
if (_bpp == 16) if (_bpp == 16) // Plot a 16 bpp image into a 16 bpp Sprite
{ {
for (uint32_t yp = yo; yp < yo + hs; yp++) for (uint32_t yp = yo; yp < yo + hs; yp++)
{ {
@@ -670,7 +675,7 @@ void TFT_eSprite::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const
} }
} }
else if (_bpp == 8) else if (_bpp == 8) // Plot a 16 bpp image into a 8 bpp Sprite
{ {
for (uint32_t yp = yo; yp < yo + hs; yp++) for (uint32_t yp = yo; yp < yo + hs; yp++)
{ {
@@ -706,7 +711,7 @@ void TFT_eSprite::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const
x = y; x = y;
y = _dheight - tx - 1; y = _dheight - tx - 1;
} }
// Plot a 1bpp image into a 1bpp Sprite
const uint8_t* pdata = (const uint8_t* ) data; const uint8_t* pdata = (const uint8_t* ) data;
uint32_t ww = (w+7) & 0xFFF8; uint32_t ww = (w+7) & 0xFFF8;
for (int32_t yp = 0; yp<h; yp++) for (int32_t yp = 0; yp<h; yp++)
@@ -721,6 +726,7 @@ void TFT_eSprite::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const
} }
} }
} }
#endif // if ESP32 else ESP8266 check
} }

34
Extensions/Touch.cpp
View File

@@ -22,18 +22,32 @@ uint8_t TFT_eSPI::getTouchRaw(uint16_t *x, uint16_t *y){
T_CS_L; T_CS_L;
// Start YP sample request for x position // Start YP sample request for x position, read 4 times and keep last sample
SPI.transfer(0xd0); // Start new YP conversion spi.transfer(0xd0); // Start new YP conversion
tmp = SPI.transfer(0); // Read first 8 bits spi.transfer(0); // Read first 8 bits
spi.transfer(0xd0); // Read last 8 bits and start new YP conversion
spi.transfer(0); // Read first 8 bits
spi.transfer(0xd0); // Read last 8 bits and start new YP conversion
spi.transfer(0); // Read first 8 bits
spi.transfer(0xd0); // Read last 8 bits and start new YP conversion
tmp = spi.transfer(0); // Read first 8 bits
tmp = tmp <<5; tmp = tmp <<5;
tmp |= 0x1f & (SPI.transfer(0x90)>>3); // Read last 8 bits and start new XP conversion tmp |= 0x1f & (spi.transfer(0x90)>>3); // Read last 8 bits and start new XP conversion
*x = tmp; *x = tmp;
// Start XP sample request for y position // Start XP sample request for y position, read 4 times and keep last sample
tmp = SPI.transfer(0); // Read first 8 bits spi.transfer(0); // Read first 8 bits
spi.transfer(0x90); // Read last 8 bits and start new XP conversion
spi.transfer(0); // Read first 8 bits
spi.transfer(0x90); // Read last 8 bits and start new XP conversion
spi.transfer(0); // Read first 8 bits
spi.transfer(0x90); // Read last 8 bits and start new XP conversion
tmp = spi.transfer(0); // Read first 8 bits
tmp = tmp <<5; tmp = tmp <<5;
tmp |= 0x1f & (SPI.transfer(0)>>3); // Read last 8 bits tmp |= 0x1f & (spi.transfer(0)>>3); // Read last 8 bits
*y = tmp; *y = tmp;
@@ -57,9 +71,9 @@ uint16_t TFT_eSPI::getTouchRawZ(void){
// Calculate Z // Calculate Z
int16_t tz = 0xFFF; int16_t tz = 0xFFF;
SPI.transfer(0xb0); // Start new Z1 conversion spi.transfer(0xb0); // Start new Z1 conversion
tz += SPI.transfer16(0xc0) >> 3; // Read Z1 and start Z2 conversion tz += spi.transfer16(0xc0) >> 3; // Read Z1 and start Z2 conversion
tz -= SPI.transfer16(0x00) >> 3; // Read Z2 tz -= spi.transfer16(0x00) >> 3; // Read Z2
T_CS_H; T_CS_H;

386
TFT_eSPI.cpp
View File

@@ -15,10 +15,16 @@
#include "TFT_eSPI.h" #include "TFT_eSPI.h"
#include <pgmspace.h> #if defined (ESP32)
#if !defined (ESP32_PARALLEL)
#ifndef ESP32_PARALLEL #ifdef USE_HSPI_PORT
#include <SPI.h> SPIClass spi = SPIClass(HSPI);
#else // use default VSPI port
SPIClass spi = SPIClass(VSPI);
#endif
#endif
#else // ESP8266
SPIClass spi = SPIClass();
#endif #endif
// SUPPORT_TRANSACTIONS is mandatory for ESP32 so the hal mutex is toggled // SUPPORT_TRANSACTIONS is mandatory for ESP32 so the hal mutex is toggled
@@ -48,32 +54,32 @@ void busDir(uint32_t mask, uint8_t mode);
inline void TFT_eSPI::spi_begin(void){ inline void TFT_eSPI::spi_begin(void){
#if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS) && !defined(ESP32_PARALLEL) #if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS) && !defined(ESP32_PARALLEL)
if (locked) {locked = false; SPI.beginTransaction(SPISettings(SPI_FREQUENCY, MSBFIRST, TFT_SPI_MODE));} if (locked) {locked = false; spi.beginTransaction(SPISettings(SPI_FREQUENCY, MSBFIRST, TFT_SPI_MODE));}
#endif #endif
} }
inline void TFT_eSPI::spi_end(void){ inline void TFT_eSPI::spi_end(void){
#if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS) && !defined(ESP32_PARALLEL) #if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS) && !defined(ESP32_PARALLEL)
if(!inTransaction) {if (!locked) {locked = true; SPI.endTransaction();}} if(!inTransaction) {if (!locked) {locked = true; spi.endTransaction();}}
#endif #endif
} }
inline void TFT_eSPI::spi_begin_read(void){ inline void TFT_eSPI::spi_begin_read(void){
#if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS) && !defined(ESP32_PARALLEL) #if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS) && !defined(ESP32_PARALLEL)
if (locked) {locked = false; SPI.beginTransaction(SPISettings(SPI_READ_FREQUENCY, MSBFIRST, TFT_SPI_MODE));} if (locked) {locked = false; spi.beginTransaction(SPISettings(SPI_READ_FREQUENCY, MSBFIRST, TFT_SPI_MODE));}
#else #else
#if !defined(ESP32_PARALLEL) #if !defined(ESP32_PARALLEL)
SPI.setFrequency(SPI_READ_FREQUENCY); spi.setFrequency(SPI_READ_FREQUENCY);
#endif #endif
#endif #endif
} }
inline void TFT_eSPI::spi_end_read(void){ inline void TFT_eSPI::spi_end_read(void){
#if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS) && !defined(ESP32_PARALLEL) #if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS) && !defined(ESP32_PARALLEL)
if(!inTransaction) {if (!locked) {locked = true; SPI.endTransaction();}} if(!inTransaction) {if (!locked) {locked = true; spi.endTransaction();}}
#else #else
#if !defined(ESP32_PARALLEL) #if !defined(ESP32_PARALLEL)
SPI.setFrequency(SPI_FREQUENCY); spi.setFrequency(SPI_FREQUENCY);
#endif #endif
#endif #endif
} }
@@ -82,17 +88,17 @@ inline void TFT_eSPI::spi_end_read(void){
inline void TFT_eSPI::spi_begin_touch(void){ inline void TFT_eSPI::spi_begin_touch(void){
#if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS) #if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS)
if (locked) {locked = false; SPI.beginTransaction(SPISettings(SPI_TOUCH_FREQUENCY, MSBFIRST, SPI_MODE0));} if (locked) {locked = false; spi.beginTransaction(SPISettings(SPI_TOUCH_FREQUENCY, MSBFIRST, SPI_MODE0));}
#else #else
SPI.setFrequency(SPI_TOUCH_FREQUENCY); spi.setFrequency(SPI_TOUCH_FREQUENCY);
#endif #endif
} }
inline void TFT_eSPI::spi_end_touch(void){ inline void TFT_eSPI::spi_end_touch(void){
#if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS) #if defined (SPI_HAS_TRANSACTION) && defined (SUPPORT_TRANSACTIONS)
if(!inTransaction) {if (!locked) {locked = true; SPI.endTransaction();}} if(!inTransaction) {if (!locked) {locked = true; spi.endTransaction();}}
#else #else
SPI.setFrequency(SPI_FREQUENCY); spi.setFrequency(SPI_FREQUENCY);
#endif #endif
} }
@@ -263,17 +269,17 @@ void TFT_eSPI::init(uint8_t tc)
#ifdef TFT_SPI_OVERLAP #ifdef TFT_SPI_OVERLAP
// Overlap mode SD0=MISO, SD1=MOSI, CLK=SCLK must use D3 as CS // Overlap mode SD0=MISO, SD1=MOSI, CLK=SCLK must use D3 as CS
// pins(int8_t sck, int8_t miso, int8_t mosi, int8_t ss); // pins(int8_t sck, int8_t miso, int8_t mosi, int8_t ss);
//SPI.pins( 6, 7, 8, 0); //spi.pins( 6, 7, 8, 0);
SPI.pins(6, 7, 8, 0); spi.pins(6, 7, 8, 0);
#endif #endif
SPI.begin(); // This will set HMISO to input spi.begin(); // This will set HMISO to input
#else #else
#if !defined(ESP32_PARALLEL) #if !defined(ESP32_PARALLEL)
#if defined (TFT_MOSI) && !defined (TFT_SPI_OVERLAP) #if defined (TFT_MOSI) && !defined (TFT_SPI_OVERLAP)
SPI.begin(TFT_SCLK, TFT_MISO, TFT_MOSI, -1); spi.begin(TFT_SCLK, TFT_MISO, TFT_MOSI, -1);
#else #else
SPI.begin(); spi.begin();
#endif #endif
#endif #endif
#endif #endif
@@ -284,9 +290,9 @@ void TFT_eSPI::init(uint8_t tc)
// SUPPORT_TRANSACTIONS is mandatory for ESP32 so the hal mutex is toggled // SUPPORT_TRANSACTIONS is mandatory for ESP32 so the hal mutex is toggled
// so the code here is for ESP8266 only // so the code here is for ESP8266 only
#if !defined (SUPPORT_TRANSACTIONS) && defined (ESP8266) #if !defined (SUPPORT_TRANSACTIONS) && defined (ESP8266)
SPI.setBitOrder(MSBFIRST); spi.setBitOrder(MSBFIRST);
SPI.setDataMode(TFT_SPI_MODE); spi.setDataMode(TFT_SPI_MODE);
SPI.setFrequency(SPI_FREQUENCY); spi.setFrequency(SPI_FREQUENCY);
#endif #endif
#if defined(ESP32_PARALLEL) #if defined(ESP32_PARALLEL)
@@ -298,7 +304,7 @@ void TFT_eSPI::init(uint8_t tc)
digitalWrite(TFT_CS, HIGH); // Chip select high (inactive) digitalWrite(TFT_CS, HIGH); // Chip select high (inactive)
pinMode(TFT_CS, OUTPUT); pinMode(TFT_CS, OUTPUT);
#else #else
SPI.setHwCs(1); // Use hardware SS toggling spi.setHwCs(1); // Use hardware SS toggling
#endif #endif
#endif #endif
@@ -611,7 +617,7 @@ uint16_t TFT_eSPI::readPixel(int32_t x0, int32_t y0)
{ {
#if defined(ESP32_PARALLEL) #if defined(ESP32_PARALLEL)
readAddrWindow(x0, y0, x0, y0); // Sets CS low readAddrWindow(x0, y0, 1, 1); // Sets CS low
// Set masked pins D0- D7 to input // Set masked pins D0- D7 to input
busDir(dir_mask, INPUT); busDir(dir_mask, INPUT);
@@ -652,7 +658,7 @@ uint16_t TFT_eSPI::readPixel(int32_t x0, int32_t y0)
spi_begin_read(); spi_begin_read();
readAddrWindow(x0, y0, x0, y0); // Sets CS low readAddrWindow(x0, y0, 1, 1); // Sets CS low
#ifdef TFT_SDA_READ #ifdef TFT_SDA_READ
begin_SDA_Read(); begin_SDA_Read();
@@ -757,7 +763,7 @@ void TFT_eSPI::readRect(uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint16_t
#if defined(ESP32_PARALLEL) #if defined(ESP32_PARALLEL)
readAddrWindow(x, y, x + w - 1, y + h - 1); // Sets CS low readAddrWindow(x, y, w, h); // Sets CS low
// Set masked pins D0- D7 to input // Set masked pins D0- D7 to input
busDir(dir_mask, INPUT); busDir(dir_mask, INPUT);
@@ -799,7 +805,7 @@ void TFT_eSPI::readRect(uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint16_t
spi_begin_read(); spi_begin_read();
readAddrWindow(x, y, x + w - 1, y + h - 1); // Sets CS low readAddrWindow(x, y, w, h); // Sets CS low
#ifdef TFT_SDA_READ #ifdef TFT_SDA_READ
begin_SDA_Read(); begin_SDA_Read();
@@ -881,7 +887,7 @@ void TFT_eSPI::begin_SDA_Read(void)
#ifdef TFT_SPI_OVERLAP #ifdef TFT_SPI_OVERLAP
// Reads in overlap mode not supported // Reads in overlap mode not supported
#else #else
SPI.end(); spi.end();
#endif #endif
#endif #endif
} }
@@ -901,9 +907,9 @@ void TFT_eSPI::end_SDA_Read(void)
pinMatrixInAttach(TFT_MISO, VSPIQ_IN_IDX, false); pinMatrixInAttach(TFT_MISO, VSPIQ_IN_IDX, false);
#else #else
#ifdef TFT_SPI_OVERLAP #ifdef TFT_SPI_OVERLAP
SPI.pins(6, 7, 8, 0); spi.pins(6, 7, 8, 0);
#else #else
SPI.begin(); spi.begin();
#endif #endif
#endif #endif
} }
@@ -946,7 +952,7 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, uint16_t
spi_begin(); spi_begin();
inTransaction = true; inTransaction = true;
setAddrWindow(x, y, x + dw - 1, y + dh - 1); // Sets CS low and sent RAMWR setWindow(x, y, x + dw - 1, y + dh - 1); // Sets CS low and sent RAMWR
data += dx + dy * w; data += dx + dy * w;
@@ -1007,7 +1013,7 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, uint16_t
{ {
if (transp != *ptr) if (transp != *ptr)
{ {
if (move) { move = false; setAddrWindow(px, y, xe, ye); } if (move) { move = false; setWindow(px, y, xe, ye); }
lineBuf[np] = *ptr; lineBuf[np] = *ptr;
np++; np++;
} }
@@ -1042,7 +1048,10 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, uint16_t
***************************************************************************************/ ***************************************************************************************/
void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uint16_t *data) void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uint16_t *data)
{ {
#ifdef ESP32
pushImage(x, y, w, h, (uint16_t*)data);
#else
// Partitioned memory FLASH processor
if ((x >= (int32_t)_width) || (y >= (int32_t)_height)) return; if ((x >= (int32_t)_width) || (y >= (int32_t)_height)) return;
int32_t dx = 0; int32_t dx = 0;
@@ -1066,7 +1075,7 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uin
uint16_t buffer[64]; uint16_t buffer[64];
uint16_t* pix_buffer = buffer; uint16_t* pix_buffer = buffer;
setAddrWindow(x, y, x + dw - 1, y + dh - 1); setWindow(x, y, x + dw - 1, y + dh - 1);
// Work out the number whole buffers to send // Work out the number whole buffers to send
uint16_t nb = (dw * dh) / 64; uint16_t nb = (dw * dh) / 64;
@@ -1095,6 +1104,7 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uin
inTransaction = false; inTransaction = false;
spi_end(); spi_end();
#endif // if ESP32 else ESP8266 check
} }
@@ -1104,7 +1114,10 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uin
***************************************************************************************/ ***************************************************************************************/
void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uint16_t *data, uint16_t transp) void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uint16_t *data, uint16_t transp)
{ {
#ifdef ESP32
pushImage(x, y, w, h, (uint16_t*) data, transp);
#else
// Partitioned memory FLASH processor
if ((x >= (int32_t)_width) || (y >= (int32_t)_height)) return; if ((x >= (int32_t)_width) || (y >= (int32_t)_height)) return;
int32_t dx = 0; int32_t dx = 0;
@@ -1145,7 +1158,7 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uin
uint16_t color = pgm_read_word(ptr); uint16_t color = pgm_read_word(ptr);
if (transp != color) if (transp != color)
{ {
if (move) { move = false; setAddrWindow(px, y, xe, ye); } if (move) { move = false; setWindow(px, y, xe, ye); }
lineBuf[np] = color; lineBuf[np] = color;
np++; np++;
} }
@@ -1171,6 +1184,7 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, const uin
inTransaction = false; inTransaction = false;
spi_end(); spi_end();
#endif // if ESP32 else ESP8266 check
} }
@@ -1198,7 +1212,7 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, uint8_t *
spi_begin(); spi_begin();
inTransaction = true; inTransaction = true;
setAddrWindow(x, y, x + dw - 1, y + dh - 1); // Sets CS low and sent RAMWR setWindow(x, y, x + dw - 1, y + dh - 1); // Sets CS low and sent RAMWR
// Line buffer makes plotting faster // Line buffer makes plotting faster
uint16_t lineBuf[dw]; uint16_t lineBuf[dw];
@@ -1339,7 +1353,7 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, uint8_t *
{ {
if (transp != *ptr) if (transp != *ptr)
{ {
if (move) { move = false; setAddrWindow(px, y, xe, ye);} if (move) { move = false; setWindow(px, y, xe, ye);}
uint8_t color = *ptr; uint8_t color = *ptr;
// Shifts are slow so check if colour has changed first // Shifts are slow so check if colour has changed first
@@ -1398,7 +1412,7 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, uint32_t w, uint32_t h, uint8_t *
if (move) if (move)
{ {
move = false; move = false;
setAddrWindow(px, y, xe, ye); setWindow(px, y, xe, ye);
} }
np++; np++;
} }
@@ -1464,7 +1478,7 @@ void TFT_eSPI::readRectRGB(int32_t x0, int32_t y0, int32_t w, int32_t h, uint8_
spi_begin_read(); spi_begin_read();
readAddrWindow(x0, y0, x0 + w - 1, y0 + h - 1); // Sets CS low readAddrWindow(x0, y0, w, h); // Sets CS low
#ifdef TFT_SDA_READ #ifdef TFT_SDA_READ
begin_SDA_Read(); begin_SDA_Read();
@@ -2397,7 +2411,7 @@ void TFT_eSPI::drawChar(int32_t x, int32_t y, unsigned char c, uint32_t color, u
uint8_t mask = 0x1; uint8_t mask = 0x1;
spi_begin(); spi_begin();
//inTransaction = true; //inTransaction = true;
setAddrWindow(x, y, x+5, y+8); setWindow(x, y, x+5, y+8);
for (int8_t i = 0; i < 5; i++ ) column[i] = pgm_read_byte(font + (c * 5) + i); for (int8_t i = 0; i < 5; i++ ) column[i] = pgm_read_byte(font + (c * 5) + i);
column[5] = 0; column[5] = 0;
@@ -2620,27 +2634,26 @@ void TFT_eSPI::drawChar(int32_t x, int32_t y, unsigned char c, uint32_t color, u
/*************************************************************************************** /***************************************************************************************
** Function name: setWindow ** Function name: setAddrWindow
** Description: define an area to receive a stream of pixels ** Description: define an area to receive a stream of pixels
***************************************************************************************/ ***************************************************************************************/
// Chip select is high at the end of this function // Chip select is high at the end of this function
void TFT_eSPI::setWindow(int16_t x0, int16_t y0, int16_t x1, int16_t y1) void TFT_eSPI::setAddrWindow(int32_t x0, int32_t y0, int32_t w, int32_t h)
{ {
spi_begin(); spi_begin();
setAddrWindow(x0, y0, x1, y1); setWindow(x0, y0, x0 + w - 1, y0 + h - 1);
CS_H; CS_H;
spi_end(); spi_end();
} }
/*************************************************************************************** /***************************************************************************************
** Function name: setAddrWindow ** Function name: setWindow
** Description: define an area to receive a stream of pixels ** Description: define an area to receive a stream of pixels
***************************************************************************************/ ***************************************************************************************/
// Chip select stays low, use setWindow() from sketches // Chip select stays low, call spi_begin first. Use setAddrWindow() from sketches
#if defined (ESP8266) && !defined (RPI_WRITE_STROBE) && !defined (RPI_ILI9486_DRIVER) #if defined (ESP8266) && !defined (RPI_WRITE_STROBE) && !defined (RPI_ILI9486_DRIVER)
void TFT_eSPI::setAddrWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye) void TFT_eSPI::setWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye)
{ {
//spi_begin(); //spi_begin();
@@ -2708,7 +2721,7 @@ void TFT_eSPI::setAddrWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye)
#elif defined (ESP8266) && !defined (RPI_WRITE_STROBE) && defined (RPI_ILI9486_DRIVER) // This is for the RPi display that needs 16 bits #elif defined (ESP8266) && !defined (RPI_WRITE_STROBE) && defined (RPI_ILI9486_DRIVER) // This is for the RPi display that needs 16 bits
void TFT_eSPI::setAddrWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye) void TFT_eSPI::setWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye)
{ {
//spi_begin(); //spi_begin();
@@ -2731,7 +2744,7 @@ void TFT_eSPI::setAddrWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye)
DC_D; DC_D;
uint8_t xb[] = { 0, (uint8_t) (xs>>8), 0, (uint8_t) (xs>>0), 0, (uint8_t) (xe>>8), 0, (uint8_t) (xe>>0), }; uint8_t xb[] = { 0, (uint8_t) (xs>>8), 0, (uint8_t) (xs>>0), 0, (uint8_t) (xe>>8), 0, (uint8_t) (xe>>0), };
SPI.writePattern(&xb[0], 8, 1); spi.writePattern(&xb[0], 8, 1);
// Row addr set // Row addr set
DC_C; DC_C;
@@ -2745,7 +2758,7 @@ void TFT_eSPI::setAddrWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye)
DC_D; DC_D;
uint8_t yb[] = { 0, (uint8_t) (ys>>8), 0, (uint8_t) (ys>>0), 0, (uint8_t) (ye>>8), 0, (uint8_t) (ye>>0), }; uint8_t yb[] = { 0, (uint8_t) (ys>>8), 0, (uint8_t) (ys>>0), 0, (uint8_t) (ye>>8), 0, (uint8_t) (ye>>0), };
SPI.writePattern(&yb[0], 8, 1); spi.writePattern(&yb[0], 8, 1);
// write to RAM // write to RAM
DC_C; DC_C;
@@ -2763,7 +2776,7 @@ void TFT_eSPI::setAddrWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye)
#else #else
#if defined (ESP8266) && defined (RPI_ILI9486_DRIVER) // This is for the RPi display that needs 16 bits #if defined (ESP8266) && defined (RPI_ILI9486_DRIVER) // This is for the RPi display that needs 16 bits
void TFT_eSPI::setAddrWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1) void TFT_eSPI::setWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
{ {
//spi_begin(); //spi_begin();
@@ -2840,7 +2853,7 @@ void TFT_eSPI::setAddrWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
#else // This is for the ESP32 #else // This is for the ESP32
void TFT_eSPI::setAddrWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1) void TFT_eSPI::setWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
{ {
//spi_begin(); //spi_begin();
@@ -2862,7 +2875,7 @@ void TFT_eSPI::setAddrWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
#if defined (RPI_ILI9486_DRIVER) #if defined (RPI_ILI9486_DRIVER)
uint8_t xb[] = { 0, (uint8_t) (x0>>8), 0, (uint8_t) (x0>>0), 0, (uint8_t) (x1>>8), 0, (uint8_t) (x1>>0), }; uint8_t xb[] = { 0, (uint8_t) (x0>>8), 0, (uint8_t) (x0>>0), 0, (uint8_t) (x1>>8), 0, (uint8_t) (x1>>0), };
SPI.writePattern(&xb[0], 8, 1); spi.writePattern(&xb[0], 8, 1);
#else #else
tft_Write_32(SPI_32(x0, x1)); tft_Write_32(SPI_32(x0, x1));
#endif #endif
@@ -2876,7 +2889,7 @@ void TFT_eSPI::setAddrWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
#if defined (RPI_ILI9486_DRIVER) #if defined (RPI_ILI9486_DRIVER)
uint8_t yb[] = { 0, (uint8_t) (y0>>8), 0, (uint8_t) (y0>>0), 0, (uint8_t) (y1>>8), 0, (uint8_t) (y1>>0), }; uint8_t yb[] = { 0, (uint8_t) (y0>>8), 0, (uint8_t) (y0>>0), 0, (uint8_t) (y1>>8), 0, (uint8_t) (y1>>0), };
SPI.writePattern(&yb[0], 8, 1); spi.writePattern(&yb[0], 8, 1);
#else #else
tft_Write_32(SPI_32(y0, y1)); tft_Write_32(SPI_32(y0, y1));
#endif #endif
@@ -2900,10 +2913,13 @@ void TFT_eSPI::setAddrWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
***************************************************************************************/ ***************************************************************************************/
// Chip select stays low // Chip select stays low
#if defined (ESP8266) && !defined (RPI_WRITE_STROBE) #if defined (ESP8266) && !defined (RPI_WRITE_STROBE)
void TFT_eSPI::readAddrWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye) void TFT_eSPI::readAddrWindow(int32_t xs, int32_t ys, int32_t w, int32_t h)
{ {
//spi_begin(); //spi_begin();
int32_t xe = xs + w - 1;
int32_t ye = ys + h - 1;
addr_col = 0xFFFF; addr_col = 0xFFFF;
addr_row = 0xFFFF; addr_row = 0xFFFF;
@@ -2966,10 +2982,13 @@ void TFT_eSPI::readAddrWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye)
#else //ESP32 #else //ESP32
void TFT_eSPI::readAddrWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1) void TFT_eSPI::readAddrWindow(int32_t xs, int32_t ys, int32_t w, int32_t h)
{ {
//spi_begin(); //spi_begin();
int32_t xe = xs + w - 1;
int32_t ye = ys + h - 1;
addr_col = 0xFFFF; addr_col = 0xFFFF;
addr_row = 0xFFFF; addr_row = 0xFFFF;
@@ -2987,7 +3006,7 @@ void TFT_eSPI::readAddrWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
DC_D; DC_D;
tft_Write_32(SPI_32(x0, x1)); tft_Write_32(SPI_32(xs, xe));
// Row addr set // Row addr set
DC_C; DC_C;
@@ -2996,7 +3015,7 @@ void TFT_eSPI::readAddrWindow(int32_t x0, int32_t y0, int32_t x1, int32_t y1)
DC_D; DC_D;
tft_Write_32(SPI_32(y0, y1)); tft_Write_32(SPI_32(ys, ye));
DC_C; DC_C;
@@ -3044,7 +3063,7 @@ void TFT_eSPI::drawPixel(uint32_t x, uint32_t y, uint32_t color)
#if defined (RPI_ILI9486_DRIVER) // This is for the RPi display that needs 16 bits per byte #if defined (RPI_ILI9486_DRIVER) // This is for the RPi display that needs 16 bits per byte
uint8_t cBin[] = { 0, (uint8_t) (x>>8), 0, (uint8_t) (x>>0)}; uint8_t cBin[] = { 0, (uint8_t) (x>>8), 0, (uint8_t) (x>>0)};
SPI.writePattern(&cBin[0], 4, 2); spi.writePattern(&cBin[0], 4, 2);
#else #else
SPI1U1 = mask | (31 << SPILMOSI) | (31 << SPILMISO); SPI1U1 = mask | (31 << SPILMOSI) | (31 << SPILMISO);
// Load the two coords as a 32 bit value and shift in one go // Load the two coords as a 32 bit value and shift in one go
@@ -3072,7 +3091,7 @@ void TFT_eSPI::drawPixel(uint32_t x, uint32_t y, uint32_t color)
#if defined (RPI_ILI9486_DRIVER) // This is for the RPi display that needs 16 bits per byte #if defined (RPI_ILI9486_DRIVER) // This is for the RPi display that needs 16 bits per byte
uint8_t cBin[] = { 0, (uint8_t) (y>>8), 0, (uint8_t) (y>>0)}; uint8_t cBin[] = { 0, (uint8_t) (y>>8), 0, (uint8_t) (y>>0)};
SPI.writePattern(&cBin[0], 4, 2); spi.writePattern(&cBin[0], 4, 2);
#else #else
SPI1U1 = mask | (31 << SPILMOSI) | (31 << SPILMISO); SPI1U1 = mask | (31 << SPILMOSI) | (31 << SPILMISO);
// Load the two coords as a 32 bit value and shift in one go // Load the two coords as a 32 bit value and shift in one go
@@ -3221,7 +3240,7 @@ void TFT_eSPI::drawPixel(uint32_t x, uint32_t y, uint32_t color)
#if defined (RPI_ILI9486_DRIVER) #if defined (RPI_ILI9486_DRIVER)
uint8_t xb[] = { 0, (uint8_t) (x>>8), 0, (uint8_t) (x>>0), 0, (uint8_t) (x>>8), 0, (uint8_t) (x>>0), }; uint8_t xb[] = { 0, (uint8_t) (x>>8), 0, (uint8_t) (x>>0), 0, (uint8_t) (x>>8), 0, (uint8_t) (x>>0), };
SPI.writePattern(&xb[0], 8, 1); spi.writePattern(&xb[0], 8, 1);
#else #else
tft_Write_32(SPI_32(x, x)); tft_Write_32(SPI_32(x, x));
#endif #endif
@@ -3240,7 +3259,7 @@ void TFT_eSPI::drawPixel(uint32_t x, uint32_t y, uint32_t color)
#if defined (RPI_ILI9486_DRIVER) #if defined (RPI_ILI9486_DRIVER)
uint8_t yb[] = { 0, (uint8_t) (y>>8), 0, (uint8_t) (y>>0), 0, (uint8_t) (y>>8), 0, (uint8_t) (y>>0), }; uint8_t yb[] = { 0, (uint8_t) (y>>8), 0, (uint8_t) (y>>0), 0, (uint8_t) (y>>8), 0, (uint8_t) (y>>0), };
SPI.writePattern(&yb[0], 8, 1); spi.writePattern(&yb[0], 8, 1);
#else #else
tft_Write_32(SPI_32(y, y)); tft_Write_32(SPI_32(y, y));
#endif #endif
@@ -3295,7 +3314,7 @@ void TFT_eSPI::pushColor(uint16_t color, uint32_t len)
#ifdef RPI_WRITE_STROBE #ifdef RPI_WRITE_STROBE
uint8_t colorBin[] = { (uint8_t) (color >> 8), (uint8_t) color }; uint8_t colorBin[] = { (uint8_t) (color >> 8), (uint8_t) color };
if(len) SPI.writePattern(&colorBin[0], 2, 1); len--; if(len) spi.writePattern(&colorBin[0], 2, 1); len--;
while(len--) {WR_L; WR_H;} while(len--) {WR_L; WR_H;}
#else #else
#if defined (ESP32_PARALLEL) #if defined (ESP32_PARALLEL)
@@ -3340,7 +3359,7 @@ void TFT_eSPI::writeColor(uint16_t color, uint32_t len)
{ {
#ifdef RPI_WRITE_STROBE #ifdef RPI_WRITE_STROBE
uint8_t colorBin[] = { (uint8_t) (color >> 8), (uint8_t) color }; uint8_t colorBin[] = { (uint8_t) (color >> 8), (uint8_t) color };
if(len) SPI.writePattern(&colorBin[0], 2, 1); len--; if(len) spi.writePattern(&colorBin[0], 2, 1); len--;
while(len--) {WR_L; WR_H;} while(len--) {WR_L; WR_H;}
#else #else
#if defined (ESP32_PARALLEL) #if defined (ESP32_PARALLEL)
@@ -3355,7 +3374,7 @@ void TFT_eSPI::writeColor(uint16_t color, uint32_t len)
** Function name: pushColors ** Function name: pushColors
** Description: push an array of pixels for 16 bit raw image drawing ** Description: push an array of pixels for 16 bit raw image drawing
***************************************************************************************/ ***************************************************************************************/
// Assumed that setWindow() has previously been called // Assumed that setAddrWindow() has previously been called
void TFT_eSPI::pushColors(uint8_t *data, uint32_t len) void TFT_eSPI::pushColors(uint8_t *data, uint32_t len)
{ {
@@ -3364,8 +3383,8 @@ void TFT_eSPI::pushColors(uint8_t *data, uint32_t len)
CS_L; CS_L;
#if defined (RPI_WRITE_STROBE) #if defined (RPI_WRITE_STROBE)
while ( len >=64 ) {SPI.writePattern(data, 64, 1); data += 64; len -= 64; } while ( len >=64 ) {spi.writePattern(data, 64, 1); data += 64; len -= 64; }
if (len) SPI.writePattern(data, len, 1); if (len) spi.writePattern(data, len, 1);
#else #else
#ifdef ESP32_PARALLEL #ifdef ESP32_PARALLEL
while (len--) {tft_Write_8(*data); data++;} while (len--) {tft_Write_8(*data); data++;}
@@ -3374,10 +3393,10 @@ void TFT_eSPI::pushColors(uint8_t *data, uint32_t len)
while (len>1) {color = (*data++) | ((*data++)<<8); tft_Write_16(color); len-=2;} while (len>1) {color = (*data++) | ((*data++)<<8); tft_Write_16(color); len-=2;}
#else #else
#if (SPI_FREQUENCY == 80000000) #if (SPI_FREQUENCY == 80000000)
while ( len >=64 ) {SPI.writePattern(data, 64, 1); data += 64; len -= 64; } while ( len >=64 ) {spi.writePattern(data, 64, 1); data += 64; len -= 64; }
if (len) SPI.writePattern(data, len, 1); if (len) spi.writePattern(data, len, 1);
#else #else
SPI.writeBytes(data, len); spi.writeBytes(data, len);
#endif #endif
#endif #endif
#endif #endif
@@ -3403,8 +3422,8 @@ void TFT_eSPI::pushColors(uint16_t *data, uint32_t len, bool swap)
if (swap) while ( len-- ) {tft_Write_16(*data); data++;} if (swap) while ( len-- ) {tft_Write_16(*data); data++;}
else while ( len-- ) {tft_Write_16S(*data); data++;} else while ( len-- ) {tft_Write_16S(*data); data++;}
#else #else
if (swap) SPI.writePixels(data,len<<1); if (swap) spi.writePixels(data,len<<1);
else SPI.writeBytes((uint8_t*)data,len<<1); else spi.writeBytes((uint8_t*)data,len<<1);
#endif #endif
#else #else
@@ -3600,7 +3619,7 @@ void TFT_eSPI::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t
if (x0 > x1) {spi_end(); return;} if (x0 > x1) {spi_end(); return;}
setAddrWindow(y0, x0, y0, _height); setWindow(y0, x0, y0, _height);
SPI1U1 = mask; SPI1U1 = mask;
SPI1W0 = swapped_color; SPI1W0 = swapped_color;
for (; x0 <= x1; x0++) { for (; x0 <= x1; x0++) {
@@ -3613,7 +3632,7 @@ void TFT_eSPI::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t
if ((y0 < 0) || (y0 >= _width)) break; if ((y0 < 0) || (y0 >= _width)) break;
err += dx; err += dx;
while(SPI1CMD & SPIBUSY) {} while(SPI1CMD & SPIBUSY) {}
setAddrWindow(y0, x0+1, y0, _height); setWindow(y0, x0+1, y0, _height);
SPI1U1 = mask; SPI1U1 = mask;
SPI1W0 = swapped_color; SPI1W0 = swapped_color;
} }
@@ -3634,7 +3653,7 @@ void TFT_eSPI::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t
if (x0 > x1) {spi_end(); return;} if (x0 > x1) {spi_end(); return;}
setAddrWindow(x0, y0, _width, y0); setWindow(x0, y0, _width, y0);
SPI1U1 = mask; SPI1U1 = mask;
SPI1W0 = swapped_color; SPI1W0 = swapped_color;
for (; x0 <= x1; x0++) { for (; x0 <= x1; x0++) {
@@ -3647,7 +3666,7 @@ void TFT_eSPI::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t
if ((y0 < 0) || (y0 >= _height)) break; if ((y0 < 0) || (y0 >= _height)) break;
err += dx; err += dx;
while(SPI1CMD & SPIBUSY) {} while(SPI1CMD & SPIBUSY) {}
setAddrWindow(x0+1, y0, _width, y0); setWindow(x0+1, y0, _width, y0);
SPI1U1 = mask; SPI1U1 = mask;
SPI1W0 = swapped_color; SPI1W0 = swapped_color;
} }
@@ -3670,13 +3689,18 @@ void TFT_eSPI::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t
#if defined (ESP8266) && !defined (RPI_WRITE_STROBE) #if defined (ESP8266) && !defined (RPI_WRITE_STROBE)
void TFT_eSPI::drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color) void TFT_eSPI::drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color)
{ {
// Rudimentary clipping // Clipping
if ((x >= _width) || (y >= _height) || (h < 1)) return; if ((x < 0) || (x >= _width) || (y >= _height)) return;
if ((y + h - 1) >= _height) h = _height - y;
if (y < 0) { h += y; y = 0; }
if ((y + h) > _height) h = _height - y;
if (h < 1) return;
spi_begin(); spi_begin();
setAddrWindow(x, y, x, y + h - 1); setWindow(x, y, x, y + h - 1);
writeBlock(color, h); writeBlock(color, h);
@@ -3689,17 +3713,22 @@ void TFT_eSPI::drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color)
void TFT_eSPI::drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color) void TFT_eSPI::drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color)
{ {
// Rudimentary clipping // Clipping
if ((x >= _width) || (y >= _height) || (h < 1)) return; if ((x < 0) || (x >= _width) || (y >= _height)) return;
if ((y + h - 1) >= _height) h = _height - y;
if (y < 0) { h += y; y = 0; }
if ((y + h) > _height) h = _height - y;
if (h < 1) return;
spi_begin(); spi_begin();
setAddrWindow(x, y, x, y + h - 1); setWindow(x, y, x, y + h - 1);
#ifdef RPI_WRITE_STROBE #ifdef RPI_WRITE_STROBE
#if defined (ESP8266) #if defined (ESP8266)
// SPI1U1 will already be set to transfer 16 bits by setAddrWindow() // SPI1U1 will already be set to transfer 16 bits by setWindow()
SPI1W0 = (color >> 8) | (color << 8); SPI1W0 = (color >> 8) | (color << 8);
SPI1CMD |= SPIBUSY; SPI1CMD |= SPIBUSY;
while(SPI1CMD & SPIBUSY) {} while(SPI1CMD & SPIBUSY) {}
@@ -3729,13 +3758,18 @@ void TFT_eSPI::drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color)
#if defined (ESP8266) && !defined (RPI_WRITE_STROBE) #if defined (ESP8266) && !defined (RPI_WRITE_STROBE)
void TFT_eSPI::drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color) void TFT_eSPI::drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color)
{ {
// Rudimentary clipping // Clipping
if ((x >= _width) || (y >= _height) || (w < 1)) return; if ((y < 0) || (x >= _width) || (y >= _height)) return;
if ((x + w - 1) >= _width) w = _width - x;
if (x < 0) { w += x; x = 0; }
if ((x + w) > _width) w = _width - x;
if (w < 1) return;
spi_begin(); spi_begin();
setAddrWindow(x, y, x + w - 1, y); setWindow(x, y, x + w - 1, y);
writeBlock(color, w); writeBlock(color, w);
@@ -3753,11 +3787,11 @@ void TFT_eSPI::drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color)
if ((x + w - 1) >= _width) w = _width - x; if ((x + w - 1) >= _width) w = _width - x;
spi_begin(); spi_begin();
setAddrWindow(x, y, x + w - 1, y); setWindow(x, y, x + w - 1, y);
#ifdef RPI_WRITE_STROBE #ifdef RPI_WRITE_STROBE
#if defined (ESP8266) #if defined (ESP8266)
// SPI1U1 will already be set to transfer 16 bits by setAddrWindow() // SPI1U1 will already be set to transfer 16 bits by setWindow()
SPI1W0 = (color >> 8) | (color << 8); SPI1W0 = (color >> 8) | (color << 8);
SPI1CMD |= SPIBUSY; SPI1CMD |= SPIBUSY;
while(SPI1CMD & SPIBUSY) {} while(SPI1CMD & SPIBUSY) {}
@@ -3787,13 +3821,19 @@ void TFT_eSPI::drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color)
#if defined (ESP8266) && !defined (RPI_WRITE_STROBE) #if defined (ESP8266) && !defined (RPI_WRITE_STROBE)
void TFT_eSPI::fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color) void TFT_eSPI::fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
{ {
// rudimentary clipping (drawChar w/big text requires this) // Clipping
if ((x > _width) || (y > _height) || (w < 1) || (h < 1)) return; if ((x >= _width) || (y >= _height)) return;
if ((x + w - 1) > _width) w = _width - x;
if ((y + h - 1) > _height) h = _height - y; if (x < 0) { w += x; x = 0; }
if (y < 0) { h += y; y = 0; }
if ((x + w) > _width) w = _width - x;
if ((y + h) > _height) h = _height - y;
if ((w < 1) || (h < 1)) return;
spi_begin(); spi_begin();
setAddrWindow(x, y, x + w - 1, y + h - 1); setWindow(x, y, x + w - 1, y + h - 1);
writeBlock(color, w * h); writeBlock(color, w * h);
@@ -3806,13 +3846,19 @@ void TFT_eSPI::fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t col
void TFT_eSPI::fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color) void TFT_eSPI::fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
{ {
// rudimentary clipping (drawChar w/big text requires this) // Clipping
if ((x > _width) || (y > _height) || (w < 1) || (h < 1)) return; if ((x >= _width) || (y >= _height)) return;
if ((x + w - 1) > _width) w = _width - x;
if ((y + h - 1) > _height) h = _height - y; if (x < 0) { w += x; x = 0; }
if (y < 0) { h += y; y = 0; }
if ((x + w) > _width) w = _width - x;
if ((y + h) > _height) h = _height - y;
if ((w < 1) || (h < 1)) return;
spi_begin(); spi_begin();
setAddrWindow(x, y, x + w - 1, y + h - 1); setWindow(x, y, x + w - 1, y + h - 1);
uint32_t n = (uint32_t)w * (uint32_t)h; uint32_t n = (uint32_t)w * (uint32_t)h;
@@ -3906,6 +3952,10 @@ size_t TFT_eSPI::write(uint8_t utf8)
if(fontLoaded) if(fontLoaded)
{ {
uint16_t unicode = decodeUTF8(utf8); uint16_t unicode = decodeUTF8(utf8);
//Serial.print("UniCode="); Serial.println(unicode);
//Serial.print("UTF8 ="); Serial.println(utf8);
if (!unicode) return 1; if (!unicode) return 1;
//fontFile = SPIFFS.open( _gFontFilename, "r" ); //fontFile = SPIFFS.open( _gFontFilename, "r" );
@@ -4176,7 +4226,7 @@ int16_t TFT_eSPI::drawChar(unsigned int uniCode, int x, int y, int font)
// Faster drawing of characters and background using block write // Faster drawing of characters and background using block write
{ {
spi_begin(); spi_begin();
setAddrWindow(x, y, (x + w * 8) - 1, y + height - 1); setWindow(x, y, (x + w * 8) - 1, y + height - 1);
uint8_t mask; uint8_t mask;
for (int i = 0; i < height; i++) for (int i = 0; i < height; i++)
@@ -4238,7 +4288,7 @@ int16_t TFT_eSPI::drawChar(unsigned int uniCode, int x, int y, int font)
} }
while (line--) { // In this case the while(line--) is faster while (line--) { // In this case the while(line--) is faster
pc++; // This is faster than putting pc+=line before while()? pc++; // This is faster than putting pc+=line before while()?
setAddrWindow(px, py, px + ts, py + ts); setWindow(px, py, px + ts, py + ts);
if (ts) { if (ts) {
tnp = np; tnp = np;
@@ -4267,7 +4317,7 @@ int16_t TFT_eSPI::drawChar(unsigned int uniCode, int x, int y, int font)
// so use faster drawing of characters and background using block write // so use faster drawing of characters and background using block write
{ {
//spi_begin(); //spi_begin();
setAddrWindow(x, y, x + width - 1, y + height - 1); setWindow(x, y, x + width - 1, y + height - 1);
#ifdef RPI_WRITE_STROBE #ifdef RPI_WRITE_STROBE
uint8_t textcolorBin[] = { (uint8_t) (textcolor >> 8), (uint8_t) textcolor }; uint8_t textcolorBin[] = { (uint8_t) (textcolor >> 8), (uint8_t) textcolor };
@@ -4282,7 +4332,7 @@ int16_t TFT_eSPI::drawChar(unsigned int uniCode, int x, int y, int font)
line &= 0x7F; line &= 0x7F;
line++; w -= line; line++; w -= line;
#ifdef RPI_WRITE_STROBE #ifdef RPI_WRITE_STROBE
SPI.writePattern(&textcolorBin[0], 2, 1); line--; spi.writePattern(&textcolorBin[0], 2, 1); line--;
while(line--) {WR_L; WR_H;} while(line--) {WR_L; WR_H;}
#else #else
#ifdef ESP32_PARALLEL #ifdef ESP32_PARALLEL
@@ -4295,7 +4345,7 @@ int16_t TFT_eSPI::drawChar(unsigned int uniCode, int x, int y, int font)
else { else {
line++; w -= line; line++; w -= line;
#ifdef RPI_WRITE_STROBE #ifdef RPI_WRITE_STROBE
SPI.writePattern(&textbgcolorBin[0], 2, 1); line--; spi.writePattern(&textbgcolorBin[0], 2, 1); line--;
while(line--) {WR_L; WR_H;} while(line--) {WR_L; WR_H;}
#else #else
#ifdef ESP32_PARALLEL #ifdef ESP32_PARALLEL
@@ -4927,56 +4977,56 @@ void writeBlock(uint16_t color, uint32_t repeat)
if (repeat > 19) if (repeat > 19)
{ {
SET_PERI_REG_BITS(SPI_MOSI_DLEN_REG(SPI_NUM), SPI_USR_MOSI_DBITLEN, 479, SPI_USR_MOSI_DBITLEN_S); SET_PERI_REG_BITS(SPI_MOSI_DLEN_REG(SPI_PORT), SPI_USR_MOSI_DBITLEN, 479, SPI_USR_MOSI_DBITLEN_S);
while(repeat>19) while(repeat>19)
{ {
while (READ_PERI_REG(SPI_CMD_REG(SPI_NUM))&SPI_USR); while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_W0_REG(SPI_NUM), r0); WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W1_REG(SPI_NUM), r1); WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W2_REG(SPI_NUM), r2); WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W3_REG(SPI_NUM), r0); WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W4_REG(SPI_NUM), r1); WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W5_REG(SPI_NUM), r2); WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W6_REG(SPI_NUM), r0); WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W7_REG(SPI_NUM), r1); WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W8_REG(SPI_NUM), r2); WRITE_PERI_REG(SPI_W8_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W9_REG(SPI_NUM), r0); WRITE_PERI_REG(SPI_W9_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W10_REG(SPI_NUM), r1); WRITE_PERI_REG(SPI_W10_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W11_REG(SPI_NUM), r2); WRITE_PERI_REG(SPI_W11_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W12_REG(SPI_NUM), r0); WRITE_PERI_REG(SPI_W12_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W13_REG(SPI_NUM), r1); WRITE_PERI_REG(SPI_W13_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W14_REG(SPI_NUM), r2); WRITE_PERI_REG(SPI_W14_REG(SPI_PORT), r2);
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_NUM), SPI_USR); SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
repeat -= 20; repeat -= 20;
} }
while (READ_PERI_REG(SPI_CMD_REG(SPI_NUM))&SPI_USR); while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
} }
if (repeat) if (repeat)
{ {
SET_PERI_REG_BITS(SPI_MOSI_DLEN_REG(SPI_NUM), SPI_USR_MOSI_DBITLEN, (repeat * 24) - 1, SPI_USR_MOSI_DBITLEN_S); SET_PERI_REG_BITS(SPI_MOSI_DLEN_REG(SPI_PORT), SPI_USR_MOSI_DBITLEN, (repeat * 24) - 1, SPI_USR_MOSI_DBITLEN_S);
WRITE_PERI_REG(SPI_W0_REG(SPI_NUM), r0); WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W1_REG(SPI_NUM), r1); WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W2_REG(SPI_NUM), r2); WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W3_REG(SPI_NUM), r0); WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W4_REG(SPI_NUM), r1); WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W5_REG(SPI_NUM), r2); WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), r2);
if (repeat > 8 ) if (repeat > 8 )
{ {
WRITE_PERI_REG(SPI_W6_REG(SPI_NUM), r0); WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W7_REG(SPI_NUM), r1); WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W8_REG(SPI_NUM), r2); WRITE_PERI_REG(SPI_W8_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W9_REG(SPI_NUM), r0); WRITE_PERI_REG(SPI_W9_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W10_REG(SPI_NUM), r1); WRITE_PERI_REG(SPI_W10_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W11_REG(SPI_NUM), r2); WRITE_PERI_REG(SPI_W11_REG(SPI_PORT), r2);
WRITE_PERI_REG(SPI_W12_REG(SPI_NUM), r0); WRITE_PERI_REG(SPI_W12_REG(SPI_PORT), r0);
WRITE_PERI_REG(SPI_W13_REG(SPI_NUM), r1); WRITE_PERI_REG(SPI_W13_REG(SPI_PORT), r1);
WRITE_PERI_REG(SPI_W14_REG(SPI_NUM), r2); WRITE_PERI_REG(SPI_W14_REG(SPI_PORT), r2);
} }
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_NUM), SPI_USR); SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
while (READ_PERI_REG(SPI_CMD_REG(SPI_NUM))&SPI_USR); while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
} }
} }
@@ -4990,39 +5040,39 @@ void writeBlock(uint16_t color, uint32_t repeat)
if (repeat > 31) // Revert legacy toggle buffer change if (repeat > 31) // Revert legacy toggle buffer change
{ {
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_NUM), 511); WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 511);
while(repeat>31) while(repeat>31)
{ {
while (READ_PERI_REG(SPI_CMD_REG(SPI_NUM))&SPI_USR); while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
WRITE_PERI_REG(SPI_W0_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W1_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W1_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W2_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W2_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W3_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W3_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W4_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W4_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W5_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W5_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W6_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W6_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W7_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W7_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W8_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W8_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W9_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W9_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W10_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W10_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W11_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W11_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W12_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W12_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W13_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W13_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W14_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W14_REG(SPI_PORT), color32);
WRITE_PERI_REG(SPI_W15_REG(SPI_NUM), color32); WRITE_PERI_REG(SPI_W15_REG(SPI_PORT), color32);
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_NUM), SPI_USR); SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
repeat -= 32; repeat -= 32;
} }
while (READ_PERI_REG(SPI_CMD_REG(SPI_NUM))&SPI_USR); while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
} }
if (repeat) if (repeat)
{ {
// Revert toggle buffer change // Revert toggle buffer change
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_NUM), (repeat << 4) - 1); WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), (repeat << 4) - 1);
for (uint32_t i=0; i <= (repeat>>1); i++) WRITE_PERI_REG((SPI_W0_REG(SPI_NUM) + (i << 2)), color32); for (uint32_t i=0; i <= (repeat>>1); i++) WRITE_PERI_REG((SPI_W0_REG(SPI_PORT) + (i << 2)), color32);
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_NUM), SPI_USR); SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR);
while (READ_PERI_REG(SPI_CMD_REG(SPI_NUM))&SPI_USR); while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
} }
} }
#endif #endif

82
TFT_eSPI.h
View File

@@ -105,7 +105,11 @@
#ifdef ESP32 #ifdef ESP32
#include "soc/spi_reg.h" #include "soc/spi_reg.h"
#define SPI_NUM 0x3 #ifdef USE_HSPI_PORT
#define SPI_PORT HSPI
#else
#define SPI_PORT VSPI
#endif
#endif #endif
#ifdef SMOOTH_FONT #ifdef SMOOTH_FONT
@@ -312,32 +316,32 @@
#elif defined (ILI9488_DRIVER) // 16 bit colour converted to 3 bytes for 18 bit RGB #elif defined (ILI9488_DRIVER) // 16 bit colour converted to 3 bytes for 18 bit RGB
// Write 8 bits to TFT // Write 8 bits to TFT
#define tft_Write_8(C) SPI.transfer(C) #define tft_Write_8(C) spi.transfer(C)
// Convert 16 bit colour to 18 bit and write in 3 bytes // Convert 16 bit colour to 18 bit and write in 3 bytes
#define tft_Write_16(C) SPI.transfer((C & 0xF800)>>8); \ #define tft_Write_16(C) spi.transfer((C & 0xF800)>>8); \
SPI.transfer((C & 0x07E0)>>3); \ spi.transfer((C & 0x07E0)>>3); \
SPI.transfer((C & 0x001F)<<3) spi.transfer((C & 0x001F)<<3)
// Convert swapped byte 16 bit colour to 18 bit and write in 3 bytes // Convert swapped byte 16 bit colour to 18 bit and write in 3 bytes
#define tft_Write_16S(C) SPI.transfer(C & 0xF8); \ #define tft_Write_16S(C) spi.transfer(C & 0xF8); \
SPI.transfer((C & 0xE0)>>11 | (C & 0x07)<<5); \ spi.transfer((C & 0xE0)>>11 | (C & 0x07)<<5); \
SPI.transfer((C & 0x1F00)>>5) spi.transfer((C & 0x1F00)>>5)
// Write 32 bits to TFT // Write 32 bits to TFT
#define tft_Write_32(C) SPI.write32(C) #define tft_Write_32(C) spi.write32(C)
#elif defined (RPI_ILI9486_DRIVER) #elif defined (RPI_ILI9486_DRIVER)
#define tft_Write_8(C) SPI.transfer(0); SPI.transfer(C) #define tft_Write_8(C) spi.transfer(0); spi.transfer(C)
#define tft_Write_16(C) SPI.write16(C) #define tft_Write_16(C) spi.write16(C)
#define tft_Write_16S(C) SPI.write16(C<<8 | C>>8) #define tft_Write_16S(C) spi.write16(C<<8 | C>>8)
#define tft_Write_32(C) SPI.write32(C) #define tft_Write_32(C) spi.write32(C)
#elif defined ESP8266 #elif defined ESP8266
#define tft_Write_8(C) SPI.write(C) #define tft_Write_8(C) spi.write(C)
#define tft_Write_16(C) SPI.write16(C) #define tft_Write_16(C) spi.write16(C)
#define tft_Write_32(C) SPI.write32(C) #define tft_Write_32(C) spi.write32(C)
#else // ESP32 using SPI with 16 bit color display #else // ESP32 using SPI with 16 bit color display
@@ -346,31 +350,31 @@
// Write 8 bits // Write 8 bits
#define tft_Write_8(C) \ #define tft_Write_8(C) \
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_NUM), 8-1); \ WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 8-1); \
WRITE_PERI_REG(SPI_W0_REG(SPI_NUM), C); \ WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), C); \
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_NUM), SPI_USR); \ SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR); \
while (READ_PERI_REG(SPI_CMD_REG(SPI_NUM))&SPI_USR); while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
// Write 16 bits with corrected endianess for 16 bit colours // Write 16 bits with corrected endianess for 16 bit colours
#define tft_Write_16(C) \ #define tft_Write_16(C) \
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_NUM), 16-1); \ WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 16-1); \
WRITE_PERI_REG(SPI_W0_REG(SPI_NUM), C<<8 | C>>8); \ WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), C<<8 | C>>8); \
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_NUM), SPI_USR); \ SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR); \
while (READ_PERI_REG(SPI_CMD_REG(SPI_NUM))&SPI_USR); while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
// Write 16 bits // Write 16 bits
#define tft_Write_16S(C) \ #define tft_Write_16S(C) \
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_NUM), 16-1); \ WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 16-1); \
WRITE_PERI_REG(SPI_W0_REG(SPI_NUM), C); \ WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), C); \
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_NUM), SPI_USR); \ SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR); \
while (READ_PERI_REG(SPI_CMD_REG(SPI_NUM))&SPI_USR); while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
// Write 32 bits // Write 32 bits
#define tft_Write_32(C) \ #define tft_Write_32(C) \
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_NUM), 32-1); \ WRITE_PERI_REG(SPI_MOSI_DLEN_REG(SPI_PORT), 32-1); \
WRITE_PERI_REG(SPI_W0_REG(SPI_NUM), C); \ WRITE_PERI_REG(SPI_W0_REG(SPI_PORT), C); \
SET_PERI_REG_MASK(SPI_CMD_REG(SPI_NUM), SPI_USR); \ SET_PERI_REG_MASK(SPI_CMD_REG(SPI_PORT), SPI_USR); \
while (READ_PERI_REG(SPI_CMD_REG(SPI_NUM))&SPI_USR); while (READ_PERI_REG(SPI_CMD_REG(SPI_PORT))&SPI_USR);
#endif #endif
@@ -383,7 +387,7 @@
#define SCLK_H GPOS=sclkpinmask #define SCLK_H GPOS=sclkpinmask
#else #else
// Use a SPI read transfer // Use a SPI read transfer
#define tft_Read_8() SPI.transfer(0) #define tft_Read_8() spi.transfer(0)
#endif #endif
#endif #endif
@@ -650,7 +654,7 @@ class TFT_eSPI : public Print {
width(void); width(void);
// The TFT_eSprite class inherits the following functions // The TFT_eSprite class inherits the following functions
void setWindow(int16_t x0, int16_t y0, int16_t x1, int16_t y1), void setWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye),
pushColor(uint16_t color), pushColor(uint16_t color),
pushColor(uint16_t color, uint32_t len), pushColor(uint16_t color, uint32_t len),
pushColors(uint16_t *data, uint32_t len, bool swap = true), // With byte swap option pushColors(uint16_t *data, uint32_t len, bool swap = true), // With byte swap option
@@ -776,11 +780,11 @@ class TFT_eSPI : public Print {
fontHeight(int16_t font), fontHeight(int16_t font),
fontHeight(void); fontHeight(void);
void setAddrWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye); void setAddrWindow(int32_t xs, int32_t ys, int32_t w, int32_t h);
// These 3 functions are used together, for every startWrite() there must be an endWrite() // Compatibility additions (non-essential)
void startWrite(void); // Begin SPI transaction void startWrite(void); // Begin SPI transaction (not normally needed)
void writeColor(uint16_t color, uint32_t len); // Write a colour without transaction overhead void writeColor(uint16_t color, uint32_t len); // Write colours without transaction overhead
void endWrite(void); // End SPI transaction void endWrite(void); // End SPI transaction
size_t write(uint8_t); size_t write(uint8_t);
@@ -816,7 +820,7 @@ class TFT_eSPI : public Print {
inline void spi_begin_read() __attribute__((always_inline)); inline void spi_begin_read() __attribute__((always_inline));
inline void spi_end_read() __attribute__((always_inline)); inline void spi_end_read() __attribute__((always_inline));
void readAddrWindow(int32_t xs, int32_t ys, int32_t xe, int32_t ye); void readAddrWindow(int32_t xs, int32_t ys, int32_t w, int32_t h);
uint8_t tabcolor, uint8_t tabcolor,
colstart = 0, rowstart = 0; // some ST7735 displays need this changed colstart = 0, rowstart = 0; // some ST7735 displays need this changed

4
User_Setup.h
View File

@@ -262,6 +262,10 @@
// The XPT2046 requires a lower SPI clock rate of 2.5MHz so we define that here: // The XPT2046 requires a lower SPI clock rate of 2.5MHz so we define that here:
#define SPI_TOUCH_FREQUENCY 2500000 #define SPI_TOUCH_FREQUENCY 2500000
// The ESP32 has 2 free SPI ports i.e. VSPI and HSPI, the VSPI is the default.
// If the VSPI port is in use and pins are not accessible (e.g. TTGO T-Beam)
// then uncomment the following line:
//#define USE_HSPI_PORT
// Comment out the following #define if "SPI Transactions" do not need to be // Comment out the following #define if "SPI Transactions" do not need to be
// supported. When commented out the code size will be smaller and sketches will // supported. When commented out the code size will be smaller and sketches will

4
User_Setups/SetupX_Template.h
View File

@@ -262,6 +262,10 @@
// The XPT2046 requires a lower SPI clock rate of 2.5MHz so we define that here: // The XPT2046 requires a lower SPI clock rate of 2.5MHz so we define that here:
#define SPI_TOUCH_FREQUENCY 2500000 #define SPI_TOUCH_FREQUENCY 2500000
// The ESP32 has 2 free SPI ports i.e. VSPI and HSPI, the VSPI is the default.
// If the VSPI port is in use and pins are not accessible (e.g. TTGO T-Beam)
// then uncomment the following line to use the HSPI port:
//#define USE_HSPI_PORT
// Comment out the following #define if "SPI Transactions" do not need to be // Comment out the following #define if "SPI Transactions" do not need to be
// supported. When commented out the code size will be smaller and sketches will // supported. When commented out the code size will be smaller and sketches will

6
examples/160 x 128/Pong_v3/Pong_v3.ino
View File

@@ -107,13 +107,17 @@ void midline() {
// If the ball is not on the line then don't redraw the line // If the ball is not on the line then don't redraw the line
if ((ball_x<dashline_x-ball_w) && (ball_x > dashline_x+dashline_w)) return; if ((ball_x<dashline_x-ball_w) && (ball_x > dashline_x+dashline_w)) return;
tft.startWrite();
// Quick way to draw a dashed line // Quick way to draw a dashed line
tft.setAddrWindow(dashline_x,0,dashline_x+dashline_w-1,h); tft.setAddrWindow(dashline_x, 0, dashline_w, h);
for(int16_t i = 0; i < dashline_n; i+=2) { for(int16_t i = 0; i < dashline_n; i+=2) {
tft.pushColor(WHITE, dashline_w*dashline_h); // push dash pixels tft.pushColor(WHITE, dashline_w*dashline_h); // push dash pixels
tft.pushColor(BLACK, dashline_w*dashline_h); // push gap pixels tft.pushColor(BLACK, dashline_w*dashline_h); // push gap pixels
} }
tft.endWrite();
} }
void lpaddle() { void lpaddle() {

6
examples/160 x 128/TFT_graphicstest_PDQ3/TFT_graphicstest_PDQ3.ino
View File

@@ -313,9 +313,11 @@ uint32_t testHaD()
uint32_t start = micros_start(); uint32_t start = micros_start();
tft.startWrite();
for (int i = 0; i < 0x10; i++) for (int i = 0; i < 0x10; i++)
{ {
tft.setAddrWindow(0, 0, tft.width()-1, tft.height()-1); tft.setAddrWindow(0, 0, tft.width(), tft.height());
uint16_t cnt = 0; uint16_t cnt = 0;
uint16_t color = tft.color565((i << 4) | i, (i << 4) | i, (i << 4) | i); uint16_t color = tft.color565((i << 4) | i, (i << 4) | i, (i << 4) | i);
@@ -335,6 +337,8 @@ uint32_t testHaD()
} }
} }
tft.endWrite();
uint32_t t = micros() - start; uint32_t t = micros() - start;
tft.setTextColor(TFT_YELLOW); tft.setTextColor(TFT_YELLOW);

11
examples/320 x 240/TFT_Mandlebrot/TFT_Mandlebrot.ino
View File

@@ -7,7 +7,7 @@
TFT_eSPI tft = TFT_eSPI(); // Invoke custom library TFT_eSPI tft = TFT_eSPI(); // Invoke custom library
#define ILI9341_GREY 0x7BEF #define TFT_GREY 0x7BEF
unsigned long runTime = 0; unsigned long runTime = 0;
@@ -16,8 +16,9 @@ uint16_t x0 = 0, x1 = 0, yy0 = 0, yy1 = 0;
void setup() void setup()
{ {
Serial.begin(250000);
//randomSeed(analogRead(A0)); //randomSeed(analogRead(A0));
Serial.println();
// Setup the LCD // Setup the LCD
tft.init(); tft.init();
tft.setRotation(3); tft.setRotation(3);
@@ -27,7 +28,8 @@ void loop()
{ {
runTime = millis(); runTime = millis();
tft.fillScreen(ILI9341_BLACK); tft.fillScreen(TFT_BLACK);
tft.startWrite();
for (int px = 1; px < 320; px++) for (int px = 1; px < 320; px++)
{ {
for (int py = 0; py < 240; py++) for (int py = 0; py < 240; py++)
@@ -49,6 +51,9 @@ void loop()
yield();tft.drawPixel(px, py, color); yield();tft.drawPixel(px, py, color);
} }
} }
tft.endWrite();
Serial.println(millis()-runTime);
while(1) yield(); while(1) yield();
} }

6
examples/320 x 240/TFT_Pong/TFT_Pong.ino
View File

@@ -108,13 +108,17 @@ void midline() {
// If the ball is not on the line then don't redraw the line // If the ball is not on the line then don't redraw the line
if ((ball_x<dashline_x-ball_w) && (ball_x > dashline_x+dashline_w)) return; if ((ball_x<dashline_x-ball_w) && (ball_x > dashline_x+dashline_w)) return;
tft.startWrite();
// Quick way to draw a dashed line // Quick way to draw a dashed line
tft.setWindow(dashline_x,0,dashline_x+dashline_w-1,h); tft.setAddrWindow(dashline_x, 0, dashline_w, h);
for(int16_t i = 0; i < dashline_n; i+=2) { for(int16_t i = 0; i < dashline_n; i+=2) {
tft.pushColor(WHITE, dashline_w*dashline_h); // push dash pixels tft.pushColor(WHITE, dashline_w*dashline_h); // push dash pixels
tft.pushColor(BLACK, dashline_w*dashline_h); // push gap pixels tft.pushColor(BLACK, dashline_w*dashline_h); // push gap pixels
} }
tft.endWrite();
} }
void lpaddle() { void lpaddle() {

4
examples/320 x 240/TFT_graphicstest_PDQ/TFT_graphicstest_PDQ.ino
View File

@@ -339,7 +339,7 @@ uint32_t testHaD()
for (int i = 0; i < 0x10; i++) for (int i = 0; i < 0x10; i++)
{ {
tft.setWindow(0, 0, 240-1, 320-1); tft.setAddrWindow(0, 0, 240, 320);
uint16_t cnt = 0; uint16_t cnt = 0;
uint16_t color = tft.color565((i << 4) | i, (i << 4) | i, (i << 4) | i); uint16_t color = tft.color565((i << 4) | i, (i << 4) | i, (i << 4) | i);
@@ -347,6 +347,7 @@ uint32_t testHaD()
const uint8_t *cmp = &HaD_240x320[0]; const uint8_t *cmp = &HaD_240x320[0];
tft.startWrite();
while (cmp < &HaD_240x320[sizeof(HaD_240x320)]) while (cmp < &HaD_240x320[sizeof(HaD_240x320)])
{ {
cnt = pgm_read_byte(cmp++); cnt = pgm_read_byte(cmp++);
@@ -354,6 +355,7 @@ uint32_t testHaD()
tft.pushColor(curcolor, cnt); // PDQ_GFX has count tft.pushColor(curcolor, cnt); // PDQ_GFX has count
curcolor ^= color; curcolor ^= color;
} }
tft.endWrite();
} }
uint32_t t = micros() - start; uint32_t t = micros() - start;

7
examples/480 x 320/TFT_flash_jpg/TFT_flash_jpg.ino
View File

@@ -171,11 +171,14 @@ void renderJPEG(int xpos, int ypos) {
// calculate how many pixels must be drawn // calculate how many pixels must be drawn
uint32_t mcu_pixels = win_w * win_h; uint32_t mcu_pixels = win_w * win_h;
tft.startWrite();
// draw image MCU block only if it will fit on the screen // draw image MCU block only if it will fit on the screen
if (( mcu_x + win_w ) <= tft.width() && ( mcu_y + win_h ) <= tft.height()) if (( mcu_x + win_w ) <= tft.width() && ( mcu_y + win_h ) <= tft.height())
{ {
// Now set a MCU bounding window on the TFT to push pixels into (x, y, x + width - 1, y + height - 1) // Now set a MCU bounding window on the TFT to push pixels into (x, y, x + width - 1, y + height - 1)
tft.setWindow(mcu_x, mcu_y, mcu_x + win_w - 1, mcu_y + win_h - 1); tft.setAddrWindow(mcu_x, mcu_y, win_w, win_h);
// Write all MCU pixels to the TFT window // Write all MCU pixels to the TFT window
while (mcu_pixels--) { while (mcu_pixels--) {
@@ -185,6 +188,8 @@ void renderJPEG(int xpos, int ypos) {
} }
else if ( (mcu_y + win_h) >= tft.height()) JpegDec.abort(); // Image has run off bottom of screen so abort decoding else if ( (mcu_y + win_h) >= tft.height()) JpegDec.abort(); // Image has run off bottom of screen so abort decoding
tft.endWrite();
} }
// calculate how long it took to draw the image // calculate how long it took to draw the image

6
examples/480 x 320/TFT_ring_meter/TFT_ring_meter.ino
View File

@@ -251,8 +251,10 @@ void drawIcon(const unsigned short* icon, int16_t x, int16_t y, int8_t width, in
uint16_t pix_buffer[BUFF_SIZE]; // Pixel buffer (16 bits per pixel) uint16_t pix_buffer[BUFF_SIZE]; // Pixel buffer (16 bits per pixel)
tft.startWrite();
// Set up a window the right size to stream pixels into // Set up a window the right size to stream pixels into
tft.setWindow(x, y, x + width - 1, y + height - 1); tft.setAddrWindow(x, y, width, height);
// Work out the number whole buffers to send // Work out the number whole buffers to send
uint16_t nb = ((uint16_t)height * width) / BUFF_SIZE; uint16_t nb = ((uint16_t)height * width) / BUFF_SIZE;
@@ -273,5 +275,7 @@ void drawIcon(const unsigned short* icon, int16_t x, int16_t y, int8_t width, in
for (int i = 0; i < np; i++) pix_buffer[i] = pgm_read_word(&icon[nb * BUFF_SIZE + i]); for (int i = 0; i < np; i++) pix_buffer[i] = pgm_read_word(&icon[nb * BUFF_SIZE + i]);
tft.pushColors(pix_buffer, np); tft.pushColors(pix_buffer, np);
} }
tft.endWrite();
} }

2
library.json
View File

@@ -1,6 +1,6 @@
{ {
"name": "TFT_eSPI", "name": "TFT_eSPI",
"version": "1.3.13", "version": "1.4.0",
"keywords": "tft, ePaper, display, ESP8266, NodeMCU, ESP32, M5Stack, ILI9341, ST7735, ILI9163, S6D02A1, ILI9486, ST7789", "keywords": "tft, ePaper, display, ESP8266, NodeMCU, ESP32, M5Stack, ILI9341, ST7735, ILI9163, S6D02A1, ILI9486, ST7789",
"description": "A TFT and ePaper SPI graphics library for ESP8266 and ESP32", "description": "A TFT and ePaper SPI graphics library for ESP8266 and ESP32",
"repository": "repository":

2
library.properties
View File

@@ -1,5 +1,5 @@
name=TFT_eSPI name=TFT_eSPI
version=1.3.13 version=1.4.0
author=Bodmer author=Bodmer
maintainer=Bodmer maintainer=Bodmer
sentence=A fast TFT graphics library for ESP8266 and ESP32 processors for the Arduino IDE sentence=A fast TFT graphics library for ESP8266 and ESP32 processors for the Arduino IDE