visus
/
framework-arduinoteensy-cxx20
Слідкувати 1
В обрані 0
Форк 0
Код Проблеми 0 Запити на злиття 0 Релізи 0 Вікі Активність
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
Ви не можете вибрати більше 25 тем Теми мають розпочинатися з літери або цифри, можуть містити дефіси (-) і не повинні перевищувати 35 символів.
2 Коміти
1 Гілка
Дерево: daa7cc5a30
Гілки Теги
${ item.name }
Створити гілку ${ searchTerm }
з 'daa7cc5a30'
${ noResults }
framework-arduinoteensy-cxx20/libraries/ILI9341_t3/ILI9341_t3.h

595 lines
22KB
Неформатований Blame Історія 

  1. // https://github.com/PaulStoffregen/ILI9341_t3

  2. // http://forum.pjrc.com/threads/26305-Highly-optimized-ILI9341-(320x240-TFT-color-display)-library

  3. 

  4. /***************************************************

  5.   This is our library for the Adafruit  ILI9341 Breakout and Shield

  6.   ----> http://www.adafruit.com/products/1651

  7. 

  8.   Check out the links above for our tutorials and wiring diagrams

  9.   These displays use SPI to communicate, 4 or 5 pins are required to

  10.   interface (RST is optional)

  11.   Adafruit invests time and resources providing this open source code,

  12.   please support Adafruit and open-source hardware by purchasing

  13.   products from Adafruit!

  14. 

  15.   Written by Limor Fried/Ladyada for Adafruit Industries.

  16.   MIT license, all text above must be included in any redistribution

  17.  ****************************************************/

  18. 

  19. // <SoftEgg>

  20. 

  21. //Additional graphics routines by Tim Trzepacz, SoftEgg LLC added December 2015

  22. //(And then accidentally deleted and rewritten March 2016. Oops!)

  23. //Gradient support

  24. //----------------

  25. //		fillRectVGradient	- fills area with vertical gradient

  26. //		fillRectHGradient	- fills area with horizontal gradient

  27. //		fillScreenVGradient - fills screen with vertical gradient

  28. // 	fillScreenHGradient - fills screen with horizontal gradient

  29. 

  30. //Additional Color Support

  31. //------------------------

  32. //		color565toRGB		- converts 565 format 16 bit color to RGB

  33. //		color565toRGB14		- converts 16 bit 565 format color to 14 bit RGB (2 bits clear for math and sign)

  34. //		RGB14tocolor565		- converts 14 bit RGB back to 16 bit 565 format color

  35. 

  36. //Low Memory Bitmap Support

  37. //-------------------------

  38. // writeRect8BPP - 	write 8 bit per pixel paletted bitmap

  39. // writeRect4BPP - 	write 4 bit per pixel paletted bitmap

  40. // writeRect2BPP - 	write 2 bit per pixel paletted bitmap

  41. // writeRect1BPP - 	write 1 bit per pixel paletted bitmap

  42. 

  43. //String Pixel Length support

  44. //---------------------------

  45. //		strPixelLen			- gets pixel length of given ASCII string

  46. 

  47. // <\SoftEgg>

  48. 

  49. #ifndef _ILI9341_t3H_

  50. #define _ILI9341_t3H_

  51. 

  52. #ifdef __cplusplus

  53. #include "Arduino.h"

  54. #endif

  55. 

  56. #if defined(__MKL26Z64__)

  57. #error "Sorry, ILI9341_t3 does not work with Teensy LC.  Use Adafruit_ILI9341."

  58. #elif defined(__AVR__)

  59. #error "Sorry, ILI9341_t3 does not work with Teensy 2.0 or Teensy++ 2.0.  Use Adafruit_ILI9341."

  60. #endif

  61. 

  62. #define ILI9341_TFTWIDTH  240

  63. #define ILI9341_TFTHEIGHT 320

  64. 

  65. #define ILI9341_NOP     0x00

  66. #define ILI9341_SWRESET 0x01

  67. #define ILI9341_RDDID   0x04

  68. #define ILI9341_RDDST   0x09

  69. 

  70. #define ILI9341_SLPIN   0x10

  71. #define ILI9341_SLPOUT  0x11

  72. #define ILI9341_PTLON   0x12

  73. #define ILI9341_NORON   0x13

  74. 

  75. #define ILI9341_RDMODE  0x0A

  76. #define ILI9341_RDMADCTL  0x0B

  77. #define ILI9341_RDPIXFMT  0x0C

  78. #define ILI9341_RDIMGFMT  0x0D

  79. #define ILI9341_RDSELFDIAG  0x0F

  80. 

  81. #define ILI9341_INVOFF  0x20

  82. #define ILI9341_INVON   0x21

  83. #define ILI9341_GAMMASET 0x26

  84. #define ILI9341_DISPOFF 0x28

  85. #define ILI9341_DISPON  0x29

  86. 

  87. #define ILI9341_CASET   0x2A

  88. #define ILI9341_PASET   0x2B

  89. #define ILI9341_RAMWR   0x2C

  90. #define ILI9341_RAMRD   0x2E

  91. 

  92. #define ILI9341_PTLAR    0x30

  93. #define ILI9341_MADCTL   0x36

  94. #define ILI9341_VSCRSADD 0x37

  95. #define ILI9341_PIXFMT   0x3A

  96. 

  97. #define ILI9341_FRMCTR1 0xB1

  98. #define ILI9341_FRMCTR2 0xB2

  99. #define ILI9341_FRMCTR3 0xB3

  100. #define ILI9341_INVCTR  0xB4

  101. #define ILI9341_DFUNCTR 0xB6

  102. 

  103. #define ILI9341_PWCTR1  0xC0

  104. #define ILI9341_PWCTR2  0xC1

  105. #define ILI9341_PWCTR3  0xC2

  106. #define ILI9341_PWCTR4  0xC3

  107. #define ILI9341_PWCTR5  0xC4

  108. #define ILI9341_VMCTR1  0xC5

  109. #define ILI9341_VMCTR2  0xC7

  110. 

  111. #define ILI9341_RDID1   0xDA

  112. #define ILI9341_RDID2   0xDB

  113. #define ILI9341_RDID3   0xDC

  114. #define ILI9341_RDID4   0xDD

  115. 

  116. #define ILI9341_GMCTRP1 0xE0

  117. #define ILI9341_GMCTRN1 0xE1

  118. /*

  119. #define ILI9341_PWCTR6  0xFC

  120. 

  121. */

  122. 

  123. // Color definitions

  124. #define ILI9341_BLACK       0x0000      /*   0,   0,   0 */

  125. #define ILI9341_NAVY        0x000F      /*   0,   0, 128 */

  126. #define ILI9341_DARKGREEN   0x03E0      /*   0, 128,   0 */

  127. #define ILI9341_DARKCYAN    0x03EF      /*   0, 128, 128 */

  128. #define ILI9341_MAROON      0x7800      /* 128,   0,   0 */

  129. #define ILI9341_PURPLE      0x780F      /* 128,   0, 128 */

  130. #define ILI9341_OLIVE       0x7BE0      /* 128, 128,   0 */

  131. #define ILI9341_LIGHTGREY   0xC618      /* 192, 192, 192 */

  132. #define ILI9341_DARKGREY    0x7BEF      /* 128, 128, 128 */

  133. #define ILI9341_BLUE        0x001F      /*   0,   0, 255 */

  134. #define ILI9341_GREEN       0x07E0      /*   0, 255,   0 */

  135. #define ILI9341_CYAN        0x07FF      /*   0, 255, 255 */

  136. #define ILI9341_RED         0xF800      /* 255,   0,   0 */

  137. #define ILI9341_MAGENTA     0xF81F      /* 255,   0, 255 */

  138. #define ILI9341_YELLOW      0xFFE0      /* 255, 255,   0 */

  139. #define ILI9341_WHITE       0xFFFF      /* 255, 255, 255 */

  140. #define ILI9341_ORANGE      0xFD20      /* 255, 165,   0 */

  141. #define ILI9341_GREENYELLOW 0xAFE5      /* 173, 255,  47 */

  142. #define ILI9341_PINK        0xF81F

  143. 

  144. #define CL(_r,_g,_b) ((((_r)&0xF8)<<8)|(((_g)&0xFC)<<3)|((_b)>>3))

  145. 

  146. #define sint16_t int16_t

  147. 

  148. 

  149. // Documentation on the ILI9341_t3 font data format:

  150. // https://forum.pjrc.com/threads/54316-ILI9341_t-font-structure-format

  151. 

  152. typedef struct {

  153. 	const unsigned char *index;

  154. 	const unsigned char *unicode;

  155. 	const unsigned char *data;

  156. 	unsigned char version;

  157. 	unsigned char reserved;

  158. 	unsigned char index1_first;

  159. 	unsigned char index1_last;

  160. 	unsigned char index2_first;

  161. 	unsigned char index2_last;

  162. 	unsigned char bits_index;

  163. 	unsigned char bits_width;

  164. 	unsigned char bits_height;

  165. 	unsigned char bits_xoffset;

  166. 	unsigned char bits_yoffset;

  167. 	unsigned char bits_delta;

  168. 	unsigned char line_space;

  169. 	unsigned char cap_height;

  170. } ILI9341_t3_font_t;

  171. 

  172. 

  173. #ifdef __cplusplus

  174. // At all other speeds, ILI9241_KINETISK__pspi->beginTransaction() will use the fastest available clock

  175. #include <SPI.h>

  176. #define ILI9341_SPICLOCK 30000000

  177. #define ILI9341_SPICLOCK_READ 6500000

  178. 

  179. class ILI9341_t3 : public Print

  180. {

  181.   public:

  182. 	ILI9341_t3(uint8_t _CS, uint8_t _DC, uint8_t _RST = 255, uint8_t _MOSI=11, uint8_t _SCLK=13, uint8_t _MISO=12);

  183. 	void begin(void);

  184.   	void sleep(bool enable);		

  185.         void setClock(unsigned long clk) { _clock = clk;}

  186. 	void pushColor(uint16_t color);

  187. 	void fillScreen(uint16_t color);

  188. 	void drawPixel(int16_t x, int16_t y, uint16_t color);

  189. 	void drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color);

  190. 	void drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color);

  191. 	void fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);

  192. 			

  193. 	void fillRectHGradient(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color1, uint16_t color2);

  194. 	void fillRectVGradient(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color1, uint16_t color2);

  195. 	void fillScreenVGradient(uint16_t color1, uint16_t color2);

  196. 	void fillScreenHGradient(uint16_t color1, uint16_t color2);

  197. 

  198. 	void setRotation(uint8_t r);

  199. 	void setScroll(uint16_t offset);

  200. 	void invertDisplay(boolean i);

  201. 	void setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1);

  202. 	// Pass 8-bit (each) R,G,B, get back 16-bit packed color

  203. 	static uint16_t color565(uint8_t r, uint8_t g, uint8_t b) {

  204. 		return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);

  205. 	}

  206. 

  207. 	//color565toRGB		- converts 565 format 16 bit color to RGB

  208. 	static void color565toRGB(uint16_t color, uint8_t &r, uint8_t &g, uint8_t &b) {

  209. 		r = (color>>8)&0x00F8;

  210. 		g = (color>>3)&0x00FC;

  211. 		b = (color<<3)&0x00F8;

  212. 	}

  213. 	

  214. 	//color565toRGB14		- converts 16 bit 565 format color to 14 bit RGB (2 bits clear for math and sign)

  215. 	//returns 00rrrrr000000000,00gggggg00000000,00bbbbb000000000

  216. 	//thus not overloading sign, and allowing up to double for additions for fixed point delta

  217. 	static void color565toRGB14(uint16_t color, int16_t &r, int16_t &g, int16_t &b) {

  218. 		r = (color>>2)&0x3E00;

  219. 		g = (color<<3)&0x3F00;

  220. 		b = (color<<9)&0x3E00;

  221. 	}

  222. 	

  223. 	//RGB14tocolor565		- converts 14 bit RGB back to 16 bit 565 format color

  224. 	static uint16_t RGB14tocolor565(int16_t r, int16_t g, int16_t b)

  225. 	{

  226. 		return (((r & 0x3E00) << 2) | ((g & 0x3F00) >>3) | ((b & 0x3E00) >> 9));

  227. 	}

  228. 	

  229. 	//uint8_t readdata(void);

  230. 	uint8_t readcommand8(uint8_t reg, uint8_t index = 0);

  231. 	uint16_t readScanLine();

  232. 

  233. 	// Added functions to read pixel data...

  234. 	uint16_t readPixel(int16_t x, int16_t y);

  235. 	void readRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t *pcolors);

  236. 	void writeRect(int16_t x, int16_t y, int16_t w, int16_t h, const uint16_t *pcolors);

  237. 

  238. 	// writeRect8BPP - 	write 8 bit per pixel paletted bitmap

  239. 	//					bitmap data in array at pixels, one byte per pixel

  240. 	//					color palette data in array at palette

  241. 	void writeRect8BPP(int16_t x, int16_t y, int16_t w, int16_t h, const uint8_t *pixels, const uint16_t * palette );

  242. 

  243. 	// writeRect4BPP - 	write 4 bit per pixel paletted bitmap

  244. 	//					bitmap data in array at pixels, 4 bits per pixel

  245. 	//					color palette data in array at palette

  246. 	//					width must be at least 2 pixels

  247. 	void writeRect4BPP(int16_t x, int16_t y, int16_t w, int16_t h, const uint8_t *pixels, const uint16_t * palette );

  248. 	

  249. 	// writeRect2BPP - 	write 2 bit per pixel paletted bitmap

  250. 	//					bitmap data in array at pixels, 4 bits per pixel

  251. 	//					color palette data in array at palette

  252. 	//					width must be at least 4 pixels

  253. 	void writeRect2BPP(int16_t x, int16_t y, int16_t w, int16_t h, const uint8_t *pixels, const uint16_t * palette );

  254. 	

  255. 	// writeRect1BPP - 	write 1 bit per pixel paletted bitmap

  256. 	//					bitmap data in array at pixels, 4 bits per pixel

  257. 	//					color palette data in array at palette

  258. 	//					width must be at least 8 pixels

  259. 	void writeRect1BPP(int16_t x, int16_t y, int16_t w, int16_t h, const uint8_t *pixels, const uint16_t * palette );

  260. 

  261. 	// from Adafruit_GFX.h

  262. 	void drawCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);

  263. 	void drawCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, uint16_t color);

  264. 	void fillCircle(int16_t x0, int16_t y0, int16_t r, uint16_t color);

  265. 	void fillCircleHelper(int16_t x0, int16_t y0, int16_t r, uint8_t cornername, int16_t delta, uint16_t color);

  266. 	void drawTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);

  267. 	void fillTriangle(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color);

  268. 	void drawRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);

  269. 	void fillRoundRect(int16_t x0, int16_t y0, int16_t w, int16_t h, int16_t radius, uint16_t color);

  270. 	void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);

  271. 	void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size);

  272. 	void setCursor(int16_t x, int16_t y);

  273.     void getCursor(int16_t *x, int16_t *y);

  274. 	void setTextColor(uint16_t c);

  275. 	void setTextColor(uint16_t c, uint16_t bg);

  276. 	void setTextSize(uint8_t s);

  277. 	uint8_t getTextSize();

  278. 	void setTextWrap(boolean w);

  279. 	boolean getTextWrap();

  280. 	virtual size_t write(uint8_t);

  281. 	int16_t width(void)  { return _width; }

  282. 	int16_t height(void) { return _height; }

  283. 	uint8_t getRotation(void);

  284. 	void drawLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);

  285. 	void drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);

  286. 	int16_t getCursorX(void) const { return cursor_x; }

  287. 	int16_t getCursorY(void) const { return cursor_y; }

  288. 	void setFont(const ILI9341_t3_font_t &f) { font = &f; }

  289. 	void setFontAdafruit(void) { font = NULL; }

  290. 	void drawFontChar(unsigned int c);

  291. 	void measureChar(uint8_t c, uint16_t* w, uint16_t* h);

  292. 	uint16_t fontCapHeight() { return (font) ? font->cap_height : textsize * 8; }

  293. 	uint16_t fontLineSpace() { return (font) ? font->line_space : textsize * 8; }

  294. 	uint16_t fontGap() { return (font) ? font->line_space - font->cap_height : 0; };

  295. 	uint16_t measureTextWidth(const char* text, int chars = 0);

  296. 	uint16_t measureTextHeight(const char* text, int chars = 0);

  297. 	int16_t strPixelLen(char * str);

  298. 

  299.  protected:

  300.         unsigned long _clock = ILI9341_SPICLOCK;

  301. 	int16_t _width, _height; // Display w/h as modified by current rotation

  302. 	int16_t  cursor_x, cursor_y;

  303. 	uint16_t textcolor, textbgcolor;

  304. 	uint8_t textsize, rotation;

  305. 	boolean wrap; // If set, 'wrap' text at right edge of display

  306. 	const ILI9341_t3_font_t *font;

  307. 

  308.   	uint8_t  _rst;

  309.   	uint8_t _cs, _dc;

  310. 	uint8_t pcs_data, pcs_command;

  311. 	uint8_t _miso, _mosi, _sclk;

  312. 	// add support to allow only one hardware CS (used for dc)

  313. #if defined(__IMXRT1052__) || defined(__IMXRT1062__)  // Teensy 4.x

  314.     uint32_t _cspinmask;

  315.     volatile uint32_t *_csport;

  316.     uint32_t _spi_tcr_current;

  317.     uint32_t _dcpinmask;

  318.     uint8_t _pending_rx_count;

  319.     volatile uint32_t *_dcport;

  320.     uint32_t _tcr_dc_assert;

  321.     uint32_t _tcr_dc_not_assert;

  322. #else

  323.     uint8_t _cspinmask;

  324.     volatile uint8_t *_csport;

  325. #endif

  326. 	uint16_t old_x0=-1, old_x1, old_y0=-1, old_y1;

  327. 	void setAddr(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)

  328. 	  __attribute__((always_inline)) {

  329. 		if (x0 != old_x0 || x1 != old_x1) {

  330. 			writecommand_cont(ILI9341_CASET); // Column addr set

  331. 			writedata16_cont(x0);   // XSTART

  332. 			writedata16_cont(x1);   // XEND

  333. 			old_x0 = x0; old_x1 = x1;

  334. 		}

  335. 		if (y0 != old_y0 || y1 != old_y1) {

  336. 			writecommand_cont(ILI9341_PASET); // Row addr set

  337. 			writedata16_cont(y0);   // YSTART

  338. 			writedata16_cont(y1);   // YEND

  339. 			old_y0 = y0; old_y1 = y1;

  340. 		}

  341. 	}

  342. 

  343. //----------------------------------------------------------------------

  344. // Processor Specific stuff

  345. 

  346. #if defined(__IMXRT1052__) || defined(__IMXRT1062__)  // Teensy 4.x

  347. // T4

  348. 	void DIRECT_WRITE_LOW(volatile uint32_t * base, uint32_t mask)  __attribute__((always_inline)) {

  349. 		*(base+34) = mask;

  350. 	}

  351. 	void DIRECT_WRITE_HIGH(volatile uint32_t * base, uint32_t mask)  __attribute__((always_inline)) {

  352. 		*(base+33) = mask;

  353. 	}

  354. 	void waitFifoNotFull(void) {

  355.     	uint32_t tmp __attribute__((unused));

  356.     	do {

  357.         	if ((IMXRT_LPSPI4_S.RSR & LPSPI_RSR_RXEMPTY) == 0)  {

  358.             	tmp = IMXRT_LPSPI4_S.RDR;  // Read any pending RX bytes in

  359.             	if (_pending_rx_count) _pending_rx_count--; //decrement count of bytes still levt

  360.         	}

  361.     	} while ((IMXRT_LPSPI4_S.SR & LPSPI_SR_TDF) == 0) ;

  362. 	}

  363. 	void waitTransmitComplete(void)  {

  364. 	    uint32_t tmp __attribute__((unused));

  365. 	//    digitalWriteFast(2, HIGH);

  366. 

  367. 	    while (_pending_rx_count) {

  368. 	        if ((IMXRT_LPSPI4_S.RSR & LPSPI_RSR_RXEMPTY) == 0)  {

  369. 	            tmp = IMXRT_LPSPI4_S.RDR;  // Read any pending RX bytes in

  370. 	            _pending_rx_count--; //decrement count of bytes still levt

  371. 	        }

  372. 	    }

  373. 	    IMXRT_LPSPI4_S.CR = LPSPI_CR_MEN | LPSPI_CR_RRF;       // Clear RX FIFO

  374. 	//    digitalWriteFast(2, LOW);

  375. 	}

  376. 

  377. 

  378. 	#define TCR_MASK  (LPSPI_TCR_PCS(3) | LPSPI_TCR_FRAMESZ(31) | LPSPI_TCR_CONT | LPSPI_TCR_RXMSK )

  379. 	void maybeUpdateTCR(uint32_t requested_tcr_state) /*__attribute__((always_inline)) */ {

  380. 		if ((_spi_tcr_current & TCR_MASK) != requested_tcr_state) {

  381. 			bool dc_state_change = (_spi_tcr_current & LPSPI_TCR_PCS(3)) != (requested_tcr_state & LPSPI_TCR_PCS(3));

  382. 			_spi_tcr_current = (_spi_tcr_current & ~TCR_MASK) | requested_tcr_state ;

  383. 			// only output when Transfer queue is empty.

  384. 			if (!dc_state_change || !_dcpinmask) {

  385. 				while ((IMXRT_LPSPI4_S.FSR & 0x1f) )	;

  386. 				IMXRT_LPSPI4_S.TCR = _spi_tcr_current;	// update the TCR

  387. 

  388. 			} else {

  389. 				waitTransmitComplete();

  390. 				if (requested_tcr_state & LPSPI_TCR_PCS(3)) DIRECT_WRITE_HIGH(_dcport, _dcpinmask);

  391. 				else DIRECT_WRITE_LOW(_dcport, _dcpinmask);

  392. 				IMXRT_LPSPI4_S.TCR = _spi_tcr_current & ~(LPSPI_TCR_PCS(3) | LPSPI_TCR_CONT);	// go ahead and update TCR anyway?  

  393. 

  394. 			}

  395. 		}

  396. 	}

  397. 

  398. 	void beginSPITransaction(uint32_t clock = ILI9341_SPICLOCK) __attribute__((always_inline)) {

  399. 		SPI.beginTransaction(SPISettings(clock, MSBFIRST, SPI_MODE0));

  400. 		if (!_dcport) _spi_tcr_current = IMXRT_LPSPI4_S.TCR; 	// Only if DC is on hardware CS 

  401. 		if (_csport)

  402. 			DIRECT_WRITE_LOW(_csport, _cspinmask);

  403. 	}

  404. 	void endSPITransaction() __attribute__((always_inline)) {

  405. 		if (_csport)

  406. 			DIRECT_WRITE_HIGH(_csport, _cspinmask);

  407. 		SPI.endTransaction();

  408. 	}

  409. 

  410. 	// BUGBUG:: currently assumming we only have CS_0 as valid CS

  411. 	void writecommand_cont(uint8_t c) __attribute__((always_inline)) {

  412. 		maybeUpdateTCR(_tcr_dc_assert | LPSPI_TCR_FRAMESZ(7) /*| LPSPI_TCR_CONT*/);

  413. 		IMXRT_LPSPI4_S.TDR = c;

  414. 		_pending_rx_count++;	//

  415. 		waitFifoNotFull();

  416. 	}

  417. 	void writedata8_cont(uint8_t c) __attribute__((always_inline)) {

  418. 		maybeUpdateTCR(_tcr_dc_not_assert | LPSPI_TCR_FRAMESZ(7) | LPSPI_TCR_CONT);

  419. 		IMXRT_LPSPI4_S.TDR = c;

  420. 		_pending_rx_count++;	//

  421. 		waitFifoNotFull();

  422. 	}

  423. 	void writedata16_cont(uint16_t d) __attribute__((always_inline)) {

  424. 		maybeUpdateTCR(_tcr_dc_not_assert | LPSPI_TCR_FRAMESZ(15) | LPSPI_TCR_CONT);

  425. 		IMXRT_LPSPI4_S.TDR = d;

  426. 		_pending_rx_count++;	//

  427. 		waitFifoNotFull();

  428. 	}

  429. 	void writecommand_last(uint8_t c) __attribute__((always_inline)) {

  430. 		maybeUpdateTCR(_tcr_dc_assert | LPSPI_TCR_FRAMESZ(7));

  431. 		IMXRT_LPSPI4_S.TDR = c;

  432. //		IMXRT_LPSPI4_S.SR = LPSPI_SR_WCF | LPSPI_SR_FCF | LPSPI_SR_TCF;

  433. 		_pending_rx_count++;	//

  434. 		waitTransmitComplete();

  435. 	}

  436. 	void writedata8_last(uint8_t c) __attribute__((always_inline)) {

  437. 		maybeUpdateTCR(_tcr_dc_not_assert | LPSPI_TCR_FRAMESZ(7));

  438. 		IMXRT_LPSPI4_S.TDR = c;

  439. //		IMXRT_LPSPI4_S.SR = LPSPI_SR_WCF | LPSPI_SR_FCF | LPSPI_SR_TCF;

  440. 		_pending_rx_count++;	//

  441. 		waitTransmitComplete();

  442. 	}

  443. 	void writedata16_last(uint16_t d) __attribute__((always_inline)) {

  444. 		maybeUpdateTCR(_tcr_dc_not_assert | LPSPI_TCR_FRAMESZ(15));

  445. 		IMXRT_LPSPI4_S.TDR = d;

  446. //		IMXRT_LPSPI4_S.SR = LPSPI_SR_WCF | LPSPI_SR_FCF | LPSPI_SR_TCF;

  447. 		_pending_rx_count++;	//

  448. 		waitTransmitComplete();

  449. 	}

  450. 

  451. #else

  452. // T3.x	

  453. 	//void waitFifoNotFull(void) __attribute__((always_inline)) {

  454. 	void waitFifoNotFull(void) {

  455. 		uint32_t sr;

  456. 		uint32_t tmp __attribute__((unused));

  457. 		do {

  458. 			sr = KINETISK_SPI0.SR;

  459. 			if (sr & 0xF0) tmp = KINETISK_SPI0.POPR;  // drain RX FIFO

  460. 		} while ((sr & (15 << 12)) > (3 << 12));

  461. 	}

  462. 	void waitFifoEmpty(void) {

  463. 		uint32_t sr;

  464. 		uint32_t tmp __attribute__((unused));

  465. 		do {

  466. 			sr = KINETISK_SPI0.SR;

  467. 			if (sr & 0xF0) tmp = KINETISK_SPI0.POPR;  // drain RX FIFO

  468. 		} while ((sr & 0xF0F0) > 0);             // wait both RX & TX empty

  469. 	}

  470. 	void waitTransmitComplete(void) __attribute__((always_inline)) {

  471. 		uint32_t tmp __attribute__((unused));

  472. 		while (!(KINETISK_SPI0.SR & SPI_SR_TCF)) ; // wait until final output done

  473. 		tmp = KINETISK_SPI0.POPR;                  // drain the final RX FIFO word

  474. 	}

  475. 	void waitTransmitComplete(uint32_t mcr) __attribute__((always_inline)) {

  476. 		uint32_t tmp __attribute__((unused));

  477. 		while (1) {

  478. 			uint32_t sr = KINETISK_SPI0.SR;

  479. 			if (sr & SPI_SR_EOQF) break;  // wait for last transmit

  480. 			if (sr &  0xF0) tmp = KINETISK_SPI0.POPR;

  481. 		}

  482. 		KINETISK_SPI0.SR = SPI_SR_EOQF;

  483. 		SPI0_MCR = mcr;

  484. 		while (KINETISK_SPI0.SR & 0xF0) {

  485. 			tmp = KINETISK_SPI0.POPR;

  486. 		}

  487. 	}

  488. 	void beginSPITransaction(uint32_t clock = ILI9341_SPICLOCK) __attribute__((always_inline)) {

  489. 		SPI.beginTransaction(SPISettings(clock, MSBFIRST, SPI_MODE0));

  490. 		if (_csport)

  491. 			*_csport  &= ~_cspinmask;

  492. 	}

  493. 	void endSPITransaction() __attribute__((always_inline)) {

  494. 		if (_csport)

  495. 			*_csport |= _cspinmask;

  496. 		SPI.endTransaction();

  497. 	}

  498. 

  499. 	void writecommand_cont(uint8_t c) __attribute__((always_inline)) {

  500. 		KINETISK_SPI0.PUSHR = c | (pcs_command << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_CONT;

  501. 		waitFifoNotFull();

  502. 	}

  503. 	void writedata8_cont(uint8_t c) __attribute__((always_inline)) {

  504. 		KINETISK_SPI0.PUSHR = c | (pcs_data << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_CONT;

  505. 		waitFifoNotFull();

  506. 	}

  507. 	void writedata16_cont(uint16_t d) __attribute__((always_inline)) {

  508. 		KINETISK_SPI0.PUSHR = d | (pcs_data << 16) | SPI_PUSHR_CTAS(1) | SPI_PUSHR_CONT;

  509. 		waitFifoNotFull();

  510. 	}

  511. 	void writecommand_last(uint8_t c) __attribute__((always_inline)) {

  512. 		uint32_t mcr = SPI0_MCR;

  513. 		KINETISK_SPI0.PUSHR = c | (pcs_command << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_EOQ;

  514. 		waitTransmitComplete(mcr);

  515. 	}

  516. 	void writedata8_last(uint8_t c) __attribute__((always_inline)) {

  517. 		uint32_t mcr = SPI0_MCR;

  518. 		KINETISK_SPI0.PUSHR = c | (pcs_data << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_EOQ;

  519. 		waitTransmitComplete(mcr);

  520. 	}

  521. 	void writedata16_last(uint16_t d) __attribute__((always_inline)) {

  522. 		uint32_t mcr = SPI0_MCR;

  523. 		KINETISK_SPI0.PUSHR = d | (pcs_data << 16) | SPI_PUSHR_CTAS(1) | SPI_PUSHR_EOQ;

  524. 		waitTransmitComplete(mcr);

  525. 	}

  526. #endif

  527. 	void HLine(int16_t x, int16_t y, int16_t w, uint16_t color)

  528. 	  __attribute__((always_inline)) {

  529. 	  	if((x >= _width) || (y >= _height) || (y < 0)) return;

  530. 		if(x < 0) {	w += x; x = 0; 	}

  531. 		if((x+w-1) >= _width)  w = _width-x;

  532. 

  533. 		setAddr(x, y, x+w-1, y);

  534. 		writecommand_cont(ILI9341_RAMWR);

  535. 		do { writedata16_cont(color); } while (--w > 0);

  536. 	}

  537. 	void VLine(int16_t x, int16_t y, int16_t h, uint16_t color)

  538. 	  __attribute__((always_inline)) {

  539. 		if((x >= _width) || (x < 0) || (y >= _height)) return;

  540. 		if(y < 0) {	h += y; y = 0; 	}

  541. 		if((y+h-1) >= _height) h = _height-y;

  542. 		setAddr(x, y, x, y+h-1);

  543. 		writecommand_cont(ILI9341_RAMWR);

  544. 		do { writedata16_cont(color); } while (--h > 0);

  545. 	}

  546. 	void Pixel(int16_t x, int16_t y, uint16_t color)

  547. 	  __attribute__((always_inline)) {

  548. 		if((x >= _width) || (x < 0) || (y >= _height) || (y < 0)) return;

  549. 		setAddr(x, y, x, y);

  550. 		writecommand_cont(ILI9341_RAMWR);

  551. 		writedata16_cont(color);

  552. 	}

  553. 	void drawFontBits(uint32_t bits, uint32_t numbits, uint32_t x, uint32_t y, uint32_t repeat);

  554. };

  555. 

  556. #ifndef swap

  557. #define swap(a, b) { typeof(a) t = a; a = b; b = t; }

  558. #endif

  559. 

  560. // To avoid conflict when also using Adafruit_GFX or any Adafruit library

  561. // which depends on Adafruit_GFX, #include the Adafruit library *BEFORE*

  562. // you #include ILI9341_t3.h.

  563. #ifndef _ADAFRUIT_GFX_H

  564. class Adafruit_GFX_Button {

  565. public:

  566. 	Adafruit_GFX_Button(void) { _gfx = NULL; }

  567. 	void initButton(ILI9341_t3 *gfx, int16_t x, int16_t y,

  568. 		uint8_t w, uint8_t h,

  569. 		uint16_t outline, uint16_t fill, uint16_t textcolor,

  570. 		const char *label, uint8_t textsize);

  571. 	void drawButton(bool inverted = false);

  572. 	bool contains(int16_t x, int16_t y);

  573. 	void press(boolean p) {

  574. 		laststate = currstate;

  575. 		currstate = p;

  576. 	}

  577. 	bool isPressed() { return currstate; }

  578. 	bool justPressed() { return (currstate && !laststate); }

  579. 	bool justReleased() { return (!currstate && laststate); }

  580. private:

  581. 	ILI9341_t3 *_gfx;

  582. 	int16_t _x, _y;

  583. 	uint16_t _w, _h;

  584. 	uint8_t _textsize;

  585. 	uint16_t _outlinecolor, _fillcolor, _textcolor;

  586. 	char _label[10];

  587. 	boolean currstate, laststate;

  588. };

  589. #endif

  590. 

  591. #endif // __cplusplus

  592. 

  593. 

  594. #endif