visus
/
framework-arduinoteensy-cxx20
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
Tree: daa7cc5a30
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'daa7cc5a30'
${ noResults }
framework-arduinoteensy-cxx20/libraries/RA8875/RA8875.h

1132 lines
48KB
Raw Blame History 

  1. /*

  2. 	--------------------------------------------------

  3. 	RA8875 LCD/TFT Graphic Controller Driver Library

  4. 	--------------------------------------------------

  5. 	Version:0.70b11p11

  6. 	++++++++++++++++++++++++++++++++++++++++++++++++++

  7. 	Written by: Max MC Costa for s.u.m.o.t.o.y

  8. 	++++++++++++++++++++++++++++++++++++++++++++++++++

  9. An attemp to create a full featured library support for RA8875 chip from RAiO.

  10. Works with many SPI drived RA8875 Boards included Adafruit, Eastrising(buydisplay).

  11. NOT work if you have a I2C or Parallel based display!

  12. 

  13. -------------------------------------------------------------------------------------

  14. 					>>>>>>>>>>>> About Copyrights <<<<<<<<<<<<<<<

  15. -------------------------------------------------------------------------------------

  16. License:GNU General Public License v3.0

  17. 

  18.     RA8875 fast SPI library for RAiO SPI RA8875 drived TFT

  19.     Copyright (C) 2014  egidio massimo costa sumotoy (a t) gmail.com

  20. 

  21.     This program is free software: you can redistribute it and/or modify

  22.     it under the terms of the GNU General Public License as published by

  23.     the Free Software Foundation, either version 3 of the License, or

  24.     (at your option) any later version.

  25. 

  26.     This program is distributed in the hope that it will be useful,

  27.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  28.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  29.     GNU General Public License for more details.

  30. 

  31.     You should have received a copy of the GNU General Public License

  32.     along with this program.  If not, see <http://www.gnu.org/licenses/>.

  33. -------------------------------------------------------------------------------------

  34. 					     >>>>>>>>>>>> Thanks to <<<<<<<<<<<<<<<

  35. -------------------------------------------------------------------------------------

  36. Teensy 3.1, a tiny MCU but monster of performances at tiny price, Arduino should learn...

  37. Paul Stoffregen, the 'guru' behind many arduino magic, the father of Teensy

  38. Bill Greyman, another 'maestro', greatly inspired many coders

  39. Jnmattern & Marek Buriak for drawArc

  40. Last but not less important the contributors and beta tester of this library:

  41. M.Sandercrock, the experimentalist, MrTom and many others

  42. -------------------------------------------------------------------------------------

  43. 				>>>>>>>>>>>> Current version notes <<<<<<<<<<<<<<<

  44. -------------------------------------------------------------------------------------

  45. 	0.70b11p8 changes: Fixed some small error (thanks Mr TOM) that affects drawLine

  46. 	and drawLineAngle. Initial support for SPARK devices (very early development)

  47. 	Fixed a couple of examples.

  48. 	0.70b11p9 changes: Now compile with particle spark! But spark development toolchain it's a nightmare so 

  49. 	use https://github.com/sumotoy/spark_ra8875

  50. 	0.70b11p10: Some changes proposed by MrTom to fix the triangle hardware bug of RA8875

  51. 	0.70b11p11: Minor changes on triangles helper (MrTom)

  52. -------------------------------------------------------------------------------------

  53. 				>>>>>>>>>>>>>>>>>>>>> Wiring <<<<<<<<<<<<<<<<<<<<<<<<<

  54. -------------------------------------------------------------------------------------

  55. TFT side	Teensy/Uno

  56. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  57. CLK:		pin 13 UNO

  58. MOSI:		pin 11 UNO

  59. MISO:		pin 12 UNO

  60. CS:			pin 10 (selectable but note 1*!)

  61. INT:		pin 2  (selectable 2*)

  62. RESET:		pin 9  (selectable and optional 0*)

  63. *(0) In some modules you can leave unconnected but check if it's needed!

  64. *(1) On Teensy3.x not all pin are usable for CS! Read the printed paper

  65. that come with your Teensy3.x for more informations!

  66. *(2) Arduino cannot use any pin for interrupts! In my examples I don't use

  67. interrupts but just reading pin state so you can use any pin :)

  68. -------------------------------------------------------------------------------------

  69. TFT side	Stellaris (LM4F120XL) module=0 (still not checked)

  70. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  71. CLK:		xxx

  72. MOSI:		xxx

  73. MISO:		xxx

  74. CS:			xxx  (selectable)

  75. INT:		xxx  (selectable)

  76. RESET:		xxx  (selectable and optional)

  77. 

  78. *if you use an [optional] SD card here's connections...

  79. -------------------------------------------------------------------------------------

  80. TFT side	Teensy2/Teensy3/Uno

  81. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  82. SD CLK:		pin 13 [shared with RA]

  83. SD MOSI:	pin 11 [shared with RA]

  84. SD MISO:	pin 12 [shared with RA]

  85. SD CS:		pin 4  (selectable 3*)

  86. SD CARD ID: pin xx (selectable and optional)

  87. *(3) On Teensy3.x not all pin are usable for CS! 

  88. can be used: 2,6,9,10,15,20,21,22,23

  89. -------------------------------------------------------------------------------------

  90. TFT side	Stellaris (LM4F120XL) module=0 (still not checked)

  91. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  92. SD CLK:		xxx shared

  93. SD MOSI:	xxx shared

  94. SD MISO:	xxx shared

  95. SD CS:		xxx  (selectable)

  96. SD CARD ID: pin xx (selectable and optional)

  97. -------------------------------------------------------------------------------------

  98. TFT side	Teensy3 alternative setup

  99. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  100. There are special cases on Teensy 3.x since it can be used for audio shield that remap

  101. some pin. Using SPI in that situation will be impossible but you can use the alternative

  102. pins definition feature of Teensy 3!

  103. SD CLK:		pin 13(normal),pin 14(alt)  [shared with RA]

  104. SD MOSI:	pin 11(normal),pin 7(alt) 	[shared with RA]

  105. SD MISO:	pin 12(normal),pin 8(alt) 	[shared with RA]

  106. SD CS:		pin 2  (selectable 3*)

  107. SD CARD ID: pin xx (selectable and optional)

  108. *(3) On Teensy3.x not all pin are usable for CS's! 

  109. can be used: 2,6,9,10,15,20,21,22,23

  110. -------------------------------------------------------------------------------------

  111. TFT side	Particle Spark  (caution, never tested!)

  112. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  113. CLK:		 	A3

  114. MOSI:			A5

  115. MISO:			A4

  116. CS:				A2

  117. INT:		

  118. SDA:			D0

  119. SCL:			D1

  120. 

  121. Benchmark results for reference --------------------------------------

  122. Screen fill              16635		16585		16561		8326

  123. Test Pixel               60			77			63			53

  124. Test Pixels              39780		52085		41885		35412

  125. Text                     4500		4389		4634		3409

  126. Lines                    96705		101951		97943		55986

  127. Horiz/Vert Lines         66656		72470		67732		42703

  128. Rectangles (outline)     269786		271251		269987		137691

  129. Rectangles (filled)      269498		271415		270002		137858

  130. Circles (filled)         110285		195011		181003		117279

  131. Circles (outline)        109604		191746		177459		115584

  132. Triangles (outline)      24521		26320		24886		14728

  133. Triangles (filled)       64947		66801		65367		35226

  134. Rounded rects (outline)  146391		167477		151142		103027

  135. Rounded rects (filled)   935691		953280		940016		493179

  136. 

  137. 

  138. PIN     UNO		MEGA       CD4050     RA8875

  139. SCK      13		52           YES       SCK

  140. MOSI     11		51           YES       MOSI

  141. MISO     12		50            NO       MISO

  142. RST      9		 5           YES       RST

  143. CS       10		53           YES       CS

  144. */

  145. 

  146. #ifndef _RA8875MC_H_

  147. #define _RA8875MC_H_

  148. 

  149. #include <inttypes.h>

  150. 

  151. 

  152. #if !defined(swapvals)

  153. 	#if defined(ESP8266)

  154. 		#define swapvals(a, b) { int16_t t = a; a = b; b = t; }

  155. 		//#define swapvals(a, b) { typeid(a) t = a; a = b; b = t; }

  156. 	#else

  157. 		#define swapvals(a, b) { typeof(a) t = a; a = b; b = t; }

  158. 	#endif

  159. #endif

  160. 

  161. enum RA8875sizes { 			RA8875_480x272, RA8875_800x480, RA8875_800x480ALT, Adafruit_480x272, Adafruit_800x480 };

  162. enum RA8875tcursor { 		NOCURSOR=0,IBEAM,UNDER,BLOCK };//0,1,2,3

  163. enum RA8875tsize { 			X16=0,X24,X32 };//0,1,2

  164. enum RA8875fontSource { 	INTFONT=0, EXTFONT };//0,1

  165. enum RA8875fontCoding { 	ISO_IEC_8859_1, ISO_IEC_8859_2, ISO_IEC_8859_3, ISO_IEC_8859_4 };

  166. enum RA8875extRomType { 	GT21L16T1W, GT21H16T1W, GT23L16U2W, GT30L16U2W, GT30H24T3Y, GT23L24T3Y, GT23L24M1Z, GT23L32S4W, GT30H32S4W, GT30L32S4W, ER3303_1, ER3304_1, ER3301_1 };

  167. enum RA8875extRomCoding { 	GB2312, GB12345, BIG5, UNICODE, ASCII, UNIJIS, JIS0208, LATIN };

  168. enum RA8875extRomFamily { 	STANDARD, ARIAL, ROMAN, BOLD };

  169. enum RA8875boolean { 		LAYER1, LAYER2, TRANSPARENT, LIGHTEN, OR, AND, FLOATING };

  170. enum RA8875writes { 		L1=0, L2, CGRAM, PATTERN, CURSOR };

  171. enum RA8875scrollMode{ 		SIMULTANEOUS, LAYER1ONLY, LAYER2ONLY, BUFFERED };

  172. enum RA8875pattern{ 		P8X8, P16X16 };

  173. enum RA8875btedatam{ 		CONT, RECT };

  174. enum RA8875btelayer{ 		SOURCE, DEST };

  175. enum RA8875intlist{ 		BTE=1,TOUCH=2, DMA=3,KEY=4 };

  176. 

  177. /*

  178. -------------- UNICODE decode (2 byte char) ---------------------

  179. Latin:      \u0000 -> \u007F	/u00

  180. Greek:		\u0370 -> \u03FF	/u03

  181. Cyrillic:   \u0400 -> \u04FF	/u04

  182. Hebrew:     \u0590 -> \u05FF	/u05

  183. Arabic: 	\u0600 -> \u06FF	/u06

  184. Hiragana:	\u3040 -> \u309F	/u30

  185. Katakana:   \u30A0 -> \u30FF	/u30

  186. CJK-Uni:	\u4E00 -> \u9FD5	/u4E ... /u9F

  187. */

  188. /* ----------------------------DO NOT TOUCH ANITHING FROM HERE ------------------------*/

  189. 

  190. 

  191. // Documentation on the ILI9488_t3 font data format:

  192. // https://forum.pjrc.com/threads/54316-ILI9488_t-font-structure-format

  193. /*

  194. typedef struct {

  195. 	const unsigned char *index;

  196. 	const unsigned char *unicode;

  197. 	const unsigned char *data;

  198. 	unsigned char version;

  199. 	unsigned char reserved;

  200. 	unsigned char index1_first;

  201. 	unsigned char index1_last;

  202. 	unsigned char index2_first;

  203. 	unsigned char index2_last;

  204. 	unsigned char bits_index;

  205. 	unsigned char bits_width;

  206. 	unsigned char bits_height;

  207. 	unsigned char bits_xoffset;

  208. 	unsigned char bits_yoffset;

  209. 	unsigned char bits_delta;

  210. 	unsigned char line_space;

  211. 	unsigned char cap_height;

  212. } ILI9341_t3_font_t;

  213. */

  214. #include "ILI9341_fonts.h"

  215. 

  216. 

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

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

  219. 	#include <gfxfont.h>

  220. #endif

  221. 

  222. #ifndef _GFXFONT_H_

  223. #define _GFXFONT_H_

  224. 

  225. /// Font data stored PER GLYPH

  226. typedef struct {

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

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

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

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

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

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

  233. } GFXglyph;

  234. 

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

  236. typedef struct { 

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

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

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

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

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

  242. } GFXfont;

  243. 

  244. #endif // _GFXFONT_H_

  245. 

  246. #ifdef __cplusplus

  247. #include "_includes/RA8875_CPU_commons.h"

  248. 

  249. #include "_includes/font.h"

  250. #include "_includes/RA8875Registers.h"

  251. #include "_includes/RA8875ColorPresets.h"

  252. #include "_settings/RA8875UserSettings.h"

  253. 

  254. #if !defined(_AVOID_TOUCHSCREEN) &&  defined(USE_FT5206_TOUCH)

  255. #include <Wire.h>

  256. #endif

  257. 

  258. #if defined(_FORCE_PROGMEM__) && !defined(ESP8266)

  259. template <typename T> T PROGMEM_read (const T * sce)

  260.   {

  261.   static T temp;

  262.   memcpy_P (&temp, sce, sizeof (T));

  263.   return temp;

  264.   }

  265. #endif

  266. 

  267. #if defined(ESP8266) && defined(_FASTSSPORT)

  268. 	#include <eagle_soc.h>

  269. #endif

  270. 

  271. class RA8875 : public Print

  272. {

  273.  public:

  274. 	// void 		debugData(uint16_t data,uint8_t len=8);

  275. 	// void 		showLineBuffer(uint8_t data[],int len);

  276. //------------- INSTANCE -------------------------------------------------------------------

  277. 	#if defined(__MK20DX128__) || defined(__MK20DX256__)

  278. 		RA8875(const uint8_t CSp,const uint8_t RSTp=255,const uint8_t mosi_pin=11,const uint8_t sclk_pin=13,const uint8_t miso_pin=12);

  279. 	#elif defined(__MKL26Z64__)//TeensyLC

  280. 		RA8875(const uint8_t CSp,const uint8_t RSTp=255,const uint8_t mosi_pin=11,const uint8_t sclk_pin=13,const uint8_t miso_pin=12);

  281. 	#elif defined(__MK64FX512__) || defined(__MK66FX1M0__)  || defined(__IMXRT1062__)	

  282. 		RA8875(const uint8_t CSp,const uint8_t RSTp=255,const uint8_t mosi_pin=11,const uint8_t sclk_pin=13,const uint8_t miso_pin=12);

  283. 	#elif defined(___DUESTUFF)//DUE

  284. 		RA8875(const uint8_t CSp, const uint8_t RSTp=255);

  285. 	#elif defined(SPARK)//SPARK

  286. 		RA8875(const uint8_t CSp, const uint8_t RSTp=255);

  287. 	#elif defined(NEEDS_SET_MODULE)//ENERGIA

  288. 		RA8875::RA8875(const uint8_t module, const uint8_t RSTp=255);

  289. 	#else//8 BIT ARDUINO's

  290. 		RA8875(const uint8_t CSp, const uint8_t RSTp=255);

  291. 	#endif

  292. //------------- SETUP -----------------------------------------------------------------------

  293. 	void 		begin(const enum RA8875sizes s,uint8_t colors=16, uint32_t SPIMaxSpeed = (uint32_t)-1, uint32_t SPIMaxReadSpeed = (uint32_t)-1 );

  294. 	//(RA8875_480x272, RA8875_800x480, Adafruit_480x272, Adafruit_800x480) , (8/16 bit)

  295. //------------- HARDWARE ------------------------------------------------------------

  296. 	void 		backlight(boolean on);

  297. 	void    	displayOn(boolean on);//turn diplay on/off

  298. 	void    	sleep(boolean sleep);//put display in sleep or not

  299. 	void 		brightness(uint8_t val);//ok

  300. 	uint8_t 	readStatus(void);//used to verify when an operation has concluded

  301. 	void 		clearMemory(bool stop=false);

  302. 	void 		clearWidthColor(bool bte);

  303. 	//void		clearMemory(boolean full);//clear the RA8875 internal buffer (fully or current layer)

  304. 	uint8_t		errorCode(void);//0: no error,

  305. 	/*

  306. 	format: 1byte 0b00000000;, bit described below:

  307. 	nan,nan,nan,nan,nan,CS(out-of-range),MOSI/MISO/SCLK(out-of-range),display(not-recognized)

  308. 	*/

  309. //------------ Low Level functions ---------------------------------------------------------

  310. 	void    	writeCommand(const uint8_t d);

  311. 	void  		writeData16(uint16_t data);

  312. //Hack fonts

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

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

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

  316. 		_originx = x; _originy = y; 

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

  318. 		updateDisplayClip();

  319. 	}

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

  321. 

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

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

  324. 

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

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

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

  328. 			updateDisplayClip();

  329. 		}

  330. 	void setClipRect() {

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

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

  333. 			 updateDisplayClip(); 

  334. 		}

  335. 		

  336. 	bool _invisible = false; 

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

  338. 

  339. 	inline void updateDisplayClip() {

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

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

  342. 

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

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

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

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

  347. 		if (Serial) {

  348. 			//Serial.printf("UDC (%d %d)-(%d %d) %d %d\n", _displayclipx1, _displayclipy1, _displayclipx2, 

  349. 			//	_displayclipy2, _invisible, _standard);

  350. 

  351. 		}

  352. 	}

  353. 	

  354. 	inline void setFontDefault() { 

  355. 		_use_default = 1; 

  356. 		if(_portrait && (!_use_gfx_font || !_use_ili_font)) {

  357. 			_cursorX += _cursorY;

  358. 			_cursorY -= _cursorX;

  359. 		}

  360. 		_use_ili_font=0; 

  361. 		_use_gfx_font=0;

  362. 		_use_int_font=1;

  363. 		_use_tfont=0;

  364. 		setActiveWindow();

  365. 		_textPosition(_cursorX, _cursorY, false);

  366. 		};

  367. 	void setFont(const ILI9341_t3_font_t &f);

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

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

  370. 	void drawFontChar(unsigned int c);

  371. 	void drawGFXFontChar(unsigned int c);

  372. 	

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

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

  375. 	

  376. 	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);

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

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

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

  380. 	void Pixel(int16_t x, int16_t y, uint16_t color);

  381. 	

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

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

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

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

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

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

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

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

  390. 	int16_t strPixelLen(const char * str);

  391. 

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

  393. 

  394. 	void write16BitColor(uint16_t color, bool last_pixel=false);

  395. 

  396. 	// Hack to see about combining outputs for speed.

  397. 	int16_t _combine_x_start = 0;

  398. 	int16_t _combine_y = 0;

  399. 	int16_t _combine_count = 0;

  400. 	uint16_t _combine_color = 0;

  401. 

  402. 	inline void combineAndDrawPixel(int16_t x, int16_t y, uint16_t color) {

  403. 		if (_combine_count && (color == _combine_color)) _combine_count++;

  404. 		else {

  405. 			if (_combine_count)drawLine(_combine_x_start, _combine_y, _combine_x_start+_combine_count-1, _combine_y, _combine_color);

  406. 			_combine_x_start = x;

  407. 			_combine_y = y;

  408. 			_combine_count = 1;

  409. 			_combine_color = color;

  410. 		}

  411. 	}

  412. 

  413. 	inline void forceCombinedPixelsOut() {

  414. 		if (_combine_count)fillRect(_combine_x_start, _combine_y, _combine_count, 1, _combine_color);

  415. 		_combine_count = 0;

  416. 	}

  417. 

  418. 

  419. //-------------- AREA ----------------------------------------------------------------------

  420. 	void		setActiveWindow(int16_t XL,int16_t XR,int16_t YT,int16_t YB);//The working area where to draw on

  421. 	void		setActiveWindow(void);

  422. 	void 		getActiveWindow(int16_t &XL,int16_t &XR ,int16_t &YT ,int16_t &YB);

  423. 	void		clearActiveWindow(bool full=false);//it clears the active window

  424. 	uint16_t 	width(bool absolute=false) const;//the phisical display width

  425. 	uint16_t 	height(bool absolute=false) const;//the phisical display height

  426. 	void		setRotation(uint8_t rotation); //rotate text and graphics

  427. 	uint8_t		getRotation(); //return the current rotation 0-3

  428. 	boolean		isPortrait(void);

  429. //-------------- COLOR ----------------------------------------------------------------------

  430. 	void		setForegroundColor(uint16_t color);//color of objects in 16bit

  431. 	void		setForegroundColor(uint8_t R,uint8_t G,uint8_t B);//color of objects in 8+8+8bit

  432. 	void		setBackgroundColor(uint16_t color);//color of objects background in 16bit

  433. 	void		setBackgroundColor(uint8_t R,uint8_t G,uint8_t B);//color of objects background in 8+8+8bit

  434. 	void 		setTransparentColor(uint16_t color);//the current transparent color in 16bit

  435. 	void 		setTransparentColor(uint8_t R,uint8_t G,uint8_t B);//the current transparent color in 8+8+8bit

  436. 	void 		setColor(uint16_t fcolor,uint16_t bcolor,bool bcolorTraspFlag=false);

  437. 	void 		setColorBpp(uint8_t colors);//set the display color space 8 or 16!

  438. 	uint8_t 	getColorBpp(void);//get the current display color space (return 8 or 16)

  439. 	uint16_t	grandient(uint8_t val);

  440. 	uint16_t 	colorInterpolation(uint16_t color1,uint16_t color2,uint16_t pos,uint16_t div=100);

  441. 	uint16_t 	colorInterpolation(uint8_t r1,uint8_t g1,uint8_t b1,uint8_t r2,uint8_t g2,uint8_t b2,uint16_t pos,uint16_t div=100);

  442. //-------------- COLOR CONVERSION -----------------------------------------------------------

  443. 	inline uint16_t Color565(uint8_t r,uint8_t g,uint8_t b) { return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3); }

  444. 	inline uint16_t Color24To565(int32_t color_) { return ((((color_ >> 16) & 0xFF) / 8) << 11) | ((((color_ >> 8) & 0xFF) / 4) << 5) | (((color_) &  0xFF) / 8);}

  445. 	inline uint16_t htmlTo565(int32_t color_) { return (uint16_t)(((color_ & 0xF80000) >> 8) | ((color_ & 0x00FC00) >> 5) | ((color_ & 0x0000F8) >> 3));}

  446. 	inline void 	Color565ToRGB(uint16_t color, uint8_t &r, uint8_t &g, uint8_t &b){r = (((color & 0xF800) >> 11) * 527 + 23) >> 6; g = (((color & 0x07E0) >> 5) * 259 + 33) >> 6; b = ((color & 0x001F) * 527 + 23) >> 6;}

  447. //-------------- CURSOR ----------------------------------------------------------------------

  448. 	void 		cursorIncrement(bool on);

  449. 	void 		setCursorBlinkRate(uint8_t rate);//set blink rate of the cursor 0...255 0:faster

  450. 	void 		showCursor(enum RA8875tcursor c,bool blink);//show cursor(NOCURSOR,IBEAM,UNDER,BLOCK), default blinking

  451. 	void    	setCursor(int16_t x, int16_t y,bool autocenter=false);//set cursor position to write text(pixels or CENTER)

  452. 	void 		getCursor(int16_t &x, int16_t &y);//from the RA8875 registers

  453. 	void 		getCursorFast(int16_t &x, int16_t &y);//from library (faster)

  454. 	int16_t		getCursorX(void);

  455. 	int16_t		getCursorY(void);

  456. 	void 		setGraphicCursor(uint8_t cur);//0...7 Select a custom graphic cursor (you should upload first)

  457. 	void 		showGraphicCursor(boolean cur);//show graphic cursor

  458. //-------------- TEXT -----------------------------------------------------------------------

  459. 	void 		uploadUserChar(const uint8_t symbol[],uint8_t address);//upload user defined char as array at the address 0..255

  460. 	void		showUserChar(uint8_t symbolAddrs,uint8_t wide=0);//show user uploaded char at the adrs 0...255

  461. 	void    	setTextColor(uint16_t fcolor, uint16_t bcolor);//set text color + text background color

  462. 	void 		setTextColor(uint16_t fcolor);//set text color (backgroud will be transparent)

  463. 	void 		setTextGrandient(uint16_t fcolor1,uint16_t fcolor2);

  464. 	void    	setFontScale(uint8_t scale);//global font scale (w+h)

  465. 	void    	setFontScale(uint8_t xscale,uint8_t yscale);//font scale separated by w and h

  466. 	void    	setFontSize(enum RA8875tsize ts);//X16,X24,X32

  467. 	void 		setFontSpacing(uint8_t spc);//0:disabled ... 63:pix max

  468. 	void 		setFontInterline(uint8_t pix);//0...63 pix

  469. 	void 		setFontFullAlign(boolean align);//mmmm... doesn't do nothing! Have to investigate

  470. 	uint8_t 	getFontWidth(boolean inColums=false);

  471. 	uint8_t 	getFontHeight(boolean inRows=false);

  472. 	

  473. 	//----------FONT -------------------------------------------------------------------------

  474. 	void		setExternalFontRom(enum RA8875extRomType ert, enum RA8875extRomCoding erc,enum RA8875extRomFamily erf=STANDARD);

  475. 	void 		setFont(enum RA8875fontSource s);//INTFONT,EXTFONT (if you have a chip installed)

  476. 	//void 		setFont(const struct FONT_DEF *	fnt);

  477. 	void		setFont(const tFont *font);

  478. 	void 		setIntFontCoding(enum RA8875fontCoding f);

  479. 	void		setExtFontFamily(enum RA8875extRomFamily erf,boolean setReg=true);

  480. 	

  481. //-------------- GRAPHIC POSITION --------------------------------------------------------------

  482. 	void    	setXY(int16_t x, int16_t y);//graphic set location

  483. 	void 		setX(int16_t x);

  484. 	void 		setY(int16_t y) ;

  485. 	//--------------- DRAW ---------------------------------------------------------------------

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

  487. 	void 		drawPixels(uint16_t p[], uint16_t count, int16_t x, int16_t y);

  488. 	uint16_t 	getPixel(int16_t x, int16_t y);

  489. 	//void 		getPixels(uint16_t * p, uint32_t count, int16_t x, int16_t y);

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

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

  492. 	void    	fillWindow(uint16_t color=_RA8875_DEFAULTBACKLIGHT);//fill the ActiveWindow with a color(default black)

  493. 	void		clearScreen(uint16_t color=_RA8875_DEFAULTBACKLIGHT);//fill the entire screen (regardless ActiveWindow) with a color(default black)

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

  495. 	void 		drawLineAngle(int16_t x, int16_t y, int16_t angle, uint16_t length, uint16_t color,int offset = -90);

  496. 	void 		drawLineAngle(int16_t x, int16_t y, int16_t angle, uint16_t start, uint16_t length, uint16_t color,int offset = -90);

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

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

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

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

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

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

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

  504. 	void    	drawEllipse(int16_t xCenter, int16_t yCenter, int16_t longAxis, int16_t shortAxis, uint16_t color);

  505. 	void    	fillEllipse(int16_t xCenter, int16_t yCenter, int16_t longAxis, int16_t shortAxis, uint16_t color);

  506. 	void    	drawCurve(int16_t xCenter, int16_t yCenter, int16_t longAxis, int16_t shortAxis, uint8_t curvePart, uint16_t color);

  507. 	void    	fillCurve(int16_t xCenter, int16_t yCenter, int16_t longAxis, int16_t shortAxis, uint8_t curvePart, uint16_t color);

  508. 	void 		drawRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color);//ok

  509. 	void 		fillRoundRect(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color);

  510. 	void 		drawQuad(int16_t x0, int16_t y0,int16_t x1, int16_t y1,int16_t x2, int16_t y2,int16_t x3, int16_t y3, uint16_t color);

  511. 	void 		fillQuad(int16_t x0, int16_t y0,int16_t x1, int16_t y1,int16_t x2, int16_t y2, int16_t x3, int16_t y3, uint16_t color, bool triangled=true);

  512. 	void 		drawPolygon(int16_t cx, int16_t cy, uint8_t sides, int16_t diameter, float rot, uint16_t color);

  513. 	void 		drawMesh(int16_t x, int16_t y, int16_t w, int16_t h, uint8_t spacing,uint16_t color);

  514. 	void 		setArcParams(float arcAngleMax, int arcAngleOffset);

  515. 	void 		setAngleOffset(int16_t angleOffset);

  516. 	inline __attribute__((always_inline)) void drawArc(uint16_t cx, uint16_t cy, uint16_t radius, uint16_t thickness, float start, float end, uint16_t color) {

  517. 		if (start == 0 && end == _arcAngle_max) {

  518. 			_drawArc_helper(cx, cy, radius, thickness, 0, _arcAngle_max, color);

  519. 		} else {

  520. 			_drawArc_helper(cx, cy, radius, thickness, start + (_arcAngle_offset / (float)360)*_arcAngle_max, end + (_arcAngle_offset / (float)360)*_arcAngle_max, color);

  521. 		}	

  522. 	}

  523. //-------------- GAUGES ---------------------------------------------------------------------------

  524. 	void 		ringMeter(int val, int minV, int maxV, int16_t x, int16_t y, uint16_t r, const char* units="none", uint16_t colorScheme=4,uint16_t backSegColor=RA8875_BLACK,int16_t angle=150,uint8_t inc=10);

  525. 	void		roundGaugeTicker(uint16_t x, uint16_t y, uint16_t r, int from, int to, float dev,uint16_t color);

  526. //-------------- LAYERS --------------------------------------------------------------------------

  527. 	void 		useLayers(boolean on);//mainly used to turn of layers!

  528. 	void		writeTo(enum RA8875writes d);//L1, L2, CGRAM, PATTERN, CURSOR

  529. 	void 		layerEffect(enum RA8875boolean efx);//LAYER1, LAYER2, TRANSPARENT, LIGHTEN, OR, AND, FLOATING

  530. 	void 		layerTransparency(uint8_t layer1,uint8_t layer2);

  531. 	uint8_t		getCurrentLayer(void); //return the current drawing layer. If layers are OFF, return 255

  532. //--------------- SCROLL --------------------------------------------------------------------------

  533. 	void        setScrollMode(enum RA8875scrollMode mode); // The experimentalist

  534. 	void 		setScrollWindow(int16_t XL,int16_t XR ,int16_t YT ,int16_t YB);

  535. 	void 		scroll(int16_t x,int16_t y);

  536. //-------------- DMA ------------------------------------------------------------------------------

  537. 	void 		DMA_blockModeSize(int16_t BWR,int16_t BHR,int16_t SPWR);

  538. 	void 		DMA_startAddress(unsigned long adrs);

  539. 	void 		DMA_enable(void);

  540. 	void 		drawFlashImage(int16_t x,int16_t y,int16_t w,int16_t h,uint8_t picnum);

  541. //-------------- BTE -------------------------------------------------------------------------------

  542. 	void 		BTE_size(int16_t w, int16_t h);

  543. 	void	 	BTE_moveFrom(int16_t SX,int16_t SY);

  544. 	void	 	BTE_moveTo(int16_t DX,int16_t DY);

  545. 	//void 		BTE_source_destination(uint16_t SX,uint16_t DX ,uint16_t SY ,uint16_t DY);

  546. 	void		BTE_ropcode(unsigned char setx);//

  547. 	void 		BTE_enable(bool on);//

  548. 	void 		BTE_dataMode(enum RA8875btedatam m);//CONT,RECT

  549. 	void 		BTE_layer(enum RA8875btelayer sd,uint8_t l);//SOURCE,DEST - 1 or 2

  550. 	void		BTE_move(int16_t SourceX, int16_t SourceY, int16_t Width, int16_t Height, int16_t DestX, int16_t DestY, uint8_t SourceLayer=0, uint8_t DestLayer=0, bool Transparent = false, uint8_t ROP=RA8875_BTEROP_SOURCE, bool Monochrome=false, bool ReverseDir = false);

  551. 	//---------- PATTERN --------------------------------------------------------------------------

  552. 	void 		setPattern(uint8_t num, enum RA8875pattern p=P8X8);

  553. 	void 		writePattern(int16_t x,int16_t y,const uint8_t *data,uint8_t size,bool setAW=true);

  554. //-------------- GPIO & PWM -------------------------

  555. 	void    	GPIOX(boolean on);

  556. 	void    	PWMout(uint8_t pw,uint8_t p);//1:backlight, 2:free

  557. //-------------- ISR ------------------------------------------------------------------------------

  558. 	void		useINT(const uint8_t INTpin=2,const uint8_t INTnum=0);

  559. 	void 		enableISR(bool force = false); 

  560. 	void 		setInternalInt(enum RA8875intlist b);//   BTE,TOUCH,DMA,KEY

  561. 	void 		clearInternalInt(enum RA8875intlist b);// BTE,TOUCH,DMA,KEY

  562. //-------------- TOUCH SCREEN ---------------------------------------------------------------------

  563. #if !defined(_AVOID_TOUCHSCREEN)

  564. 	bool 		touched(bool safe=false);

  565. 	void 		setTouchLimit(uint8_t limit);//5 for FT5206, 1 for  RA8875

  566. 	uint8_t 	getTouchLimit(void);

  567. 

  568. #	if defined(USE_RA8875_TOUCH)

  569. 		//void		useINT(const uint8_t INTpin=2,const uint8_t INTnum=0);

  570. 		//void 		enableISR(bool force = false); 

  571. 		void 		touchBegin(void);//prepare Touch Screen driver

  572. 		void    	touchEnable(boolean enabled);//enable/disable Touch Polling (disable INT)

  573. 		void 		touchReadAdc(uint16_t *x, uint16_t *y);//returns 10bit ADC data (0...1024)

  574. 		void 		touchReadPixel(uint16_t *x, uint16_t *y);//return pixels (0...width, 0...height)

  575. 		boolean		touchCalibrated(void);//true if screen calibration it's present

  576. 		void		setTouchCalibrationData(uint16_t minX, uint16_t maxX, uint16_t minY, uint16_t maxY);

  577. 	#elif defined (USE_FT5206_TOUCH)

  578. 		void		setWireObject(TwoWire *wire) {_wire = wire; }

  579. 		void		useCapINT(const uint8_t INTpin=2,const uint8_t INTnum=0);

  580. 		void 		enableCapISR(bool force = false); 

  581. 		void	 	updateTS(void);

  582. 		uint8_t 	getGesture(void);

  583. 		uint8_t 	getTouches(void);

  584. 		uint8_t 	getTouchState(void);

  585. 		uint8_t 	getTScoordinates(uint16_t (*touch_coordinates)[2]);

  586. 	#endif

  587. #endif

  588. 

  589. //--------------Text Write -------------------------

  590. //virtual size_t write(uint8_t b) {

  591. //	if (_FNTgrandient) _FNTgrandient = false;//cannot use this with write

  592. //	_textWrite((const char *)&b, 1);

  593. //	return 1;

  594. //}

  595. 

  596. virtual size_t write(uint8_t c) {

  597. 	_fontWrite(&c, 1);

  598. 	return 1;

  599. }

  600. 

  601. virtual size_t write(const uint8_t *buffer, size_t size){

  602. 	if(_use_default) {

  603. 		_textWrite((const char *)buffer, size);

  604. 	} else {

  605. 		_fontWrite(buffer, size);

  606. 	}

  607. 	return size;

  608. }

  609. 

  610. 

  611. using Print::write;

  612. 

  613.  protected:

  614.  	uint32_t textcolorPrexpanded, textbgcolorPrexpanded;

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

  616. 	const ILI9341_t3_font_t *font;

  617. 	

  618. 	int16_t  _clipx1, _clipy1, _clipx2, _clipy2;

  619. 	int16_t  _originx, _originy;

  620. 	int16_t  _displayclipx1, _displayclipy1, _displayclipx2, _displayclipy2;

  621. 	

  622.  	// GFX Font support

  623. 	const GFXfont *gfxFont = nullptr;

  624. 	int8_t _gfxFont_min_yOffset = 0;

  625. 	

  626. 	// Opaque font chracter overlap?

  627. 	unsigned int _gfx_c_last;

  628. 	int16_t   _gfx_last__cursorX, _gfx_last__cursorY;

  629. 	int16_t	 _gfx_last_char_x_write = 0;

  630. 	uint16_t _gfx_last_char_textcolor;

  631. 	uint16_t _gfx_last_char_textbgcolor;

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

  633.  

  634.  //=====================

  635. 	volatile bool 				  _textMode;

  636. 	volatile uint8_t 			  _MWCR0_Reg; //keep track of the register 		  [0x40]

  637. 	int16_t 		 			   RA8875_WIDTH, 	   RA8875_HEIGHT;//absolute

  638. 	int16_t 		 			  _width, 			  _height;

  639. 	int16_t						  _cursorX, 		  _cursorY;

  640. 	uint8_t						  _scaleX,			  _scaleY;

  641. 	bool						  _scaling;

  642. 	uint8_t						  _FNTwidth, 		  _FNTheight;

  643. 	uint8_t						  _FNTbaselineLow, 	  _FNTbaselineTop;

  644. 	volatile uint8_t			  _TXTparameters;

  645. 	/* It contains several parameters in one byte

  646. 	bit			 parameter

  647. 	0	->		_extFontRom 		i's using an ext rom font

  648. 	1	->		_autoAdvance		after a char the pointer move ahead

  649. 	2	->		_textWrap

  650. 	3	->		_fontFullAlig		

  651. 	4	->		_fontRotation       (actually not used)

  652. 	5	->		_alignXToCenter;

  653. 	6	->		_alignYToCenter;

  654. 	7	->		_renderFont active;

  655. 	*/

  656. 	bool						  _FNTgrandient;

  657. 	uint16_t					  _FNTgrandientColor1;

  658. 	uint16_t					  _FNTgrandientColor2;

  659. 	bool						  _FNTcompression;

  660. 	int							  _spaceCharWidth;

  661. 	volatile bool				  _needISRrearm;

  662. 	volatile uint8_t			  _enabledInterrups;

  663. 	// Allow up to three displays to have touch?

  664. 	static void 		 		  _isr(void);

  665. 	static void 		 		  _isr1(void);

  666. 	static void 		 		  _isr2(void);

  667. 	static RA8875 				 *_active_touch_objects[3]; 

  668. 	volatile uint8_t 			 _RA8875_INTS = 0b00000000;//container for INT states

  669. 

  670. 	#if !defined(_AVOID_TOUCHSCREEN)

  671. 		volatile bool			  _touchEnabled;

  672. 		volatile bool			  _clearTInt;

  673. 	#endif

  674. 

  675. 	#if defined(USE_FT5206_TOUCH)

  676. 		volatile bool			  _needCTS_ISRrearm;

  677. 		static void 		 	  cts_isr(void);

  678. 		#if defined(___DUESTUFF) && defined(USE_DUE_WIRE1_INTERFACE)

  679. 		TwoWire 				 *_wire=&Wire1;

  680. 		#else

  681. 		TwoWire 				 *_wire=&Wire;

  682. 		#endif

  683. 	#elif defined(USE_RA8875_TOUCH)

  684. 		//volatile bool			  _touchEnabled;

  685. 		//volatile bool			  _clearTInt;

  686. 	#endif

  687. 

  688. 	

  689. 	#ifdef SPI_HAS_TRANSACTION

  690. 	volatile uint32_t 			_SPITransactionSpeed; //holder for SPI speed

  691. 	uint32_t					_SPIMaxSpeed;         // Max Speed defined in either begin or presets...

  692. 	uint32_t					_SPIMaxReadSpeed;	  // Max Read speed defined in either begin or presets.

  693. 	#endif

  694. 	#if defined(TEENSYDUINO)//all of them (32 bit only)

  695. 		uint8_t 				  _cs;

  696. 		uint8_t 				  _miso, _mosi, _sclk;

  697. 	  #if defined(__MK64FX512__) || defined(__MK66FX1M0__)  || defined(__IMXRT1062__) || defined(__MKL26Z64__)

  698. 		SPIClass				*_pspi;	// which SPI are we using...

  699.       #endif

  700. 	#elif defined(ENERGIA)

  701. 		uint8_t _cs;

  702. 	#else

  703. 		#if defined(___DUESTUFF)

  704. 			#if defined(_FASTSSPORT)

  705. 				uint32_t 		  _cs, cspinmask;

  706. 			#else

  707. 				uint8_t 		  _cs;

  708. 			#endif

  709. 		#elif defined(ESP8266)	

  710. 			#if defined(_FASTSSPORT)

  711. 				uint32_t 		  _cs;

  712. 			#else

  713. 				uint8_t 		  _cs;

  714. 			#endif

  715. 		#elif defined(SPARK)

  716. 			#if defined(_FASTSSPORT)

  717. 				uint32_t 		  _cs;

  718. 			#else

  719. 				uint8_t 		  _cs;

  720. 			#endif

  721. 		#else

  722. 			#if defined(_FASTSSPORT)

  723. 				uint8_t 		  _cs, cspinmask;

  724. 			#else

  725. 				uint8_t 		  _cs;

  726. 			#endif

  727. 		#endif

  728. 	#endif

  729.  private:

  730.  //HACK

  731. 	uint8_t  _use_ili_font = 0;

  732. 	uint8_t _use_gfx_font = 0;

  733. 	uint8_t _use_tfont = 0;

  734. 	uint8_t  _use_int_font = 0;

  735. 	uint8_t _use_default = 1;

  736. 	uint8_t textsize, textsize_x, textsize_y;

  737. 	uint16_t textcolor, textbgcolor; 

  738. 	//anti-alias font

  739. 	uint8_t fontbpp = 1;

  740. 	uint8_t fontbppindex = 0;

  741. 	uint8_t fontbppmask = 1;

  742. 	uint8_t fontppb = 8;

  743. 	uint8_t* fontalphalut;

  744. 	float fontalphamx = 1;

  745. 	

  746. 	uint8_t							_rst;

  747. 	uint8_t							_intPin;

  748. 	uint8_t						 	_intNum;

  749. 	bool							_useISR;

  750. 	const tFont 			  	 *  _currentFont;

  751. 	bool 						 	_checkInterrupt(uint8_t _bit,bool _clear=true);

  752. 	void 						    _disableISR(void);

  753. 	

  754. 	uint32_t fetchbit(const uint8_t *p, uint32_t index);

  755. 	uint32_t fetchbits_unsigned(const uint8_t *p, uint32_t index, uint32_t required);

  756. 	uint32_t fetchbits_signed(const uint8_t *p, uint32_t index, uint32_t required);

  757. 	void 	 _fontWrite(const uint8_t* buffer, uint16_t len);

  758. 	

  759. 	/**

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

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

  762. 	 * Converts  0000000000000000rrrrrggggggbbbbb

  763. 	 *     into  00000gggggg00000rrrrr000000bbbbb

  764. 	 * with mask 00000111111000001111100000011111

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

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

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

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

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

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

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

  772. 	 **/

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

  774. 	 __attribute__((always_inline)) {

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

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

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

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

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

  780. 	}

  781. 	

  782. 	/**

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

  784. 	 */

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

  786. 	 __attribute__((always_inline)) {

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

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

  789. 	}

  790. 	

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

  792. 

  793. 	// Touch Screen vars ---------------------

  794. 	#if !defined(_AVOID_TOUCHSCREEN)

  795. 	uint8_t						    _maxTouch;//5 on FT5206, 1 on resistive

  796. 		#if defined(USE_FT5206_TOUCH)// FT5206 specifics

  797. 			uint8_t					_intCTSNum;

  798. 			uint8_t					_intCTSPin;

  799. 			uint8_t 				_cptRegisters[31];

  800. 			uint8_t					_gesture;

  801. 			uint8_t					_currentTouches;//0...5

  802. 			uint8_t					_currentTouchState;//0,1,2

  803. 			void 					_initializeFT5206(void);

  804. 			void 					_sendRegFT5206(uint8_t reg,const uint8_t val);

  805. 			void 					_disableCapISR(void);

  806. 		#elif defined(USE_RA8875_TOUCH)//RA8875 internal resistive specifics

  807. 			uint16_t 				_tsAdcMinX,_tsAdcMinY,_tsAdcMaxX,_tsAdcMaxY;

  808. 			uint16_t 				_touchrcal_xlow,_touchrcal_ylow,_touchrcal_xhigh,_touchrcal_yhigh;

  809. 			void					readTouchADC(uint16_t *x, uint16_t *y);

  810. 			bool					_calibrated;

  811. 			boolean					_isCalibrated(void);//true if screen calibration it's present

  812. 		#endif

  813. 	#endif

  814. 	#if defined(USE_RA8875_KEYMATRIX)

  815. 		bool						_keyMatrixEnabled;

  816. 	#endif

  817. 	//system vars -------------------------------------------

  818. 	bool							_inited;//true when init has been ended

  819. 	bool							_sleep;

  820. 	enum RA8875sizes 				_displaySize;//Adafruit_480x272, etc

  821. 	bool							_portrait;

  822. 	uint8_t							_rotation;

  823. 	uint8_t							_initIndex;

  824. 	int16_t							_activeWindowXL,_activeWindowXR,_activeWindowYT,_activeWindowYB;

  825. 	uint8_t							_errorCode;

  826. 	//color vars ----------------------------------------------

  827. 	uint16_t						_foreColor;

  828. 	uint16_t						_backColor;

  829. 	bool							_backTransparent;

  830. 	uint8_t							_colorIndex;

  831. 	#if defined(USE_RA8875_SEPARATE_TEXT_COLOR)

  832. 		uint16_t					_TXTForeColor;

  833. 		uint16_t					_TXTBackColor;

  834. 		bool						_TXTrecoverColor;

  835. 	#endif

  836. 	//text vars-------------------------------------------------		

  837. 	uint8_t							_FNTspacing;

  838. 	uint8_t							_FNTinterline;

  839. 	enum RA8875extRomFamily 		_EXTFNTfamily;

  840. 	enum RA8875extRomType 			_EXTFNTrom;

  841. 	enum RA8875extRomCoding 		_EXTFNTcoding;

  842. 	enum RA8875tsize				_EXTFNTsize;//X16,X24,X32

  843. 	enum RA8875fontSource 			_FNTsource;

  844. 	enum RA8875tcursor				_FNTcursorType;

  845. 	//centering -------------------------------

  846. 	bool							_relativeCenter;

  847. 	bool							_absoluteCenter;

  848. 	//layer vars -----------------------------

  849. 	uint8_t							_maxLayers;

  850. 	bool							_useMultiLayers;

  851. 	uint8_t							_currentLayer;

  852. 	bool 							_hasLayerLimits;//helper

  853. 	//scroll vars ----------------------------

  854. 	int16_t							_scrollXL,_scrollXR,_scrollYT,_scrollYB;

  855. 	//color space-----------------------------

  856. 	uint8_t							_color_bpp;//8=256, 16=64K colors

  857. 	uint8_t							_brightness;

  858. 	//various

  859. 	float 							_arcAngle_max;

  860. 	int 							_arcAngle_offset;

  861. 	int								_angle_offset;

  862. 	// Register containers -----------------------------------------

  863. 	// this needed to  prevent readRegister from chip that it's slow.

  864. 	

  865. 	uint8_t			 _DPCR_Reg;  ////Display Configuration		  	  [0x20]

  866. 	uint8_t			 _FNCR0_Reg; //Font Control Register 0 		  	  [0x21]

  867. 	uint8_t			 _FNCR1_Reg; //Font Control Register1 			  [0x22]

  868. 	uint8_t			 _FWTSET_Reg; //Font Write Type Setting Register   [0x2E]

  869. 	uint8_t			 _SFRSET_Reg; //Serial Font ROM Setting 		  	  [0x2F]

  870. 	uint8_t			 _INTC1_Reg; //Interrupt Control Register1		  [0xF0]

  871. 	//		functions --------------------------------------------------

  872. 	void 		_initialize();

  873. 	void 		_setSysClock(uint8_t pll1,uint8_t pll2,uint8_t pixclk);

  874. 	//      TEXT writing stuff-------------------------------------------

  875. 	void    	_textWrite(const char* buffer, uint16_t len=0);//thanks to Paul Stoffregen for the initial version of this one

  876. 	void 		_charWrite(const char c,uint8_t offset);

  877. 	void 		_charWriteR(const char c,uint8_t offset,uint16_t fcolor,uint16_t bcolor);

  878. 	int 		_getCharCode(uint8_t ch);

  879. 	#if defined(_RA8875_TXTRNDOPTIMIZER)

  880. 		void 		_drawChar_unc(int16_t x,int16_t y,int charW,int index,uint16_t fcolor);

  881. 	#else

  882. 		void 		_drawChar_unc(int16_t x,int16_t y,int16_t w,const uint8_t *data,uint16_t fcolor,uint16_t bcolor);

  883. 	#endif

  884. 	

  885. 	//void 		_drawChar_com(int16_t x,int16_t y,int16_t w,const uint8_t *data);

  886. 	void 		_textPosition(int16_t x, int16_t y,bool update);

  887. 	void 		_setFNTdimensions(uint8_t index);

  888. 	int16_t 	_STRlen_helper(const char* buffer,uint16_t len=0);

  889. 	void 		fontRomSpeed(uint8_t sp);

  890. 	//--------------------------------------------------------------------

  891. 	void 		PWMsetup(uint8_t pw,boolean on, uint8_t clock);

  892. 	void 		_updateActiveWindow(bool full);

  893. 	void 		_setTextMode(bool m);

  894. 	void 		_scanDirection(boolean invertH,boolean invertV);

  895. 	// 		helpers-----------------------------

  896. 	

  897. 	void 		_circle_helper(int16_t x0, int16_t y0, int16_t r, uint16_t color, bool filled);

  898. 	void 		_rect_helper(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color, bool filled);

  899. 	void 		_roundRect_helper(int16_t x, int16_t y, int16_t w, int16_t h, int16_t r, uint16_t color, bool filled);

  900. 	float		_check_area(int16_t Ax, int16_t Ay, int16_t Bx, int16_t By, int16_t Cx, int16_t Cy);

  901. 	void 		_triangle_helper(int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color, bool filled);

  902. 	void 		_ellipseCurve_helper(int16_t xCenter, int16_t yCenter, int16_t longAxis, int16_t shortAxis,uint8_t curvePart, uint16_t color, bool filled);

  903. 	void 		_drawArc_helper(uint16_t cx, uint16_t cy, uint16_t radius, uint16_t thickness, float startAngle, float endAngle, uint16_t color);

  904. 	void 		_line_addressing(int16_t x0, int16_t y0, int16_t x1, int16_t y1);

  905. 	void 		_curve_addressing(int16_t x0, int16_t y0, int16_t x1, int16_t y1);

  906. 	float 		_cosDeg_helper(float angle);

  907. 	float 		_sinDeg_helper(float angle);

  908. 	#if defined(_RA8875_TXTRNDOPTIMIZER)

  909. 	void 		_charLineRender(bool lineBuffer[],int charW,int16_t x,int16_t y,int16_t currentYposition,uint16_t fcolor);

  910. 	#endif

  911. 	

  912. 	

  913. 	//convert a 16bit color(565) into 8bit color(332) as requested by RA8875 datasheet

  914. 	//inline __attribute__((always_inline))

  915. 	uint8_t _color16To8bpp(uint16_t color) 

  916. 		__attribute__((always_inline)) {

  917.  		return ((color & 0xe000) >> 8) | ((color & 0x700) >> 6) | ((color & 0x18) >> 3);

  918. //		return (map((color & 0xF800) >> 11, 0,28, 0,7)<<5 | map((color & 0x07E0) >> 5, 0,56, 0,7)<<2 | map(color & 0x001F, 0,24, 0,3));

  919. 	}

  920. 		

  921. 	//inline __attribute__((always_inline)) 

  922. 	void _checkLimits_helper(int16_t &x,int16_t &y)

  923. 		__attribute__((always_inline)) {

  924. 			if (x < 0) x = 0;

  925. 			if (y < 0) y = 0;

  926. 			if (x >= RA8875_WIDTH) x = RA8875_WIDTH - 1;

  927. 			if (y >= RA8875_HEIGHT) y = RA8875_HEIGHT -1;

  928. 			x = x;

  929. 			y = y;

  930. 	}

  931. 		

  932. 	//inline __attribute__((always_inline)) 	

  933. 	void _center_helper(int16_t &x, int16_t &y)

  934. 		__attribute__((always_inline)) {

  935. 			if (x == CENTER) x = _width/2;

  936. 			if (y == CENTER) y = _height/2;

  937. 	}

  938. 	#if defined(TEENSYDUINO)//all of them (32 bit only)

  939. 		// nothing, already done

  940. 	#elif defined(ENERGIA)

  941. 		// TODO

  942. 	#else

  943. 		#if defined(___DUESTUFF) // DUE

  944. 			#if defined(_FASTSSPORT)

  945. 				volatile uint32_t *csport;

  946. 			#endif

  947. 		#elif defined(ESP8266) // ESP8266

  948. 				uint32_t _pinRegister(uint8_t pin)

  949. 				__attribute__((always_inline)) {

  950. 					return _BV(pin);

  951. 				}

  952. 		#elif defined(SPARK)

  953. 			// Mmmm, dunno... put nothing for now

  954. 		#else// AVR,ARM (not DUE),STM,CHIPKIT

  955. 	    //TODO:must check if all processor are compatible

  956. 			#if defined(_FASTSSPORT)

  957. 				volatile uint8_t *csport;

  958. 			#endif

  959. 		#endif

  960. 	#endif

  961.     // Low level access  commands ----------------------

  962. 	

  963. 	//inline __attribute__((always_inline)) 

  964. 	void _startSend()

  965. 		__attribute__((always_inline)) {

  966. 		#if defined(SPI_HAS_TRANSACTION)

  967. 			#if defined(__MK64FX512__) || defined(__MK66FX1M0__)  || defined(__IMXRT1062__) || defined(__MKL26Z64__)

  968. 				_pspi->beginTransaction(SPISettings(_SPITransactionSpeed, MSBFIRST, SPI_MODE3));

  969. 			#elif defined(ESP8266)	

  970. 				SPI.beginTransaction(SPISettings(_SPITransactionSpeed, MSBFIRST, SPI_MODE3));//it works, anyway ESP doesn't work in MODE3!

  971. 			#elif defined(SPARK)	

  972. 				SPI.beginTransaction(SPISettings(_SPITransactionSpeed, MSBFIRST, SPI_MODE0));//TODO !

  973. 			#else

  974. 				SPI.beginTransaction(SPISettings(_SPITransactionSpeed, MSBFIRST, SPI_MODE3));

  975. 			#endif

  976. 		#elif !defined(ENERGIA) && !defined(_SPITransactionSpeed) && !defined(___STM32STUFF) && !defined(ESP8266) && !defined(SPARK)

  977. 			cli();//protect from interrupts

  978. 		#endif//end has transaction

  979. 		

  980. 		#if defined(TEENSYDUINO)//all of them (32 bit only)

  981. 			digitalWriteFast(_cs, LOW);

  982. 		#elif !defined(ENERGIA)//UNO,DUE,ETC.

  983. 			#if defined(___DUESTUFF) && defined(SPI_DUE_MODE_EXTENDED)//DUE extended SPI

  984. 				//nothing

  985. 			#else//DUE (normal),UNO,ETC.

  986. 				#if defined(ESP8266)	

  987. 					#if defined(_FASTSSPORT)

  988. 						GPIO_REG_WRITE(GPIO_OUT_W1TC_ADDRESS, _pinRegister(_cs));//L

  989. 					#else

  990. 						digitalWrite(_cs, LOW);// for now

  991. 					#endif

  992. 				#elif defined(SPARK)

  993. 					pinResetFast(_cs);

  994. 				#elif !defined(ESP8266) && defined(_FASTSSPORT)

  995. 					*csport &= ~cspinmask;

  996. 				#else

  997. 					digitalWrite(_cs, LOW);

  998. 				#endif

  999. 			#endif

  1000. 		#else//ENERGIA

  1001. 			digitalWrite(_cs, LOW);

  1002. 		#endif

  1003. 	}

  1004. 	

  1005. 	//inline __attribute__((always_inline)) 

  1006. 	void _endSend()

  1007. 		__attribute__((always_inline)) {

  1008. 	#if defined(TEENSYDUINO)//all of them (32 bit only)

  1009. 		digitalWriteFast(_cs, HIGH);

  1010. 	#elif !defined(ENERGIA)

  1011. 		#if defined(___DUESTUFF) && defined(SPI_DUE_MODE_EXTENDED)//DUE extended SPI

  1012. 			//nothing

  1013. 		#else//DUE (normal),UNO,ETC.

  1014. 			#if defined(ESP8266)	

  1015. 				#if defined(_FASTSSPORT)

  1016. 					GPIO_REG_WRITE(GPIO_OUT_W1TS_ADDRESS, _pinRegister(_cs));//H

  1017. 				#else

  1018. 					digitalWrite(_cs, HIGH);

  1019. 				#endif

  1020. 			#elif defined(SPARK)

  1021. 				pinSetFast(_cs);

  1022. 			#elif !defined(ESP8266) && defined(_FASTSSPORT)

  1023. 				*csport |= cspinmask;

  1024. 			#else

  1025. 				digitalWrite(_cs, HIGH);

  1026. 			#endif

  1027. 		#endif

  1028. 	#else//ENERGIA

  1029. 		digitalWrite(_cs, HIGH);

  1030. 	#endif

  1031. 	

  1032. 	#if defined(SPI_HAS_TRANSACTION)

  1033. 		#if defined(__MK64FX512__) || defined(__MK66FX1M0__)  || defined(__IMXRT1062__) || defined(__MKL26Z64__)

  1034. 			_pspi->endTransaction();

  1035. 		#else

  1036. 			SPI.endTransaction();

  1037. 		#endif

  1038. 	#elif !defined(ENERGIA) && !defined(SPI_HAS_TRANSACTION) && !defined(___STM32STUFF) && !defined(ESP8266) && !defined(SPARK)

  1039. 		sei();//enable interrupts

  1040. 	#endif

  1041. } 

  1042. 	void    	_writeRegister(const uint8_t reg, uint8_t val);

  1043. 	uint8_t 	_readRegister(const uint8_t reg);

  1044. 	void    	_writeData(uint8_t data);

  1045. 	uint8_t 	_readData(bool stat=false);

  1046. 	boolean 	_waitPoll(uint8_t r, uint8_t f, uint8_t timeout=15);//from adafruit add settable timeout

  1047. 	void 		_waitBusy(uint8_t res=0x80);//0x80, 0x40(BTE busy), 0x01(DMA busy)

  1048. 

  1049. 	#if defined(NEEDS_SET_MODULE)//for Energia

  1050. 		void 		selectCS(uint8_t module);

  1051. 	#endif

  1052. 

  1053. #if defined(_FASTCPU)

  1054. //inline __attribute__((always_inline)) 

  1055. void _slowDownSPI(bool slow,uint32_t slowSpeed=10000000UL)

  1056. 	__attribute__((always_inline)) {

  1057. 	#if defined(SPI_HAS_TRANSACTION)

  1058. 		if (slow){

  1059. 			_SPITransactionSpeed = slowSpeed;

  1060. 		} else {

  1061. 			_SPITransactionSpeed = _SPIMaxSpeed;

  1062. 		}

  1063. 	#else

  1064. 		if (slow){

  1065. 			#if defined(___DUESTUFF) && defined(SPI_DUE_MODE_EXTENDED)

  1066. 				SPI.setClockDivider(_cs,SPI_SPEED_SAFE);

  1067. 			#else

  1068. 				SPI.setClockDivider(SPI_SPEED_SAFE);

  1069. 			#endif

  1070. 		} else {

  1071. 			#if defined(___DUESTUFF) && defined(SPI_DUE_MODE_EXTENDED)

  1072. 				SPI.setClockDivider(_cs,SPI_SPEED_WRITE);

  1073. 			#else

  1074. 				SPI.setClockDivider(SPI_SPEED_WRITE);

  1075. 			#endif

  1076. 		}

  1077. 	#endif

  1078. }

  1079. #endif

  1080. 

  1081. #if defined(__AVR__)

  1082. 	//inline __attribute__((always_inline))

  1083. 		void _spiwrite16(uint16_t d) 

  1084. 			__attribute__((always_inline)) {

  1085. 			SPDR = highByte(d);

  1086. 			while (!(SPSR & _BV(SPIF)));

  1087. 			SPDR = lowByte(d);

  1088. 			while (!(SPSR & _BV(SPIF)));

  1089. 		}

  1090. 

  1091. 	//inline __attribute__((always_inline))

  1092. 		void _spiwrite(uint8_t c) 

  1093. 			__attribute__((always_inline)) {

  1094. 			SPDR = c;

  1095. 			//asm volatile("nop");

  1096. 			while (!(SPSR & _BV(SPIF)));

  1097. 		}

  1098. 		

  1099. 	//inline __attribute__((always_inline))

  1100. 		uint8_t _spiread(void) 

  1101. 			__attribute__((always_inline)) {

  1102. 			uint8_t r = 0;

  1103. 			SPDR = 0x00;

  1104. 			//asm volatile("nop");

  1105. 			while(!(SPSR & _BV(SPIF)));

  1106. 			r = SPDR;

  1107. 			return r;

  1108. 		}

  1109. #elif defined(SPARK)

  1110. 		void _spiwrite16(uint16_t d) 

  1111. 			__attribute__((always_inline)) {

  1112. 			SPI.transfer(d >> 8);

  1113. 			SPI.transfer(d & 0xFF);

  1114. 		}

  1115. 

  1116. 		void _spiwrite(uint8_t c) 

  1117. 			__attribute__((always_inline)) {

  1118. 			SPI.transfer(c);

  1119. 		}

  1120. 		

  1121. 		uint8_t _spiread(void) 

  1122. 			__attribute__((always_inline)) {

  1123. 			uint8_t r = SPI.transfer(0x00);

  1124. 			return r;

  1125. 		}

  1126. 		

  1127. #endif

  1128. };

  1129. #endif // __cplusplus

  1130. 

  1131. #endif