Managed to get the Async branch to compile with the Latest Teensyduino 1.39, Arduino IDE and SPIN that comes with 1.39. Compiler kept getting stuck on the 2 below calls in a few places. Not idea if it changes anything still trying to get dma working.

_pkinetisk_spi = _pspin->kinetisk_spi();
_pkinetisl_spi = _pspin->kinetisl_spi();

``// https://github.com/PaulStoffregen/ILI9341_t3n // http://forum.pjrc.com/threads/26305-Highly-optimized-ILI9341-(320x240-TFT-color-display)-library

/*** This is our library for the Adafruit ILI9341 Breakout and Shield ----> http://www.adafruit.com/products/1651

Check out the links above for our tutorials and wiring diagrams These displays use SPI to communicate, 4 or 5 pins are required to interface (RST is optional) Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!

Written by Limor Fried/Ladyada for Adafruit Industries. MIT license, all text above must be included in any redistribution ****/ //

//Additional graphics routines by Tim Trzepacz, SoftEgg LLC added December 2015 //(And then accidentally deleted and rewritten March 2016. Oops!) //Gradient support //---------------- // fillRectVGradient - fills area with vertical gradient // fillRectHGradient - fills area with horizontal gradient // fillScreenVGradient - fills screen with vertical gradient // fillScreenHGradient - fills screen with horizontal gradient

//Additional Color Support //------------------------ // color565toRGB - converts 565 format 16 bit color to RGB // color565toRGB14 - converts 16 bit 565 format color to 14 bit RGB (2 bits clear for math and sign) // RGB14tocolor565 - converts 14 bit RGB back to 16 bit 565 format color

//Low Memory Bitmap Support //------------------------- // writeRect8BPP - write 8 bit per pixel paletted bitmap // writeRect4BPP - write 4 bit per pixel paletted bitmap // writeRect2BPP - write 2 bit per pixel paletted bitmap // writeRect1BPP - write 1 bit per pixel paletted bitmap

//TODO: transparent bitmap writing routines for sprites

//String Pixel Length support //--------------------------- // strPixelLen - gets pixel length of given ASCII string

// <\SoftEgg>

include "ILI9341_t3n.h"

include

//#define DEBUG_ASYNC_UPDATE // Enable to print out dma info

ifdef ENABLE_ILI9341_FRAMEBUFFER

DMASetting ILI9341_t3n::_dmasettings[4]; DMAChannel ILI9341_t3n::_dmatx;

DMAChannel _dmatx; ILI9341_t3n *ILI9341_t3n::_dmaActiveDisplay = 0; volatile uint8_t ILI9341_t3n::_dma_state = 0; // Use pointer to this as a way to get back to object... volatile uint32_t ILI9341_t3n::_dma_frame_count = 0; // Can return a frame count...

void ILI9341_t3n::dmaInterrupt(void) { //Serial.println("DMA Interrupt"); /// digitalWriteFast(1,!digitalReadFast(1)); _dma_frame_count++; _dmatx.clearInterrupt();

// See if we are in continuous mode or not..
if ((_dma_state & ILI9341_DMA_CONT) == 0) {
    // We are in single refresh mode or the user has called cancel so
    // Lets try to release the CS pin
    _dmaActiveDisplay->writecommand_last(ILI9341_NOP);
    _dmaActiveDisplay->endSPITransaction();
    _dma_state &= ~ILI9341_DMA_ACTIVE;
    _dmaActiveDisplay = 0;  // We don't have a display active any more... 
}

}

endif

// Teensy 3.1 can only generate 30 MHz SPI when running at 120 MHz (overclock)

define WIDTH ILI9341_TFTWIDTH

define HEIGHT ILI9341_TFTHEIGHT

// Constructor when using hardware ILI9241_KINETISK__pspi-> Faster, but must use SPI pins // specific to each board type (e.g. 11,13 for Uno, 51,52 for Mega, etc.) ILI9341_t3n::ILI9341_t3n(uint8_t cs, uint8_t dc, uint8_t rst, uint8_t mosi, uint8_t sclk, uint8_t miso, SPINClass *pspin ) { _cs = cs; _dc = dc; _rst = rst; _mosi = mosi; _sclk = sclk; _miso = miso; _width = WIDTH; _height = HEIGHT; _pspin = pspin;

ifdef KINETISK

_pkinetisk_spi = _pspin->kinetisk_spi();

else

_pkinetisl_spi = _pspin->kinetisl_spi();

endif

rotation  = 0;
cursor_y  = cursor_x    = 0;
textsize  = 1;
textcolor = textbgcolor = 0xFFFF;
wrap      = true;
font      = NULL;
setClipRect();
setOrigin();

// Added to see how much impact actually using non hardware CS pin might be
_cspinmask = 0;
_csport = NULL;

#ifdef ENABLE_ILI9341_FRAMEBUFFER
_pfbtft = NULL; 
_use_fbtft = 0;                     // Are we in frame buffer mode?
_we_allocated_buffer = 0;
#endif

}

//======================================================================= // Add optinal support for using frame buffer to speed up complex outputs //=======================================================================

define CBALLOC (ILI9341_TFTHEIGHTILI9341_TFTWIDTH2)

void ILI9341_t3n::setFrameBuffer(uint16_t *frame_buffer) {

ifdef ENABLE_ILI9341_FRAMEBUFFER

_pfbtft = frame_buffer;
if (_pfbtft != NULL) {
    memset(_pfbtft, 0, ILI9341_TFTHEIGHT*ILI9341_TFTWIDTH*2);
}

#endif

}

uint8_t ILI9341_t3n::useFrameBuffer(boolean b) // use the frame buffer? First call will allocate {

ifdef ENABLE_ILI9341_FRAMEBUFFER

if (b) {
    // First see if we need to allocate buffer
    if (_pfbtft == NULL) {
        _pfbtft = (uint16_t *)malloc(CBALLOC);
        if (_pfbtft == NULL)
            return 0;   // failed 
        memset(_pfbtft, 0, CBALLOC);    
        _we_allocated_buffer = 1;
    }
    _use_fbtft = 1;
} else 
    _use_fbtft = 0;

return _use_fbtft;  
#else
return 0;
#endif

}

void ILI9341_t3n::freeFrameBuffer(void) // explicit call to release the buffer {

ifdef ENABLE_ILI9341_FRAMEBUFFER

if (_we_allocated_buffer && (_pfbtft != NULL)) {
    _pfbtft = NULL;
    _use_fbtft = 0; // make sure the use is turned off
    _we_allocated_buffer = 0;
}
#endif

} void ILI9341_t3n::updateScreen(void) // call to say update the screen now. { // Not sure if better here to check flag or check existence of buffer. // Will go by buffer as maybe can do interesting things?

ifdef ENABLE_ILI9341_FRAMEBUFFER

if (_use_fbtft) {
    beginSPITransaction();
    if (_standard) {
        // Doing full window. 
        setAddr(0, 0, _width-1, _height-1);
        writecommand_cont(ILI9341_RAMWR);

        // BUGBUG doing as one shot.  Not sure if should or not or do like
        // main code and break up into transactions...
        uint16_t *pfbtft_end = &_pfbtft[(ILI9341_TFTWIDTH*ILI9341_TFTHEIGHT)-1];    // setup 
        uint16_t *pftbft = _pfbtft;

        // Quick write out the data;
        while (pftbft < pfbtft_end) {
            writedata16_cont(*pftbft++);
        }
        writedata16_last(*pftbft);
    } else {
        // setup just to output the clip rectangle area. 
        setAddr(_displayclipx1, _displayclipy1, _displayclipx2-1, _displayclipy2-1);
        writecommand_cont(ILI9341_RAMWR);

        // BUGBUG doing as one shot.  Not sure if should or not or do like
        // main code and break up into transactions...
        uint16_t * pfbPixel_row = &_pfbtft[ _displayclipy1*_width + _displayclipx1];
        for (uint16_t y = _displayclipy1; y < _displayclipy2; y++) {
            uint16_t * pfbPixel = pfbPixel_row;
            for (uint16_t x = _displayclipx1; x < (_displayclipx2-1); x++) {
                writedata16_cont(*pfbPixel++);
            }
            if (y < (_displayclipy2-1))
                writedata16_cont(*pfbPixel);
            else    
                writedata16_last(*pfbPixel);
            pfbPixel_row += _width; // setup for the next row. 
        }
    }
    endSPITransaction();
}
#endif

}

ifdef DEBUG_ASYNC_UPDATE

void dumpDMA_TCD(DMABaseClass *dmabc) { Serial.printf("%x %x:", (uint32_t)dmabc, (uint32_t)dmabc->TCD);

const uint32_t *p = (const uint32_t *)dmabc->TCD;

for (uint8_t i=0; i<8; i++) {
    Serial.printf("%x ", *p++);
}
Serial.println();

}

endif

void ILI9341_t3n::initDMASettings(void) { // Serial.printf("initDMASettings called %d\n", ili9341_t3n_dma_has_been_init); if (_dma_state) { // should test for init, but... return; // we already init this. }

//Serial.println("InitDMASettings");

uint8_t dmaTXevent = _pspin->dmaTXEvent();

// BUGBUG:: check for -1 as wont work on SPI2 on T3.5

// uint16_t *fbtft_start_dma_addr = _pfbtft; uint32_t count_words_write = (CBALLOC/SCREEN_DMA_NUM_SETTINGS)/2; // Note I know the divide will give whole number

//Serial.printf("CWW: %d %d %d\n", CBALLOC, SCREEN_DMA_NUM_SETTINGS, count_words_write);
// Now lets setup DMA access to this memory... 
_dmasettings[0].sourceBuffer(&_pfbtft[1], (count_words_write-1)*2);
_dmasettings[0].destination(_pkinetisk_spi->PUSHR);

// Hack to reset the destination to only output 2 bytes.
_dmasettings[0].TCD->ATTR_DST = 1;
_dmasettings[0].replaceSettingsOnCompletion(_dmasettings[1]);

_dmasettings[1].sourceBuffer(&_pfbtft[count_words_write], count_words_write*2);
_dmasettings[1].destination(_pkinetisk_spi->PUSHR);
_dmasettings[1].TCD->ATTR_DST = 1;
_dmasettings[1].replaceSettingsOnCompletion(_dmasettings[2]);

_dmasettings[2].sourceBuffer(&_pfbtft[count_words_write*2], count_words_write*2);
_dmasettings[2].destination(_pkinetisk_spi->PUSHR);
_dmasettings[2].TCD->ATTR_DST = 1;
_dmasettings[2].replaceSettingsOnCompletion(_dmasettings[3]);

// Sort of hack - but wrap around to output the first word again. 
_dmasettings[3].sourceBuffer(_pfbtft, 2);
_dmasettings[3].destination(_pkinetisk_spi->PUSHR);
_dmasettings[3].TCD->ATTR_DST = 1;
_dmasettings[3].replaceSettingsOnCompletion(_dmasettings[0]);

// Setup DMA main object
//Serial.println("Setup _dmatx");
_dmatx.begin(true);
_dmatx.triggerAtHardwareEvent(dmaTXevent);
_dmatx = _dmasettings[0];
_dmatx.attachInterrupt(dmaInterrupt);
_dma_state = ILI9341_DMA_INIT;  // Should be first thing set!

}

bool ILI9341_t3n::updateScreenAsync(bool update_cont) // call to say update the screen now. { // Not sure if better here to check flag or check existence of buffer. // Will go by buffer as maybe can do interesting things? // BUGBUG:: only handles full screen so bail on the rest of it...

ifdef ENABLE_ILI9341_FRAMEBUFFER

if (!_use_fbtft) return false;

// Init DMA settings. 
initDMASettings();

// Don't start one if already active.
if (_dma_state & ILI9341_DMA_ACTIVE) {
    return false;
}

if (update_cont) {
    // Try to link in #3 into the chain
    _dmasettings[2].replaceSettingsOnCompletion(_dmasettings[3]);
    _dmasettings[2].TCD->CSR &= ~(DMA_TCD_CSR_INTMAJOR | DMA_TCD_CSR_DREQ);  // Don't interrupt on this one... 
    _dmasettings[3].interruptAtCompletion();
    _dmasettings[3].TCD->CSR &= ~(DMA_TCD_CSR_DREQ);  // Don't disable on this one  
    _dma_state |= ILI9341_DMA_CONT;
} else {
    // In this case we will only run through once...
    _dmasettings[2].replaceSettingsOnCompletion(_dmasettings[0]);
    _dmasettings[2].interruptAtCompletion();
    _dmasettings[2].disableOnCompletion();
    _dma_state &= ~ILI9341_DMA_CONT;
}

beginSPITransaction();

// Doing full window. 
setAddr(0, 0, _width-1, _height-1);
writecommand_cont(ILI9341_RAMWR);

// Write the first Word out before enter DMA as to setup the proper CS/DC/Continue flaugs
writedata16_cont(*_pfbtft);

// now lets start up the DMA

ifdef DEBUG_ASYNC_UPDATE

Serial.printf("DMA dump TCDs %d\n", _dmatx.channel);
dumpDMA_TCD(&_dmatx);
dumpDMA_TCD(&_dmasettings[0]);
dumpDMA_TCD(&_dmasettings[1]);
dumpDMA_TCD(&_dmasettings[2]);
dumpDMA_TCD(&_dmasettings[3]);

endif

// volatile uint16_t biter = _dmatx.TCD->BITER; //DMA_CDNE_CDNE(_dmatx.channel); // _dmatx = _dmasettings[0]; // _dmatx.TCD->BITER = biter; _dma_frame_count = 0; // Set frame count back to zero. _pkinetisk_spi->RSER |= SPI_RSER_TFFF_DIRS | SPI_RSER_TFFF_RE; // Set DMA Interrupt Request Select and Enable register _pkinetisk_spi->MCR &= ~SPI_MCR_HALT; //Start transfers. _dmatx.enable(); _dmaActiveDisplay = this; _dma_state |= ILI9341_DMA_ACTIVE; return true;

else

return false;     // no frame buffer so will never start... 
#endif

}

void ILI9341_t3n::endUpdateAsync() { // make sure it is on

ifdef ENABLE_ILI9341_FRAMEBUFFER

if (_dma_state & ILI9341_DMA_CONT) {
    _dma_state &= ~ILI9341_DMA_CONT; // Turn of the continueous mode
    _dmasettings[3].disableOnCompletion();
}
#endif

}

void ILI9341_t3n::waitUpdateAsyncComplete(void) {

ifdef ENABLE_ILI9341_FRAMEBUFFER

while ((_dma_state & ILI9341_DMA_ACTIVE)) {
    asm volatile("wfi");
};
#endif

}

//=======================================================================

void ILI9341_t3n::setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) { beginSPITransaction(); setAddr(x0, y0, x1, y1); writecommand_last(ILI9341_RAMWR); // write to RAM endSPITransaction(); }

void ILI9341_t3n::pushColor(uint16_t color) { beginSPITransaction(); writedata16_last(color); endSPITransaction(); }

void ILI9341_t3n::drawPixel(int16_t x, int16_t y, uint16_t color) { x += _originx; y += _originy; if((x < _displayclipx1) ||(x >= _displayclipx2) || (y < _displayclipy1) || (y >= _displayclipy2)) return;

#ifdef ENABLE_ILI9341_FRAMEBUFFER
if (_use_fbtft) {
    _pfbtft[y*_width + x] = color;

} else 
#endif
{
    beginSPITransaction();
    setAddr(x, y, x, y);
    writecommand_cont(ILI9341_RAMWR);
    writedata16_last(color);
    endSPITransaction();
}

}

void ILI9341_t3n::drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) { x+=_originx; y+=_originy; // Rectangular clipping if((x < _displayclipx1) || (x >= _displayclipx2) || (y >= _displayclipy2)) return; if(y < _displayclipy1) { h = h - (_displayclipy1 - y); y = _displayclipy1;} if((y+h-1) >= _displayclipy2) h = _displayclipy2-y; if(h<1) return;

#ifdef ENABLE_ILI9341_FRAMEBUFFER
if (_use_fbtft) {
    uint16_t * pfbPixel = &_pfbtft[ y*_width + x];
    while (h--) {
        *pfbPixel = color;
        pfbPixel += _width;
    }
} else 
#endif
{
    beginSPITransaction();
    setAddr(x, y, x, y+h-1);
    writecommand_cont(ILI9341_RAMWR);
    while (h-- > 1) {
        writedata16_cont(color);
    }
    writedata16_last(color);
    endSPITransaction();
}

}

void ILI9341_t3n::drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) { x+=_originx; y+=_originy;

// Rectangular clipping
if((y < _displayclipy1) || (x >= _displayclipx2) || (y >= _displayclipy2)) return;
if(x<_displayclipx1) { w = w - (_displayclipx1 - x); x = _displayclipx1; }
if((x+w-1) >= _displayclipx2)  w = _displayclipx2-x;
if (w<1) return;

#ifdef ENABLE_ILI9341_FRAMEBUFFER
if (_use_fbtft) {
    if ((x&1) || (w&1)) {
        uint16_t * pfbPixel = &_pfbtft[ y*_width + x];
        while (w--) {
            *pfbPixel++ = color;
        }
    } else {
        // X is even and so is w, try 32 bit writes..
        uint32_t color32 = (color << 16) | color;
        uint32_t * pfbPixel = (uint32_t*)((uint16_t*)&_pfbtft[ y*_width + x]);
        while (w) {
            *pfbPixel++ = color32;
            w -= 2;
        }
    }
} else 
#endif
{
    beginSPITransaction();
    setAddr(x, y, x+w-1, y);
    writecommand_cont(ILI9341_RAMWR);
    while (w-- > 1) {
        writedata16_cont(color);
    }
    writedata16_last(color);
    endSPITransaction();
}

}

void ILI9341_t3n::fillScreen(uint16_t color) {

ifdef ENABLE_ILI9341_FRAMEBUFFER

if (_use_fbtft && _standard) {
    // Speed up lifted from Franks DMA code... _standard is if no offsets and rects..
    uint32_t color32 = (color << 16) | color;

    uint32_t *pfbPixel = (uint32_t *)_pfbtft;
    uint32_t *pfbtft_end = (uint32_t *)((uint16_t *)&_pfbtft[(ILI9341_TFTWIDTH * ILI9341_TFTHEIGHT)]); // setup
    while (pfbPixel < pfbtft_end) {
        *pfbPixel++ = color32; *pfbPixel++ = color32; *pfbPixel++ = color32;*pfbPixel++ = color32;
        *pfbPixel++ = color32; *pfbPixel++ = color32; *pfbPixel++ = color32;*pfbPixel++ = color32;
        *pfbPixel++ = color32; *pfbPixel++ = color32; *pfbPixel++ = color32;*pfbPixel++ = color32;
        *pfbPixel++ = color32; *pfbPixel++ = color32; *pfbPixel++ = color32;*pfbPixel++ = color32;
        *pfbPixel++ = color32; *pfbPixel++ = color32; *pfbPixel++ = color32;*pfbPixel++ = color32;
        *pfbPixel++ = color32; *pfbPixel++ = color32; *pfbPixel++ = color32;*pfbPixel++ = color32;
        *pfbPixel++ = color32; *pfbPixel++ = color32; *pfbPixel++ = color32;*pfbPixel++ = color32;
        *pfbPixel++ = color32; *pfbPixel++ = color32; *pfbPixel++ = color32;*pfbPixel++ = color32;
    }

} else 
#endif
{
    fillRect(0, 0, _width, _height, color);
}

}

// fill a rectangle void ILI9341_t3n::fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) { x+=_originx; y+=_originy;

// Rectangular clipping (drawChar w/big text requires this)
if((x >= _displayclipx2) || (y >= _displayclipy2)) return;
if (((x+w) <= _displayclipx1) || ((y+h) <= _displayclipy1)) return;
if(x < _displayclipx1) {    w -= (_displayclipx1-x); x = _displayclipx1;    }
if(y < _displayclipy1) {    h -= (_displayclipy1 - y); y = _displayclipy1;  }
if((x + w - 1) >= _displayclipx2)  w = _displayclipx2  - x;
if((y + h - 1) >= _displayclipy2) h = _displayclipy2 - y;

#ifdef ENABLE_ILI9341_FRAMEBUFFER
if (_use_fbtft) {
    if ((x&1) || (w&1)) {
        uint16_t * pfbPixel_row = &_pfbtft[ y*_width + x];
        for (;h>0; h--) {
            uint16_t * pfbPixel = pfbPixel_row;
            for (int i = 0 ;i < w; i++) {
                *pfbPixel++ = color;
            }
            pfbPixel_row += _width;
        }
    } else {
        // Horizontal is even number so try 32 bit writes instead
        uint32_t color32 = (color << 16) | color;
        uint32_t * pfbPixel_row = (uint32_t *)((uint16_t*)&_pfbtft[ y*_width + x]);
        w = w/2;    // only iterate half the times
        for (;h>0; h--) {
            uint32_t * pfbPixel = pfbPixel_row;
            for (int i = 0 ;i < w; i++) {
                *pfbPixel++ = color32;
            }
            pfbPixel_row += (_width/2);
        }
    }
} else 
#endif
{

    // TODO: this can result in a very long transaction time
    // should break this into multiple transactions, even though
    // it'll cost more overhead, so we don't stall other SPI libs
    beginSPITransaction();
    setAddr(x, y, x+w-1, y+h-1);
    writecommand_cont(ILI9341_RAMWR);
    for(y=h; y>0; y--) {
        for(x=w; x>1; x--) {
            writedata16_cont(color);
        }
        writedata16_last(color);
        if (y > 1 && (y & 1)) {
            endSPITransaction();
            beginSPITransaction();
        }
    }
    endSPITransaction();
}

}

// fillRectVGradient - fills area with vertical gradient void ILI9341_t3n::fillRectVGradient(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color1, uint16_t color2) { x+=_originx; y+=_originy;

// Rectangular clipping 
if((x >= _displayclipx2) || (y >= _displayclipy2)) return;
if(x < _displayclipx1) {    w -= (_displayclipx1-x); x = _displayclipx1;    }
if(y < _displayclipy1) {    h -= (_displayclipy1 - y); y = _displayclipy1;  }
if((x + w - 1) >= _displayclipx2)  w = _displayclipx2  - x;
if((y + h - 1) >= _displayclipy2) h = _displayclipy2 - y;

int16_t r1, g1, b1, r2, g2, b2, dr, dg, db, r, g, b;
color565toRGB14(color1,r1,g1,b1);
color565toRGB14(color2,r2,g2,b2);
dr=(r2-r1)/h; dg=(g2-g1)/h; db=(b2-b1)/h;
r=r1;g=g1;b=b1; 

#ifdef ENABLE_ILI9341_FRAMEBUFFER
if (_use_fbtft) {
    if ((x&1) || (w&1)) {
        uint16_t * pfbPixel_row = &_pfbtft[ y*_width + x];
        for (;h>0; h--) {
            uint16_t color = RGB14tocolor565(r,g,b);
            uint16_t * pfbPixel = pfbPixel_row;
            for (int i = 0 ;i < w; i++) {
                *pfbPixel++ = color;
            }
            r+=dr;g+=dg; b+=db;
            pfbPixel_row += _width;
        }
    } else {
        // Horizontal is even number so try 32 bit writes instead
        uint32_t * pfbPixel_row = (uint32_t *)((uint16_t*)&_pfbtft[ y*_width + x]);
        w = w/2;    // only iterate half the times
        for (;h>0; h--) {
            uint32_t * pfbPixel = pfbPixel_row;
            uint16_t color = RGB14tocolor565(r,g,b);
            uint32_t color32 = (color << 16) | color;
            for (int i = 0 ;i < w; i++) {
                *pfbPixel++ = color32;
            }
            pfbPixel_row += (_width/2);
            r+=dr;g+=dg; b+=db;
        }
    }
} else 
#endif
{       
    beginSPITransaction();
    setAddr(x, y, x+w-1, y+h-1);
    writecommand_cont(ILI9341_RAMWR);
    for(y=h; y>0; y--) {
        uint16_t color = RGB14tocolor565(r,g,b);

        for(x=w; x>1; x--) {
            writedata16_cont(color);
        }
        writedata16_last(color);
        if (y > 1 && (y & 1)) {
            endSPITransaction();
            beginSPITransaction();
        }
        r+=dr;g+=dg; b+=db;
    }
    endSPITransaction();
}

}

// fillRectHGradient - fills area with horizontal gradient void ILI9341_t3n::fillRectHGradient(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color1, uint16_t color2) { x+=_originx; y+=_originy;

// Rectangular clipping 
if((x >= _displayclipx2) || (y >= _displayclipy2)) return;
if(x < _displayclipx1) {    w -= (_displayclipx1-x); x = _displayclipx1;    }
if(y < _displayclipy1) {    h -= (_displayclipy1 - y); y = _displayclipy1;  }
if((x + w - 1) >= _displayclipx2)  w = _displayclipx2  - x;
if((y + h - 1) >= _displayclipy2) h = _displayclipy2 - y;

int16_t r1, g1, b1, r2, g2, b2, dr, dg, db, r, g, b;
uint16_t color;
color565toRGB14(color1,r1,g1,b1);
color565toRGB14(color2,r2,g2,b2);
dr=(r2-r1)/w; dg=(g2-g1)/w; db=(b2-b1)/w;
r=r1;g=g1;b=b1; 
#ifdef ENABLE_ILI9341_FRAMEBUFFER
if (_use_fbtft) {
    uint16_t * pfbPixel_row = &_pfbtft[ y*_width + x];
    for (;h>0; h--) {
        uint16_t * pfbPixel = pfbPixel_row;
        for (int i = 0 ;i < w; i++) {
            *pfbPixel++ = RGB14tocolor565(r,g,b);
            r+=dr;g+=dg; b+=db;
        }
        pfbPixel_row += _width;
        r=r1;g=g1;b=b1;
    }
} else 
#endif
{
    beginSPITransaction();
    setAddr(x, y, x+w-1, y+h-1);
    writecommand_cont(ILI9341_RAMWR);
    for(y=h; y>0; y--) {
        for(x=w; x>1; x--) {
            color = RGB14tocolor565(r,g,b);
            writedata16_cont(color);
            r+=dr;g+=dg; b+=db;
        }
        color = RGB14tocolor565(r,g,b);
        writedata16_last(color);
        if (y > 1 && (y & 1)) {
            endSPITransaction();
            beginSPITransaction();
        }
        r=r1;g=g1;b=b1;
    }
    endSPITransaction();
}

}

// fillScreenVGradient - fills screen with vertical gradient void ILI9341_t3n::fillScreenVGradient(uint16_t color1, uint16_t color2) { fillRectVGradient(0,0,_width,_height,color1,color2); }

// fillScreenHGradient - fills screen with horizontal gradient void ILI9341_t3n::fillScreenHGradient(uint16_t color1, uint16_t color2) { fillRectHGradient(0,0,_width,_height,color1,color2); }

define MADCTL_MY 0x80

define MADCTL_MX 0x40

define MADCTL_MV 0x20

define MADCTL_ML 0x10

define MADCTL_RGB 0x00

define MADCTL_BGR 0x08

define MADCTL_MH 0x04

void ILI9341_t3n::setRotation(uint8_t m) { rotation = m % 4; // can't be higher than 3 beginSPITransaction(); writecommand_cont(ILI9341_MADCTL); switch (rotation) { case 0: writedata8_last(MADCTL_MX | MADCTL_BGR); _width = ILI9341_TFTWIDTH; _height = ILI9341_TFTHEIGHT; break; case 1: writedata8_last(MADCTL_MV | MADCTL_BGR); _width = ILI9341_TFTHEIGHT; _height = ILI9341_TFTWIDTH; break; case 2: writedata8_last(MADCTL_MY | MADCTL_BGR); _width = ILI9341_TFTWIDTH; _height = ILI9341_TFTHEIGHT; break; case 3: writedata8_last(MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR); _width = ILI9341_TFTHEIGHT; _height = ILI9341_TFTWIDTH; break; } endSPITransaction(); setClipRect(); setOrigin();

cursor_x = 0;
cursor_y = 0;

}

void ILI9341_t3n::setScroll(uint16_t offset) { beginSPITransaction(); writecommand_cont(ILI9341_VSCRSADD); writedata16_last(offset); endSPITransaction(); }

void ILI9341_t3n::invertDisplay(boolean i) { beginSPITransaction(); writecommand_last(i ? ILI9341_INVON : ILI9341_INVOFF); endSPITransaction(); }

/* uint8_t ILI9341_t3n::readdata(void) { uint8_t r; // Try to work directly with SPI registers... // First wait until output queue is empty uint16_t wTimeout = 0xffff; while (((_pkinetisk_spi->SR) & (15 << 12)) && (--wTimeout)) ; // wait until empty

// _pkinetisk_spi->MCR |= SPI_MCR_CLR_RXF; // discard any received data // _pkinetisk_spi->SR = SPI_SR_TCF;

    // Transfer a 0 out... 
    writedata8_cont(0);   

    // Now wait until completed. 
    wTimeout = 0xffff;
    while (((_pkinetisk_spi->SR) & (15 << 12)) && (--wTimeout)) ; // wait until empty
    r = _pkinetisk_spi->POPR;  // get the received byte... should check for it first...
return r;

} */

uint8_t ILI9341_t3n::readcommand8(uint8_t c, uint8_t index) { // Bail if not valid miso if (_miso == 0xff) return 0;

ifdef KINETISK

uint16_t wTimeout = 0xffff;
uint8_t r=0;

beginSPITransaction();
if (_pspin->sizeFIFO() >= 4) {
    while (((_pkinetisk_spi->SR) & (15 << 12)) && (--wTimeout)) ; // wait until empty

    // Make sure the last frame has been sent...
    _pkinetisk_spi->SR = SPI_SR_TCF;   // dlear it out;
    wTimeout = 0xffff;
    while (!((_pkinetisk_spi->SR) & SPI_SR_TCF) && (--wTimeout)) ; // wait until it says the last frame completed

    // clear out any current received bytes
    wTimeout = 0x10;    // should not go more than 4...
    while ((((_pkinetisk_spi->SR) >> 4) & 0xf) && (--wTimeout))  {
        r = _pkinetisk_spi->POPR;
    }

    //writecommand(0xD9); // sekret command
    _pkinetisk_spi->PUSHR = 0xD9 | (pcs_command << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_CONT;
//  while (((_pkinetisk_spi->SR) & (15 << 12)) > (3 << 12)) ; // wait if FIFO full

    // writedata(0x10 + index);
    _pkinetisk_spi->PUSHR = (0x10 + index) | (pcs_data << 16) | SPI_PUSHR_CTAS(0);
//  while (((_pkinetisk_spi->SR) & (15 << 12)) > (3 << 12)) ; // wait if FIFO full
    // writecommand(c);
    _pkinetisk_spi->PUSHR = c | (pcs_command << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_CONT;
//  while (((_pkinetisk_spi->SR) & (15 << 12)) > (3 << 12)) ; // wait if FIFO full

    // readdata
    _pkinetisk_spi->PUSHR = 0 | (pcs_data << 16) | SPI_PUSHR_CTAS(0);
//  while (((_pkinetisk_spi->SR) & (15 << 12)) > (3 << 12)) ; // wait if FIFO full

    // Now wait until completed.
    wTimeout = 0xffff;
    while (((_pkinetisk_spi->SR) & (15 << 12)) && (--wTimeout)) ; // wait until empty

    // Make sure the last frame has been sent...
    _pkinetisk_spi->SR = SPI_SR_TCF;   // dlear it out;
    wTimeout = 0xffff;
    while (!((_pkinetisk_spi->SR) & SPI_SR_TCF) && (--wTimeout)) ; // wait until it says the last frame completed

    wTimeout = 0x10;    // should not go more than 4...
    // lets get all of the values on the FIFO
    while ((((_pkinetisk_spi->SR) >> 4) & 0xf) && (--wTimeout))  {
        r = _pkinetisk_spi->POPR;
    }
} else {
    while (((_pkinetisk_spi->SR) & (15 << 12)) && (--wTimeout)) ; // wait until empty

    // Make sure the last frame has been sent...
    _pkinetisk_spi->SR = SPI_SR_TCF;   // dlear it out;
    wTimeout = 0xffff;
    while (!((_pkinetisk_spi->SR) & SPI_SR_TCF) && (--wTimeout)) ; // wait until it says the last frame completed

    // clear out any current received bytes
    wTimeout = 0x10;    // should not go more than 4...
    while ((((_pkinetisk_spi->SR) >> 4) & 0xf) && (--wTimeout))  {
        r = _pkinetisk_spi->POPR;
    }

    //writecommand(0xD9); // sekret command
    _pkinetisk_spi->PUSHR = 0xD9 | (pcs_command << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_CONT;
    while (((_pkinetisk_spi->SR) & (15 << 12)) > (0 << 12)) ; // wait if FIFO full

    // writedata(0x10 + index);
    _pkinetisk_spi->PUSHR = (0x10 + index) | (pcs_data << 16) | SPI_PUSHR_CTAS(0);
    while (((_pkinetisk_spi->SR) & (15 << 12)) > (0 << 12)) ; // wait if FIFO full

    // See if there are any return values to pop 
    while (((_pkinetisk_spi->SR) >> 4) & 0xf)  {
        r = _pkinetisk_spi->POPR;
    }

    // writecommand(c);
    _pkinetisk_spi->PUSHR = c | (pcs_command << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_CONT;
    while (((_pkinetisk_spi->SR) & (15 << 12)) > (0 << 12)) ; // wait if FIFO full

    // See if there are any return values to pop 
    while (((_pkinetisk_spi->SR) >> 4) & 0xf)  {
        r = _pkinetisk_spi->POPR;
    }

    // readdata
    _pkinetisk_spi->PUSHR = 0 | (pcs_data << 16) | SPI_PUSHR_CTAS(0);
    while (((_pkinetisk_spi->SR) & (15 << 12)) > (0 << 12)) ; // wait if FIFO full

    // See if there are any return values to pop 
    while (((_pkinetisk_spi->SR) >> 4) & 0xf)  {
        r = _pkinetisk_spi->POPR;
    }
    // Now wait until completed.
    wTimeout = 0xffff;
    while (((_pkinetisk_spi->SR) & (15 << 12)) && (--wTimeout)) ; // wait until empty

    // Make sure the last frame has been sent...
    _pkinetisk_spi->SR = SPI_SR_TCF;   // dlear it out;
    wTimeout = 0xffff;
    while (!((_pkinetisk_spi->SR) & SPI_SR_TCF) && (--wTimeout)) ; // wait until it says the last frame completed

    wTimeout = 0x10;    // should not go more than 4...
    // lets get all of the values on the FIFO
    while ((((_pkinetisk_spi->SR) >> 4) & 0xf) && (--wTimeout))  {
        r = _pkinetisk_spi->POPR;
    }

}  
endSPITransaction();
return r;  // get the received byte... should check for it first...

else

beginSPITransaction();
writecommand_cont(0xD9);
writedata8_cont(0x10 + index);

writecommand_cont(c);
writedata8_cont(0);
uint8_t r = waitTransmitCompleteReturnLast();
endSPITransaction();
return r;

endif

}

// Read Pixel at x,y and get back 16-bit packed color

define READ_PIXEL_PUSH_BYTE 0x3f

uint16_t ILI9341_t3n::readPixel(int16_t x, int16_t y) {

ifdef KINETISK

//BUGBUG:: Should add some validation of X and Y
// Now if we are in buffer mode can return real fast
#ifdef ENABLE_ILI9341_FRAMEBUFFER
if (_use_fbtft) {
    x+=_originx;
    y+=_originy;

    return _pfbtft[y*_width + x] ;
}
#endif

if (_miso == 0xff) return 0xffff; // bail if not valid miso

// First pass for other SPI busses use readRect to handle the read... 
if (_pspin->sizeFIFO() < 4) {
    uint16_t colors;
    readRect(x, y, 1, 1, &colors);
    return colors;
}

uint8_t dummy __attribute__((unused));
uint8_t r,g,b;

beginSPITransaction(ILI9341_SPICLOCK_READ);

// Update our origin. 
x+=_originx;
y+=_originy;

setAddr(x, y, x, y);
writecommand_cont(ILI9341_RAMRD); // read from RAM
_pspin->waitTransmitComplete();

// Push 4 bytes over SPI
_pkinetisk_spi->PUSHR = 0 | (pcs_data << 16) | SPI_PUSHR_CTAS(0)| SPI_PUSHR_CONT;
_pspin->waitFifoEmpty();    // wait for both queues to be empty.

_pkinetisk_spi->PUSHR = 0 | (pcs_data << 16) | SPI_PUSHR_CTAS(0)| SPI_PUSHR_CONT;
_pkinetisk_spi->PUSHR = 0 | (pcs_data << 16) | SPI_PUSHR_CTAS(0)| SPI_PUSHR_CONT;
_pkinetisk_spi->PUSHR = 0 | (pcs_data << 16) | SPI_PUSHR_CTAS(0)| SPI_PUSHR_EOQ;

// Wait for End of Queue
while ((_pkinetisk_spi->SR & SPI_SR_EOQF) == 0) ;
_pkinetisk_spi->SR = SPI_SR_EOQF;  // make sure it is clear

// Read Pixel Data
dummy = _pkinetisk_spi->POPR;   // Read a DUMMY byte of GRAM
r = _pkinetisk_spi->POPR;       // Read a RED byte of GRAM
g = _pkinetisk_spi->POPR;       // Read a GREEN byte of GRAM
b = _pkinetisk_spi->POPR;       // Read a BLUE byte of GRAM

endSPITransaction();
return color565(r,g,b);

else

// Kinetisk
uint16_t colors;
readRect(x, y, 1, 1, &colors);
return colors;

endif

}

// Now lets see if we can read in multiple pixels

ifdef KINETISK

void ILI9341_t3n::readRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t *pcolors) { // Use our Origin. x+=_originx; y+=_originy; //BUGBUG:: Should add some validation of X and Y

#ifdef ENABLE_ILI9341_FRAMEBUFFER
if (_use_fbtft) {
    uint16_t * pfbPixel_row = &_pfbtft[ y*_width + x];
    for (;h>0; h--) {
        uint16_t * pfbPixel = pfbPixel_row;
        for (int i = 0 ;i < w; i++) {
            *pcolors++ = *pfbPixel++;
        }
        pfbPixel_row += _width;
    }
    return; 
}
#endif

if (_miso == 0xff) return; // bail if not valid miso

uint8_t rgb[3];               // RGB bytes received from the display
uint8_t rgbIdx = 0;
uint32_t txCount = w * h * 3; // number of bytes we will transmit to the display
uint32_t rxCount = txCount;   // number of bytes we will receive back from the display

beginSPITransaction(ILI9341_SPICLOCK_READ);

setAddr(x, y, x+w-1, y+h-1);
writecommand_cont(ILI9341_RAMRD); // read from RAM

// transmit a DUMMY byte before the color bytes
_pkinetisk_spi->PUSHR = 0 | (pcs_data << 16) | SPI_PUSHR_CTAS(0)| SPI_PUSHR_CONT;

// skip values returned by the queued up transfers and the current in-flight transfer
uint32_t sr = _pkinetisk_spi->SR;
uint8_t skipCount = ((sr >> 4) & 0xF) + ((sr >> 12) & 0xF) + 1;

while (txCount || rxCount) {
    // transmit another byte if possible
    if (txCount && ((_pkinetisk_spi->SR & 0xF000) >> 12) < _pspin->sizeFIFO()) {
        txCount--;
        if (txCount) {
            _pkinetisk_spi->PUSHR = READ_PIXEL_PUSH_BYTE | (pcs_data << 16) | SPI_PUSHR_CTAS(0)| SPI_PUSHR_CONT;
        } else {
            _pkinetisk_spi->PUSHR = READ_PIXEL_PUSH_BYTE | (pcs_data << 16) | SPI_PUSHR_CTAS(0)| SPI_PUSHR_EOQ;
        }
    }

    // receive another byte if possible, and either skip it or store the color
    if (rxCount && (_pkinetisk_spi->SR & 0xF0)) {
        rgb[rgbIdx] = _pkinetisk_spi->POPR;

        if (skipCount) {
            skipCount--;
        } else {
            rxCount--;
            rgbIdx++;
            if (rgbIdx == 3) {
                rgbIdx = 0;
                *pcolors++ = color565(rgb[0], rgb[1], rgb[2]);
            }
        }
    }
}

// wait for End of Queue
while ((_pkinetisk_spi->SR & SPI_SR_EOQF) == 0) ;
_pkinetisk_spi->SR = SPI_SR_EOQF;  // make sure it is clear
endSPITransaction();

}

else

// Teensy LC version void ILI9341_t3n::readRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t *pcolors) { // Use our Origin. x+=_originx; y+=_originy; //BUGBUG:: Should add some validation of X and Y

if (_miso == 0xff) return; // bail if not valid miso

uint8_t rgb[3];               // RGB bytes received from the display
uint8_t rgbIdx = 0;
uint32_t txCount = w * h * 3; // number of bytes we will transmit to the display
uint32_t rxCount = txCount;   // number of bytes we will receive back from the display

beginSPITransaction(ILI9341_SPICLOCK_READ);

setAddr(x, y, x+w-1, y+h-1);
writecommand_cont(ILI9341_RAMRD); // read from RAM

// transmit a DUMMY byte before the color bytes
writedata8_cont(0);

// Wait until that one returns, Could do a little better and double buffer but this is easer for now.
waitTransmitComplete();

// Since double buffer setup lets try keeping read/write in sync

define RRECT_TIMEOUT 0xffff

undef READ_PIXEL_PUSH_BYTE

define READ_PIXEL_PUSH_BYTE 0 // try with zero to see...

uint16_t timeout_countdown = RRECT_TIMEOUT;
uint16_t dl_in;
// Write out first byte:

while (!(_pkinetisl_spi->S & SPI_S_SPTEF)) ; // Not worried that this can completely hang?
_pkinetisl_spi->DL = READ_PIXEL_PUSH_BYTE;

while (rxCount && timeout_countdown) {
    // Now wait until we can output something
    dl_in = 0xffff;
    if (rxCount > 1) {
        while (!(_pkinetisl_spi->S & SPI_S_SPTEF)) ; // Not worried that this can completely hang?
        if (_pkinetisl_spi->S & SPI_S_SPRF)
            dl_in = _pkinetisl_spi->DL;  
        _pkinetisl_spi->DL = READ_PIXEL_PUSH_BYTE;
    }

    // Now wait until there is a byte available to receive
    while ((dl_in != 0xffff) && !(_pkinetisl_spi->S & SPI_S_SPRF) && --timeout_countdown) ;
    if (timeout_countdown) {   // Make sure we did not get here because of timeout 
        rxCount--;
        rgb[rgbIdx] = (dl_in != 0xffff)? dl_in : _pkinetisl_spi->DL;
        rgbIdx++;
        if (rgbIdx == 3) {
            rgbIdx = 0;
            *pcolors++ = color565(rgb[0], rgb[1], rgb[2]);
        }
        timeout_countdown = timeout_countdown;
    }
}

// Debug code.

/ if (timeout_countdown == 0) { Serial.print("RRect Timeout "); Serial.println(rxCount, DEC); } / endSPITransaction(); }

endif

// Now lets see if we can writemultiple pixels void ILI9341_t3n::writeRect(int16_t x, int16_t y, int16_t w, int16_t h, const uint16_t *pcolors) {

x+=_originx;
y+=_originy;
uint16_t x_clip_left = 0;  // How many entries at start of colors to skip at start of row
uint16_t x_clip_right = 0;    // how many color entries to skip at end of row for clipping
// Rectangular clipping 

// See if the whole thing out of bounds...
if((x >= _displayclipx2) || (y >= _displayclipy2)) return;
if (((x+w) <= _displayclipx1) || ((y+h) <= _displayclipy1)) return;

// In these cases you can not do simple clipping, as we need to synchronize the colors array with the
// We can clip the height as when we get to the last visible we don't have to go any farther. 
// also maybe starting y as we will advance the color array. 
if(y < _displayclipy1) {
    int dy = (_displayclipy1 - y);
    h -= dy; 
    pcolors += (dy*w); // Advance color array to 
    y = _displayclipy1;     
}

if((y + h - 1) >= _displayclipy2) h = _displayclipy2 - y;

// For X see how many items in color array to skip at start of row and likewise end of row 
if(x < _displayclipx1) {
    x_clip_left = _displayclipx1-x; 
    w -= x_clip_left; 
    x = _displayclipx1;     
}
if((x + w - 1) >= _displayclipx2) {
    x_clip_right = w;
    w = _displayclipx2  - x;
    x_clip_right -= w; 
} 

#ifdef ENABLE_ILI9341_FRAMEBUFFER
if (_use_fbtft) {
    uint16_t * pfbPixel_row = &_pfbtft[ y*_width + x];
    for (;h>0; h--) {
        uint16_t * pfbPixel = pfbPixel_row;
        pcolors += x_clip_left;
        for (int i = 0 ;i < w; i++) {
            *pfbPixel++ = *pcolors++;
        }
        pfbPixel_row += _width;
        pcolors += x_clip_right;

    }
    return; 
}
#endif

beginSPITransaction();
setAddr(x, y, x+w-1, y+h-1);
writecommand_cont(ILI9341_RAMWR);
for(y=h; y>0; y--) {
    pcolors += x_clip_left;
    for(x=w; x>1; x--) {
        writedata16_cont(*pcolors++);
    }
    writedata16_last(*pcolors++);
    pcolors += x_clip_right;
}
endSPITransaction();

}

// writeRect8BPP - write 8 bit per pixel paletted bitmap // bitmap data in array at pixels, one byte per pixel // color palette data in array at palette void ILI9341_t3n::writeRect8BPP(int16_t x, int16_t y, int16_t w, int16_t h, const uint8_t pixels, const uint16_t palette ) { //Serial.printf("\nWR8: %d %d %d %d %x\n", x, y, w, h, (uint32_t)pixels); x+=_originx; y+=_originy;

uint16_t x_clip_left = 0;  // How many entries at start of colors to skip at start of row
uint16_t x_clip_right = 0;    // how many color entries to skip at end of row for clipping
// Rectangular clipping 

// See if the whole thing out of bounds...
if((x >= _displayclipx2) || (y >= _displayclipy2)) return;
if (((x+w) <= _displayclipx1) || ((y+h) <= _displayclipy1)) return;

// In these cases you can not do simple clipping, as we need to synchronize the colors array with the
// We can clip the height as when we get to the last visible we don't have to go any farther. 
// also maybe starting y as we will advance the color array. 
if(y < _displayclipy1) {
    int dy = (_displayclipy1 - y);
    h -= dy; 
    pixels += (dy*w); // Advance color array to 
    y = _displayclipy1;     
}

if((y + h - 1) >= _displayclipy2) h = _displayclipy2 - y;

// For X see how many items in color array to skip at start of row and likewise end of row 
if(x < _displayclipx1) {
    x_clip_left = _displayclipx1-x; 
    w -= x_clip_left; 
    x = _displayclipx1;     
}
if((x + w - 1) >= _displayclipx2) {
    x_clip_right = w;
    w = _displayclipx2  - x;
    x_clip_right -= w; 
} 
//Serial.printf("WR8C: %d %d %d %d %x- %d %d\n", x, y, w, h, (uint32_t)pixels, x_clip_right, x_clip_left);
#ifdef ENABLE_ILI9341_FRAMEBUFFER
if (_use_fbtft) {
    uint16_t * pfbPixel_row = &_pfbtft[ y*_width + x];
    for (;h>0; h--) {
        pixels += x_clip_left;
        uint16_t * pfbPixel = pfbPixel_row;
        for (int i = 0 ;i < w; i++) {
            *pfbPixel++ = palette[*pixels++];
        }
        pixels += x_clip_right;
        pfbPixel_row += _width;
    }
    return; 
}
#endif

beginSPITransaction();
setAddr(x, y, x+w-1, y+h-1);
writecommand_cont(ILI9341_RAMWR);
for(y=h; y>0; y--) {
    pixels += x_clip_left;
    //Serial.printf("%x: ", (uint32_t)pixels);
    for(x=w; x>1; x--) {
        //Serial.print(*pixels, DEC);
        writedata16_cont(palette[*pixels++]);
    }
    //Serial.println(*pixels, DEC);
    writedata16_last(palette[*pixels++]);
    pixels += x_clip_right;
}
endSPITransaction();

}

// writeRect4BPP - write 4 bit per pixel paletted bitmap // bitmap data in array at pixels, 4 bits per pixel // color palette data in array at palette // width must be at least 2 pixels void ILI9341_t3n::writeRect4BPP(int16_t x, int16_t y, int16_t w, int16_t h, const uint8_t pixels, const uint16_t palette ) { // Simply call through our helper writeRectNBPP(x, y, w, h, 4, pixels, palette ); }

// writeRect2BPP - write 2 bit per pixel paletted bitmap // bitmap data in array at pixels, 4 bits per pixel // color palette data in array at palette // width must be at least 4 pixels void ILI9341_t3n::writeRect2BPP(int16_t x, int16_t y, int16_t w, int16_t h, const uint8_t pixels, const uint16_t palette ) { // Simply call through our helper writeRectNBPP(x, y, w, h, 2, pixels, palette );

}

///============================================================================ // writeRect1BPP - write 1 bit per pixel paletted bitmap // bitmap data in array at pixels, 4 bits per pixel // color palette data in array at palette // width must be at least 8 pixels void ILI9341_t3n::writeRect1BPP(int16_t x, int16_t y, int16_t w, int16_t h, const uint8_t pixels, const uint16_t palette ) { // Simply call through our helper writeRectNBPP(x, y, w, h, 1, pixels, palette ); }

///============================================================================ // writeRectNBPP - write N(1, 2, 4, 8) bit per pixel paletted bitmap // bitmap data in array at pixels // Currently writeRect1BPP, writeRect2BPP, writeRect4BPP use this to do all of the work. void ILI9341_t3n::writeRectNBPP(int16_t x, int16_t y, int16_t w, int16_t h, uint8_t bits_per_pixel, const uint8_t pixels, const uint16_t palette ) { //Serial.printf("\nWR8: %d %d %d %d %x\n", x, y, w, h, (uint32_t)pixels); x+=_originx; y+=_originy; uint8_t pixels_per_byte = 8/ bits_per_pixel; uint16_t count_of_bytes_per_row = (w + pixels_per_byte -1)/pixels_per_byte; // Round up to handle non multiples uint8_t row_shift_init = 8 - bits_per_pixel; // We shift down 6 bits by default uint8_t pixel_bit_mask = (1 << bits_per_pixel) - 1; // get mask to use below // Rectangular clipping

// See if the whole thing out of bounds...
if((x >= _displayclipx2) || (y >= _displayclipy2)) return;
if (((x+w) <= _displayclipx1) || ((y+h) <= _displayclipy1)) return;

// In these cases you can not do simple clipping, as we need to synchronize the colors array with the
// We can clip the height as when we get to the last visible we don't have to go any farther. 
// also maybe starting y as we will advance the color array. 
// Again assume multiple of 8 for width
if(y < _displayclipy1) {
    int dy = (_displayclipy1 - y);
    h -= dy; 
    pixels += dy * count_of_bytes_per_row;
    y = _displayclipy1;     
}

if((y + h - 1) >= _displayclipy2) h = _displayclipy2 - y;

// For X see how many items in color array to skip at start of row and likewise end of row 
if(x < _displayclipx1) {
    uint16_t x_clip_left = _displayclipx1-x; 
    w -= x_clip_left; 
    x = _displayclipx1; 
    // Now lets update pixels to the rigth offset and mask
    uint8_t x_clip_left_bytes_incr = x_clip_left / pixels_per_byte;
    pixels += x_clip_left_bytes_incr;
    row_shift_init = 8 - (x_clip_left - (x_clip_left_bytes_incr * pixels_per_byte) + 1) * bits_per_pixel;   
}

if((x + w - 1) >= _displayclipx2) {
    w = _displayclipx2  - x;
} 

const uint8_t * pixels_row_start = pixels;  // remember our starting position offset into row

#ifdef ENABLE_ILI9341_FRAMEBUFFER
if (_use_fbtft) {
    uint16_t * pfbPixel_row = &_pfbtft[ y*_width + x];
    for (;h>0; h--) {
        uint16_t * pfbPixel = pfbPixel_row;
        pixels = pixels_row_start;              // setup for this row
        uint8_t pixel_shift = row_shift_init;           // Setup mask

        for (int i = 0 ; i < w; i++) {
            *pfbPixel++ = palette[((*pixels)>>pixel_shift) & pixel_bit_mask];
            if (!pixel_shift) {
                pixel_shift = 8 - bits_per_pixel;   //setup next mask
                pixels++;
            } else {
                pixel_shift -= bits_per_pixel;
            }
        }
        pfbPixel_row += _width;
        pixels_row_start += count_of_bytes_per_row;
    }
    return; 

}
#endif

beginSPITransaction();
setAddr(x, y, x+w-1, y+h-1);
writecommand_cont(ILI9341_RAMWR);
for (;h>0; h--) {
    pixels = pixels_row_start;              // setup for this row
    uint8_t pixel_shift = row_shift_init;           // Setup mask

    for (int i = 0 ;i < w; i++) {
        writedata16_cont(palette[((*pixels)>>pixel_shift) & pixel_bit_mask]);
        if (!pixel_shift) {
            pixel_shift = 8 - bits_per_pixel;   //setup next mask
            pixels++;
        } else {
            pixel_shift -= bits_per_pixel;
        }
    }
    pixels_row_start += count_of_bytes_per_row;
}
writecommand_last(ILI9341_NOP);
endSPITransaction();

}

static const uint8_t init_commands[] = { 4, 0xEF, 0x03, 0x80, 0x02, 4, 0xCF, 0x00, 0XC1, 0X30, 5, 0xED, 0x64, 0x03, 0X12, 0X81, 4, 0xE8, 0x85, 0x00, 0x78, 6, 0xCB, 0x39, 0x2C, 0x00, 0x34, 0x02, 2, 0xF7, 0x20, 3, 0xEA, 0x00, 0x00, 2, ILI9341_PWCTR1, 0x23, // Power control 2, ILI9341_PWCTR2, 0x10, // Power control 3, ILI9341_VMCTR1, 0x3e, 0x28, // VCM control 2, ILI9341_VMCTR2, 0x86, // VCM control2 2, ILI9341_MADCTL, 0x48, // Memory Access Control 2, ILI9341_PIXFMT, 0x55, 3, ILI9341_FRMCTR1, 0x00, 0x18, 4, ILI9341_DFUNCTR, 0x08, 0x82, 0x27, // Display Function Control 2, 0xF2, 0x00, // Gamma Function Disable 2, ILI9341_GAMMASET, 0x01, // Gamma curve selected 16, ILI9341_GMCTRP1, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, 0x4E, 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00, // Set Gamma 16, ILI9341_GMCTRN1, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, 0x31, 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F, // Set Gamma 0 };

void ILI9341_t3n::begin(void) { // verify SPI pins are valid; // allow user to say use current ones...

ifdef DEBUG_ASYNC_UPDATE

Serial.printf("????? _dmasettings[0] %x %x\n", (uint32_t)&_dmasettings[0], (uint32_t)_dmasettings[0].TCD); Serial.flush();

endif

if ((_mosi != 255) || (_miso != 255) || (_sclk != 255)) {
    if (!(_pspin->pinIsMOSI(_mosi)) || !(_pspin->pinIsMISO(_miso)) || !(_pspin->pinIsSCK(_sclk))) {
        #ifdef SPIN1_OBJECT_CREATED         
        if (SPIN1.pinIsMOSI(_mosi) && SPIN1.pinIsMISO(_miso) && SPIN1.pinIsSCK(_sclk)) {
            _pspin = &SPIN1;

ifdef KINETISK

_pkinetisk_spi = _pspin->kinetisk_spi();

else

_pkinetisl_spi = _pspin->kinetisl_spi();

endif

            //Serial.println("ILI9341_t3n: SPIN1 automatically selected");
        } else {
            #ifdef SPIN2_OBJECT_CREATED         
            if (SPIN2.pinIsMOSI(_mosi) && SPIN2.pinIsMISO(_miso) && SPIN2.pinIsSCK(_sclk)) {
                _pspin = &SPIN2;
                _pkinetisk_spi = _pspin->kinetisk_spi();
                //Serial.println("ILI9341_t3n: SPIN2 automatically selected");
            } else {
            #endif
        #endif
                uint8_t mosi_sck_bad = false;
                Serial.print("ILI9341_t3n: Error not valid SPI pins:");
                if(!(_pspin->pinIsMOSI(_mosi)))  {
                    Serial.print(" MOSI");
                    mosi_sck_bad = true;
                }
                if (!_pspin->pinIsSCK(_sclk)) {
                    Serial.print(" SCLK");
                    mosi_sck_bad = true;
                }

                // Maybe allow us to limp with only MISO bad
                if(!(_pspin->pinIsMISO(_miso))) {
                    Serial.print(" MISO");
                    _miso = 0xff;   // set miso to 255 as flag it is bad
                }
                Serial.println();

                if (mosi_sck_bad) {
                    return; // not valid pins...
                }
            #ifdef SPIN2_OBJECT_CREATED         
            }
            #endif
        #ifdef SPIN1_OBJECT_CREATED         
        }
        #endif

    }
    //Serial.printf("MOSI:%d MISO:%d SCK:%d\n\r", _mosi, _miso, _sclk);         
    _pspin->setMOSI(_mosi);
    if (_miso != 0xff) _pspin->setMISO(_miso);
    _pspin->setSCK(_sclk);
}

_pspin->begin();

ifdef KINETISK

if (_pspin->pinIsChipSelect(_cs, _dc)) {
    pcs_data = _pspin->setCS(_cs);
    pcs_command = pcs_data | _pspin->setCS(_dc);
} else {
    // See if at least DC is on chipselect pin, if so try to limp along...
    if (_pspin->pinIsChipSelect(_dc)) {
        pcs_data = 0;
        pcs_command = pcs_data | _pspin->setCS(_dc);
        pinMode(_cs, OUTPUT);
        _csport    = portOutputRegister(digitalPinToPort(_cs));
        _cspinmask = digitalPinToBitMask(_cs);
        *_csport |= _cspinmask;
    } else {
        pcs_data = 0;
        pcs_command = 0;
        Serial.println("ILI9341_t3n: Error not DC is not valid hardware CS pin");
        return;
    }
}

else

// TLC
pcs_data = 0;
pcs_command = 0;
pinMode(_cs, OUTPUT);
_csport    = portOutputRegister(digitalPinToPort(_cs));
_cspinmask = digitalPinToBitMask(_cs);
*_csport |= _cspinmask;
pinMode(_dc, OUTPUT);
_dcport    = portOutputRegister(digitalPinToPort(_dc));
_dcpinmask = digitalPinToBitMask(_dc);
*_dcport |= _dcpinmask;
_dcpinAsserted = 0;

endif

// toggle RST low to reset
if (_rst < 255) {
    pinMode(_rst, OUTPUT);
    digitalWrite(_rst, HIGH);
    delay(5);
    digitalWrite(_rst, LOW);
    delay(20);
    digitalWrite(_rst, HIGH);
    delay(150);
}

/ uint8_t x = readcommand8(ILI9341_RDMODE); Serial.print("\nDisplay Power Mode: 0x"); Serial.println(x, HEX); x = readcommand8(ILI9341_RDMADCTL); Serial.print("\nMADCTL Mode: 0x"); Serial.println(x, HEX); x = readcommand8(ILI9341_RDPIXFMT); Serial.print("\nPixel Format: 0x"); Serial.println(x, HEX); x = readcommand8(ILI9341_RDIMGFMT); Serial.print("\nImage Format: 0x"); Serial.println(x, HEX); x = readcommand8(ILI9341_RDSELFDIAG); Serial.print("\nSelf Diagnostic: 0x"); Serial.println(x, HEX); /
beginSPITransaction(); const uint8_t addr = init_commands; while (1) { uint8_t count = addr++; if (count-- == 0) break; writecommand_cont(addr++); while (count-- > 0) { writedata8_cont(addr++); } } writecommand_last(ILI9341_SLPOUT); // Exit Sleep endSPITransaction(); delay(120);
beginSPITransaction(); writecommand_last(ILI9341_DISPON); // Display on endSPITransaction(); }

/* This is the core graphics library for all our displays, providing a common set of graphics primitives (points, lines, circles, etc.). It needs to be paired with a hardware-specific library for each display device we carry (to handle the lower-level functions).

Adafruit invests time and resources providing this open source code, please support Adafruit & open-source hardware by purchasing products from Adafruit!

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */

//#include "glcdfont.c" extern "C" const unsigned char glcdfont[];

// Draw a circle outline void ILI9341_t3n::drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) { int16_t f = 1 - r; int16_t ddF_x = 1; int16_t ddF_y = -2 * r; int16_t x = 0; int16_t y = r;

drawPixel(x0 , y0+r, color); drawPixel(x0 , y0-r, color); drawPixel(x0+r, y0 , color); drawPixel(x0-r, y0 , color);

while (x<y) { if (f >= 0) { y--; ddF_y += 2; f += ddF_y; } x++; ddF_x += 2; f += ddF_x;

drawPixel(x0 + x, y0 + y, color);
drawPixel(x0 - x, y0 + y, color);
drawPixel(x0 + x, y0 - y, color);
drawPixel(x0 - x, y0 - y, color);
drawPixel(x0 + y, y0 + x, color);
drawPixel(x0 - y, y0 + x, color);
drawPixel(x0 + y, y0 - x, color);
drawPixel(x0 - y, y0 - x, color);

} }

void ILI9341_t3n::drawCircleHelper( int16_t x0, int16_t y0, int16_t r, uint8_t cornername, uint16_t color) { int16_t f = 1 - r; int16_t ddF_x = 1; int16_t ddF_y = -2 * r; int16_t x = 0; int16_t y = r;

while (x<y) { if (f >= 0) { y--; ddF_y += 2; f += ddF_y; } x++; ddF_x += 2; f += ddF_x; if (cornername & 0x4) { drawPixel(x0 + x, y0 + y, color); drawPixel(x0 + y, y0 + x, color); } if (cornername & 0x2) { drawPixel(x0 + x, y0 - y, color); drawPixel(x0 + y, y0 - x, color); } if (cornername & 0x8) { drawPixel(x0 - y, y0 + x, color); drawPixel(x0 - x, y0 + y, color); } if (cornername & 0x1) { drawPixel(x0 - y, y0 - x, color); drawPixel(x0 - x, y0 - y, color); } } }

void ILI9341_t3n::fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color) { drawFastVLine(x0, y0-r, 2*r+1, color); fillCircleHelper(x0, y0, r, 3, 0, color); }

// Used to do circles and roundrects void ILI9341_t3n::fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color) {

int16_t f = 1 - r; int16_t ddF_x = 1; int16_t ddF_y = -2 * r; int16_t x = 0; int16_t y = r;

while (x<y) { if (f >= 0) { y--; ddF_y += 2; f += ddF_y; } x++; ddF_x += 2; f += ddF_x;

if (cornername & 0x1) {
  drawFastVLine(x0+x, y0-y, 2*y+1+delta, color);
  drawFastVLine(x0+y, y0-x, 2*x+1+delta, color);
}
if (cornername & 0x2) {
  drawFastVLine(x0-x, y0-y, 2*y+1+delta, color);
  drawFastVLine(x0-y, y0-x, 2*x+1+delta, color);
}

} }

// Bresenham's algorithm - thx wikpedia void ILI9341_t3n::drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) { if (y0 == y1) { if (x1 > x0) { drawFastHLine(x0, y0, x1 - x0 + 1, color); } else if (x1 < x0) { drawFastHLine(x1, y0, x0 - x1 + 1, color); } else { drawPixel(x0, y0, color); } return; } else if (x0 == x1) { if (y1 > y0) { drawFastVLine(x0, y0, y1 - y0 + 1, color); } else { drawFastVLine(x0, y1, y0 - y1 + 1, color); } return; }

bool steep = abs(y1 - y0) > abs(x1 - x0);
if (steep) {
    swap(x0, y0);
    swap(x1, y1);
}
if (x0 > x1) {
    swap(x0, x1);
    swap(y0, y1);
}

int16_t dx, dy;
dx = x1 - x0;
dy = abs(y1 - y0);

int16_t err = dx / 2;
int16_t ystep;

if (y0 < y1) {
    ystep = 1;
} else {
    ystep = -1;
}

beginSPITransaction();
int16_t xbegin = x0;
if (steep) {
    for (; x0<=x1; x0++) {
        err -= dy;
        if (err < 0) {
            int16_t len = x0 - xbegin;
            if (len) {
                VLine(y0, xbegin, len + 1, color);
            } else {
                Pixel(y0, x0, color);
            }
            xbegin = x0 + 1;
            y0 += ystep;
            err += dx;
        }
    }
    if (x0 > xbegin + 1) {
        VLine(y0, xbegin, x0 - xbegin, color);
    }

} else {
    for (; x0<=x1; x0++) {
        err -= dy;
        if (err < 0) {
            int16_t len = x0 - xbegin;
            if (len) {
                HLine(xbegin, y0, len + 1, color);
            } else {
                Pixel(x0, y0, color);
            }
            xbegin = x0 + 1;
            y0 += ystep;
            err += dx;
        }
    }
    if (x0 > xbegin + 1) {
        HLine(xbegin, y0, x0 - xbegin, color);
    }
}
writecommand_last(ILI9341_NOP);
endSPITransaction();

}

// Draw a rectangle void ILI9341_t3n::drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) {

ifdef ENABLE_ILI9341_FRAMEBUFFER

if (_use_fbtft) {
    drawFastHLine(x, y, w, color);
    drawFastHLine(x, y+h-1, w, color);
    drawFastVLine(x, y, h, color);
    drawFastVLine(x+w-1, y, h, color);
} else 
#endif
{
    beginSPITransaction();
    HLine(x, y, w, color);
    HLine(x, y+h-1, w, color);
    VLine(x, y, h, color);
    VLine(x+w-1, y, h, color);
    writecommand_last(ILI9341_NOP);
    endSPITransaction();
}

}

// Draw a rounded rectangle void ILI9341_t3n::drawRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color) { // smarter version drawFastHLine(x+r , y , w-2r, color); // Top drawFastHLine(x+r , y+h-1, w-2r, color); // Bottom drawFastVLine(x , y+r , h-2r, color); // Left drawFastVLine(x+w-1, y+r , h-2r, color); // Right // draw four corners drawCircleHelper(x+r , y+r , r, 1, color); drawCircleHelper(x+w-r-1, y+r , r, 2, color); drawCircleHelper(x+w-r-1, y+h-r-1, r, 4, color); drawCircleHelper(x+r , y+h-r-1, r, 8, color); }

// Fill a rounded rectangle void ILI9341_t3n::fillRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color) { // smarter version fillRect(x+r, y, w-2*r, h, color);

// draw four corners fillCircleHelper(x+w-r-1, y+r, r, 1, h-2r-1, color); fillCircleHelper(x+r , y+r, r, 2, h-2r-1, color); }

// Draw a triangle void ILI9341_t3n::drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) { drawLine(x0, y0, x1, y1, color); drawLine(x1, y1, x2, y2, color); drawLine(x2, y2, x0, y0, color); }

// Fill a triangle void ILI9341_t3n::fillTriangle ( int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {

int16_t a, b, y, last;

// Sort coordinates by Y order (y2 >= y1 >= y0) if (y0 > y1) { swap(y0, y1); swap(x0, x1); } if (y1 > y2) { swap(y2, y1); swap(x2, x1); } if (y0 > y1) { swap(y0, y1); swap(x0, x1); }

if(y0 == y2) { // Handle awkward all-on-same-line case as its own thing a = b = x0; if(x1 < a) a = x1; else if(x1 > b) b = x1; if(x2 < a) a = x2; else if(x2 > b) b = x2; drawFastHLine(a, y0, b-a+1, color); return; }

int16_t dx01 = x1 - x0, dy01 = y1 - y0, dx02 = x2 - x0, dy02 = y2 - y0, dx12 = x2 - x1, dy12 = y2 - y1, sa = 0, sb = 0;

// For upper part of triangle, find scanline crossings for segments // 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1 // is included here (and second loop will be skipped, avoiding a /0 // error there), otherwise scanline y1 is skipped here and handled // in the second loop...which also avoids a /0 error here if y0=y1 // (flat-topped triangle). if(y1 == y2) last = y1; // Include y1 scanline else last = y1-1; // Skip it

for(y=y0; y<=last; y++) { a = x0 + sa / dy01; b = x0 + sb / dy02; sa += dx01; sb += dx02; / longhand: a = x0 + (x1 - x0) (y - y0) / (y1 - y0); b = x0 + (x2 - x0) (y - y0) / (y2 - y0); / if(a > b) swap(a,b); drawFastHLine(a, y, b-a+1, color); }

// For lower part of triangle, find scanline crossings for segments // 0-2 and 1-2. This loop is skipped if y1=y2. sa = dx12 (y - y1); sb = dx02 (y - y0); for(; y<=y2; y++) { a = x1 + sa / dy12; b = x0 + sb / dy02; sa += dx12; sb += dx02; / longhand: a = x1 + (x2 - x1) (y - y1) / (y2 - y1); b = x0 + (x2 - x0) (y - y0) / (y2 - y0); / if(a > b) swap(a,b); drawFastHLine(a, y, b-a+1, color); } }

void ILI9341_t3n::drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {

int16_t i, j, byteWidth = (w + 7) / 8;

for(j=0; j<h; j++) { for(i=0; i<w; i++ ) { if(pgm_read_byte(bitmap + j * byteWidth + i / 8) & (128 >> (i & 7))) { drawPixel(x+i, y+j, color); } } } }

size_t ILI9341_t3n::write(uint8_t c) { if (font) { if (c == '\n') { cursor_y += font->line_space; // Fix linefeed. Added by T.T., SoftEgg cursor_x = 0; } else { drawFontChar(c); } } else { if (c == '\n') { cursor_y += textsize8; cursor_x = 0; } else if (c == '\r') { // skip em } else { drawChar(cursor_x, cursor_y, c, textcolor, textbgcolor, textsize); cursor_x += textsize6; if (wrap && (cursor_x > (_width - textsize6))) { cursor_y += textsize8; cursor_x = 0; } } } return 1; }

// Draw a character void ILI9341_t3n::drawChar(int16_t x, int16_t y, unsigned char c, uint16_t fgcolor, uint16_t bgcolor, uint8_t size) { if((x >= _width) || // Clip right (y >= _height) || // Clip bottom ((x + 6 size - 1) < 0) || // Clip left TODO: is this correct? ((y + 8 size - 1) < 0)) // Clip top TODO: is this correct? return;

if (fgcolor == bgcolor) {
    // This transparent approach is only about 20% faster
    if (size == 1) {
        uint8_t mask = 0x01;
        int16_t xoff, yoff;
        for (yoff=0; yoff < 8; yoff++) {
            uint8_t line = 0;
            for (xoff=0; xoff < 5; xoff++) {
                if (glcdfont[c * 5 + xoff] & mask) line |= 1;
                line <<= 1;
            }
            line >>= 1;
            xoff = 0;
            while (line) {
                if (line == 0x1F) {
                    drawFastHLine(x + xoff, y + yoff, 5, fgcolor);
                    break;
                } else if (line == 0x1E) {
                    drawFastHLine(x + xoff, y + yoff, 4, fgcolor);
                    break;
                } else if ((line & 0x1C) == 0x1C) {
                    drawFastHLine(x + xoff, y + yoff, 3, fgcolor);
                    line <<= 4;
                    xoff += 4;
                } else if ((line & 0x18) == 0x18) {
                    drawFastHLine(x + xoff, y + yoff, 2, fgcolor);
                    line <<= 3;
                    xoff += 3;
                } else if ((line & 0x10) == 0x10) {
                    drawPixel(x + xoff, y + yoff, fgcolor);
                    line <<= 2;
                    xoff += 2;
                } else {
                    line <<= 1;
                    xoff += 1;
                }
            }
            mask = mask << 1;
        }
    } else {
        uint8_t mask = 0x01;
        int16_t xoff, yoff;
        for (yoff=0; yoff < 8; yoff++) {
            uint8_t line = 0;
            for (xoff=0; xoff < 5; xoff++) {
                if (glcdfont[c * 5 + xoff] & mask) line |= 1;
                line <<= 1;
            }
            line >>= 1;
            xoff = 0;
            while (line) {
                if (line == 0x1F) {
                    fillRect(x + xoff * size, y + yoff * size,
                        5 * size, size, fgcolor);
                    break;
                } else if (line == 0x1E) {
                    fillRect(x + xoff * size, y + yoff * size,
                        4 * size, size, fgcolor);
                    break;
                } else if ((line & 0x1C) == 0x1C) {
                    fillRect(x + xoff * size, y + yoff * size,
                        3 * size, size, fgcolor);
                    line <<= 4;
                    xoff += 4;
                } else if ((line & 0x18) == 0x18) {
                    fillRect(x + xoff * size, y + yoff * size,
                        2 * size, size, fgcolor);
                    line <<= 3;
                    xoff += 3;
                } else if ((line & 0x10) == 0x10) {
                    fillRect(x + xoff * size, y + yoff * size,
                        size, size, fgcolor);
                    line <<= 2;
                    xoff += 2;
                } else {
                    line <<= 1;
                    xoff += 1;
                }
            }
            mask = mask << 1;
        }
    }
} else {
    // This solid background approach is about 5 time faster
    uint8_t xc, yc;
    uint8_t xr, yr;
    uint8_t mask = 0x01;
    uint16_t color;

    // We need to offset by the origin.
    x+=_originx;
    y+=_originy;
    int16_t x_char_start = x;  // remember our X where we start outputting...

    if((x >= _displayclipx2)            || // Clip right
         (y >= _displayclipy2)           || // Clip bottom
         ((x + 6 * size - 1) < _displayclipx1) || // Clip left  TODO: this is not correct
         ((y + 8 * size - 1) < _displayclipy1))   // Clip top   TODO: this is not correct
        return;

    #ifdef ENABLE_ILI9341_FRAMEBUFFER
    if (_use_fbtft) {

        uint16_t * pfbPixel_row = &_pfbtft[ y*_width + x];
        for (yc=0; (yc < 8) && (y < _displayclipy2); yc++) {
            for (yr=0; (yr < size) && (y < _displayclipy2); yr++) {
                x = x_char_start;       // get our first x position...
                if (y >= _displayclipy1) {
                    uint16_t * pfbPixel = pfbPixel_row;
                    for (xc=0; xc < 5; xc++) {
                        if (glcdfont[c * 5 + xc] & mask) {
                            color = fgcolor;
                        } else {
                            color = bgcolor;
                        }
                        for (xr=0; xr < size; xr++) {
                            if ((x >= _displayclipx1) && (x < _displayclipx2)) {
                                *pfbPixel = color;
                            }
                            pfbPixel++;
                            x++;
                        }
                    }
                    for (xr=0; xr < size; xr++) {
                        if ((x >= _displayclipx1) && (x < _displayclipx2)) {
                            *pfbPixel = bgcolor;
                        }
                        pfbPixel++;
                        x++;
                    }
                }
                pfbPixel_row += _width; // setup pointer to 
                y++;
            }
            mask = mask << 1;
        }

    } else 
    #endif
    {
        // need to build actual pixel rectangle we will output into.
        int16_t y_char_top = y; // remember the y
        int16_t w =  6 * size;
        int16_t h = 8 * size;

        if(x < _displayclipx1) {    w -= (_displayclipx1-x); x = _displayclipx1;    }
        if((x + w - 1) >= _displayclipx2)  w = _displayclipx2  - x;
        if(y < _displayclipy1) {    h -= (_displayclipy1 - y); y = _displayclipy1;  }
        if((y + h - 1) >= _displayclipy2) h = _displayclipy2 - y;

        beginSPITransaction();
        setAddr(x, y, x + w -1, y + h - 1);

        y = y_char_top; // restore the actual y.
        writecommand_cont(ILI9341_RAMWR);
        for (yc=0; (yc < 8) && (y < _displayclipy2); yc++) {
            for (yr=0; (yr < size) && (y < _displayclipy2); yr++) {
                x = x_char_start;       // get our first x position...
                if (y >= _displayclipy1) {
                    for (xc=0; xc < 5; xc++) {
                        if (glcdfont[c * 5 + xc] & mask) {
                            color = fgcolor;
                        } else {
                            color = bgcolor;
                        }
                        for (xr=0; xr < size; xr++) {
                            if ((x >= _displayclipx1) && (x < _displayclipx2)) {
                                writedata16_cont(color);
                            }
                            x++;
                        }
                    }
                    for (xr=0; xr < size; xr++) {
                        if ((x >= _displayclipx1) && (x < _displayclipx2)) {
                            writedata16_cont(bgcolor);
                        }
                        x++;
                    }
                }
                y++;
            }
            mask = mask << 1;
        }
        writecommand_last(ILI9341_NOP);
        endSPITransaction();
    }
}

}

static uint32_t fetchbit(const uint8_t *p, uint32_t index) { if (p[index >> 3] & (1 << (7 - (index & 7)))) return 1; return 0; }

static uint32_t fetchbits_unsigned(const uint8_t *p, uint32_t index, uint32_t required) { uint32_t val = 0; do { uint8_t b = p[index >> 3]; uint32_t avail = 8 - (index & 7); if (avail <= required) { val <<= avail; val |= b & ((1 << avail) - 1); index += avail; required -= avail; } else { b >>= avail - required; val <<= required; val |= b & ((1 << required) - 1); break; } } while (required); return val; }

static uint32_t fetchbits_signed(const uint8_t *p, uint32_t index, uint32_t required) { uint32_t val = fetchbits_unsigned(p, index, required); if (val & (1 << (required - 1))) { return (int32_t)val - (1 << required); } return (int32_t)val; }

void ILI9341_t3n::drawFontChar(unsigned int c) { uint32_t bitoffset; const uint8_t *data;

//Serial.printf("drawFontChar(%c) %d\n", c, c);

if (c >= font->index1_first && c <= font->index1_last) {
    bitoffset = c - font->index1_first;
    bitoffset *= font->bits_index;
} else if (c >= font->index2_first && c <= font->index2_last) {
    bitoffset = c - font->index2_first + font->index1_last - font->index1_first + 1;
    bitoffset *= font->bits_index;
} else if (font->unicode) {
    return; // TODO: implement sparse unicode
} else {
    return;
}
//Serial.printf("  index =  %d\n", fetchbits_unsigned(font->index, bitoffset, font->bits_index));
data = font->data + fetchbits_unsigned(font->index, bitoffset, font->bits_index);

uint32_t encoding = fetchbits_unsigned(data, 0, 3);
if (encoding != 0) return;
uint32_t width = fetchbits_unsigned(data, 3, font->bits_width);
bitoffset = font->bits_width + 3;
uint32_t height = fetchbits_unsigned(data, bitoffset, font->bits_height);
bitoffset += font->bits_height;
//Serial.printf("  size =   %d,%d\n", width, height);
//Serial.printf("  line space = %d\n", font->line_space);

int32_t xoffset = fetchbits_signed(data, bitoffset, font->bits_xoffset);
bitoffset += font->bits_xoffset;
int32_t yoffset = fetchbits_signed(data, bitoffset, font->bits_yoffset);
bitoffset += font->bits_yoffset;
//Serial.printf("  offset = %d,%d\n", xoffset, yoffset);

uint32_t delta = fetchbits_unsigned(data, bitoffset, font->bits_delta);
bitoffset += font->bits_delta;
//Serial.printf("  delta =  %d\n", delta);

//Serial.printf("  cursor = %d,%d\n", cursor_x, cursor_y);

 //horizontally, we draw every pixel, or none at all
if (cursor_x < 0) cursor_x = 0;
int32_t origin_x = cursor_x + xoffset;
if (origin_x < 0) {
    cursor_x -= xoffset;
    origin_x = 0;
}
if (origin_x + (int)width > _width) {
    if (!wrap) return;
    origin_x = 0;
    if (xoffset >= 0) {
        cursor_x = 0;
    } else {
        cursor_x = -xoffset;
    }
    cursor_y += font->line_space;
}
if (cursor_y >= _height) return;

// vertically, the top and/or bottom can be clipped
int32_t origin_y = cursor_y + font->cap_height - height - yoffset;
//Serial.printf("  origin = %d,%d\n", origin_x, origin_y);

// TODO: compute top skip and number of lines
int32_t linecount = height;
//uint32_t loopcount = 0;
int32_t y = origin_y;
bool opaque = (textbgcolor != textcolor);

// Going to try a fast Opaque method which works similar to drawChar, which is near the speed of writerect
if (!opaque) {
    while (linecount > 0) {
        //Serial.printf("    linecount = %d\n", linecount);
        uint32_t n = 1;
        if (fetchbit(data, bitoffset++) != 0) {
            n = fetchbits_unsigned(data, bitoffset, 3) + 2;
            bitoffset += 3;
        }
        uint32_t x = 0;
        do {
            int32_t xsize = width - x;
            if (xsize > 32) xsize = 32;
            uint32_t bits = fetchbits_unsigned(data, bitoffset, xsize);
            //Serial.printf("    multi line %d %d %x\n", n, x, bits);
            drawFontBits(opaque, bits, xsize, origin_x + x, y, n);
            bitoffset += xsize;
            x += xsize;
        } while (x < width);

        y += n;
        linecount -= n;
        //if (++loopcount > 100) {
            //Serial.println("     abort draw loop");
            //break;
        //}
    }
} else {
    // Now opaque mode... 
    // Now write out background color for the number of rows above the above the character
    // figure out bounding rectangle... 
    // In this mode we need to update to use the offset and bounding rectangles as we are doing it it direct.
    // also update the Origin 
    int cursor_x_origin = cursor_x + _originx;
    int cursor_y_origin = cursor_y + _originy;
    origin_x += _originx;
    origin_y += _originy;

    int start_x = (origin_x < cursor_x_origin) ? origin_x : cursor_x_origin;    
    if (start_x < 0) start_x = 0;

    int start_y = (origin_y < cursor_y_origin) ? origin_y : cursor_y_origin; 
    if (start_y < 0) start_y = 0;
    int end_x = cursor_x_origin + delta; 
    if ((origin_x + (int)width) > end_x)
        end_x = origin_x + (int)width;
    if (end_x >= _displayclipx2)  end_x = _displayclipx2;   
    int end_y = cursor_y_origin + font->line_space; 
    if ((origin_y + (int)height) > end_y)
        end_y = origin_y + (int)height;
    if (end_y >= _displayclipy2) end_y = _displayclipy2;    
    end_x--;    // setup to last one we draw
    end_y--;
    int start_x_min = (start_x >= _displayclipx1) ? start_x : _displayclipx1;
    int start_y_min = (start_y >= _displayclipy1) ? start_y : _displayclipy1;

    // See if anything is in the display area.
    if((end_x < _displayclipx1) ||(start_x >= _displayclipx2) || (end_y < _displayclipy1) || (start_y >= _displayclipy2)) {
        cursor_x += delta;  // could use goto or another indent level...
        return;
    }

/* Serial.printf("drawFontChar(%c) %d\n", c, c); Serial.printf(" size = %d,%d\n", width, height); Serial.printf(" line space = %d\n", font->line_space); Serial.printf(" offset = %d,%d\n", xoffset, yoffset); Serial.printf(" delta = %d\n", delta); Serial.printf(" cursor = %d,%d\n", cursor_x, cursor_y); Serial.printf(" origin = %d,%d\n", origin_x, origin_y);

    Serial.printf("  Bounding: (%d, %d)-(%d, %d)\n", start_x, start_y, end_x, end_y);
    Serial.printf("  mins (%d %d),\n", start_x_min, start_y_min);

ifdef ENABLE_ILI9341_FRAMEBUFFER

    if (_use_fbtft) {
        uint16_t * pfbPixel_row = &_pfbtft[ start_y*_width + start_x];
        uint16_t * pfbPixel;
        int screen_y = start_y;
        int screen_x;

        while (screen_y < origin_y) {
            pfbPixel = pfbPixel_row;
            // only output if this line is within the clipping region.
            if ((screen_y >= _displayclipy1) && (screen_y < _displayclipy2)) {
                for (screen_x = start_x; screen_x <= end_x; screen_x++) {
                    if (screen_x >= _displayclipx1) {
                        *pfbPixel = textbgcolor;
                    }
                    pfbPixel++;
                }
            }
            screen_y++;
            pfbPixel_row += _width;
        }

        // Now lets process each of the data lines. 
        screen_y = origin_y;

        while (linecount > 0) {
            //Serial.printf("    linecount = %d\n", linecount);
            uint32_t b = fetchbit(data, bitoffset++);
            uint32_t n;
            if (b == 0) {
                //Serial.println("Single");
                n = 1;
            } else {
                //Serial.println("Multi");
                n = fetchbits_unsigned(data, bitoffset, 3) + 2;
                bitoffset += 3;
            }
            uint32_t bitoffset_row_start = bitoffset;
            while (n--) {
                pfbPixel = pfbPixel_row;
                if ((screen_y >= _displayclipy1) && (screen_y < _displayclipy2)) {
                    bitoffset = bitoffset_row_start;    // we will work through these bits maybe multiple times

                    for (screen_x = start_x; screen_x < origin_x; screen_x++) {
                        if (screen_x >= _displayclipx1) {
                            *pfbPixel = textbgcolor;
                        } // make sure not clipped
                        pfbPixel++;
                    }
                }

                screen_x = origin_x;
                uint32_t x = 0;
                do {
                    uint32_t xsize = width - x;
                    if (xsize > 32) xsize = 32;
                    uint32_t bits = fetchbits_unsigned(data, bitoffset, xsize);
                    uint32_t bit_mask = 1 << (xsize-1);
                    //Serial.printf(" %d %d %x %x\n", x, xsize, bits, bit_mask);
                    if ((screen_y >= _displayclipy1) && (screen_y < _displayclipy2)) {
                        while (bit_mask && (screen_x <= end_x)) {
                            if ((screen_x >= _displayclipx1) && (screen_x < _displayclipx2)) {
                                *pfbPixel = (bits & bit_mask) ? textcolor : textbgcolor;
                            }
                            pfbPixel++; 
                            bit_mask = bit_mask >> 1;
                            screen_x++; // increment our pixel position. 
                        }
                    }
                        bitoffset += xsize;
                    x += xsize;
                } while (x < width);
                if ((screen_y >= _displayclipy1) && (screen_y < _displayclipy2)) {
                    // output bg color and right hand side
                    while (screen_x++ <= end_x) {
                        *pfbPixel++ = textbgcolor;
                    }
                }            
                screen_y++;
                pfbPixel_row += _width;
                linecount--;
            }
        }

        // clear below character
        while (screen_y++ <= end_y) {
            if ((screen_y >= _displayclipy1) && (screen_y < _displayclipy2)) {
                pfbPixel = pfbPixel_row;
                for (screen_x = start_x; screen_x <= end_x; screen_x++) {
                    if (screen_x >= _displayclipx1) {
                        *pfbPixel = textbgcolor;
                    }
                    pfbPixel++;
                }
            }
            pfbPixel_row += _width;
        }

    } else 
    #endif
    {
        beginSPITransaction();
        //Serial.printf("SetAddr %d %d %d %d\n", start_x_min, start_y_min, end_x, end_y);
        // output rectangle we are updating... We have already clipped end_x/y, but not yet start_x/y
        setAddr( start_x_min, start_y_min, end_x, end_y);
        writecommand_cont(ILI9341_RAMWR);
        int screen_y = start_y_min;
        int screen_x;
        while (screen_y < origin_y) {
            for (screen_x = start_x_min; screen_x <= end_x; screen_x++) {
                writedata16_cont(textbgcolor);
            }
            screen_y++;
        }

        // Now lets process each of the data lines. 
        screen_y = origin_y;
        while (linecount > 0) {
            //Serial.printf("    linecount = %d\n", linecount);
            uint32_t b = fetchbit(data, bitoffset++);
            uint32_t n;
            if (b == 0) {
                //Serial.println("    Single");
                n = 1;
            } else {
                //Serial.println("    Multi");
                n = fetchbits_unsigned(data, bitoffset, 3) + 2;
                bitoffset += 3;
            }
            uint32_t bitoffset_row_start = bitoffset;
            while (n--) {
                // do some clipping here. 
                bitoffset = bitoffset_row_start;    // we will work through these bits maybe multiple times
                // We need to handle case where some of the bits may not be visible, but we still need to
                // read through them
                //Serial.printf("y:%d  %d %d %d %d\n", screen_y, start_x, origin_x, _displayclipx1, _displayclipx2);
                if ((screen_y >= _displayclipy1) && (screen_y < _displayclipy2)) {
                    for (screen_x = start_x; screen_x < origin_x; screen_x++) {
                        if ((screen_x >= _displayclipx1) && (screen_x < _displayclipx2)) {
                            //Serial.write('-');
                            writedata16_cont(textbgcolor);
                        }
                    }
                }   
                uint32_t x = 0;
                screen_x = origin_x;
                do {
                    uint32_t xsize = width - x;
                    if (xsize > 32) xsize = 32;
                    uint32_t bits = fetchbits_unsigned(data, bitoffset, xsize);
                    uint32_t bit_mask = 1 << (xsize-1);
                    //Serial.printf("     %d %d %x %x - ", x, xsize, bits, bit_mask);
                    if ((screen_y >= _displayclipy1) && (screen_y < _displayclipy2)) {
                        while (bit_mask) {
                            if ((screen_x >= _displayclipx1) && (screen_x < _displayclipx2)) {
                                writedata16_cont((bits & bit_mask) ? textcolor : textbgcolor);
                                //Serial.write((bits & bit_mask) ? '*' : '.');
                            }
                            bit_mask = bit_mask >> 1;
                            screen_x++ ; // Current actual screen X
                        }
                        //Serial.println();
                        bitoffset += xsize;
                    }
                    x += xsize;
                } while (x < width) ;
                if ((screen_y >= _displayclipy1) && (screen_y < _displayclipy2)) {
                    // output bg color and right hand side
                    while (screen_x++ <= end_x) {
                        writedata16_cont(textbgcolor);
                        //Serial.write('+');
                    }
                    //Serial.println();
                }
                screen_y++;
                linecount--;
            }
        }

        // clear below character - note reusing xcreen_x for this
        screen_x = (end_y + 1 - screen_y) * (end_x + 1 - start_x_min); // How many bytes we need to still output
        //Serial.printf("Clear Below: %d\n", screen_x);
        while (screen_x-- > 1) {
            writedata16_cont(textbgcolor);
        }
        writedata16_last(textbgcolor);
        endSPITransaction();
    }

}
// Increment to setup for the next character.
cursor_x += delta;

}

//strPixelLen - gets pixel length of given ASCII string int16_t ILI9341_t3n::strPixelLen(char str) { // //Serial.printf("strPixelLen %s\n", str); if (!str) return(0); uint16_t len=0, maxlen=0; while (str) { if (str=='\n') { if ( len > maxlen ) { maxlen=len; len=0; } } else { if (!font) { len+=textsize6; } else {

            uint32_t bitoffset;
            const uint8_t *data;
            uint16_t c = *str;

// //Serial.printf("char %c(%d)\n", c,c);

            if (c >= font->index1_first && c <= font->index1_last) {
                bitoffset = c - font->index1_first;
                bitoffset *= font->bits_index;
            } else if (c >= font->index2_first && c <= font->index2_last) {
                bitoffset = c - font->index2_first + font->index1_last - font->index1_first + 1;
                bitoffset *= font->bits_index;
            } else if (font->unicode) {
                continue;
            } else {
                continue;
            }
            //Serial.printf("  index =  %d\n", fetchbits_unsigned(font->index, bitoffset, font->bits_index));
            data = font->data + fetchbits_unsigned(font->index, bitoffset, font->bits_index);

            uint32_t encoding = fetchbits_unsigned(data, 0, 3);
            if (encoding != 0) continue;

// uint32_t width = fetchbits_unsigned(data, 3, font->bits_width); // //Serial.printf(" width = %d\n", width); bitoffset = font->bits_width + 3; bitoffset += font->bits_height;

// int32_t xoffset = fetchbits_signed(data, bitoffset, font->bits_xoffset); // //Serial.printf(" xoffset = %d\n", xoffset); bitoffset += font->bits_xoffset; bitoffset += font->bits_yoffset;

            uint32_t delta = fetchbits_unsigned(data, bitoffset, font->bits_delta);
            bitoffset += font->bits_delta;

// //Serial.printf(" delta = %d\n", delta);

            len += delta;//+width-xoffset;

// //Serial.printf(" len = %d\n", len); if ( len > maxlen ) { maxlen=len; // //Serial.printf(" maxlen = %d\n", maxlen); }

        }
    }
    str++;
}

// //Serial.printf("Return maxlen = %d\n", maxlen); return( maxlen ); } void ILI9341_t3n::drawFontBits(bool opaque, uint32_t bits, uint32_t numbits, int32_t x, int32_t y, uint32_t repeat) { if (bits == 0) { if (opaque) { fillRect(x, y, numbits, repeat, textbgcolor); } } else { int32_t x1 = x; uint32_t n = numbits; int w; int bgw;

    w = 0;
    bgw = 0;

    do {
        n--;
        if (bits & (1 << n)) {
            if (bgw>0) {
                if (opaque) {
                    fillRect(x1 - bgw, y, bgw, repeat, textbgcolor);
                }
                bgw=0;
            }
            w++;
        } else {
            if (w>0) {
                fillRect(x1 - w, y, w, repeat, textcolor);
                w = 0;
            }
            bgw++;
        }
        x1++;
    } while (n > 0);

    if (w > 0) {
        fillRect(x1 - w, y, w, repeat, textcolor);
    }

    if (bgw > 0) {
        if (opaque) {
            fillRect(x1 - bgw, y, bgw, repeat, textbgcolor);
        }
    }
}

}

void ILI9341_t3n::setCursor(int16_t x, int16_t y) { if (x < 0) x = 0; else if (x >= _width) x = _width - 1; cursor_x = x; if (y < 0) y = 0; else if (y >= _height) y = _height - 1; cursor_y = y; } void ILI9341_t3n::getCursor(int16_t x, int16_t y) { x = cursor_x; y = cursor_y; }

void ILI9341_t3n::setTextSize(uint8_t s) { textsize = (s > 0) ? s : 1; }

uint8_t ILI9341_t3n::getTextSize() { return textsize; }

void ILI9341_t3n::setTextColor(uint16_t c) { // For 'transparent' background, we'll set the bg // to the same as fg instead of using a flag textcolor = textbgcolor = c; }

void ILI9341_t3n::setTextColor(uint16_t c, uint16_t b) { textcolor = c; textbgcolor = b; }

void ILI9341_t3n::setTextWrap(boolean w) { wrap = w; }

boolean ILI9341_t3n::getTextWrap() { return wrap; }

uint8_t ILI9341_t3n::getRotation(void) { return rotation; }

void ILI9341_t3n::sleep(bool enable) { beginSPITransaction(); if (enable) { writecommand_cont(ILI9341_DISPOFF);
writecommand_last(ILI9341_SLPIN);
endSPITransaction(); } else { writecommand_cont(ILI9341_DISPON); writecommand_last(ILI9341_SLPOUT); endSPITransaction(); delay(5); } }

void Adafruit_GFX_Button::initButton(ILI9341_t3n gfx, int16_t x, int16_t y, uint8_t w, uint8_t h, uint16_t outline, uint16_t fill, uint16_t textcolor, const char label, uint8_t textsize) { _x = x; _y = y; _w = w; _h = h; _outlinecolor = outline; _fillcolor = fill; _textcolor = textcolor; _textsize = textsize; _gfx = gfx; strncpy(_label, label, 9); _label[9] = 0; }

void Adafruit_GFX_Button::drawButton(bool inverted) { uint16_t fill, outline, text;

if (! inverted) {
    fill = _fillcolor;
    outline = _outlinecolor;
    text = _textcolor;
} else {
    fill =  _textcolor;
    outline = _outlinecolor;
    text = _fillcolor;
}
_gfx->fillRoundRect(_x - (_w/2), _y - (_h/2), _w, _h, min(_w,_h)/4, fill);
_gfx->drawRoundRect(_x - (_w/2), _y - (_h/2), _w, _h, min(_w,_h)/4, outline);
_gfx->setCursor(_x - strlen(_label)*3*_textsize, _y-4*_textsize);
_gfx->setTextColor(text);
_gfx->setTextSize(_textsize);
_gfx->print(_label);

}

bool Adafruit_GFX_Button::contains(int16_t x, int16_t y) { if ((x < (_x - _w/2)) || (x > (_x + _w/2))) return false; if ((y < (_y - _h/2)) || (y > (_y + _h/2))) return false; return true; }

KurtE / ILI9341_t3n

Async Compiling with latest Teensyduino and Arduino IDE #4

include "ILI9341_t3n.h"

include

include

ifdef ENABLE_ILI9341_FRAMEBUFFER

endif

define WIDTH ILI9341_TFTWIDTH

define HEIGHT ILI9341_TFTHEIGHT

ifdef KINETISK

else

endif

define CBALLOC (ILI9341_TFTHEIGHTILI9341_TFTWIDTH2)

ifdef ENABLE_ILI9341_FRAMEBUFFER

ifdef ENABLE_ILI9341_FRAMEBUFFER

ifdef ENABLE_ILI9341_FRAMEBUFFER

ifdef ENABLE_ILI9341_FRAMEBUFFER

ifdef DEBUG_ASYNC_UPDATE

endif

ifdef ENABLE_ILI9341_FRAMEBUFFER

ifdef DEBUG_ASYNC_UPDATE

endif

else

ifdef ENABLE_ILI9341_FRAMEBUFFER

ifdef ENABLE_ILI9341_FRAMEBUFFER

ifdef ENABLE_ILI9341_FRAMEBUFFER

define MADCTL_MY 0x80

define MADCTL_MX 0x40

define MADCTL_MV 0x20

define MADCTL_ML 0x10

define MADCTL_RGB 0x00

define MADCTL_BGR 0x08

define MADCTL_MH 0x04

ifdef KINETISK

else

endif

define READ_PIXEL_PUSH_BYTE 0x3f

ifdef KINETISK

else

endif

ifdef KINETISK

else

define RRECT_TIMEOUT 0xffff

undef READ_PIXEL_PUSH_BYTE

define READ_PIXEL_PUSH_BYTE 0 // try with zero to see...

endif

ifdef DEBUG_ASYNC_UPDATE

endif

ifdef KINETISK

else

endif

ifdef KINETISK

else

endif

ifdef ENABLE_ILI9341_FRAMEBUFFER

ifdef ENABLE_ILI9341_FRAMEBUFFER