visus
/
framework-arduinoteensy-cxx20
Bevaka 1
Stjärnmärk 0
Förgrening 0
Kod Ärenden 0 Pull-förfrågningar 0 Släpp 0 Wiki Aktiviteter
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
5 Incheckningar
1 Gren
Träd: a7a66c2f14
Grenar Taggar
${ item.name }
Skapa branchen ${ searchTerm }
från 'a7a66c2f14'
${ noResults }
framework-arduinoteensy-cxx20/libraries/TFT_ILI9163C/TFT_ILI9163C.cpp

1115 lines
27KB
Rå Blame Historik 

  1. #include "TFT_ILI9163C.h"

  2. #include <limits.h>

  3. #include "pins_arduino.h"

  4. #include "wiring_private.h"

  5. #include <SPI.h>

  6. 

  7. #if defined(SPI_HAS_TRANSACTION)

  8. 	static SPISettings ILI9163C_SPI;

  9. #endif

  10. 

  11. 

  12. //constructors

  13. 

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

  15. 	TFT_ILI9163C::TFT_ILI9163C(uint8_t cspin,uint8_t dcpin,uint8_t rstpin,uint8_t mosi,uint8_t sclk) : Adafruit_GFX(_TFTWIDTH,_TFTHEIGHT)

  16. 	{

  17. 		_cs   = cspin;

  18. 		_rs   = dcpin;

  19. 		_rst  = rstpin;

  20. 		_mosi = mosi;

  21. 		_sclk = sclk;

  22. 	}

  23. #elif defined(__MKL26Z64__)

  24. 	TFT_ILI9163C::TFT_ILI9163C(uint8_t cspin,uint8_t dcpin,uint8_t rstpin,uint8_t mosi,uint8_t sclk) : Adafruit_GFX(_TFTWIDTH,_TFTHEIGHT)

  25. 	{

  26. 		_cs   = cspin;

  27. 		_rs   = dcpin;

  28. 		_rst  = rstpin;

  29. 		_mosi = mosi;

  30. 		_sclk = sclk;

  31. 		_useSPI1 = false;

  32. 		if ((_mosi == 0 || _mosi == 21) && (_sclk == 20)) _useSPI1 = true;

  33. 	}

  34. #else

  35. 	TFT_ILI9163C::TFT_ILI9163C(uint8_t cspin,uint8_t dcpin,uint8_t rstpin) : Adafruit_GFX(_TFTWIDTH,_TFTHEIGHT)

  36. 	{

  37. 		_cs   = cspin;

  38. 		_rs   = dcpin;

  39. 		_rst  = rstpin;

  40. 	}

  41. #endif

  42. 

  43. 

  44. //Arduino Uno, Leonardo, Mega, Teensy 2.0, etc

  45. #if defined(__AVR__)

  46. 

  47. 	inline void TFT_ILI9163C::spiwrite(uint8_t c)

  48. 	{

  49. 		SPDR = c;

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

  51. 	}

  52. 

  53. 	void TFT_ILI9163C::writecommand(uint8_t c)

  54. 	{

  55. 		#if defined(SPI_HAS_TRANSACTION)

  56. 			SPI.beginTransaction(ILI9163C_SPI);

  57. 		#endif

  58. 		*rsport &= ~rspinmask;//low

  59. 		*csport &= ~cspinmask;//low

  60. 		spiwrite(c);

  61. 		*csport |= cspinmask;//hi

  62. 		#if defined(SPI_HAS_TRANSACTION)

  63. 			SPI.endTransaction();

  64. 		#endif

  65. 	}

  66. 

  67. 	void TFT_ILI9163C::writedata(uint8_t c)

  68. 	{

  69. 		#if defined(SPI_HAS_TRANSACTION)

  70. 			SPI.beginTransaction(ILI9163C_SPI);

  71. 		#endif

  72. 		*rsport |=  rspinmask;//hi

  73. 		*csport &= ~cspinmask;//low

  74. 		spiwrite(c);

  75. 		*csport |= cspinmask;//hi

  76. 		#if defined(SPI_HAS_TRANSACTION)

  77. 			SPI.endTransaction();

  78. 		#endif

  79. 	} 

  80. 

  81. 	void TFT_ILI9163C::writedata16(uint16_t d)

  82. 	{

  83. 		#if defined(SPI_HAS_TRANSACTION)

  84. 			SPI.beginTransaction(ILI9163C_SPI);

  85. 		#endif

  86. 		*rsport |=  rspinmask;//hi

  87. 		*csport &= ~cspinmask;//low

  88. 		spiwrite(d >> 8);

  89. 		spiwrite(d);

  90. 		*csport |= cspinmask;//hi

  91. 		#if defined(SPI_HAS_TRANSACTION)

  92. 			SPI.endTransaction();

  93. 		#endif

  94. 	} 

  95. 

  96. 	void TFT_ILI9163C::setBitrate(uint32_t n)

  97. 	{

  98. 		#if !defined (SPI_HAS_TRANSACTION)

  99. 			if (n >= 8000000) {

  100. 				SPI.setClockDivider(SPI_CLOCK_DIV2);

  101. 			} else if (n >= 4000000) {

  102. 				SPI.setClockDivider(SPI_CLOCK_DIV4);

  103. 			} else if (n >= 2000000) {

  104. 				SPI.setClockDivider(SPI_CLOCK_DIV8);

  105. 			} else {

  106. 				SPI.setClockDivider(SPI_CLOCK_DIV16);

  107. 			}

  108. 		#endif

  109. 	}

  110. #elif defined(__SAM3X8E__)// Arduino Due

  111. 	inline void TFT_ILI9163C::spiwrite(uint8_t c)

  112. 	{

  113. 		SPI.transfer(c);

  114. 	}

  115. 

  116. 	void TFT_ILI9163C::writecommand(uint8_t c)

  117. 	{

  118. 		#if defined(SPI_HAS_TRANSACTION)

  119. 			SPI.beginTransaction(ILI9163C_SPI);

  120. 		#endif

  121. 		rsport->PIO_CODR |=  rspinmask;//LO

  122. 		csport->PIO_CODR  |=  cspinmask;//LO

  123. 		spiwrite(c);

  124. 		csport->PIO_SODR  |=  cspinmask;//HI

  125. 		#if defined(SPI_HAS_TRANSACTION)

  126. 			SPI.endTransaction();

  127. 		#endif

  128. 	}

  129. 

  130. 	void TFT_ILI9163C::writedata(uint8_t c)

  131. 	{

  132. 		#if defined(SPI_HAS_TRANSACTION)

  133. 			SPI.beginTransaction(ILI9163C_SPI);

  134. 		#endif

  135. 		rsport->PIO_SODR |=  rspinmask;//HI

  136. 		csport->PIO_CODR  |=  cspinmask;//LO

  137. 		spiwrite(c);

  138. 		csport->PIO_SODR  |=  cspinmask;//HI

  139. 		#if defined(SPI_HAS_TRANSACTION)

  140. 			SPI.endTransaction();

  141. 		#endif

  142. 	} 

  143. 

  144. 	void TFT_ILI9163C::writedata16(uint16_t d)

  145. 	{

  146. 		#if defined(SPI_HAS_TRANSACTION)

  147. 			SPI.beginTransaction(ILI9163C_SPI);

  148. 		#endif

  149. 		rsport->PIO_SODR |=  rspinmask;//HI

  150. 		csport->PIO_CODR  |=  cspinmask;//LO

  151. 		spiwrite(d >> 8);

  152. 		spiwrite(d);

  153. 		csport->PIO_SODR  |=  cspinmask;//HI

  154. 		#if defined(SPI_HAS_TRANSACTION)

  155. 			SPI.endTransaction();

  156. 		#endif

  157. 	}

  158. 

  159. 

  160. 	void TFT_ILI9163C::setBitrate(uint32_t n)

  161. 	{

  162. 		#if !defined(SPI_HAS_TRANSACTION)

  163. 			uint32_t divider = 1;

  164. 			while (divider < 255) {

  165. 				if (n >= 84000000 / divider) break;

  166. 				divider = divider - 1;

  167. 			}

  168. 			SPI.setClockDivider(divider);

  169. 		#endif

  170. 	}

  171. #elif defined(__MKL26Z64__)//Teensy LC (preliminary

  172. 

  173. 	void TFT_ILI9163C::writecommand(uint8_t c)

  174. 	{

  175. 		if (_useSPI1){

  176. 			SPI1.beginTransaction(ILI9163C_SPI);

  177. 			digitalWriteFast(_rs,LOW);

  178. 			digitalWriteFast(_cs,LOW);

  179. 			SPI1.transfer(c);

  180. 			digitalWriteFast(_cs,HIGH);

  181. 			SPI1.endTransaction();

  182. 		} else {

  183. 			SPI.beginTransaction(ILI9163C_SPI);

  184. 			digitalWriteFast(_rs,LOW);

  185. 			digitalWriteFast(_cs,LOW);

  186. 			SPI.transfer(c);

  187. 			digitalWriteFast(_cs,HIGH);

  188. 			SPI.endTransaction();

  189. 		}

  190. 	}

  191. 

  192. 	void TFT_ILI9163C::writedata(uint8_t c)

  193. 	{

  194. 		if (_useSPI1){

  195. 			SPI1.beginTransaction(ILI9163C_SPI);

  196. 			digitalWriteFast(_rs,HIGH);

  197. 			digitalWriteFast(_cs,LOW);

  198. 			SPI1.transfer(c);

  199. 			digitalWriteFast(_cs,HIGH);

  200. 			SPI1.endTransaction();

  201. 		} else {

  202. 			SPI.beginTransaction(ILI9163C_SPI);

  203. 			digitalWriteFast(_rs,HIGH);

  204. 			digitalWriteFast(_cs,LOW);

  205. 			SPI.transfer(c);

  206. 			digitalWriteFast(_cs,HIGH);

  207. 			SPI.endTransaction();

  208. 		}

  209. 	} 

  210. 

  211. 	void TFT_ILI9163C::writedata16(uint16_t d)

  212. 	{

  213. 		if (_useSPI1){

  214. 			SPI1.beginTransaction(ILI9163C_SPI);

  215. 			digitalWriteFast(_rs,HIGH);

  216. 			digitalWriteFast(_cs,LOW);

  217. 			SPI1.transfer16(d);

  218. 			digitalWriteFast(_cs,HIGH);

  219. 			SPI1.endTransaction();

  220. 		} else {

  221. 			SPI.beginTransaction(ILI9163C_SPI);

  222. 			digitalWriteFast(_rs,HIGH);

  223. 			digitalWriteFast(_cs,LOW);

  224. 			SPI.transfer16(d);

  225. 			digitalWriteFast(_cs,HIGH);

  226. 			SPI.endTransaction();

  227. 		}

  228. 	} 

  229. 

  230. 	void TFT_ILI9163C::setBitrate(uint32_t n)

  231. 	{

  232. 		//nop

  233. 	}

  234. #elif defined(__MK20DX128__) || defined(__MK20DX256__)  || defined(__MK64FX512__) || defined(__MK66FX1M0__) //Teensy 3.0 & 3.1 & 3.2 & 3.5 & 3.6

  235.  

  236. 	void TFT_ILI9163C::setBitrate(uint32_t n)

  237. 	{

  238. 		//nop

  239. 	}

  240. #else

  241. 

  242. 	void TFT_ILI9163C::writecommand(uint8_t c)

  243. 	{

  244. 		#if defined(SPI_HAS_TRANSACTION)

  245. 			SPI.beginTransaction(ILI9163C_SPI);

  246. 		#endif

  247. 		digitalWrite(_rs,LOW);

  248. 		digitalWrite(_cs,LOW);

  249. 		SPI.transfer(c);

  250. 		digitalWrite(_cs,HIGH);

  251. 		#if defined(SPI_HAS_TRANSACTION)

  252. 			SPI.endTransaction();

  253. 		#endif

  254. 	}

  255. 

  256. 	void TFT_ILI9163C::writedata(uint8_t c)

  257. 	{

  258. 		#if defined(SPI_HAS_TRANSACTION)

  259. 			SPI.beginTransaction(ILI9163C_SPI);

  260. 		#endif

  261. 		digitalWrite(_rs,HIGH);

  262. 		digitalWrite(_cs,LOW);

  263. 		SPI.transfer(c);

  264. 		digitalWrite(_cs,HIGH);

  265. 		#if defined(SPI_HAS_TRANSACTION)

  266. 			SPI.endTransaction();

  267. 		#endif

  268. 	} 

  269. 

  270. 	void TFT_ILI9163C::writedata16(uint16_t d)

  271. 	{

  272. 		#if defined(SPI_HAS_TRANSACTION)

  273. 			SPI.beginTransaction(ILI9163C_SPI);

  274. 		#endif

  275. 		digitalWrite(_rs,HIGH);

  276. 		digitalWrite(_cs,LOW);

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

  278. 		SPI.transfer(d);

  279. 		digitalWrite(_cs,HIGH);

  280. 		#if defined(SPI_HAS_TRANSACTION)

  281. 			SPI.endTransaction();

  282. 		#endif

  283. 	} 

  284. 

  285. 	void TFT_ILI9163C::setBitrate(uint32_t n)

  286. 	{

  287. 		//nop

  288. 	}

  289. #endif //#if defined(TEENSY3.x)

  290. 

  291. 

  292. void TFT_ILI9163C::begin(void) 

  293. {

  294. 	sleep = 0;

  295. 	_initError = 0b00000000;

  296. #if defined(__AVR__)

  297. 	pinMode(_rs, OUTPUT);

  298. 	pinMode(_cs, OUTPUT);

  299. 	csport    = portOutputRegister(digitalPinToPort(_cs));

  300. 	rsport    = portOutputRegister(digitalPinToPort(_rs));

  301. 	cspinmask = digitalPinToBitMask(_cs);

  302. 	rspinmask = digitalPinToBitMask(_rs);

  303.     SPI.begin();

  304. 	#if !defined(SPI_HAS_TRANSACTION)

  305. 		SPI.setClockDivider(SPI_CLOCK_DIV2); // 8 MHz

  306. 		SPI.setBitOrder(MSBFIRST);

  307. 		SPI.setDataMode(SPI_MODE0);

  308. 	#else

  309. 		ILI9163C_SPI = SPISettings(8000000, MSBFIRST, SPI_MODE0);

  310. 	#endif

  311. 	*csport &= ~cspinmask;// toggle CS low so it'll listen to us

  312. #elif defined(__SAM3X8E__)

  313. 	pinMode(_rs, OUTPUT);

  314. 	pinMode(_cs, OUTPUT);

  315. 	csport    = digitalPinToPort(_cs);

  316. 	rsport    = digitalPinToPort(_rs);

  317. 	cspinmask = digitalPinToBitMask(_cs);

  318. 	rspinmask = digitalPinToBitMask(_rs);

  319.     SPI.begin();

  320. 	#if !defined(SPI_HAS_TRANSACTION)

  321. 		SPI.setClockDivider(5); // 8 MHz

  322. 		SPI.setBitOrder(MSBFIRST);

  323. 		SPI.setDataMode(SPI_MODE0);

  324. 	#else

  325. 		ILI9163C_SPI = SPISettings(24000000, MSBFIRST, SPI_MODE0);

  326. 	#endif

  327. 	csport ->PIO_CODR  |=  cspinmask; // toggle CS low so it'll listen to us

  328. #elif defined(__MKL26Z64__)//Teensy LC (preliminary)

  329. 	pinMode(_rs, OUTPUT);

  330. 	pinMode(_cs, OUTPUT);

  331. 	if (_useSPI1){

  332. 		if ((_mosi == 0 || _mosi == 21) && (_sclk == 20)) {//identify alternate SPI channel 1 (24Mhz)

  333. 			ILI9163C_SPI = SPISettings(24000000, MSBFIRST, SPI_MODE0);

  334. 			SPI1.setMOSI(_mosi);

  335. 			SPI1.setSCK(_sclk);

  336. 			SPI1.begin();

  337. 			_useSPI1 = true; //confirm

  338. 		} else {

  339. 			bitSet(_initError,0);

  340. 			return;

  341. 		}

  342. 		if (!SPI.pinIsChipSelect(_cs)) {//ERROR

  343. 			bitSet(_initError,1);

  344. 			return;

  345. 		}

  346. 	} else {

  347. 		if ((_mosi == 11 || _mosi == 7) && (_sclk == 13 || _sclk == 14)) {//valid SPI pins?

  348. 			ILI9163C_SPI = SPISettings(12000000, MSBFIRST, SPI_MODE0);

  349. 			SPI.setMOSI(_mosi);

  350. 			SPI.setSCK(_sclk);

  351. 			SPI.begin();

  352. 			_useSPI1 = false; //confirm

  353. 		} else {

  354. 			bitSet(_initError,0);

  355. 			return;

  356. 		}

  357. 		if (!SPI.pinIsChipSelect(_cs)) {//ERROR

  358. 			bitSet(_initError,1);

  359. 			return;

  360. 		}

  361. 	}

  362. 	digitalWriteFast(_cs, LOW);

  363. #elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)

  364. 	ILI9163C_SPI = SPISettings(30000000, MSBFIRST, SPI_MODE0);

  365. 	if ((_mosi == 11 || _mosi == 7) && (_sclk == 13 || _sclk == 14)) {

  366.         SPI.setMOSI(_mosi);

  367.         SPI.setSCK(_sclk);

  368. 	} else {

  369. 		bitSet(_initError,0);

  370. 		return;

  371. 	}

  372. 	SPI.begin();

  373. 	if (SPI.pinIsChipSelect(_cs, _rs)) {

  374. 		pcs_data = SPI.setCS(_cs);

  375. 		pcs_command = pcs_data | SPI.setCS(_rs);

  376. 	} else {

  377. 		pcs_data = 0;

  378. 		pcs_command = 0;

  379. 		bitSet(_initError,1);

  380. 		return;

  381. 	}

  382. #else//all the rest of possible boards

  383. 	pinMode(_rs, OUTPUT);

  384. 	pinMode(_cs, OUTPUT);

  385. 	SPI.begin();

  386. 	#if !defined(SPI_HAS_TRANSACTION)

  387. 		SPI.setClockDivider(4);

  388. 		SPI.setBitOrder(MSBFIRST);

  389. 		SPI.setDataMode(SPI_MODE0);

  390. 	#else

  391. 		ILI9163C_SPI = SPISettings(8000000, MSBFIRST, SPI_MODE0);

  392. 	#endif

  393. 	digitalWrite(_cs, LOW);

  394. #endif

  395. 	if (_rst != 255) {

  396. 		pinMode(_rst, OUTPUT);

  397. 		digitalWrite(_rst, HIGH);

  398. 		delay(500);

  399. 		digitalWrite(_rst, LOW);

  400. 		delay(500);

  401. 		digitalWrite(_rst, HIGH);

  402. 		delay(500);

  403. 	}

  404. 

  405. /*

  406. 7) MY:  1(bottom to top), 0(top to bottom) 	Row Address Order

  407. 6) MX:  1(R to L),        0(L to R)        	Column Address Order

  408. 5) MV:  1(Exchanged),     0(normal)        	Row/Column exchange

  409. 4) ML:  1(bottom to top), 0(top to bottom) 	Vertical Refresh Order

  410. 3) RGB: 1(BGR), 		   0(RGB)           	Color Space

  411. 2) MH:  1(R to L),        0(L to R)        	Horizontal Refresh Order

  412. 1)

  413. 0)

  414. 

  415.      MY, MX, MV, ML,RGB, MH, D1, D0

  416. 	 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0	//normal

  417. 	 1 | 0 | 0 | 0 | 1 | 0 | 0 | 0	//Y-Mirror

  418. 	 0 | 1 | 0 | 0 | 1 | 0 | 0 | 0	//X-Mirror

  419. 	 1 | 1 | 0 | 0 | 1 | 0 | 0 | 0	//X-Y-Mirror

  420. 	 0 | 0 | 1 | 0 | 1 | 0 | 0 | 0	//X-Y Exchange

  421. 	 1 | 0 | 1 | 0 | 1 | 0 | 0 | 0	//X-Y Exchange, Y-Mirror

  422. 	 0 | 1 | 1 | 0 | 1 | 0 | 0 | 0	//XY exchange

  423. 	 1 | 1 | 1 | 0 | 1 | 0 | 0 | 0

  424. */

  425. 	_Mactrl_Data = 0b00000000;

  426. 	_colorspaceData = __COLORSPC;//start with default data;

  427. 	chipInit();

  428. }

  429. 

  430. uint8_t TFT_ILI9163C::errorCode(void) 

  431. {

  432. 	return _initError;

  433. }

  434. 

  435. void TFT_ILI9163C::chipInit() {

  436. 	uint8_t i;

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

  438. 		SPI.beginTransaction(ILI9163C_SPI);

  439. 		

  440. 		writecommand_cont(CMD_SWRESET);//software reset

  441. 		delay(500);

  442. 		

  443. 		writecommand_cont(CMD_SLPOUT);//exit sleep

  444. 		delay(5);

  445. 		

  446. 		writecommand_cont(CMD_PIXFMT);//Set Color Format 16bit   

  447. 		writedata8_cont(0x05);

  448. 		delay(5);

  449. 		

  450. 		writecommand_cont(CMD_GAMMASET);//default gamma curve 3

  451. 		writedata8_cont(0x08);//0x04

  452. 		delay(1);

  453. 		

  454. 		writecommand_cont(CMD_GAMRSEL);//Enable Gamma adj    

  455. 		writedata8_cont(0x01); 

  456. 		delay(1);

  457. 		

  458. 		writecommand_cont(CMD_NORML);

  459. 	

  460. 		writecommand_cont(CMD_DFUNCTR);

  461. 		writedata8_cont(0b11111111);//

  462. 		writedata8_cont(0b00000110);//

  463. 

  464. 		writecommand_cont(CMD_PGAMMAC);//Positive Gamma Correction Setting

  465. 		for (i=0;i<15;i++){

  466. 			writedata8_cont(pGammaSet[i]);

  467. 		}

  468. 		

  469. 		writecommand_cont(CMD_NGAMMAC);//Negative Gamma Correction Setting

  470. 		for (i=0;i<15;i++){

  471. 			writedata8_cont(nGammaSet[i]);

  472. 		}

  473. 	

  474. 		writecommand_cont(CMD_FRMCTR1);//Frame Rate Control (In normal mode/Full colors)

  475. 		writedata8_cont(0x08);//0x0C//0x08

  476. 		writedata8_cont(0x02);//0x14//0x08

  477. 		delay(1);

  478. 	

  479. 		writecommand_cont(CMD_DINVCTR);//display inversion 

  480. 		writedata8_cont(0x07);

  481. 		delay(1);

  482. 	

  483. 		writecommand_cont(CMD_PWCTR1);//Set VRH1[4:0] & VC[2:0] for VCI1 & GVDD   

  484. 		writedata8_cont(0x0A);//4.30 - 0x0A

  485. 		writedata8_cont(0x02);//0x05

  486. 		delay(1);

  487. 	

  488. 		writecommand_cont(CMD_PWCTR2);//Set BT[2:0] for AVDD & VCL & VGH & VGL   

  489. 		writedata8_cont(0x02);

  490. 		delay(1);

  491. 	

  492. 		writecommand_cont(CMD_VCOMCTR1);//Set VMH[6:0] & VML[6:0] for VOMH & VCOML   

  493. 		writedata8_cont(0x50);//0x50

  494. 		writedata8_cont(99);//0x5b

  495. 		delay(1);

  496. 	

  497. 		writecommand_cont(CMD_VCOMOFFS);

  498. 		writedata8_cont(0);//0x40

  499. 		delay(1);

  500.   

  501. 		writecommand_cont(CMD_CLMADRS);//Set Column Address  

  502. 		writedata16_cont(0x00);

  503. 		writedata16_cont(_GRAMWIDTH); 

  504.   

  505. 		writecommand_cont(CMD_PGEADRS);//Set Page Address  

  506. 		writedata16_cont(0x00);

  507. 		writedata16_cont(_GRAMHEIGH); 

  508. 		// set scroll area (thanks Masuda)

  509. 		writecommand_cont(CMD_VSCLLDEF);

  510. 		writedata16_cont(__OFFSET);

  511. 		writedata16_cont(_GRAMHEIGH - __OFFSET);

  512. 		writedata16_last(0);

  513. 		

  514. 		SPI.endTransaction();

  515. 		

  516. 		colorSpace(_colorspaceData);

  517. 		

  518. 		setRotation(0);

  519. 		

  520. 		SPI.beginTransaction(ILI9163C_SPI);

  521. 		

  522. 		writecommand_cont(CMD_DISPON);//display ON 

  523. 		delay(1);

  524. 		writecommand_last(CMD_RAMWR);//Memory Write

  525. 		

  526. 		SPI.endTransaction();

  527. 		delay(1);

  528. 	#else

  529. 		writecommand(CMD_SWRESET);//software reset

  530. 		delay(500);

  531. 		

  532. 		writecommand(CMD_SLPOUT);//exit sleep

  533. 		delay(5);

  534. 		

  535. 		writecommand(CMD_PIXFMT);//Set Color Format 16bit   

  536. 		writedata(0x05);

  537. 		delay(5);

  538. 		

  539. 		writecommand(CMD_GAMMASET);//default gamma curve 3

  540. 		writedata(0x04);//0x04

  541. 		delay(1);

  542. 		

  543. 		writecommand(CMD_GAMRSEL);//Enable Gamma adj    

  544. 		writedata(0x01); 

  545. 		delay(1);

  546. 		

  547. 		writecommand(CMD_NORML);

  548. 	

  549. 		writecommand(CMD_DFUNCTR);

  550. 		writedata(0b11111111);//

  551. 		writedata(0b00000110);//

  552. 

  553. 		writecommand(CMD_PGAMMAC);//Positive Gamma Correction Setting

  554. 		for (i=0;i<15;i++){

  555. 			writedata(pGammaSet[i]);

  556. 		}

  557. 		

  558. 		writecommand(CMD_NGAMMAC);//Negative Gamma Correction Setting

  559. 		for (i=0;i<15;i++){

  560. 			writedata(nGammaSet[i]);

  561. 		}

  562. 

  563. 		writecommand(CMD_FRMCTR1);//Frame Rate Control (In normal mode/Full colors)

  564. 		writedata(0x08);//0x0C//0x08

  565. 		writedata(0x02);//0x14//0x08

  566. 		delay(1);

  567. 		

  568. 		writecommand(CMD_DINVCTR);//display inversion 

  569. 		writedata(0x07);

  570. 		delay(1);

  571. 		

  572. 		writecommand(CMD_PWCTR1);//Set VRH1[4:0] & VC[2:0] for VCI1 & GVDD   

  573. 		writedata(0x0A);//4.30 - 0x0A

  574. 		writedata(0x02);//0x05

  575. 		delay(1);

  576. 		

  577. 		writecommand(CMD_PWCTR2);//Set BT[2:0] for AVDD & VCL & VGH & VGL   

  578. 		writedata(0x02);

  579. 		delay(1);

  580. 		

  581. 		writecommand(CMD_VCOMCTR1);//Set VMH[6:0] & VML[6:0] for VOMH & VCOML   

  582. 		writedata(0x50);//0x50

  583. 		writedata(99);//0x5b

  584. 		delay(1);

  585. 		

  586. 		writecommand(CMD_VCOMOFFS);

  587. 		writedata(0);//0x40

  588. 		delay(1);

  589.   

  590. 		writecommand(CMD_CLMADRS);//Set Column Address  

  591. 		writedata16(0x00); 

  592. 		writedata16(_GRAMWIDTH); 

  593.   

  594. 		writecommand(CMD_PGEADRS);//Set Page Address  

  595. 		writedata16(0X00); 

  596. 		writedata16(_GRAMHEIGH);

  597. 		// set scroll area (thanks Masuda)

  598. 		writecommand(CMD_VSCLLDEF);

  599. 		writedata16(__OFFSET);

  600. 		writedata16(_GRAMHEIGH - __OFFSET);

  601. 		writedata16(0);

  602. 		

  603. 		colorSpace(_colorspaceData);

  604. 		

  605. 		setRotation(0);

  606. 		writecommand(CMD_DISPON);//display ON 

  607. 		delay(1);

  608. 		writecommand(CMD_RAMWR);//Memory Write

  609. 

  610. 		delay(1);

  611. 	#endif

  612. 	fillScreen(BLACK);

  613. }

  614. 

  615. /*

  616. Colorspace selection:

  617. 0: RGB

  618. 1: GBR

  619. */

  620. void TFT_ILI9163C::colorSpace(uint8_t cspace) {

  621. 	if (cspace < 1){

  622. 		bitClear(_Mactrl_Data,3);

  623. 	} else {

  624. 		bitSet(_Mactrl_Data,3);

  625. 	}

  626. }

  627. 

  628. void TFT_ILI9163C::invertDisplay(boolean i) {

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

  630. 		SPI.beginTransaction(ILI9163C_SPI);

  631. 		writecommand_last(i ? CMD_DINVON : CMD_DINVOF);

  632. 		SPI.endTransaction();

  633. 	#else

  634. 		writecommand(i ? CMD_DINVON : CMD_DINVOF);

  635. 	#endif

  636. }

  637. 

  638. void TFT_ILI9163C::display(boolean onOff) {

  639. 	if (onOff){

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

  641. 			SPI.beginTransaction(ILI9163C_SPI);

  642. 			writecommand_last(CMD_DISPON);

  643. 			SPI.endTransaction();

  644. 		#else

  645. 			writecommand(CMD_DISPON);

  646. 		#endif

  647. 	} else {

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

  649. 			SPI.beginTransaction(ILI9163C_SPI);

  650. 			writecommand_last(CMD_DISPOFF);

  651. 			SPI.endTransaction();

  652. 		#else

  653. 			writecommand(CMD_DISPOFF);

  654. 		#endif

  655. 	}

  656. }

  657. 

  658. void TFT_ILI9163C::idleMode(boolean onOff) {

  659. 	if (onOff){

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

  661. 			SPI.beginTransaction(ILI9163C_SPI);

  662. 			writecommand_last(CMD_IDLEON);

  663. 			SPI.endTransaction();

  664. 		#else

  665. 			writecommand(CMD_IDLEON);

  666. 		#endif

  667. 	} else {

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

  669. 			SPI.beginTransaction(ILI9163C_SPI);

  670. 			writecommand_last(CMD_IDLEOF);

  671. 			SPI.endTransaction();

  672. 		#else

  673. 			writecommand(CMD_IDLEOF);

  674. 		#endif

  675. 	}

  676. }

  677. 

  678. void TFT_ILI9163C::sleepMode(boolean mode) {

  679. 	if (mode){

  680. 		if (sleep == 1) return;//already sleeping

  681. 		sleep = 1;

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

  683. 			SPI.beginTransaction(ILI9163C_SPI);

  684. 			writecommand_last(CMD_SLPIN);

  685. 			SPI.endTransaction();

  686. 		#else

  687. 			writecommand(CMD_SLPIN);

  688. 		#endif

  689. 		delay(5);//needed

  690. 	} else {

  691. 		if (sleep == 0) return; //Already awake

  692. 		sleep = 0;

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

  694. 			SPI.beginTransaction(ILI9163C_SPI);

  695. 			writecommand_last(CMD_SLPOUT);

  696. 			SPI.endTransaction();

  697. 		#else

  698. 			writecommand(CMD_SLPOUT);

  699. 		#endif

  700. 		delay(120);//needed

  701. 	}

  702. }

  703. 

  704. void TFT_ILI9163C::defineScrollArea(uint16_t tfa, uint16_t bfa){

  705.     tfa += __OFFSET;

  706.     int16_t vsa = _GRAMHEIGH - tfa - bfa;

  707.     if (vsa >= 0) {

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

  709. 			SPI.beginTransaction(ILI9163C_SPI);

  710. 			writecommand_cont(CMD_VSCLLDEF);

  711. 			writedata16_cont(tfa);

  712. 			writedata16_cont(vsa);

  713. 			writedata16_last(bfa);

  714. 			SPI.endTransaction();

  715. 		#else

  716. 			writecommand(CMD_VSCLLDEF);

  717. 			writedata16(tfa);

  718. 			writedata16(vsa);

  719. 			writedata16(bfa);

  720. 		#endif

  721.     }

  722. }

  723. 

  724. void TFT_ILI9163C::scroll(uint16_t adrs) {

  725. 	if (adrs <= _GRAMHEIGH) {

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

  727. 		SPI.beginTransaction(ILI9163C_SPI);

  728. 		writecommand_cont(CMD_VSSTADRS);

  729. 		writedata16_last(adrs + __OFFSET);

  730. 		SPI.endTransaction();

  731. 	#else

  732. 		writecommand(CMD_VSSTADRS);

  733. 		writedata16(adrs + __OFFSET);

  734. 	#endif

  735. 	}

  736. }

  737. 

  738. 

  739. //corrected! v3

  740. void TFT_ILI9163C::clearScreen(uint16_t color) {

  741. 	int px;

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

  743. 		SPI.beginTransaction(ILI9163C_SPI);

  744. 		_setAddrWindow(0x00,0x00,_GRAMWIDTH,_GRAMHEIGH);

  745. 		for (px = 0;px < _GRAMSIZE; px++){

  746. 			writedata16_cont(color);

  747. 		}

  748. 		writecommand_last(CMD_NOP);

  749. 		SPI.endTransaction();

  750. 	#else

  751. 		setAddr(0x00,0x00,_GRAMWIDTH,_GRAMHEIGH);//go home

  752. 		for (px = 0;px < _GRAMSIZE; px++){

  753. 			writedata16(color);

  754. 		}

  755. 	#endif

  756. }

  757. 

  758. void TFT_ILI9163C::startPushData(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {

  759. 	setAddr(x0,y0,x1,y1);

  760. }

  761. 

  762. void TFT_ILI9163C::pushData(uint16_t color) {

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

  764. 		writedata16_cont(color);

  765. 	#else

  766. 		writedata16(color);

  767. 	#endif

  768. }

  769. 

  770. 

  771. void TFT_ILI9163C::endPushData() {

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

  773. 		writecommand_last(CMD_NOP);

  774. 		SPI.endTransaction();

  775. 	#endif

  776. }

  777. 

  778. 

  779. void TFT_ILI9163C::pushColor(uint16_t color) {

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

  781. 		SPI.beginTransaction(ILI9163C_SPI);

  782. 		writedata16_last(color);

  783. 		SPI.endTransaction();

  784. 	#else

  785. 		writedata16(color);

  786. 	#endif

  787. }

  788. 	

  789. void TFT_ILI9163C::writeScreen24(const uint32_t *bitmap,uint16_t size) {

  790. 	uint16_t color;

  791. 	uint16_t px;

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

  793. 		writecommand_cont(CMD_RAMWR);

  794. 		for (px = 0;px < size; px++){//16384

  795. 			color = Color24To565(bitmap[px]);

  796. 			writedata16_cont(color);

  797. 		}

  798. 		_setAddrWindow(0x00,0x00,_GRAMWIDTH,_GRAMHEIGH);//home

  799. 		SPI.endTransaction();

  800. 	#else

  801. 		writecommand(CMD_RAMWR);

  802. 		for (px = 0;px < size; px++){

  803. 			color = Color24To565(bitmap[px]);

  804. 			writedata16(color);

  805. 		}

  806. 		homeAddress();

  807. 	#endif

  808. }

  809. 

  810. void TFT_ILI9163C::homeAddress() {

  811. 	setAddrWindow(0x00,0x00,_GRAMWIDTH,_GRAMHEIGH);

  812. }

  813. 

  814. 

  815. 

  816. void TFT_ILI9163C::setCursor(int16_t x, int16_t y) {

  817. 	if (boundaryCheck(x,y)) return;

  818. 	setAddrWindow(0x00,0x00,x,y);

  819. 	cursor_x = x;

  820. 	cursor_y = y;

  821. }

  822. 

  823. 

  824. 

  825. 

  826. 

  827. void TFT_ILI9163C::drawPixel(int16_t x, int16_t y, uint16_t color) {

  828. 	if (boundaryCheck(x,y)) return;

  829. 	if ((x < 0) || (y < 0)) return;

  830. 	setAddr(x,y,x+1,y+1);

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

  832. 		writedata16_last(color);

  833. 		SPI.endTransaction();

  834. 	#else

  835. 		writedata16(color);

  836. 	#endif

  837. }

  838. 

  839. 

  840. 

  841. void TFT_ILI9163C::drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t color) {

  842. 	// Rudimentary clipping

  843. 	if (boundaryCheck(x,y)) return;

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

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

  846. 	while (h-- > 0) {

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

  848. 		if (h == 0){

  849. 			writedata16_last(color);

  850. 		} else {

  851. 			writedata16_cont(color);

  852. 		}

  853. 		#else

  854. 			writedata16(color);

  855. 		#endif

  856. 	}

  857. 	#if defined(SPI_HAS_TRANSACTION)

  858. 		SPI.endTransaction();

  859. 	#endif

  860. }

  861. 

  862. bool TFT_ILI9163C::boundaryCheck(int16_t x,int16_t y){

  863. 	if ((x >= _width) || (y >= _height)) return true;

  864. 	return false;

  865. }

  866. 

  867. void TFT_ILI9163C::drawFastHLine(int16_t x, int16_t y, int16_t w, uint16_t color) {

  868. 	// Rudimentary clipping

  869. 	if (boundaryCheck(x,y)) return;

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

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

  872. 	while (w-- > 0) {

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

  874. 		if (w == 0){

  875. 			writedata16_last(color);

  876. 		} else {

  877. 			writedata16_cont(color);

  878. 		}

  879. 		#else

  880. 			writedata16(color);

  881. 		#endif

  882. 	}

  883. 	#if defined(SPI_HAS_TRANSACTION)

  884. 		SPI.endTransaction();

  885. 	#endif

  886. }

  887. 

  888. void TFT_ILI9163C::fillScreen(uint16_t color) {

  889. 	clearScreen(color);

  890. }

  891. 

  892. // fill a rectangle

  893. void TFT_ILI9163C::fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) {

  894. 	if (boundaryCheck(x,y)) return;

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

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

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

  898. 	for (y = h;y > 0;y--) {

  899. 		for (x = w;x > 1;x--) {

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

  901. 				writedata16_cont(color);

  902. 			#else

  903. 				writedata16(color);

  904. 			#endif

  905. 		}

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

  907. 			writedata16_last(color);

  908. 		#else

  909. 			writedata16(color);

  910. 		#endif

  911. 	}

  912. 	#if defined(SPI_HAS_TRANSACTION)

  913. 		SPI.endTransaction();

  914. 	#endif

  915. }

  916. 

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

  918. void TFT_ILI9163C::drawLine(int16_t x0, int16_t y0,int16_t x1, int16_t y1, uint16_t color){

  919. 	if (y0 == y1) {

  920. 		if (x1 > x0) {

  921. 			drawFastHLine(x0, y0, x1 - x0 + 1, color);

  922. 		} else if (x1 < x0) {

  923. 			drawFastHLine(x1, y0, x0 - x1 + 1, color);

  924. 		} else {

  925. 			drawPixel(x0, y0, color);

  926. 		}

  927. 		return;

  928. 	} else if (x0 == x1) {

  929. 		if (y1 > y0) {

  930. 			drawFastVLine(x0, y0, y1 - y0 + 1, color);

  931. 		} else {

  932. 			drawFastVLine(x0, y1, y0 - y1 + 1, color);

  933. 		}

  934. 		return;

  935. 	}

  936. 

  937. 	bool steep = abs(y1 - y0) > abs(x1 - x0);

  938. 	if (steep) {

  939. 		std::swap(x0, y0);

  940. 		std::swap(x1, y1);

  941. 	}

  942. 	if (x0 > x1) {

  943. 		std::swap(x0, x1);

  944. 		std::swap(y0, y1);

  945. 	}

  946. 

  947. 	int16_t dx, dy;

  948. 	dx = x1 - x0;

  949. 	dy = abs(y1 - y0);

  950. 

  951. 	int16_t err = dx / 2;

  952. 	int16_t ystep;

  953. 

  954. 	if (y0 < y1) {

  955. 		ystep = 1;

  956. 	} else {

  957. 		ystep = -1;

  958. 	}

  959. 

  960. 	SPI.beginTransaction(ILI9163C_SPI);

  961. 	

  962. 	int16_t xbegin = x0;

  963. 	if (steep) {

  964. 		for (; x0<=x1; x0++) {

  965. 			err -= dy;

  966. 			if (err < 0) {

  967. 				int16_t len = x0 - xbegin;

  968. 				if (len) {

  969. 					VLine(y0, xbegin, len + 1, color);

  970. 				} else {

  971. 					Pixel(y0, x0, color);

  972. 				}

  973. 				xbegin = x0 + 1;

  974. 				y0 += ystep;

  975. 				err += dx;

  976. 			}

  977. 		}

  978. 		if (x0 > xbegin + 1) {

  979. 			VLine(y0, xbegin, x0 - xbegin, color);

  980. 		}

  981. 

  982. 	} else {

  983. 		for (; x0<=x1; x0++) {

  984. 			err -= dy;

  985. 			if (err < 0) {

  986. 				int16_t len = x0 - xbegin;

  987. 				if (len) {

  988. 					HLine(xbegin, y0, len + 1, color);

  989. 				} else {

  990. 					Pixel(x0, y0, color);

  991. 				}

  992. 				xbegin = x0 + 1;

  993. 				y0 += ystep;

  994. 				err += dx;

  995. 			}

  996. 		}

  997. 		if (x0 > xbegin + 1) {

  998. 			HLine(xbegin, y0, x0 - xbegin, color);

  999. 		}

  1000. 	}

  1001. 	writecommand_last(CMD_NOP);

  1002. 	SPI.endTransaction();

  1003. }

  1004. 

  1005. void TFT_ILI9163C::drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color){

  1006. 	SPI.beginTransaction(ILI9163C_SPI);

  1007. 	HLine(x, y, w, color);

  1008. 	HLine(x, y+h-1, w, color);

  1009. 	VLine(x, y, h, color);

  1010. 	VLine(x+w-1, y, h, color);

  1011. 	writecommand_last(CMD_NOP);

  1012. 	SPI.endTransaction();

  1013. }

  1014. 

  1015. 

  1016. #endif

  1017. 

  1018. void TFT_ILI9163C::setAddr(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1){

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

  1020. 		SPI.beginTransaction(ILI9163C_SPI);

  1021. 		_setAddrWindow(x0,y0,x1,y1);

  1022. 	#else

  1023. 		setAddrWindow(x0,y0,x1,y1);

  1024. 	#endif

  1025. }

  1026. 

  1027. void TFT_ILI9163C::setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {

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

  1029. 		SPI.beginTransaction(ILI9163C_SPI);

  1030. 		_setAddrWindow(x0,y0,x1,y1);

  1031. 		SPI.endTransaction();

  1032. 	#else

  1033. 		writecommand(CMD_CLMADRS); // Column

  1034. 		if (rotation == 0 || rotation > 1){

  1035. 			writedata16(x0);

  1036. 			writedata16(x1);

  1037. 		} else {

  1038. 			writedata16(x0 + __OFFSET);

  1039. 			writedata16(x1 + __OFFSET);

  1040. 		}

  1041. 

  1042. 		writecommand(CMD_PGEADRS); // Page

  1043. 		if (rotation == 0){

  1044. 			writedata16(y0 + __OFFSET);

  1045. 			writedata16(y1 + __OFFSET);

  1046. 		} else {

  1047. 			writedata16(y0);

  1048. 			writedata16(y1);

  1049. 		}

  1050. 		writecommand(CMD_RAMWR); //Into RAM

  1051. 	#endif

  1052. }

  1053. 

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

  1055. void TFT_ILI9163C::_setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {

  1056. 	writecommand_cont(CMD_CLMADRS); // Column

  1057. 	if (rotation == 0 || rotation > 1){

  1058. 		writedata16_cont(x0);

  1059. 		writedata16_cont(x1);

  1060. 	} else {

  1061. 		writedata16_cont(x0 + __OFFSET);

  1062. 		writedata16_cont(x1 + __OFFSET);

  1063. 	}

  1064. 	writecommand_cont(CMD_PGEADRS); // Page

  1065. 	if (rotation == 0){

  1066. 		writedata16_cont(y0 + __OFFSET);

  1067. 		writedata16_cont(y1 + __OFFSET);

  1068. 	} else {

  1069. 		writedata16_cont(y0);

  1070. 		writedata16_cont(y1);

  1071. 	}

  1072. 	writecommand_cont(CMD_RAMWR); //Into RAM

  1073. }

  1074. #endif

  1075. 

  1076. void TFT_ILI9163C::setRotation(uint8_t m) {

  1077. 	rotation = m % 4; // can't be higher than 3

  1078. 	switch (rotation) {

  1079. 	case 0:

  1080. 		_Mactrl_Data = 0b00001000;

  1081. 		_width  = _TFTWIDTH;

  1082. 		_height = _TFTHEIGHT;//-__OFFSET;

  1083. 		break;

  1084. 	case 1:

  1085. 		_Mactrl_Data = 0b01101000;

  1086. 		_width  = _TFTHEIGHT;//-__OFFSET;

  1087. 		_height = _TFTWIDTH;

  1088. 		break;

  1089. 	case 2:

  1090. 		_Mactrl_Data = 0b11001000;

  1091. 		_width  = _TFTWIDTH;

  1092. 		_height = _TFTHEIGHT;//-__OFFSET;

  1093. 		break;

  1094. 	case 3:

  1095. 		_Mactrl_Data = 0b10101000;

  1096. 		_width  = _TFTWIDTH;

  1097. 		_height = _TFTHEIGHT;//-__OFFSET;

  1098. 		break;

  1099. 	}

  1100. 	colorSpace(_colorspaceData);

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

  1102. 		SPI.beginTransaction(ILI9163C_SPI);

  1103. 		writecommand_cont(CMD_MADCTL);

  1104. 		writedata8_last(_Mactrl_Data);

  1105. 		SPI.endTransaction();

  1106. 	#else

  1107. 		writecommand(CMD_MADCTL);

  1108. 		writedata(_Mactrl_Data);

  1109. 	#endif

  1110. }

  1111. 

  1112. 

  1113.