kuba/TEF6686_ESP32
1
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

Compare commits

base: kuba:f9b53f170e9e0ef8f51fbf19db678e8725374d12
Branches Tags
kuba:main
kuba:spiffs_release
...
compare: kuba:bb0675b8a3c490936ee7103113b993a380fb9e33
Branches Tags
kuba:main
kuba:spiffs_release

3 Commits
f9b53f170e ... bb0675b8a3

Author SHA1 Message Date
KubaPro010
bb0675b8a3 better spi 2026-01-19 17:08:41 +01:00
KubaPro010
c322badd37 no arduino spi in tft_espi 2026-01-19 09:59:08 +01:00
KubaPro010
a3addcb21c more dma in tft driver 2026-01-18 23:05:06 +01:00
3 changed files with 143 additions and 371 deletions
Expand all files Collapse all files

454
lib/TFT_eSPI/TFT_eSPI.cpp
View File

@@ -1,16 +1,34 @@
#include "TFT_eSPI.h"
#include <Arduino.h>
#include <SPI.h>
SPIClass spi = SPIClass(VSPI);
spi_device_handle_t dmaHAL;
spi_host_device_t spi_host = VSPI_HOST;
#include "soc/dport_access.h"
#include "soc/dport_reg.h"
volatile uint32_t* _spi_cmd = (volatile uint32_t*)(SPI_CMD_REG(VSPI));
volatile uint32_t* _spi_ctrl = (volatile uint32_t*)(SPI_CTRL_REG(VSPI));
volatile uint32_t* _spi_user = (volatile uint32_t*)(SPI_USER_REG(VSPI));
volatile uint32_t* _spi_mosi_dlen = (volatile uint32_t*)(SPI_MOSI_DLEN_REG(VSPI));
volatile uint32_t* _spi_miso_dlen = (volatile uint32_t*)(SPI_MISO_DLEN_REG(VSPI));
volatile uint32_t* _spi_w = (volatile uint32_t*)(SPI_W0_REG(VSPI));
volatile uint32_t* _spi_clock = (volatile uint32_t*)(SPI_CLOCK_REG(VSPI));
uint8_t transfer(uint8_t val) {
SPI_BUSY_CHECK;
*_spi_miso_dlen = 7;
tft_Write_8(val);
return *_spi_w & 0xff;
}
#define MSB_16_SET(var) { (var) = (((var) & 0xFF00) >> 8) | (((var) & 0xFF) << 8); }
uint16_t transfer16(uint16_t val) {
SPI_BUSY_CHECK;
if(!(*_spi_ctrl & SPI_WR_BIT_ORDER)) MSB_16_SET(val);
*_spi_miso_dlen = 15;
tft_Write_16S(val);
uint16_t out = *_spi_w & 0xffff;
if(!(*_spi_ctrl & SPI_RD_BIT_ORDER)) MSB_16_SET(out);
return out;
}
void TFT_eSPI::pushBlock(uint16_t color, uint32_t len) {
@@ -18,7 +36,7 @@ void TFT_eSPI::pushBlock(uint16_t color, uint32_t len) {
uint32_t color32 = (color<<8 | color >>8)<<16 | (color<<8 | color >>8);
uint32_t i = 0;
uint32_t rem = len & 0x1F;
len = len - rem;
len = len - rem;
if (rem) {
while (*_spi_cmd&SPI_USR);
@@ -50,7 +68,7 @@ void TFT_eSPI::pushSwapBytePixels(const void* data_in, uint32_t len) {
uint32_t i = 0;
while(i<16) {
color[i++] = DAT8TO32(data);
data+=4;
data += 4;
}
while (READ_PERI_REG(SPI_CMD_REG(VSPI))&SPI_USR);
WRITE_PERI_REG(SPI_W0_REG(VSPI), color[0]);
@@ -74,13 +92,11 @@ void TFT_eSPI::pushSwapBytePixels(const void* data_in, uint32_t len) {
}
}
if (len > 15)
{
if (len > 15) {
uint32_t i = 0;
while(i<8)
{
while(i<8) {
color[i++] = DAT8TO32(data);
data+=4;
data +=4 ;
}
while (READ_PERI_REG(SPI_CMD_REG(VSPI))&SPI_USR);
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(VSPI), 255);
@@ -96,12 +112,11 @@ void TFT_eSPI::pushSwapBytePixels(const void* data_in, uint32_t len) {
len -= 16;
}
if (len)
{
if (len) {
while (READ_PERI_REG(SPI_CMD_REG(VSPI))&SPI_USR);
WRITE_PERI_REG(SPI_MOSI_DLEN_REG(VSPI), (len << 4) - 1);
for (uint32_t i=0; i <= (len<<1); i+=4) {
WRITE_PERI_REG(SPI_W0_REG(VSPI)+i, DAT8TO32(data)); data+=4;
WRITE_PERI_REG(SPI_W0_REG(VSPI)+i, DAT8TO32(data)); data += 4;
}
SET_PERI_REG_MASK(SPI_CMD_REG(VSPI), SPI_USR);
}
@@ -152,67 +167,6 @@ void TFT_eSPI::pushPixels(const void* data_in, uint32_t len){
while (READ_PERI_REG(SPI_CMD_REG(VSPI))&SPI_USR);
}
void TFT_eSPI::dmaWait()
{
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;
}
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,
.data4_io_num = -1,
.data5_io_num = -1,
.data6_io_num = -1,
.data7_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 = SPI_MODE0,
.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,
.post_cb = 0
};
ret = spi_bus_initialize(spi_host, &buscfg, 1);
ESP_ERROR_CHECK(ret);
ret = spi_bus_add_device(spi_host, &devcfg, &dmaHAL);
ESP_ERROR_CHECK(ret);
DMA_Enabled = true;
spiBusyCheck = 0;
return true;
}
// Clipping macro for pushImage
#define PI_CLIP \
if (_vpOoB) return; \
@@ -236,65 +190,37 @@ bool TFT_eSPI::initDMA(bool ctrl_cs)
inline void TFT_eSPI::begin_tft_write() {
if (locked) {
locked = false; // Flag to show SPI access now unlocked
spi.beginTransaction(SPISettings(spi_write_speed * 1000000, MSBFIRST, SPI_MODE0));
CS_L;
SET_BUS_WRITE_MODE;
}
SPI_SET_CLOCK_FREQ(spi_write_speed * 1000000);
CS_L;
SET_BUS_WRITE_MODE;
}
void TFT_eSPI::begin_nin_write() {
if (locked) {
locked = false; // Flag to show SPI access now unlocked
spi.beginTransaction(SPISettings(spi_write_speed * 1000000, MSBFIRST, SPI_MODE0));
CS_L;
SET_BUS_WRITE_MODE;
}
SPI_SET_CLOCK_FREQ(spi_write_speed * 1000000);
CS_L;
SET_BUS_WRITE_MODE;
}
inline void TFT_eSPI::end_tft_write() {
if(!inTransaction) { // Flag to stop ending transaction during multiple graphics calls
if (!locked) { // Locked when beginTransaction has been called
locked = true; // Flag to show SPI access now locked
SPI_BUSY_CHECK; // Check send complete and clean out unused rx data
CS_H;
SET_BUS_READ_MODE; // In case bus has been configured for tx only
spi.endTransaction();
}
}
SPI_BUSY_CHECK; // Check send complete and clean out unused rx data
CS_H;
SET_BUS_READ_MODE; // In case bus has been configured for tx only
}
inline void TFT_eSPI::end_nin_write() {
if(!inTransaction) { // Flag to stop ending transaction during multiple graphics calls
if (!locked) { // Locked when beginTransaction has been called
locked = true; // Flag to show SPI access now locked
SPI_BUSY_CHECK; // Check send complete and clean out unused rx data
CS_H;
SET_BUS_READ_MODE; // In case SPI has been configured for tx only
spi.endTransaction();
}
}
SPI_BUSY_CHECK; // Check send complete and clean out unused rx data
CS_H;
SET_BUS_READ_MODE; // In case SPI has been configured for tx only
}
inline void TFT_eSPI::begin_tft_read() {
dmaWait();
if (locked) {
locked = false;
spi.beginTransaction(SPISettings(SPI_READ_FREQUENCY, MSBFIRST, SPI_MODE0));
CS_L;
}
SPI_SET_CLOCK_FREQ(SPI_READ_FREQUENCY);
CS_L;
SET_BUS_READ_MODE;
}
inline void TFT_eSPI::end_tft_read() {
if(!inTransaction) {
if (!locked) {
locked = true;
CS_H;
spi.endTransaction();
}
}
CS_H;
SET_BUS_WRITE_MODE;
}
@@ -373,8 +299,7 @@ bool TFT_eSPI::clipWindow(int32_t *xs, int32_t *ys, int32_t *xe, int32_t *ye)
return true; // Area is wholly or partially inside viewport
}
TFT_eSPI::TFT_eSPI(int16_t w, int16_t h)
{
TFT_eSPI::TFT_eSPI(int16_t w, int16_t h) {
_init_width = _width = w;
_init_height = _height = h;
@@ -393,10 +318,6 @@ TFT_eSPI::TFT_eSPI(int16_t w, int16_t h)
_swapBytes = false;
locked = true;
inTransaction = false;
lockTransaction = false;
booted = true;
addr_row = 0xFFFF;
@@ -432,20 +353,24 @@ if (TOUCH_CS >= 0) {
}
}
void TFT_eSPI::init()
{
void TFT_eSPI::init() {
if (booted) {
initBus();
#if defined (TFT_MOSI) && !defined (TFT_SPI_OVERLAP)
spi.begin(TFT_SCLK, TFT_MISO, TFT_MOSI, -1); // This will set MISO to input
#else
spi.begin(); // This will set MISO to input
#endif
lockTransaction = false;
inTransaction = false;
locked = true;
DPORT_SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_SPI3_CLK_EN);
DPORT_CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_SPI3_RST);
SET_BUS_READ_MODE;
*_spi_ctrl = 0;
for(int i = 0; i < 16; i++) _spi_w[i] = 0;
SPI_SET_CLOCK_FREQ(SPI_FREQUENCY);
pinMode(TFT_SCLK, OUTPUT);
pinMode(TFT_MOSI, OUTPUT);
pinMode(TFT_MISO, INPUT);
pinMatrixOutAttach(TFT_SCLK, VSPICLK_OUT_IDX, false, false);
pinMatrixInAttach(TFT_MISO, VSPID_IN_IDX, false);
pinMatrixOutAttach(TFT_MOSI, VSPID_IN_IDX, false, false);
SET_PERI_REG_MASK(SPI_DMA_CONF_REG(VSPI), SPI_DMA_RX_EN | SPI_DMA_TX_EN);
#if defined (TFT_CS)
// Set to output once again in case MISO is used for CS
@@ -540,9 +465,6 @@ uint16_t TFT_eSPI::readPixel(int32_t x0, int32_t y0) {
// Range checking
if ((x0 < _vpX) || (y0 < _vpY) ||(x0 >= _vpW) || (y0 >= _vpH)) return 0;
// This function can get called during anti-aliased font rendering
// so a transaction may be in progress
bool wasInTransaction = inTransaction;
if (inTransaction) { inTransaction= false; end_tft_write();}
uint16_t color = 0;
@@ -563,9 +485,6 @@ uint16_t TFT_eSPI::readPixel(int32_t x0, int32_t y0) {
end_tft_read();
// Reinstate the transaction if one was in progress
if(wasInTransaction) { begin_tft_write(); inTransaction = true; }
return color;
}
@@ -573,7 +492,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *d
PI_CLIP;
begin_tft_write();
inTransaction = true;
setWindow(x, y, x + dw - 1, y + dh - 1);
@@ -589,7 +507,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *d
}
}
inTransaction = lockTransaction;
end_tft_write();
}
@@ -597,7 +514,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *d
PI_CLIP;
begin_tft_write();
inTransaction = true;
data += dx + dy * w;
@@ -637,7 +553,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint16_t *d
data += w;
}
inTransaction = lockTransaction;
end_tft_write();
}
@@ -645,7 +560,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint1
PI_CLIP;
begin_tft_write();
inTransaction = true;
data += dx + dy * w;
@@ -659,7 +573,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint1
pushPixels(buffer, dw);
}
inTransaction = lockTransaction;
end_tft_write();
}
@@ -667,7 +580,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint1
PI_CLIP;
begin_tft_write();
inTransaction = true;
data += dx + dy * w;
@@ -707,7 +619,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint1
data += w;
}
inTransaction = lockTransaction;
end_tft_write();
}
@@ -715,7 +626,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint8
PI_CLIP;
begin_tft_write();
inTransaction = true;
bool swap = _swapBytes;
setWindow(x, y, x + dw - 1, y + dh - 1); // Sets CS low and sent RAMWR
@@ -818,7 +728,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint8
}
_swapBytes = swap; // Restore old value
inTransaction = lockTransaction;
end_tft_write();
}
@@ -827,7 +736,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint8_t *da
PI_CLIP;
begin_tft_write();
inTransaction = true;
bool swap = _swapBytes;
setWindow(x, y, x + dw - 1, y + dh - 1); // Sets CS low and sent RAMWR
@@ -933,7 +841,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint8_t *da
}
_swapBytes = swap; // Restore old value
inTransaction = lockTransaction;
end_tft_write();
}
@@ -942,7 +849,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint8_t *da
PI_CLIP;
begin_tft_write();
inTransaction = true;
bool swap = _swapBytes;
@@ -1125,7 +1031,6 @@ void TFT_eSPI::pushImage(int32_t x, int32_t y, int32_t w, int32_t h, uint8_t *da
}
}
_swapBytes = swap; // Restore old value
inTransaction = lockTransaction;
end_tft_write();
}
@@ -1146,8 +1051,6 @@ void TFT_eSPI::drawCircleHelper( int32_t x0, int32_t y0, int32_t rr, uint8_t cor
int32_t xs = 0;
int32_t len = 0;
inTransaction = true;
do {
while (f < 0) {
++xe;
@@ -1195,7 +1098,6 @@ void TFT_eSPI::drawCircleHelper( int32_t x0, int32_t y0, int32_t rr, uint8_t cor
xs = xe;
} while (xe < rr--);
inTransaction = lockTransaction;
end_tft_write(); // Does nothing if Sprite class uses this function
}
@@ -1205,9 +1107,6 @@ void TFT_eSPI::fillCircle(int32_t x0, int32_t y0, int32_t r, uint32_t color) {
int32_t dy = r+r;
int32_t p = -(r>>1);
//begin_tft_write(); // Sprite class can use this function, avoiding begin_tft_write()
inTransaction = true;
drawFastHLine(x0 - r, y0, dy+1, color);
while(x<r){
@@ -1229,7 +1128,6 @@ void TFT_eSPI::fillCircle(int32_t x0, int32_t y0, int32_t r, uint32_t color) {
}
inTransaction = lockTransaction;
end_tft_write(); // Does nothing if Sprite class uses this function
}
@@ -1269,8 +1167,6 @@ void TFT_eSPI::drawEllipse(int16_t x0, int16_t y0, int32_t rx, int32_t ry, uint1
int32_t fy2 = 4 * ry2;
int32_t s;
inTransaction = true;
for (x = 0, y = ry, s = 2*ry2+rx2*(1-2*ry); ry2*x <= rx2*y; x++) {
// These are ordered to minimise coordinate changes in x or y
// drawPixel can then send fewer bounding box commands
@@ -1299,7 +1195,6 @@ void TFT_eSPI::drawEllipse(int16_t x0, int16_t y0, int32_t rx, int32_t ry, uint1
s += rx2 * ((4 * y) + 6);
}
inTransaction = lockTransaction;
end_tft_write(); // Does nothing if Sprite class uses this function
}
@@ -1314,8 +1209,6 @@ void TFT_eSPI::fillEllipse(int16_t x0, int16_t y0, int32_t rx, int32_t ry, uint1
int32_t fy2 = 4 * ry2;
int32_t s;
inTransaction = true;
for (x = 0, y = ry, s = 2*ry2+rx2*(1-2*ry); ry2*x <= rx2*y; x++) {
drawFastHLine(x0 - x, y0 - y, x + x + 1, color);
drawFastHLine(x0 - x, y0 + y, x + x + 1, color);
@@ -1338,7 +1231,6 @@ void TFT_eSPI::fillEllipse(int16_t x0, int16_t y0, int32_t rx, int32_t ry, uint1
s += rx2 * ((4 * y) + 6);
}
inTransaction = lockTransaction;
end_tft_write(); // Does nothing if Sprite class uses this function
}
@@ -1347,24 +1239,17 @@ void TFT_eSPI::fillScreen(uint32_t color) {
fillRect(0, 0, _width, _height, color);
}
void TFT_eSPI::drawRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
{
inTransaction = true;
void TFT_eSPI::drawRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color) {
drawFastHLine(x, y, w, color);
drawFastHLine(x, y + h - 1, w, color);
drawFastVLine(x, y+1, h-2, color);
drawFastVLine(x + w - 1, y+1, h-2, color);
inTransaction = lockTransaction;
end_tft_write(); // Does nothing if Sprite class uses this function
}
void TFT_eSPI::drawRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t r, uint32_t color)
{
//begin_tft_write(); // Sprite class can use this function, avoiding begin_tft_write()
inTransaction = true;
void TFT_eSPI::drawRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t r, uint32_t color) {
// smarter version
drawFastHLine(x + r , y , w - r - r, color); // Top
drawFastHLine(x + r , y + h - 1, w - r - r, color); // Bottom
@@ -1376,15 +1261,10 @@ void TFT_eSPI::drawRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t
drawCircleHelper(x + w - r - 1, y + h - r - 1, r, 4, color);
drawCircleHelper(x + r , y + h - r - 1, r, 8, color);
inTransaction = lockTransaction;
end_tft_write(); // Does nothing if Sprite class uses this function
}
void TFT_eSPI::fillRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t r, uint32_t color)
{
//begin_tft_write(); // Sprite class can use this function, avoiding begin_tft_write()
inTransaction = true;
void TFT_eSPI::fillRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t r, uint32_t color) {
// smarter version
fillRect(x, y + r, w, h - r - r, color);
@@ -1392,16 +1272,10 @@ void TFT_eSPI::fillRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t
fillCircleHelper(x + r, y + h - r - 1, r, 1, w - r - r - 1, color);
fillCircleHelper(x + r , y + r, r, 2, w - r - r - 1, color);
inTransaction = lockTransaction;
end_tft_write(); // Does nothing if Sprite class uses this function
}
/***************************************************************************************
** Function name: fillTriangle
** Description: Draw a filled triangle using 3 arbitrary points
***************************************************************************************/
// Fill a triangle - original Adafruit function works well and code footprint is small
void TFT_eSPI::fillTriangle ( int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t x2, int32_t y2, uint32_t color)
{
int32_t a, b, y, last;
@@ -1427,9 +1301,6 @@ void TFT_eSPI::fillTriangle ( int32_t x0, int32_t y0, int32_t x1, int32_t y1, in
return;
}
//begin_tft_write(); // Sprite class can use this function, avoiding begin_tft_write()
inTransaction = true;
int32_t
dx01 = x1 - x0,
dy01 = y1 - y0,
@@ -1473,15 +1344,10 @@ void TFT_eSPI::fillTriangle ( int32_t x0, int32_t y0, int32_t x1, int32_t y1, in
drawFastHLine(a, y, b - a + 1, color);
}
inTransaction = lockTransaction;
end_tft_write(); // Does nothing if Sprite class uses this function
}
void TFT_eSPI::drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color)
{
//begin_tft_write(); // Sprite class can use this function, avoiding begin_tft_write()
inTransaction = true;
void TFT_eSPI::drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
int32_t i, j, byteWidth = (w + 7) / 8;
for (j = 0; j < h; j++) {
@@ -1490,15 +1356,10 @@ void TFT_eSPI::drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w
}
}
inTransaction = lockTransaction;
end_tft_write(); // Does nothing if Sprite class uses this function
}
void TFT_eSPI::drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t fgcolor, uint16_t bgcolor)
{
//begin_tft_write(); // Sprite class can use this function, avoiding begin_tft_write()
inTransaction = true;
void TFT_eSPI::drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t fgcolor, uint16_t bgcolor) {
int32_t i, j, byteWidth = (w + 7) / 8;
for (j = 0; j < h; j++) {
@@ -1509,7 +1370,6 @@ void TFT_eSPI::drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w
}
}
inTransaction = lockTransaction;
end_tft_write(); // Does nothing if Sprite class uses this function
}
@@ -1777,14 +1637,9 @@ void TFT_eSPI::pushColor(uint16_t color, uint32_t len)
void TFT_eSPI::startWrite() {
begin_tft_write();
lockTransaction = true; // Lock transaction for all sequentially run sketch functions
inTransaction = true;
}
void TFT_eSPI::endWrite() {
lockTransaction = false; // Release sketch induced transaction lock
inTransaction = false;
dmaWait(); // Safety check - user code should have checked this!
end_tft_write(); // Release SPI bus
}
@@ -1803,12 +1658,10 @@ void TFT_eSPI::pushColors(uint16_t *data, uint32_t len, bool swap)
end_tft_write();
}
void TFT_eSPI::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t color)
{
void TFT_eSPI::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t color) {
if (_vpOoB) return;
//begin_tft_write(); // Sprite class can use this function, avoiding begin_tft_write()
inTransaction = true;
bool steep = abs(y1 - y0) > abs(x1 - x0);
if (steep) {
@@ -1856,7 +1709,6 @@ void TFT_eSPI::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t
if (dlen) drawFastHLine(xs, y0, dlen, color);
}
inTransaction = lockTransaction;
end_tft_write();
}
@@ -1908,7 +1760,6 @@ void TFT_eSPI::drawArc(int32_t x, int32_t y, int32_t r, int32_t ir, uint32_t sta
if (endAngle == 0) return;
startAngle = 0;
}
inTransaction = true;
int32_t xs = 0; // x start position for quadrant scan
uint8_t alpha = 0; // alpha value for blending pixels
@@ -2044,7 +1895,6 @@ void TFT_eSPI::drawArc(int32_t x, int32_t y, int32_t r, int32_t ir, uint32_t sta
if (startAngle <= 180 && endAngle >= 180) drawFastVLine(x, y - r + 1, w, fg_color); // Top
if (startAngle <= 270 && endAngle >= 270) drawFastHLine(x + r - w, y, w, fg_color); // Right
inTransaction = lockTransaction;
end_tft_write();
}
@@ -2055,8 +1905,6 @@ void TFT_eSPI::drawSmoothCircle(int32_t x, int32_t y, int32_t r, uint32_t fg_col
void TFT_eSPI::fillSmoothCircle(int32_t x, int32_t y, int32_t r, uint32_t color, uint32_t bg_color) {
if (r <= 0) return;
inTransaction = true;
drawFastHLine(x - r, y, 2 * r + 1, color);
int32_t xs = 1;
int32_t cx = 0;
@@ -2095,7 +1943,6 @@ void TFT_eSPI::fillSmoothCircle(int32_t x, int32_t y, int32_t r, uint32_t color,
drawFastHLine(x + cx - r, y + cy - r, 2 * (r - cx) + 1, color);
drawFastHLine(x + cx - r, y - cy + r, 2 * (r - cx) + 1, color);
}
inTransaction = lockTransaction;
end_tft_write();
}
@@ -2111,8 +1958,6 @@ void TFT_eSPI::drawSmoothRoundRect(int32_t x, int32_t y, int32_t r, int32_t ir,
if (w < 0) w = 0;
if (h < 0) h = 0;
inTransaction = true;
x += r;
y += r;
@@ -2184,14 +2029,10 @@ void TFT_eSPI::drawSmoothRoundRect(int32_t x, int32_t y, int32_t r, int32_t ir,
if ((quadrants & 0x3) == 0x3) fillRect(x, y - r + 1, w + 1, t, fg_color); // Top
if ((quadrants & 0x6) == 0x6) fillRect(x + r - t + w, y, t, h + 1, fg_color); // Right
inTransaction = lockTransaction;
end_tft_write();
}
void TFT_eSPI::fillSmoothRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t r, uint32_t color, uint32_t bg_color)
{
inTransaction = true;
void TFT_eSPI::fillSmoothRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, int32_t r, uint32_t color, uint32_t bg_color) {
int32_t xs = 0;
int32_t cx = 0;
@@ -2232,7 +2073,6 @@ void TFT_eSPI::fillSmoothRoundRect(int32_t x, int32_t y, int32_t w, int32_t h, i
drawFastHLine(x + cx - r, y + cy - r, 2 * (r - cx) + 1 + w, color);
drawFastHLine(x + cx - r, y - cy + r + h, 2 * (r - cx) + 1 + w, color);
}
inTransaction = lockTransaction;
end_tft_write();
}
@@ -2259,7 +2099,6 @@ void TFT_eSPI::drawWedgeLine(float ax, float ay, float bx, float by, float ar, f
float xpax, ypay, bax = bx - ax, bay = by - ay;
begin_nin_write();
inTransaction = true;
int32_t xs = x0;
// Scan bounding box from ys down, calculate pixel intensity from distance to line
@@ -2315,7 +2154,6 @@ void TFT_eSPI::drawWedgeLine(float ax, float ay, float bx, float by, float ar, f
}
}
inTransaction = lockTransaction;
end_nin_write();
}
@@ -2485,42 +2323,6 @@ uint16_t TFT_eSPI::alphaBlend(uint8_t alpha, uint16_t fgc, uint16_t bgc, uint8_t
return alphaBlend(alpha, fgc, bgc);
}
int16_t TFT_eSPI::drawChar(uint16_t uniCode, int32_t x, int32_t y) {
return drawChar(uniCode, x, y, textfont);
}
int16_t TFT_eSPI::drawChar(uint16_t uniCode, int32_t x, int32_t y, uint8_t font) {
if (_vpOoB || !uniCode) return 0;
if (font == 1) return 0;
if ((font>1) && (font<9) && ((uniCode < 32) || (uniCode > 127))) return 0;
int32_t width = 0;
int32_t height = 0;
uint32_t flash_address = 0;
uniCode -= 32;
int32_t xd = x + _xDatum;
int32_t yd = y + _yDatum;
if ((xd + width * textsize < _vpX || xd >= _vpW) && (yd + height * textsize < _vpY || yd >= _vpH)) return width * textsize ;
int32_t w = width;
int32_t pX = 0;
int32_t pY = y;
uint8_t line = 0;
bool clip = xd < _vpX || xd + width * textsize >= _vpW || yd < _vpY || yd + height * textsize >= _vpH;
flash_address = flash_address;
w = w;
pX = pX;
pY = pY;
line = line;
clip = clip;
return width * textsize;
}
int16_t TFT_eSPI::drawString(const String& string, int32_t poX, int32_t poY) {
int16_t len = string.length() + 2;
char buffer[len];
@@ -2919,7 +2721,7 @@ void TFT_eSPI::drawGlyph(uint16_t code, uint16_t font) {
int16_t bx = 0;
uint8_t pixel;
startWrite(); // Avoid slow ESP32 transaction overhead for every pixel
startWrite();
int16_t fillwidth = 0;
int16_t fillheight = 0;
@@ -3011,16 +2813,14 @@ void TFT_eSPI::drawGlyph(uint16_t code, uint16_t font) {
#endif
inline void TFT_eSPI::begin_touch_read_write() {
dmaWait();
CS_H; // Just in case it has been left low
if (locked) {locked = false; spi.beginTransaction(SPISettings(SPI_TOUCH_FREQUENCY, MSBFIRST, SPI_MODE0));}
SPI_SET_CLOCK_FREQ(SPI_TOUCH_FREQUENCY);
SET_BUS_READ_MODE;
gpio_set_level((gpio_num_t)TOUCH_CS, 0);
}
inline void TFT_eSPI::end_touch_read_write() {
gpio_set_level((gpio_num_t)TOUCH_CS, 1);
if(!inTransaction) {if (!locked) {locked = true; spi.endTransaction();}}
}
uint8_t TFT_eSPI::getTouchRaw(uint16_t *x, uint16_t *y){
@@ -3028,31 +2828,29 @@ uint8_t TFT_eSPI::getTouchRaw(uint16_t *x, uint16_t *y){
begin_touch_read_write();
spi.transfer(0xd0);
spi.transfer(0);
spi.transfer(0xd0);
spi.transfer(0);
spi.transfer(0xd0);
spi.transfer(0);
spi.transfer(0xd0);
transfer(0xd0);
transfer(0);
transfer(0xd0);
transfer(0);
transfer(0xd0);
transfer(0);
transfer(0xd0);
tmp = spi.transfer(0); // Read first 8 bits
tmp = tmp <<5;
tmp |= 0x1f & (spi.transfer(0x90)>>3); // Read last 8 bits and start new XP conversion
tmp = transfer(0) << 5; // Read first 8 bits
tmp |= 0x1f & (transfer(0x90)>>3); // Read last 8 bits and start new XP conversion
*x = tmp;
// Start XP sample request for y position, read 4 times and keep last sample
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
transfer(0); // Read first 8 bits
transfer(0x90); // Read last 8 bits and start new XP conversion
transfer(0); // Read first 8 bits
transfer(0x90); // Read last 8 bits and start new XP conversion
transfer(0); // Read first 8 bits
transfer(0x90); // Read last 8 bits and start new XP conversion
tmp = spi.transfer(0); // Read first 8 bits
tmp = tmp <<5;
tmp |= 0x1f & (spi.transfer(0)>>3); // Read last 8 bits
tmp = transfer(0) << 5; // Read first 8 bits
tmp |= 0x1f & (transfer(0)>>3); // Read last 8 bits
*y = tmp;
@@ -3061,19 +2859,15 @@ uint8_t TFT_eSPI::getTouchRaw(uint16_t *x, uint16_t *y){
return true;
}
/***************************************************************************************
** Function name: getTouchRawZ
** Description: read raw pressure on touchpad and return Z value.
***************************************************************************************/
uint16_t TFT_eSPI::getTouchRawZ() {
begin_touch_read_write();
// Z sample request
int16_t tz = 0xFFF;
spi.transfer(0xb0); // Start new Z1 conversion
tz += spi.transfer16(0xc0) >> 3; // Read Z1 and start Z2 conversion
tz -= spi.transfer16(0x00) >> 3; // Read Z2
transfer(0xb0); // Start new Z1 conversion
tz += transfer16(0xc0) >> 3; // Read Z1 and start Z2 conversion
tz -= transfer16(0x00) >> 3; // Read Z2
end_touch_read_write();
@@ -3089,8 +2883,7 @@ uint8_t TFT_eSPI::validTouch(uint16_t *x, uint16_t *y, uint16_t threshold){
// Wait until pressure stops increasing to debounce pressure
uint16_t z1 = 1;
uint16_t z2 = 0;
while (z1 > z2)
{
while (z1 > z2) {
z2 = z1;
z1 = getTouchRawZ();
delay(1);
@@ -3115,10 +2908,6 @@ uint8_t TFT_eSPI::validTouch(uint16_t *x, uint16_t *y, uint16_t threshold){
return true;
}
/***************************************************************************************
** Function name: getTouch
** Description: read callibrated position. Return false if not pressed.
***************************************************************************************/
uint8_t TFT_eSPI::getTouch(uint16_t *x, uint16_t *y, uint16_t threshold){
uint16_t x_tmp, y_tmp;
@@ -3127,9 +2916,8 @@ uint8_t TFT_eSPI::getTouch(uint16_t *x, uint16_t *y, uint16_t threshold){
uint8_t n = 5;
uint8_t valid = 0;
while (n--)
{
if (validTouch(&x_tmp, &y_tmp, threshold)) valid++;;
while (n--) {
if (validTouch(&x_tmp, &y_tmp, threshold)) valid++;
}
if (valid<1) { _pressTime = 0; return false; }
@@ -3145,10 +2933,6 @@ uint8_t TFT_eSPI::getTouch(uint16_t *x, uint16_t *y, uint16_t threshold){
return valid;
}
/***************************************************************************************
** Function name: convertRawXY
** Description: convert raw touch x,y values to screen coordinates
***************************************************************************************/
void TFT_eSPI::convertRawXY(uint16_t *x, uint16_t *y)
{
uint16_t x_tmp = *x, y_tmp = *y, xx, yy;
@@ -3309,9 +3093,6 @@ TFT_eSprite::TFT_eSprite(TFT_eSPI *tft) {
_yptr = 0;
_colorMap = nullptr;
// Ensure end_tft_write() does nothing in inherited functions.
lockTransaction = true;
}
void* TFT_eSprite::createSprite(int16_t w, int16_t h, uint8_t frames) {
@@ -4254,8 +4035,7 @@ void TFT_eSprite::drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint3
}
}
void TFT_eSprite::drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color)
{
void TFT_eSprite::drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color) {
if (!_created || _vpOoB) return;
x+= _xDatum;
@@ -4298,8 +4078,7 @@ void TFT_eSprite::drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t color)
}
}
void TFT_eSprite::drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color)
{
void TFT_eSprite::drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color) {
if (!_created || _vpOoB) return;
x+= _xDatum;
@@ -4345,8 +4124,7 @@ void TFT_eSprite::drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color)
}
}
void TFT_eSprite::fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color)
{
void TFT_eSprite::fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color) {
if (!_created || _vpOoB) return;
x+= _xDatum;
@@ -4429,45 +4207,7 @@ void TFT_eSprite::fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t
}
}
int16_t TFT_eSprite::drawChar(uint16_t uniCode, int32_t x, int32_t y) {
return drawChar(uniCode, x, y, textfont);
}
int16_t TFT_eSprite::drawChar(uint16_t uniCode, int32_t x, int32_t y, uint8_t font) {
if (_vpOoB || !uniCode) return 0;
if (font==1) return 0;
if ((font>1) && (font<9) && ((uniCode < 32) || (uniCode > 127))) return 0;
int32_t width = 0;
int32_t height = 0;
uint32_t flash_address = 0;
uniCode -= 32;
int32_t xd = x + _xDatum;
int32_t yd = y + _yDatum;
if ((xd + width * textsize < _vpX || xd >= _vpW) && (yd + height * textsize < _vpY || yd >= _vpH)) return width * textsize ;
int32_t w = width;
int32_t pX = 0;
int32_t pY = y;
uint8_t line = 0;
bool clip = xd < _vpX || xd + width * textsize >= _vpW || yd < _vpY || yd + height * textsize >= _vpH;
flash_address = flash_address;
w = w;
pX = pX;
pY = pY;
line = line;
clip = clip;
return width * textsize; // x +
}
void TFT_eSprite::drawGlyph(uint16_t code, uint16_t font)
{
void TFT_eSprite::drawGlyph(uint16_t code, uint16_t font) {
bool getBG = false;
if (textcolor == textbgcolor) getBG = true;

58
lib/TFT_eSPI/TFT_eSPI.h
View File

@@ -1,12 +1,54 @@
#pragma once
#include <Arduino.h>
#include <SPI.h>
#define SPI_FREQUENCY 7500000
#define SPI_READ_FREQUENCY 20000000
#define SPI_TOUCH_FREQUENCY 2500000
#define OR_REGISTER(register, value) WRITE_PERI_REG(register, READ_PERI_REG(register | value))
#define SPI_SET_CLOCK_FREQ(target_freq_hz) \
do { \
uint32_t sys_freq = getApbFrequency(); \
if(sys_freq == target_freq_hz) { \
*_spi_clock = 1 << 31;\
return; \
} \
uint32_t pre_div = 1; \
uint32_t cnt_n = 1; \
\
/* Find optimal dividers: sys_freq / pre_div / cnt_n = target_freq */ \
uint32_t total_div = (sys_freq + (target_freq_hz) - 1) / (target_freq_hz); \
\
/* Try to balance pre_div and cnt_n for best accuracy */ \
for (uint32_t p = 1; p <= 0x2000; p++) { \
uint32_t c = (total_div + p - 1) / p; \
if (c >= 1 && c <= 0x40) { \
pre_div = p; \
cnt_n = c; \
break; \
} \
} \
\
/* Adjust to register format (values are minus one) */ \
pre_div = (pre_div > 1) ? (pre_div - 1) : 0; \
cnt_n = (cnt_n > 1) ? (cnt_n - 1) : 0; \
\
/* Calculate cnt_h for 50% duty cycle */ \
uint32_t cnt_h = (cnt_n > 0) ? ((cnt_n + 1) / 2 - 1) : 0; \
\
/* Build register value */ \
uint32_t reg_val = 0; \
reg_val |= (0 << 31); /* SPI_CLK_EQU_SYSCLK = 0 (use dividers) */ \
reg_val |= (pre_div << 18); /* SPI_CLKDIV_PRE */ \
reg_val |= (cnt_n << 12); /* SPI_CLKCNT_N */ \
reg_val |= (cnt_h << 6); /* SPI_CLKCNT_H */ \
reg_val |= (cnt_n << 0); /* SPI_CLKCNT_L = SPI_CLKCNT_N */ \
\
*_spi_clock = reg_val; \
} while(0)
#define TFT_WIDTH 240
#define TFT_HEIGHT 320
@@ -72,7 +114,7 @@
// 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)
#define tft_Read_8() spi.transfer(0)
#define tft_Read_8() transfer(0)
#define DAT8TO32(P) ( (uint32_t)P[0]<<8 | P[1] | P[2]<<24 | P[3]<<16 )
@@ -162,9 +204,7 @@ class TFT_eSPI { friend class TFT_eSprite;
drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t color),
fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t color);
virtual int16_t drawChar(uint16_t uniCode, int32_t x, int32_t y, uint8_t font),
drawChar(uint16_t uniCode, int32_t x, int32_t y),
height(),
virtual int16_t height(),
width();
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);
@@ -271,10 +311,6 @@ class TFT_eSPI { friend class TFT_eSprite;
// 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);
bool initDMA(bool ctrl_cs = false); // Initialise the DMA engine and attach to SPI bus - typically used in setup()
void dmaWait(); // wait until DMA is complete
bool DMA_Enabled = false; // Flag for DMA enabled state
uint8_t spiBusyCheck = 0; // Number of ESP32 transfer buffers to check
// Bare metal functions
@@ -368,8 +404,6 @@ class TFT_eSPI { friend class TFT_eSprite;
getColorCallback getColor = nullptr; // Smooth font callback function pointer
bool locked, inTransaction, lockTransaction; // SPI transaction and mutex lock flags
void loadMetrics(uint8_t font); // Function of Fear, which is Unhandled Exception, writing to 0x000000000
uint32_t readInt32();
@@ -455,8 +489,6 @@ 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);
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);
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);
int16_t width(),
height();
void drawGlyph(uint16_t code, uint16_t font);

2
src/main.cpp
View File

@@ -1571,7 +1571,7 @@ void loop() {
}
if (hardwaremodel == PORTABLE_TOUCH_ILI9341 && touch_detect) {
if (tft.getTouchRawZ() > 100) {
if (tft.getTouchRawZ() > 250) {
uint16_t x, y;
tft.getTouch(&x, &y);
if (x > 0 || y > 0) {