visus
/
framework-arduinoteensy-cxx20
Obserwuj 1
Polub 0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
4 Commity
1 Gałąź
Drzewo: 16a0c39090
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '16a0c39090'
${ noResults }
framework-arduinoteensy-cxx20/libraries/ST7735_t3/ST7735_t3.h

839 lines
30KB
Czysty Wina Historia 

  1. /***************************************************

  2.   This is a library for the Adafruit 1.8" SPI display.

  3.   This library works with the Adafruit 1.8" TFT Breakout w/SD card

  4.   ----> http://www.adafruit.com/products/358

  5.   as well as Adafruit raw 1.8" TFT display

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

  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. #ifndef __ST7735_t3_H_

  20. #define __ST7735_t3_H_

  21. 

  22. #include "Arduino.h"

  23. #include "DMAChannel.h"

  24. #ifdef __cplusplus

  25. #include <SPI.h>

  26. #endif

  27. 

  28. #include "ILI9341_fonts.h"

  29. 

  30. #ifndef DISABLE_ST77XX_FRAMEBUFFER

  31. #if defined(__MK64FX512__) || defined(__MK66FX1M0__)

  32. #define ENABLE_ST77XX_FRAMEBUFFER

  33. #elif defined(__IMXRT1062__)

  34. #define ENABLE_ST77XX_FRAMEBUFFER

  35. #endif

  36. // Lets allow the user to define if they want T3.2 to enable frame buffer.

  37. // it will only work on subset of displays due to memory

  38. #define ENABLE_ST77XX_FRAMEBUFFER_T32

  39. #if defined(__MK20DX256__) && defined(ENABLE_ST77XX_FRAMEBUFFER_T32)

  40. #define ENABLE_ST77XX_FRAMEBUFFER

  41. #endif

  42. #endif

  43. 

  44. 

  45. #define ST7735_SPICLOCK 24000000

  46. //#define ST7735_SPICLOCK 16000000

  47. 

  48. // some flags for initR() :(

  49. #define INITR_GREENTAB 0x0

  50. #define INITR_REDTAB   0x1

  51. #define INITR_BLACKTAB 0x2

  52. 

  53. #define INITR_18GREENTAB    INITR_GREENTAB

  54. #define INITR_18REDTAB      INITR_REDTAB

  55. #define INITR_18BLACKTAB    INITR_BLACKTAB

  56. #define INITR_144GREENTAB   0x1

  57. #define INITR_144GREENTAB_OFFSET   0x4

  58. #define INITR_MINI160x80  0x05

  59. #define INITR_MINI160x80_ST7735S 0x06

  60. 

  61. #define INIT_ST7789_TABCOLOR 42  // Not used except as a indicator to the code... 

  62. 

  63. #define ST7735_TFTWIDTH  128

  64. #define ST7735_TFTWIDTH_80     80 // for mini

  65. // for 1.44" display

  66. #define ST7735_TFTHEIGHT_144 128

  67. // for 1.8" display and mini

  68. #define ST7735_TFTHEIGHT_160  160 // for 1.8" and mini display

  69. 

  70. #define ST7735_NOP     0x00

  71. #define ST7735_SWRESET 0x01

  72. #define ST7735_RDDID   0x04

  73. #define ST7735_RDDST   0x09

  74. 

  75. #define ST7735_SLPIN   0x10

  76. #define ST7735_SLPOUT  0x11

  77. #define ST7735_PTLON   0x12

  78. #define ST7735_NORON   0x13

  79. 

  80. #define ST7735_INVOFF  0x20

  81. #define ST7735_INVON   0x21

  82. #define ST7735_DISPOFF 0x28

  83. #define ST7735_DISPON  0x29

  84. #define ST7735_CASET   0x2A

  85. #define ST7735_RASET   0x2B

  86. #define ST7735_RAMWR   0x2C

  87. #define ST7735_RAMRD   0x2E

  88. 

  89. #define ST7735_PTLAR   0x30

  90. #define ST7735_COLMOD  0x3A

  91. #define ST7735_MADCTL  0x36

  92. 

  93. #define ST7735_FRMCTR1 0xB1

  94. #define ST7735_FRMCTR2 0xB2

  95. #define ST7735_FRMCTR3 0xB3

  96. #define ST7735_INVCTR  0xB4

  97. #define ST7735_DISSET5 0xB6

  98. 

  99. #define ST7735_PWCTR1  0xC0

  100. #define ST7735_PWCTR2  0xC1

  101. #define ST7735_PWCTR3  0xC2

  102. #define ST7735_PWCTR4  0xC3

  103. #define ST7735_PWCTR5  0xC4

  104. #define ST7735_VMCTR1  0xC5

  105. 

  106. #define ST7735_RDID1   0xDA

  107. #define ST7735_RDID2   0xDB

  108. #define ST7735_RDID3   0xDC

  109. #define ST7735_RDID4   0xDD

  110. 

  111. #define ST7735_PWCTR6  0xFC

  112. 

  113. #define ST7735_GMCTRP1 0xE0

  114. #define ST7735_GMCTRN1 0xE1

  115. 

  116. // Color definitions

  117. #define ST7735_BLACK   0x0000

  118. #define ST7735_BLUE    0x001F

  119. #define ST7735_RED     0xF800

  120. #define ST7735_GREEN   0x07E0

  121. #define ST7735_CYAN    0x07FF

  122. #define ST7735_MAGENTA 0xF81F

  123. #define ST7735_YELLOW  0xFFE0

  124. #define ST7735_WHITE   0xFFFF

  125. 

  126. // Also define them in a non specific ST77XX specific name

  127. #define ST77XX_BLACK      0x0000

  128. #define ST77XX_WHITE      0xFFFF

  129. #define ST77XX_RED        0xF800

  130. #define ST77XX_GREEN      0x07E0

  131. #define ST77XX_BLUE       0x001F

  132. #define ST77XX_CYAN       0x07FF

  133. #define ST77XX_MAGENTA    0xF81F

  134. #define ST77XX_YELLOW     0xFFE0

  135. #define ST77XX_ORANGE     0xFC00

  136. #define ST77XX_PINK       0xF81F

  137. 

  138. // Map fonts that were modified back to the ILI9341 font

  139. #define ST7735_t3_font_t ILI9341_t3_font_t

  140. 

  141. // Lets see about supporting Adafruit fonts as well?

  142. #if __has_include(<gfxfont.h>)

  143.   #include <gfxfont.h>

  144. #endif

  145. 

  146. #ifndef _GFXFONT_H_

  147. #define _GFXFONT_H_

  148. 

  149. /// Font data stored PER GLYPH

  150. typedef struct {

  151. 	uint16_t bitmapOffset;     ///< Pointer into GFXfont->bitmap

  152. 	uint8_t  width;            ///< Bitmap dimensions in pixels

  153.     uint8_t  height;           ///< Bitmap dimensions in pixels

  154. 	uint8_t  xAdvance;         ///< Distance to advance cursor (x axis)

  155. 	int8_t   xOffset;          ///< X dist from cursor pos to UL corner

  156.     int8_t   yOffset;          ///< Y dist from cursor pos to UL corner

  157. } GFXglyph;

  158. 

  159. /// Data stored for FONT AS A WHOLE

  160. typedef struct { 

  161. 	uint8_t  *bitmap;      ///< Glyph bitmaps, concatenated

  162. 	GFXglyph *glyph;       ///< Glyph array

  163. 	uint8_t   first;       ///< ASCII extents (first char)

  164.     uint8_t   last;        ///< ASCII extents (last char)

  165. 	uint8_t   yAdvance;    ///< Newline distance (y axis)

  166. } GFXfont;

  167. 

  168. #endif // _GFXFONT_H_

  169. 

  170. 

  171. #ifndef st7735_swap

  172. #define st7735_swap(a, b) { typeof(a) t = a; a = b; b = t; }

  173. #endif

  174. 

  175. #ifdef __cplusplus

  176. 

  177. #if defined(__IMXRT1062__)  // Teensy 4.x

  178. // Also define these in lower memory so as to make sure they are not cached...

  179. // try work around DMA memory cached.  So have a couple of buffers we copy frame buffer into

  180. // as to move it out of the memory that is cached...

  181. #define ST77XX_DMA_BUFFER_SIZE 512

  182. typedef struct {

  183.   DMASetting      _dmasettings[2];

  184.   DMAChannel      _dmatx;

  185.   uint16_t        _dma_buffer1[ST77XX_DMA_BUFFER_SIZE] __attribute__ ((aligned(4)));

  186.   uint16_t        _dma_buffer2[ST77XX_DMA_BUFFER_SIZE] __attribute__ ((aligned(4)));  

  187. } ST7735DMA_Data;

  188. #endif

  189. 

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

  191. 

  192. 

  193. //These enumerate the text plotting alignment (reference datum point)

  194. #define TL_DATUM 0 // Top left (default)

  195. #define TC_DATUM 1 // Top centre

  196. #define TR_DATUM 2 // Top right

  197. #define ML_DATUM 3 // Middle left

  198. #define CL_DATUM 3 // Centre left, same as above

  199. #define MC_DATUM 4 // Middle centre

  200. #define CC_DATUM 4 // Centre centre, same as above

  201. #define MR_DATUM 5 // Middle right

  202. #define CR_DATUM 5 // Centre right, same as above

  203. #define BL_DATUM 6 // Bottom left

  204. #define BC_DATUM 7 // Bottom centre

  205. #define BR_DATUM 8 // Bottom right

  206. //#define L_BASELINE  9 // Left character baseline (Line the 'A' character would sit on)

  207. //#define C_BASELINE 10 // Centre character baseline

  208. //#define R_BASELINE 11 // Right character baseline

  209. 

  210. 

  211. 

  212. class ST7735_t3 : public Print

  213. {

  214. 

  215.  public:

  216. 

  217.   ST7735_t3(uint8_t CS, uint8_t RS, uint8_t SID, uint8_t SCLK, uint8_t RST = -1);

  218.   ST7735_t3(uint8_t CS, uint8_t RS, uint8_t RST = -1);

  219. 

  220.   void     initB(void),                             // for ST7735B displays

  221.            initR(uint8_t options = INITR_GREENTAB), // for ST7735R

  222.            setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1),

  223.            pushColor(uint16_t color, boolean last_pixel=false),

  224.            fillScreen(uint16_t color),

  225.            drawPixel(int16_t x, int16_t y, uint16_t color),

  226.            drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color),

  227.            drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color),

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

  229.    inline void fillWindow(uint16_t color) {fillScreen(color);}

  230.   virtual void setRotation(uint8_t r);

  231.   void     invertDisplay(boolean i);

  232.   void     setRowColStart(uint16_t x, uint16_t y);

  233.   uint16_t  rowStart() {return _rowstart;}

  234.   uint16_t  colStart() {return _colstart;}

  235. 

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

  237.     __attribute__((always_inline)) {

  238.         writecommand(ST7735_CASET); // Column addr set

  239.         writedata16(x0+_xstart);   // XSTART 

  240.         writedata16(x1+_xstart);   // XEND

  241.         writecommand(ST7735_RASET); // Row addr set

  242.         writedata16(y0+_ystart);   // YSTART

  243.         writedata16(y1+_ystart);   // YEND

  244.   }

  245. 

  246.   ////

  247.   	// from Adafruit_GFX.h

  248. 	int16_t width(void) const { return _width; };

  249. 	int16_t height(void) const { return _height; }

  250. 	uint8_t getRotation(void);

  251. 	

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

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

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

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

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

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

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

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

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

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

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

  263. 	void drawChar(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t bg, uint8_t size_x, uint8_t size_y);

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

  265. 	    { drawChar(x, y, c, color, bg, size, size);}

  266. 	

  267. 	static const int16_t CENTER = 9998;

  268. 	void setCursor(int16_t x, int16_t y, bool autoCenter=false);

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

  270. 	void setTextColor(uint16_t c);

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

  272.     void setTextSize(uint8_t sx, uint8_t sy);

  273. 	void inline setTextSize(uint8_t s) { setTextSize(s,s); }

  274. 	uint8_t getTextSizeX();

  275. 	uint8_t getTextSizeY();

  276. 	uint8_t getTextSize();

  277. 	void setTextWrap(boolean w);

  278. 	boolean getTextWrap();

  279. 	

  280. 	//////

  281. 	virtual size_t write(uint8_t);		

  282. 	virtual size_t write(const uint8_t *buffer, size_t size);

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

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

  285. 	void setFont(const ILI9341_t3_font_t &f);

  286.     void setFont(const GFXfont *f = NULL);

  287. 	void setFontAdafruit(void) { setFont(); }

  288. 	void drawFontChar(unsigned int c);

  289. 	void drawGFXFontChar(unsigned int c);

  290. 

  291.     void getTextBounds(const uint8_t *buffer, uint16_t len, int16_t x, int16_t y,

  292.       int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);

  293.     void getTextBounds(const char *string, int16_t x, int16_t y,

  294.       int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);

  295.     void getTextBounds(const String &str, int16_t x, int16_t y,

  296.       int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h);

  297. 	int16_t strPixelLen(const char * str);

  298. 

  299. 	// added support for drawing strings/numbers/floats with centering

  300. 	// modified from tft_ili9341_ESP github library

  301. 	// Handle numbers

  302. 	int16_t  drawNumber(long long_num,int poX, int poY);

  303. 	int16_t  drawFloat(float floatNumber,int decimal,int poX, int poY);   

  304. 	// Handle char arrays

  305. 	int16_t drawString(const String& string, int poX, int poY);

  306. 	int16_t drawString1(char string[], int16_t len, int poX, int poY);

  307. 

  308. 	void setTextDatum(uint8_t datum);

  309. 	

  310. 	// added support for scrolling text area

  311. 	// https://github.com/vitormhenrique/ILI9341_t3

  312. 	// Discussion regarding this optimized version:

  313.     //http://forum.pjrc.com/threads/26305-Highly-optimized-ILI9341-%28320x240-TFT-color-display%29-library

  314. 	//	

  315. 	void setScrollTextArea(int16_t x, int16_t y, int16_t w, int16_t h);

  316. 	void setScrollBackgroundColor(uint16_t color);

  317. 	void enableScroll(void);

  318. 	void disableScroll(void);

  319. 	void scrollTextArea(uint8_t scrollSize);

  320. 	void resetScrollBackgroundColor(uint16_t color);

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

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

  323. 

  324. 	// setOrigin sets an offset in display pixels where drawing to (0,0) will appear

  325. 	// for example: setOrigin(10,10); drawPixel(5,5); will cause a pixel to be drawn at hardware pixel (15,15)

  326. 	void setOrigin(int16_t x = 0, int16_t y = 0) { 

  327. 		_originx = x; _originy = y; 

  328. 		//if (Serial) Serial.printf("Set Origin %d %d\n", x, y);

  329. 		updateDisplayClip();

  330. 	}

  331. 	void getOrigin(int16_t* x, int16_t* y) { *x = _originx; *y = _originy; }

  332. 

  333. 	// setClipRect() sets a clipping rectangle (relative to any set origin) for drawing to be limited to.

  334. 	// Drawing is also restricted to the bounds of the display

  335. 

  336. 	void setClipRect(int16_t x1, int16_t y1, int16_t w, int16_t h) 

  337. 		{ _clipx1 = x1; _clipy1 = y1; _clipx2 = x1+w; _clipy2 = y1+h; 

  338. 			//if (Serial) Serial.printf("Set clip Rect %d %d %d %d\n", x1, y1, w, h);

  339. 			updateDisplayClip();

  340. 		}

  341. 	void setClipRect() {

  342. 			 _clipx1 = 0; _clipy1 = 0; _clipx2 = _width; _clipy2 = _height; 

  343. 			//if (Serial) Serial.printf("clear clip Rect\n");

  344. 			updateDisplayClip(); 

  345. 		}	

  346. ////

  347. 	

  348.   void sendCommand(uint8_t commandByte, const uint8_t *dataBytes, uint8_t numDataBytes);

  349. 

  350. 

  351. 

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

  353.   inline uint16_t Color565(uint8_t r, uint8_t g, uint8_t b) {

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

  355.   }

  356.   void setBitrate(uint32_t n);

  357. 

  358.   /* These are not for current use, 8-bit protocol only!

  359.   uint8_t  readdata(void),

  360.            readcommand8(uint8_t);

  361.   uint16_t readcommand16(uint8_t);

  362.   uint32_t readcommand32(uint8_t);

  363.   void     dummyclock(void);

  364.   */

  365.   // Useful methods added from ili9341_t3 

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

  367. 

  368. // Frame buffer support

  369. #ifdef ENABLE_ST77XX_FRAMEBUFFER

  370.   enum {ST77XX_DMA_INIT=0x01, ST77XX_DMA_CONT=0x02, ST77XX_DMA_FINISH=0x04,ST77XX_DMA_ACTIVE=0x80};

  371. 

  372.   // added support to use optional Frame buffer

  373.   void  setFrameBuffer(uint16_t *frame_buffer);

  374.   uint8_t useFrameBuffer(boolean b);    // use the frame buffer?  First call will allocate

  375.   void  freeFrameBuffer(void);      // explicit call to release the buffer

  376.   void  updateScreen(void);       // call to say update the screen now. 

  377.   bool  updateScreenAsync(bool update_cont = false);  // call to say update the screen optinoally turn into continuous mode. 

  378.   void  waitUpdateAsyncComplete(void);

  379.   void  endUpdateAsync();      // Turn of the continueous mode fla

  380.   void  dumpDMASettings();

  381.   uint16_t *getFrameBuffer() {return _pfbtft;}

  382.   uint32_t frameCount() {return _dma_frame_count; }

  383.   boolean asyncUpdateActive(void)  {return (_dma_state & ST77XX_DMA_ACTIVE);}

  384.   void  initDMASettings(void);

  385.   #else

  386.   // added support to use optional Frame buffer

  387.   void  setFrameBuffer(uint16_t *frame_buffer) {return;}

  388.   uint8_t useFrameBuffer(boolean b) {return 0;};    // use the frame buffer?  First call will allocate

  389.   void  freeFrameBuffer(void) {return;}      // explicit call to release the buffer

  390.   void  updateScreen(void) {return;}       // call to say update the screen now. 

  391.   bool  updateScreenAsync(bool update_cont = false) {return false;}  // call to say update the screen optinoally turn into continuous mode. 

  392.   void  waitUpdateAsyncComplete(void) {return;}

  393.   void  endUpdateAsync() {return;}      // Turn of the continueous mode fla

  394.   void  dumpDMASettings() {return;}

  395. 

  396.   uint32_t frameCount() {return 0; }

  397.   uint16_t *getFrameBuffer() {return NULL;}

  398.   boolean asyncUpdateActive(void)  {return false;}

  399.   #endif

  400. 

  401. 

  402.  protected:

  403.   uint8_t  tabcolor;

  404. 

  405.   void     spiwrite(uint8_t),

  406.   		   spiwrite16(uint16_t d),

  407.            writecommand(uint8_t c),

  408.            writecommand_last(uint8_t c),

  409.            writedata(uint8_t d),

  410.            writedata_last(uint8_t d),

  411.            writedata16(uint16_t d),

  412.            writedata16_last(uint16_t d),

  413.            commandList(const uint8_t *addr),

  414.            commonInit(const uint8_t *cmdList, uint8_t mode=SPI_MODE0);

  415.   void charBounds(char c, int16_t *x, int16_t *y,

  416.       			int16_t *minx, int16_t *miny, int16_t *maxx, int16_t *maxy);

  417. //uint8_t  spiread(void);

  418. 

  419.   boolean  hwSPI;

  420.   ////

  421.   	int16_t  cursor_x, cursor_y;

  422. 	bool 	 _center_x_text = false; 

  423. 	bool 	 _center_y_text = false; 

  424. 	int16_t  _clipx1, _clipy1, _clipx2, _clipy2;

  425. 	int16_t  _originx, _originy;

  426. 	int16_t  _displayclipx1, _displayclipy1, _displayclipx2, _displayclipy2;

  427. 	bool _invisible = false; 

  428. 	bool _standard = true; // no bounding rectangle or origin set. 

  429. 

  430. 	inline void updateDisplayClip() {

  431. 		_displayclipx1 = max(0,min(_clipx1+_originx, width()));

  432. 		_displayclipx2 = max(0,min(_clipx2+_originx, width()));

  433. 

  434. 		_displayclipy1 = max(0,min(_clipy1+_originy, height()));

  435. 		_displayclipy2 = max(0,min(_clipy2+_originy, height()));

  436. 		_invisible = (_displayclipx1 == _displayclipx2 || _displayclipy1 == _displayclipy2);

  437. 		_standard =  (_displayclipx1 == 0) && (_displayclipx2 == _width) && (_displayclipy1 == 0) && (_displayclipy2 == _height);

  438. 		if (Serial) {

  439. 			//Serial.printf("UDC (%d %d)-(%d %d) %d %d\n", _displayclipx1, _displayclipy1, _displayclipx2, _displayclipy2, _invisible, _standard);

  440. 		}

  441. 	}

  442. 	

  443. 	int16_t _width, _height;

  444. 	int16_t scroll_x, scroll_y, scroll_width, scroll_height;

  445. 	boolean scrollEnable,isWritingScrollArea; // If set, 'wrap' text at right edge of display

  446. 

  447. 	uint16_t textcolor, textbgcolor, scrollbgcolor;

  448. 	uint32_t textcolorPrexpanded, textbgcolorPrexpanded;

  449. 	uint8_t textsize_x, textsize_y, rotation, textdatum;

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

  451. 	const ILI9341_t3_font_t *font;

  452. 	// Anti-aliased font support

  453. 	uint8_t fontbpp = 1;

  454. 	uint8_t fontbppindex = 0;

  455. 	uint8_t fontbppmask = 1;

  456. 	uint8_t fontppb = 8;

  457. 	uint8_t* fontalphalut;

  458. 	float fontalphamx = 1;

  459. 	

  460. 	uint32_t padX;

  461. 

  462. 	// GFX Font support

  463. 	const GFXfont *gfxFont = nullptr;

  464. 	int8_t _gfxFont_min_yOffset = 0;

  465. 

  466. 	// Opaque font chracter overlap?

  467. 	unsigned int _gfx_c_last;

  468. 	int16_t   _gfx_last_cursor_x, _gfx_last_cursor_y;

  469. 	int16_t	 _gfx_last_char_x_write = 0;

  470. 	uint16_t _gfx_last_char_textcolor;

  471. 	uint16_t _gfx_last_char_textbgcolor;

  472. 	bool gfxFontLastCharPosFG(int16_t x, int16_t y);

  473. 	

  474. 	void drawFontBits(bool opaque, uint32_t bits, uint32_t numbits, int32_t x, int32_t y, uint32_t repeat);

  475. 	void drawFontPixel( uint8_t alpha, uint32_t x, uint32_t y );

  476. 	uint32_t fetchpixel(const uint8_t *p, uint32_t index, uint32_t x);

  477. 

  478. 

  479.   uint16_t _colstart, _rowstart, _xstart, _ystart, _rot, _screenHeight, _screenWidth;

  480.   

  481.   SPISettings _spiSettings;

  482. #if defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)

  483.   uint8_t  _cs, _rs, _rst, _sid, _sclk;

  484.   uint8_t pcs_data, pcs_command;

  485.   uint32_t ctar;

  486.   volatile uint8_t *datapin, *clkpin, *cspin, *rspin;

  487. 

  488.   SPIClass *_pspi = nullptr;

  489.   uint8_t   _spi_num;          // Which buss is this spi on? 

  490.   KINETISK_SPI_t *_pkinetisk_spi;

  491.   SPIClass::SPI_Hardware_t *_spi_hardware;

  492.   void waitTransmitComplete(void);

  493.   void waitTransmitComplete(uint32_t mcr);

  494.   uint32_t _fifo_full_test;

  495. 

  496.   inline void beginSPITransaction() {

  497.     if (_pspi) _pspi->beginTransaction(_spiSettings);

  498.     if (cspin) *cspin = 0;

  499.   }

  500. 

  501.   inline void endSPITransaction()

  502.   {

  503.     if (cspin) *cspin = 1;

  504.     if (_pspi) _pspi->endTransaction();  

  505.   }

  506. 

  507. 

  508. #endif

  509. #if defined(__IMXRT1062__)  // Teensy 4.x

  510.   SPIClass *_pspi = nullptr;

  511.   uint8_t   _spi_num = 0;          // Which buss is this spi on? 

  512.   IMXRT_LPSPI_t *_pimxrt_spi = nullptr;

  513.   SPIClass::SPI_Hardware_t *_spi_hardware;

  514.   uint8_t _pending_rx_count = 0;

  515.   uint32_t _spi_tcr_current = 0; 

  516.   uint32_t _tcr_dc_assert;

  517.   uint32_t _tcr_dc_not_assert;

  518. 

  519. 

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

  521.     *(base+34) = mask;

  522.   }

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

  524.     *(base+33) = mask;

  525.   }

  526.   

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

  528. 

  529.   void maybeUpdateTCR(uint32_t requested_tcr_state) {

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

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

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

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

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

  535.         while ((_pimxrt_spi->FSR & 0x1f) )  ;

  536.         _pimxrt_spi->TCR = _spi_tcr_current;  // update the TCR

  537. 

  538.       } else {

  539.         waitTransmitComplete();

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

  541.         else DIRECT_WRITE_LOW(_dcport, _dcpinmask);

  542.         _pimxrt_spi->TCR = _spi_tcr_current & ~(LPSPI_TCR_PCS(3) | LPSPI_TCR_CONT); // go ahead and update TCR anyway?  

  543. 

  544.       }

  545.     }

  546.   }

  547. 

  548.   inline void beginSPITransaction() {

  549.     if (hwSPI) _pspi->beginTransaction(_spiSettings);

  550.     if (!_dcport) _spi_tcr_current = _pimxrt_spi->TCR;  // Only if DC is on hardware CS 

  551.     if (_csport)DIRECT_WRITE_LOW(_csport, _cspinmask);

  552.   }

  553. 

  554.   inline void endSPITransaction() {

  555.     if (_csport)DIRECT_WRITE_HIGH(_csport, _cspinmask);

  556.     if (hwSPI) _pspi->endTransaction();  

  557.   }

  558. 

  559.  

  560.   void waitFifoNotFull(void) {

  561.     uint32_t tmp __attribute__((unused));

  562.     do {

  563.         if ((_pimxrt_spi->RSR & LPSPI_RSR_RXEMPTY) == 0)  {

  564.             tmp = _pimxrt_spi->RDR;  // Read any pending RX bytes in

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

  566.         }

  567.     } while ((_pimxrt_spi->SR & LPSPI_SR_TDF) == 0) ;

  568.  }

  569.  void waitTransmitComplete(void)  {

  570.     uint32_t tmp __attribute__((unused));

  571. //    digitalWriteFast(2, HIGH);

  572. 

  573.     while (_pending_rx_count) {

  574.         if ((_pimxrt_spi->RSR & LPSPI_RSR_RXEMPTY) == 0)  {

  575.             tmp = _pimxrt_spi->RDR;  // Read any pending RX bytes in

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

  577.         }

  578.     }

  579.     _pimxrt_spi->CR = LPSPI_CR_MEN | LPSPI_CR_RRF;       // Clear RX FIFO

  580. //    digitalWriteFast(2, LOW);

  581. }

  582. 

  583. 

  584.   uint8_t  _cs, _rs, _rst, _sid, _sclk;

  585. 

  586.   uint32_t _cspinmask;

  587.   volatile uint32_t *_csport;

  588.   uint32_t _dcpinmask;

  589.   volatile uint32_t *_dcport;

  590.   uint32_t _mosipinmask;

  591.   volatile uint32_t *_mosiport;

  592.   uint32_t _sckpinmask;

  593.   volatile uint32_t *_sckport;

  594.   

  595. 

  596.   uint32_t ctar;

  597. #endif

  598. #if defined(__MKL26Z64__)

  599. volatile uint8_t *dataport, *clkport, *csport, *rsport;

  600.   uint8_t  _cs, _rs, _rst, _sid, _sclk,

  601.            datapinmask, clkpinmask, cspinmask, rspinmask;

  602.   boolean  hwSPI1;

  603.   inline void beginSPITransaction() {

  604.     if (hwSPI) SPI.beginTransaction(_spiSettings);

  605.     else if (hwSPI1) SPI1.beginTransaction(_spiSettings);

  606.     if (csport)*csport &= ~cspinmask;

  607.   }

  608. 

  609.   inline void endSPITransaction() {

  610.     if (csport) *csport |= cspinmask;

  611.     if (hwSPI) SPI.endTransaction(); 

  612.     else if (hwSPI1)  SPI1.endTransaction();  

  613.   }

  614. #endif 

  615. 

  616. #ifdef ENABLE_ST77XX_FRAMEBUFFER

  617.     // Add support for optional frame buffer

  618.   uint16_t  *_pfbtft;           // Optional Frame buffer 

  619.   uint8_t   _use_fbtft;         // Are we in frame buffer mode?

  620.   uint16_t  *_we_allocated_buffer;      // We allocated the buffer; 

  621.   uint32_t  _count_pixels;       // How big is the display in total pixels...

  622. 

  623.   // Add DMA support. 

  624.   // Note: We have enough memory to have more than one, so could have multiple active devices (one per SPI BUS)

  625.   //     All three devices have 3 SPI buss so hard coded

  626.   static  ST7735_t3     *_dmaActiveDisplay[3];  // Use pointer to this as a way to get back to object...

  627.   volatile uint8_t      _dma_state;         // DMA status

  628.   volatile uint32_t     _dma_frame_count;   // Can return a frame count...

  629. 

  630.   #if defined(__MK66FX1M0__) 

  631.   // T3.6 use Scatter/gather with chain to do transfer

  632.   static DMASetting   _dmasettings[3][4];

  633.   DMAChannel   _dmatx;

  634.   uint8_t      _cnt_dma_settings;   // how many do we need for this display?

  635.   #elif defined(__IMXRT1062__)  // Teensy 4.x

  636.   static ST7735DMA_Data _dma_data[3];   // one structure for each SPI buss... 

  637.   // try work around DMA memory cached.  So have a couple of buffers we copy frame buffer into

  638.   // as to move it out of the memory that is cached...

  639.   volatile    uint32_t _dma_pixel_index = 0;

  640.   volatile uint16_t _dma_sub_frame_count = 0; // Can return a frame count...

  641.   uint16_t          _dma_buffer_size;   // the actual size we are using <= DMA_BUFFER_SIZE;

  642.   uint16_t          _dma_cnt_sub_frames_per_frame;  

  643.   uint32_t      _spi_fcr_save;    // save away previous FCR register value

  644. 

  645.   #elif defined(__MK64FX512__)

  646.   // T3.5 - had issues scatter/gather so do just use channels/interrupts

  647.   // and update and continue

  648.   uint8_t _cspinmask;

  649.   volatile uint8_t *_csport = nullptr;

  650.   DMAChannel   _dmatx;

  651.   DMAChannel   _dmarx;

  652.   uint32_t   _dma_count_remaining;

  653.   uint16_t   _dma_write_size_words;

  654.   #elif defined(__MK20DX256__)

  655.   // For first pass maybe emulate T3.5 on SPI...

  656.   uint8_t _cspinmask;

  657.   volatile uint8_t *_csport = nullptr;

  658.   DMAChannel   _dmatx;

  659.   DMAChannel   _dmarx;

  660.   uint16_t   _dma_count_remaining;

  661.   uint16_t   _dma_write_size_words;

  662. 

  663.   #endif  

  664.   static void dmaInterrupt(void);

  665.   static void dmaInterrupt1(void);

  666.   static void dmaInterrupt2(void);

  667.   void process_dma_interrupt(void);

  668. #endif

  669. 

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

  671. 	  __attribute__((always_inline)) 

  672. 	  {

  673. 		#ifdef ENABLE_ST77XX_FRAMEBUFFER

  674. 	  	if (_use_fbtft) {

  675. 	  		drawFastHLine(x, y, w, color);

  676. 	  		return;

  677. 	  	}

  678. 	  	#endif

  679. 	    x+=_originx;

  680. 	    y+=_originy;

  681. 

  682. 	    // Rectangular clipping

  683. 	    if((y < _displayclipy1) || (x >= _displayclipx2) || (y >= _displayclipy2)) return;

  684. 	    if(x<_displayclipx1) { w = w - (_displayclipx1 - x); x = _displayclipx1; }

  685. 	    if((x+w-1) >= _displayclipx2)  w = _displayclipx2-x;

  686. 	    if (w<1) return;

  687. 

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

  689. 		writecommand(ST7735_RAMWR);

  690. 		do { writedata16(color); } while (--w > 0);

  691. 	  }

  692. 	  

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

  694. 	  __attribute__((always_inline)) 

  695. 	  {

  696. 		#ifdef ENABLE_ST77XX_FRAMEBUFFER

  697. 	  	if (_use_fbtft) {

  698. 	  		drawFastVLine(x, y, h, color);

  699. 	  		return;

  700. 	  	}

  701. 	  	#endif

  702. 		x+=_originx;

  703. 	    y+=_originy;

  704. 

  705. 	    // Rectangular clipping

  706. 	    if((x < _displayclipx1) || (x >= _displayclipx2) || (y >= _displayclipy2)) return;

  707. 	    if(y < _displayclipy1) { h = h - (_displayclipy1 - y); y = _displayclipy1;}

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

  709. 	    if(h<1) return;

  710. 

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

  712. 		writecommand(ST7735_RAMWR);

  713. 		do { writedata16(color); } while (--h > 0);

  714. 	  }

  715. 	  

  716. 	/**

  717. 	 * Found in a pull request for the Adafruit framebuffer library. Clever!

  718. 	 * https://github.com/tricorderproject/arducordermini/pull/1/files#diff-d22a481ade4dbb4e41acc4d7c77f683d

  719. 	 * Converts  0000000000000000rrrrrggggggbbbbb

  720. 	 *     into  00000gggggg00000rrrrr000000bbbbb

  721. 	 * with mask 00000111111000001111100000011111

  722. 	 * This is useful because it makes space for a parallel fixed-point multiply

  723. 	 * This implements the linear interpolation formula: result = bg * (1.0 - alpha) + fg * alpha

  724. 	 * This can be factorized into: result = bg + (fg - bg) * alpha

  725. 	 * alpha is in Q1.5 format, so 0.0 is represented by 0, and 1.0 is represented by 32

  726. 	 * @param	fg		Color to draw in RGB565 (16bit)

  727. 	 * @param	bg		Color to draw over in RGB565 (16bit)

  728. 	 * @param	alpha	Alpha in range 0-255

  729. 	 **/

  730. 	uint16_t alphaBlendRGB565( uint32_t fg, uint32_t bg, uint8_t alpha )

  731. 	 __attribute__((always_inline)) {

  732. 	 	alpha = ( alpha + 4 ) >> 3; // from 0-255 to 0-31

  733. 		bg = (bg | (bg << 16)) & 0b00000111111000001111100000011111;

  734. 		fg = (fg | (fg << 16)) & 0b00000111111000001111100000011111;

  735. 		uint32_t result = ((((fg - bg) * alpha) >> 5) + bg) & 0b00000111111000001111100000011111;

  736. 		return (uint16_t)((result >> 16) | result); // contract result

  737. 	}

  738. 	/**

  739. 	 * Same as above, but fg and bg are premultiplied, and alpah is already in range 0-31

  740. 	 */

  741. 	uint16_t alphaBlendRGB565Premultiplied( uint32_t fg, uint32_t bg, uint8_t alpha )

  742. 	 __attribute__((always_inline)) {

  743. 		uint32_t result = ((((fg - bg) * alpha) >> 5) + bg) & 0b00000111111000001111100000011111;

  744. 		return (uint16_t)((result >> 16) | result); // contract result

  745. 	}

  746. 	  

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

  748. 	  __attribute__((always_inline)) {

  749. 	    x+=_originx;

  750. 	    y+=_originy;

  751. 

  752. 	  	//if((x < _displayclipx1) ||(x >= _displayclipx2) || (y < _displayclipy1) || (y >= _displayclipy2)) return;

  753. 

  754. 		#ifdef ENABLE_ST77XX_FRAMEBUFFER

  755. 	  	if (_use_fbtft) {

  756. 	  		_pfbtft[y*_screenWidth + x] = color;

  757. 	  		return;

  758. 	  	}

  759. 	  	#endif

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

  761. 		writecommand(ST7735_RAMWR);

  762. 		writedata16(color);

  763. 	}

  764. 

  765. };

  766. 

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

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

  769. // you #include ST7735_t3.h.

  770. // Warning the implemention of class needs to be here, else the code

  771. // compiled in the c++ file will cause duplicate defines in the link phase. 

  772. #define Adafruit_GFX_Button ST7735_Button

  773. class ST7735_Button {

  774. public:

  775. 	ST7735_Button(void) { _gfx = NULL; }

  776. 	void initButton(ST7735_t3 *gfx, int16_t x, int16_t y,

  777. 		uint8_t w, uint8_t h,

  778. 		uint16_t outline, uint16_t fill, uint16_t textcolor,

  779. 		const char *label, uint8_t textsize_x, uint8_t textsize_y) {

  780. 		_x = x;

  781. 		_y = y;

  782. 		_w = w;

  783. 		_h = h;

  784. 		_outlinecolor = outline;

  785. 		_fillcolor = fill;

  786. 		_textcolor = textcolor;

  787. 		_textsize_x = textsize_x;

  788. 		_textsize_y = textsize_y;

  789. 		_gfx = gfx;

  790. 		strncpy(_label, label, 9);

  791. 		_label[9] = 0;

  792. 

  793. 	}

  794. 	void drawButton(bool inverted = false) {

  795. 		uint16_t fill, outline, text;

  796. 

  797. 		if (! inverted) {

  798. 			fill = _fillcolor;

  799. 			outline = _outlinecolor;

  800. 			text = _textcolor;

  801. 		} else {

  802. 			fill =  _textcolor;

  803. 			outline = _outlinecolor;

  804. 			text = _fillcolor;

  805. 		}

  806. 		_gfx->fillRoundRect(_x - (_w/2), _y - (_h/2), _w, _h, min(_w,_h)/4, fill);

  807. 		_gfx->drawRoundRect(_x - (_w/2), _y - (_h/2), _w, _h, min(_w,_h)/4, outline);

  808. 		_gfx->setCursor(_x - strlen(_label)*3*_textsize_x, _y-4*_textsize_y);

  809. 		_gfx->setTextColor(text);

  810. 		_gfx->setTextSize(_textsize_x, _textsize_y);

  811. 		_gfx->print(_label);

  812. 	}

  813. 

  814. 	bool contains(int16_t x, int16_t y) {

  815. 		if ((x < (_x - _w/2)) || (x > (_x + _w/2))) return false;

  816. 		if ((y < (_y - _h/2)) || (y > (_y + _h/2))) return false;

  817. 		return true;

  818. 	}

  819. 

  820. 	void press(boolean p) {

  821. 		laststate = currstate;

  822. 		currstate = p;

  823. 	}

  824. 	bool isPressed() { return currstate; }

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

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

  827. private:

  828. 	ST7735_t3 *_gfx;

  829. 	int16_t _x, _y;

  830. 	uint16_t _w, _h;

  831. 	uint8_t _textsize_x, _textsize_y;

  832. 	uint16_t _outlinecolor, _fillcolor, _textcolor;

  833. 	char _label[10];

  834. 	boolean currstate, laststate;

  835. };

  836. 

  837. #endif	 //end cplus

  838. 

  839. #endif