chris
/
Weather_ESP
1
0
Fork 0
Code Releases 0 Activity
Repo for ESP32 Weather Station Development
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.
20 Commits
2 Branches
4.3MB
Tree: 79a99b0b35
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '79a99b0b35'
${ noResults }
Weather_ESP/components/tft/tftspi.c

948 lines
29KB
Raw Blame History 

  1. /*

  2.  *  Author: LoBo (loboris@gmail.com, loboris.github)

  3.  *

  4.  *  Module supporting SPI TFT displays based on ILI9341 & ILI9488 controllers

  5.  *

  6.  * HIGH SPEED LOW LEVEL DISPLAY FUNCTIONS

  7.  * USING DIRECT or DMA SPI TRANSFER MODEs

  8.  *

  9. */

  10. 

  11. #include <string.h>

  12. #include "tftspi.h"

  13. #include "freertos/task.h"

  14. #include "soc/spi_reg.h"

  15. #include "driver/gpio.h"

  16. 

  17. 

  18. // ====================================================

  19. // ==== Global variables, default values ==============

  20. 

  21. // Converts colors to grayscale if set to 1

  22. uint8_t tft_gray_scale = 0;

  23. // Spi clock for reading data from display memory in Hz

  24. uint32_t tft_max_rdclock = 8000000;

  25. 

  26. // Default display dimensions

  27. int tft_width = DEFAULT_TFT_DISPLAY_WIDTH;

  28. int tft_height = DEFAULT_TFT_DISPLAY_HEIGHT;

  29. 

  30. // Display type, DISP_TYPE_ILI9488 or DISP_TYPE_ILI9341

  31. uint8_t tft_disp_type = DEFAULT_DISP_TYPE;

  32. 

  33. // Spi device handles for display and touch screen

  34. spi_lobo_device_handle_t tft_disp_spi = NULL;

  35. spi_lobo_device_handle_t tft_ts_spi = NULL;

  36. 

  37. // ====================================================

  38. 

  39. 

  40. static color_t *trans_cline = NULL;

  41. static uint8_t _dma_sending = 0;

  42. 

  43. // RGB to GRAYSCALE constants

  44. // 0.2989  0.5870  0.1140

  45. #define GS_FACT_R 0.2989

  46. #define GS_FACT_G 0.4870

  47. #define GS_FACT_B 0.2140

  48. 

  49. 

  50. 

  51. // ==== Functions =====================

  52. 

  53. //------------------------------------------------------

  54. esp_err_t IRAM_ATTR wait_trans_finish(uint8_t free_line)

  55. {

  56. 	// Wait for SPI bus ready

  57. 	while (tft_disp_spi->host->hw->cmd.usr);

  58. 	if ((free_line) && (trans_cline)) {

  59. 		free(trans_cline);

  60. 		trans_cline = NULL;

  61. 	}

  62. 	if (_dma_sending) {

  63. 	    //Tell common code DMA workaround that our DMA channel is idle. If needed, the code will do a DMA reset.

  64. 	    if (tft_disp_spi->host->dma_chan) spi_lobo_dmaworkaround_idle(tft_disp_spi->host->dma_chan);

  65. 

  66. 	    // Reset DMA

  67. 		tft_disp_spi->host->hw->dma_conf.val |= SPI_OUT_RST|SPI_IN_RST|SPI_AHBM_RST|SPI_AHBM_FIFO_RST;

  68. 		tft_disp_spi->host->hw->dma_out_link.start=0;

  69. 		tft_disp_spi->host->hw->dma_in_link.start=0;

  70. 		tft_disp_spi->host->hw->dma_conf.val &= ~(SPI_OUT_RST|SPI_IN_RST|SPI_AHBM_RST|SPI_AHBM_FIFO_RST);

  71. 		tft_disp_spi->host->hw->dma_conf.out_data_burst_en=1;

  72. 		_dma_sending = 0;

  73. 	}

  74.     return ESP_OK;

  75. }

  76. 

  77. //-------------------------------

  78. esp_err_t IRAM_ATTR disp_select()

  79. {

  80. 	wait_trans_finish(1);

  81. 	return spi_lobo_device_select(tft_disp_spi, 0);

  82. }

  83. 

  84. //---------------------------------

  85. esp_err_t IRAM_ATTR disp_deselect()

  86. {

  87. 	wait_trans_finish(1);

  88. 	return spi_lobo_device_deselect(tft_disp_spi);

  89. }

  90. 

  91. //---------------------------------------------------------------------------------------------------

  92. static void IRAM_ATTR _spi_transfer_start(spi_lobo_device_handle_t spi_dev, int wrbits, int rdbits) {

  93. 	// Load send buffer

  94. 	spi_dev->host->hw->user.usr_mosi_highpart = 0;

  95. 	spi_dev->host->hw->mosi_dlen.usr_mosi_dbitlen = wrbits-1;

  96. 	spi_dev->host->hw->user.usr_mosi = 1;

  97.     if (rdbits) {

  98.         spi_dev->host->hw->miso_dlen.usr_miso_dbitlen = rdbits;

  99.         spi_dev->host->hw->user.usr_miso = 1;

  100.     }

  101.     else {

  102.         spi_dev->host->hw->miso_dlen.usr_miso_dbitlen = 0;

  103.         spi_dev->host->hw->user.usr_miso = 0;

  104.     }

  105. 	// Start transfer

  106. 	spi_dev->host->hw->cmd.usr = 1;

  107.     // Wait for SPI bus ready

  108. 	while (spi_dev->host->hw->cmd.usr);

  109. }

  110. 

  111. // Send 1 byte display command, display must be selected

  112. //------------------------------------------------

  113. void IRAM_ATTR disp_spi_transfer_cmd(int8_t cmd) {

  114. 	// Wait for SPI bus ready

  115. 	while (tft_disp_spi->host->hw->cmd.usr);

  116. 

  117. 	// Set DC to 0 (command mode);

  118.     gpio_set_level(PIN_NUM_DC, 0);

  119. 

  120.     tft_disp_spi->host->hw->data_buf[0] = (uint32_t)cmd;

  121.     _spi_transfer_start(tft_disp_spi, 8, 0);

  122. }

  123. 

  124. // Send command with data to display, display must be selected

  125. //----------------------------------------------------------------------------------

  126. void IRAM_ATTR disp_spi_transfer_cmd_data(int8_t cmd, uint8_t *data, uint32_t len) {

  127. 	// Wait for SPI bus ready

  128. 	while (tft_disp_spi->host->hw->cmd.usr);

  129. 

  130.     // Set DC to 0 (command mode);

  131.     gpio_set_level(PIN_NUM_DC, 0);

  132. 

  133.     tft_disp_spi->host->hw->data_buf[0] = (uint32_t)cmd;

  134.     _spi_transfer_start(tft_disp_spi, 8, 0);

  135. 

  136. 	if ((len == 0) || (data == NULL)) return;

  137. 

  138.     // Set DC to 1 (data mode);

  139. 	gpio_set_level(PIN_NUM_DC, 1);

  140. 

  141. 	uint8_t idx=0, bidx=0;

  142. 	uint32_t bits=0;

  143. 	uint32_t count=0;

  144. 	uint32_t wd = 0;

  145. 	while (count < len) {

  146. 		// get data byte from buffer

  147. 		wd |= (uint32_t)data[count] << bidx;

  148.     	count++;

  149.     	bits += 8;

  150. 		bidx += 8;

  151.     	if (count == len) {

  152.     		tft_disp_spi->host->hw->data_buf[idx] = wd;

  153.     		break;

  154.     	}

  155. 		if (bidx == 32) {

  156. 			tft_disp_spi->host->hw->data_buf[idx] = wd;

  157. 			idx++;

  158. 			bidx = 0;

  159. 			wd = 0;

  160. 		}

  161.     	if (idx == 16) {

  162.     		// SPI buffer full, send data

  163. 			_spi_transfer_start(tft_disp_spi, bits, 0);

  164. 

  165. 			bits = 0;

  166.     		idx = 0;

  167. 			bidx = 0;

  168.     	}

  169.     }

  170.     if (bits > 0) _spi_transfer_start(tft_disp_spi, bits, 0);

  171. }

  172. 

  173. // Set the address window for display write & read commands, display must be selected

  174. //---------------------------------------------------------------------------------------------------

  175. static void IRAM_ATTR disp_spi_transfer_addrwin(uint16_t x1, uint16_t x2, uint16_t y1, uint16_t y2) {

  176. 	uint32_t wd;

  177. 

  178.     taskDISABLE_INTERRUPTS();

  179. 	// Wait for SPI bus ready

  180. 	while (tft_disp_spi->host->hw->cmd.usr);

  181.     gpio_set_level(PIN_NUM_DC, 0);

  182. 

  183. 	tft_disp_spi->host->hw->data_buf[0] = (uint32_t)TFT_CASET;

  184. 	tft_disp_spi->host->hw->user.usr_mosi_highpart = 0;

  185. 	tft_disp_spi->host->hw->mosi_dlen.usr_mosi_dbitlen = 7;

  186. 	tft_disp_spi->host->hw->user.usr_mosi = 1;

  187. 	tft_disp_spi->host->hw->miso_dlen.usr_miso_dbitlen = 0;

  188. 	tft_disp_spi->host->hw->user.usr_miso = 0;

  189. 

  190. 	tft_disp_spi->host->hw->cmd.usr = 1; // Start transfer

  191. 

  192. 	wd = (uint32_t)(x1>>8);

  193. 	wd |= (uint32_t)(x1&0xff) << 8;

  194. 	wd |= (uint32_t)(x2>>8) << 16;

  195. 	wd |= (uint32_t)(x2&0xff) << 24;

  196. 

  197. 	while (tft_disp_spi->host->hw->cmd.usr); // wait transfer end

  198. 	gpio_set_level(PIN_NUM_DC, 1);

  199. 	tft_disp_spi->host->hw->data_buf[0] = wd;

  200. 	tft_disp_spi->host->hw->mosi_dlen.usr_mosi_dbitlen = 31;

  201. 	tft_disp_spi->host->hw->cmd.usr = 1; // Start transfer

  202. 

  203.     while (tft_disp_spi->host->hw->cmd.usr);

  204.     gpio_set_level(PIN_NUM_DC, 0);

  205.     tft_disp_spi->host->hw->data_buf[0] = (uint32_t)TFT_PASET;

  206. 	tft_disp_spi->host->hw->mosi_dlen.usr_mosi_dbitlen = 7;

  207. 	tft_disp_spi->host->hw->cmd.usr = 1; // Start transfer

  208. 

  209. 	wd = (uint32_t)(y1>>8);

  210. 	wd |= (uint32_t)(y1&0xff) << 8;

  211. 	wd |= (uint32_t)(y2>>8) << 16;

  212. 	wd |= (uint32_t)(y2&0xff) << 24;

  213. 

  214. 	while (tft_disp_spi->host->hw->cmd.usr);

  215. 	gpio_set_level(PIN_NUM_DC, 1);

  216. 

  217. 	tft_disp_spi->host->hw->data_buf[0] = wd;

  218. 	tft_disp_spi->host->hw->mosi_dlen.usr_mosi_dbitlen = 31;

  219. 	tft_disp_spi->host->hw->cmd.usr = 1; // Start transfer

  220. 	while (tft_disp_spi->host->hw->cmd.usr);

  221.     taskENABLE_INTERRUPTS();

  222. }

  223. 

  224. // Convert color to gray scale

  225. //----------------------------------------------

  226. static color_t IRAM_ATTR color2gs(color_t color)

  227. {

  228. 	color_t _color;

  229.     float gs_clr = GS_FACT_R * color.r + GS_FACT_G * color.g + GS_FACT_B * color.b;

  230.     if (gs_clr > 255) gs_clr = 255;

  231. 

  232.     _color.r = (uint8_t)gs_clr;

  233.     _color.g = (uint8_t)gs_clr;

  234.     _color.b = (uint8_t)gs_clr;

  235. 

  236.     return _color;

  237. }

  238. 

  239. // Set display pixel at given coordinates to given color

  240. //------------------------------------------------------------------------

  241. void IRAM_ATTR drawPixel(int16_t x, int16_t y, color_t color, uint8_t sel)

  242. {

  243. 	if (!(tft_disp_spi->cfg.flags & LB_SPI_DEVICE_HALFDUPLEX)) return;

  244. 

  245. 	if (sel) {

  246. 		if (disp_select()) return;

  247. 	}

  248. 	else wait_trans_finish(1);

  249. 

  250. 	uint32_t wd = 0;

  251.     color_t _color = color;

  252. 	if (tft_gray_scale) _color = color2gs(color);

  253. 

  254.     taskDISABLE_INTERRUPTS();

  255. 	disp_spi_transfer_addrwin(x, x+1, y, y+1);

  256. 

  257. 	// Send RAM WRITE command

  258.     gpio_set_level(PIN_NUM_DC, 0);

  259.     tft_disp_spi->host->hw->data_buf[0] = (uint32_t)TFT_RAMWR;

  260. 	tft_disp_spi->host->hw->mosi_dlen.usr_mosi_dbitlen = 7;

  261. 	tft_disp_spi->host->hw->cmd.usr = 1;		// Start transfer

  262. 	while (tft_disp_spi->host->hw->cmd.usr);	// Wait for SPI bus ready

  263. 

  264. 	wd = (uint32_t)_color.r;

  265. 	wd |= (uint32_t)_color.g << 8;

  266. 	wd |= (uint32_t)_color.b << 16;

  267. 

  268.     // Set DC to 1 (data mode);

  269. 	gpio_set_level(PIN_NUM_DC, 1);

  270. 

  271. 	tft_disp_spi->host->hw->data_buf[0] = wd;

  272. 	tft_disp_spi->host->hw->mosi_dlen.usr_mosi_dbitlen = 23;

  273. 	tft_disp_spi->host->hw->cmd.usr = 1;		// Start transfer

  274. 	while (tft_disp_spi->host->hw->cmd.usr);	// Wait for SPI bus ready

  275. 

  276.     taskENABLE_INTERRUPTS();

  277.    if (sel) disp_deselect();

  278. }

  279. 

  280. //-----------------------------------------------------------

  281. static void IRAM_ATTR _dma_send(uint8_t *data, uint32_t size)

  282. {

  283.     //Fill DMA descriptors

  284.     spi_lobo_dmaworkaround_transfer_active(tft_disp_spi->host->dma_chan); //mark channel as active

  285.     spi_lobo_setup_dma_desc_links(tft_disp_spi->host->dmadesc_tx, size, data, false);

  286.     tft_disp_spi->host->hw->user.usr_mosi_highpart=0;

  287.     tft_disp_spi->host->hw->dma_out_link.addr=(int)(&tft_disp_spi->host->dmadesc_tx[0]) & 0xFFFFF;

  288.     tft_disp_spi->host->hw->dma_out_link.start=1;

  289.     tft_disp_spi->host->hw->user.usr_mosi_highpart=0;

  290. 

  291. 	tft_disp_spi->host->hw->mosi_dlen.usr_mosi_dbitlen = (size * 8) - 1;

  292. 

  293. 	_dma_sending = 1;

  294. 	// Start transfer

  295. 	tft_disp_spi->host->hw->cmd.usr = 1;

  296. }

  297. 

  298. //---------------------------------------------------------------------------

  299. static void IRAM_ATTR _direct_send(color_t *color, uint32_t len, uint8_t rep)

  300. {

  301. 	uint32_t cidx = 0;	// color buffer index

  302. 	uint32_t wd = 0;

  303. 	int idx = 0;

  304. 	int bits = 0;

  305. 	int wbits = 0;

  306. 

  307.     taskDISABLE_INTERRUPTS();

  308. 	color_t _color = color[0];

  309. 	if ((rep) && (tft_gray_scale)) _color = color2gs(color[0]);

  310. 

  311. 	while (len) {

  312. 		// ** Get color data from color buffer **

  313. 		if (rep == 0) {

  314. 			if (tft_gray_scale) _color = color2gs(color[cidx]);

  315. 			else _color = color[cidx];

  316. 		}

  317. 

  318. 		wd |= (uint32_t)_color.r << wbits;

  319. 		wbits += 8;

  320. 		if (wbits == 32) {

  321. 			bits += wbits;

  322. 			wbits = 0;

  323. 			tft_disp_spi->host->hw->data_buf[idx++] = wd;

  324. 			wd = 0;

  325. 		}

  326. 		wd |= (uint32_t)_color.g << wbits;

  327. 		wbits += 8;

  328. 		if (wbits == 32) {

  329. 			bits += wbits;

  330. 			wbits = 0;

  331. 			tft_disp_spi->host->hw->data_buf[idx++] = wd;

  332. 			wd = 0;

  333. 		}

  334. 		wd |= (uint32_t)_color.b << wbits;

  335. 		wbits += 8;

  336. 		if (wbits == 32) {

  337. 			bits += wbits;

  338. 			wbits = 0;

  339. 			tft_disp_spi->host->hw->data_buf[idx++] = wd;

  340. 			wd = 0;

  341. 		}

  342.     	len--;					// Decrement colors counter

  343.         if (rep == 0) cidx++;	// if not repeating color, increment color buffer index

  344.     }

  345. 	if (bits) {

  346. 		while (tft_disp_spi->host->hw->cmd.usr);						// Wait for SPI bus ready

  347. 		tft_disp_spi->host->hw->mosi_dlen.usr_mosi_dbitlen = bits-1;	// set number of bits to be sent

  348.         tft_disp_spi->host->hw->cmd.usr = 1;							// Start transfer

  349. 	}

  350.     taskENABLE_INTERRUPTS();

  351. }

  352. 

  353. // ================================================================

  354. // === Main function to send data to display ======================

  355. // If  rep==true:  repeat sending color data to display 'len' times

  356. // If rep==false:  send 'len' color data from color buffer to display

  357. // ** Device must already be selected and address window set **

  358. // ================================================================

  359. //----------------------------------------------------------------------------------------------

  360. static void IRAM_ATTR _TFT_pushColorRep(color_t *color, uint32_t len, uint8_t rep, uint8_t wait)

  361. {

  362. 	if (len == 0) return;

  363. 	if (!(tft_disp_spi->cfg.flags & LB_SPI_DEVICE_HALFDUPLEX)) return;

  364. 

  365. 	// Send RAM WRITE command

  366.     gpio_set_level(PIN_NUM_DC, 0);

  367.     tft_disp_spi->host->hw->data_buf[0] = (uint32_t)TFT_RAMWR;

  368. 	tft_disp_spi->host->hw->mosi_dlen.usr_mosi_dbitlen = 7;

  369. 	tft_disp_spi->host->hw->cmd.usr = 1;		// Start transfer

  370. 	while (tft_disp_spi->host->hw->cmd.usr);	// Wait for SPI bus ready

  371. 

  372. 	gpio_set_level(PIN_NUM_DC, 1);								// Set DC to 1 (data mode);

  373. 

  374. 	if ((len*24) <= 512) {

  375. 

  376. 		_direct_send(color, len, rep);

  377. 

  378. 	}

  379. 	else if (rep == 0)  {

  380. 		// ==== use DMA transfer ====

  381. 		// ** Prepare data

  382. 		if (tft_gray_scale) {

  383. 			for (int n=0; n<len; n++) {

  384. 				color[n] = color2gs(color[n]);

  385. 			}

  386. 	    }

  387. 

  388. 	    _dma_send((uint8_t *)color, len*3);

  389. 	}

  390. 	else {

  391. 		// ==== Repeat color, more than 512 bits total ====

  392. 

  393. 		color_t _color;

  394. 		uint32_t buf_colors;

  395. 		int buf_bytes, to_send;

  396. 

  397. 		/*

  398. 		to_send = len;

  399. 		while (to_send > 0) {

  400. 			wait_trans_finish(0);

  401. 			_direct_send(color, ((to_send > 21) ? 21 : to_send), rep);

  402. 			to_send -= 21;

  403. 		}

  404. 		*/

  405. 

  406. 		buf_colors = ((len > (tft_width*2)) ? (tft_width*2) : len);

  407. 		buf_bytes = buf_colors * 3;

  408. 

  409. 		// Prepare color buffer of maximum 2 color lines

  410. 		trans_cline = heap_caps_malloc(buf_bytes, MALLOC_CAP_DMA);

  411. 		if (trans_cline == NULL) return;

  412. 

  413. 		// Prepare fill color

  414. 		if (tft_gray_scale) _color = color2gs(color[0]);

  415. 		else _color = color[0];

  416. 

  417. 		// Fill color buffer with fill color

  418. 		for (uint32_t i=0; i<buf_colors; i++) {

  419. 			trans_cline[i] = _color;

  420. 		}

  421. 

  422. 		// Send 'len' colors

  423. 		to_send = len;

  424. 		while (to_send > 0) {

  425. 			wait_trans_finish(0);

  426. 			_dma_send((uint8_t *)trans_cline, ((to_send > buf_colors) ? buf_bytes : (to_send*3)));

  427. 			to_send -= buf_colors;

  428. 		}

  429. 	}

  430. 

  431. 	if (wait) wait_trans_finish(1);

  432. }

  433. 

  434. // Write 'len' color data to TFT 'window' (x1,y2),(x2,y2)

  435. //-------------------------------------------------------------------------------------------

  436. void IRAM_ATTR TFT_pushColorRep(int x1, int y1, int x2, int y2, color_t color, uint32_t len)

  437. {

  438. 	if (disp_select() != ESP_OK) return;

  439. 

  440. 	// ** Send address window **

  441. 	disp_spi_transfer_addrwin(x1, x2, y1, y2);

  442. 

  443. 	_TFT_pushColorRep(&color, len, 1, 1);

  444. 

  445. 	disp_deselect();

  446. }

  447. 

  448. // Write 'len' color data to TFT 'window' (x1,y2),(x2,y2) from given buffer

  449. // ** Device must already be selected **

  450. //-----------------------------------------------------------------------------------

  451. void IRAM_ATTR send_data(int x1, int y1, int x2, int y2, uint32_t len, color_t *buf)

  452. {

  453. 	// ** Send address window **

  454. 	disp_spi_transfer_addrwin(x1, x2, y1, y2);

  455. 	_TFT_pushColorRep(buf, len, 0, 0);

  456. }

  457. 

  458. // Reads 'len' pixels/colors from the TFT's GRAM 'window'

  459. // 'buf' is an array of bytes with 1st byte reserved for reading 1 dummy byte

  460. // and the rest is actually an array of color_t values

  461. //--------------------------------------------------------------------------------------------

  462. int IRAM_ATTR read_data(int x1, int y1, int x2, int y2, int len, uint8_t *buf, uint8_t set_sp)

  463. {

  464. 	spi_lobo_transaction_t t;

  465. 	uint32_t current_clock = 0;

  466. 

  467.     memset(&t, 0, sizeof(t));  //Zero out the transaction

  468. 	memset(buf, 0, len*sizeof(color_t));

  469. 

  470. 	if (set_sp) {

  471. 		if (disp_deselect() != ESP_OK) return -1;

  472. 		// Change spi clock if needed

  473. 		current_clock = spi_lobo_get_speed(tft_disp_spi);

  474. 		if (tft_max_rdclock < current_clock) spi_lobo_set_speed(tft_disp_spi, tft_max_rdclock);

  475. 	}

  476. 

  477. 	if (disp_select() != ESP_OK) return -2;

  478. 

  479. 	// ** Send address window **

  480. 	disp_spi_transfer_addrwin(x1, x2, y1, y2);

  481. 

  482.     // ** GET pixels/colors **

  483. 	disp_spi_transfer_cmd(TFT_RAMRD);

  484. 

  485.     t.length=0;                //Send nothing

  486.     t.tx_buffer=NULL;

  487.     t.rxlength=8*((len*3)+1);  //Receive size in bits

  488.     t.rx_buffer=buf;

  489.     //t.user = (void*)1;

  490. 

  491. 	esp_err_t res = spi_lobo_transfer_data(tft_disp_spi, &t); // Receive using direct mode

  492. 

  493. 	disp_deselect();

  494. 

  495. 	if (set_sp) {

  496. 		// Restore spi clock if needed

  497. 		if (tft_max_rdclock < current_clock) spi_lobo_set_speed(tft_disp_spi, current_clock);

  498. 	}

  499. 

  500.     return res;

  501. }

  502. 

  503. // Reads one pixel/color from the TFT's GRAM at position (x,y)

  504. //-----------------------------------------------

  505. color_t IRAM_ATTR readPixel(int16_t x, int16_t y)

  506. {

  507.     uint8_t color_buf[sizeof(color_t)+1] = {0};

  508. 

  509.     read_data(x, y, x+1, y+1, 1, color_buf, 1);

  510. 

  511.     color_t color;

  512. 	color.r = color_buf[1];

  513. 	color.g = color_buf[2];

  514. 	color.b = color_buf[3];

  515. 	return color;

  516. }

  517. 

  518. // get 16-bit data from touch controller for specified type

  519. // ** Touch device must already be selected **

  520. //----------------------------------------

  521. int IRAM_ATTR touch_get_data(uint8_t type)

  522. {

  523.     /*

  524.     esp_err_t ret;

  525.     spi_lobo_transaction_t t;

  526.     memset(&t, 0, sizeof(t));            //Zero out the transaction

  527.     uint8_t rxdata[2] = {0};

  528. 

  529.     // send command byte & receive 2 byte response

  530.     t.rxlength=8*2;

  531.     t.rx_buffer=&rxdata;

  532.     t.command = type;

  533. 

  534.     ret = spi_lobo_transfer_data(tft_ts_spi, &t);    // Transmit using direct mode

  535. 

  536.     if (ret != ESP_OK) return -1;

  537.     return (((int)(rxdata[0] << 8) | (int)(rxdata[1])) >> 4);

  538.     */

  539.     spi_lobo_device_select(tft_ts_spi, 0);

  540. 

  541.     tft_ts_spi->host->hw->data_buf[0] = type;

  542.     _spi_transfer_start(tft_ts_spi, 24, 24);

  543.     uint16_t res = (uint16_t)(tft_ts_spi->host->hw->data_buf[0] >> 8);

  544. 

  545.     spi_lobo_device_deselect(tft_ts_spi);

  546. 

  547.     return res;

  548. }

  549. 

  550. // ==== STMPE610 ===============================================================

  551. 

  552. 

  553. // ----- STMPE610 --------------------------------------------------------------------------

  554. 

  555. // Send 1 byte display command, display must be selected

  556. //---------------------------------------------------------

  557. static void IRAM_ATTR stmpe610_write_reg(uint8_t reg, uint8_t val) {

  558. 

  559.     spi_lobo_device_select(tft_ts_spi, 0);

  560. 

  561.     tft_ts_spi->host->hw->data_buf[0] = (val << 8) | reg;

  562.     _spi_transfer_start(tft_ts_spi, 16, 0);

  563. 

  564.     spi_lobo_device_deselect(tft_ts_spi);

  565. }

  566. 

  567. //-----------------------------------------------

  568. static uint8_t IRAM_ATTR stmpe610_read_byte(uint8_t reg) {

  569.     spi_lobo_device_select(tft_ts_spi, 0);

  570. 

  571.     tft_ts_spi->host->hw->data_buf[0] = (reg << 8) | (reg | 0x80);

  572.     _spi_transfer_start(tft_ts_spi, 16, 16);

  573.     uint8_t res = tft_ts_spi->host->hw->data_buf[0] >> 8;

  574. 

  575.     spi_lobo_device_deselect(tft_ts_spi);

  576.     return res;

  577. }

  578. 

  579. //-----------------------------------------

  580. static uint16_t IRAM_ATTR stmpe610_read_word(uint8_t reg) {

  581.     spi_lobo_device_select(tft_ts_spi, 0);

  582. 

  583.     tft_ts_spi->host->hw->data_buf[0] = ((((reg+1) << 8) | ((reg+1) | 0x80)) << 16) | (reg << 8) | (reg | 0x80);

  584.     _spi_transfer_start(tft_ts_spi, 32, 32);

  585.     uint16_t res = (uint16_t)(tft_ts_spi->host->hw->data_buf[0] & 0xFF00);

  586.     res |= (uint16_t)(tft_ts_spi->host->hw->data_buf[0] >> 24);

  587. 

  588.     spi_lobo_device_deselect(tft_ts_spi);

  589.     return res;

  590. }

  591. 

  592. //-----------------------

  593. uint32_t stmpe610_getID()

  594. {

  595.     uint16_t tid = stmpe610_read_word(0);

  596.     uint8_t tver = stmpe610_read_byte(2);

  597.     return (tid << 8) | tver;

  598. }

  599. 

  600. //==================

  601. void stmpe610_Init()

  602. {

  603.     stmpe610_write_reg(STMPE610_REG_SYS_CTRL1, 0x02);        // Software chip reset

  604.     vTaskDelay(10 / portTICK_RATE_MS);

  605. 

  606.     stmpe610_write_reg(STMPE610_REG_SYS_CTRL2, 0x04);        // Temperature sensor clock off, GPIO clock off, touch clock on, ADC clock on

  607. 

  608.     stmpe610_write_reg(STMPE610_REG_INT_EN, 0x00);           // Don't Interrupt on INT pin

  609. 

  610.     stmpe610_write_reg(STMPE610_REG_ADC_CTRL1, 0x48);        // ADC conversion time = 80 clock ticks, 12-bit ADC, internal voltage refernce

  611.     vTaskDelay(2 / portTICK_RATE_MS);

  612.     stmpe610_write_reg(STMPE610_REG_ADC_CTRL2, 0x01);        // ADC speed 3.25MHz

  613.     stmpe610_write_reg(STMPE610_REG_GPIO_AF, 0x00);          // GPIO alternate function - OFF

  614.     stmpe610_write_reg(STMPE610_REG_TSC_CFG, 0xE3);          // Averaging 8, touch detect delay 1ms, panel driver settling time 1ms

  615.     stmpe610_write_reg(STMPE610_REG_FIFO_TH, 0x01);          // FIFO threshold = 1

  616.     stmpe610_write_reg(STMPE610_REG_FIFO_STA, 0x01);         // FIFO reset enable

  617.     stmpe610_write_reg(STMPE610_REG_FIFO_STA, 0x00);         // FIFO reset disable

  618.     stmpe610_write_reg(STMPE610_REG_TSC_FRACT_XYZ, 0x07);    // Z axis data format

  619.     stmpe610_write_reg(STMPE610_REG_TSC_I_DRIVE, 0x01);      // max 50mA touchscreen line current

  620.     stmpe610_write_reg(STMPE610_REG_TSC_CTRL, 0x30);         // X&Y&Z, 16 reading window

  621.     stmpe610_write_reg(STMPE610_REG_TSC_CTRL, 0x31);         // X&Y&Z, 16 reading window, TSC enable

  622.     stmpe610_write_reg(STMPE610_REG_INT_STA, 0xFF);          // Clear all interrupts

  623.     stmpe610_write_reg(STMPE610_REG_INT_CTRL, 0x00);         // Level interrupt, disable interrupts

  624. }

  625. 

  626. //===========================================================

  627. int stmpe610_get_touch(uint16_t *x, uint16_t *y, uint16_t *z)

  628. {

  629. 	if (!(stmpe610_read_byte(STMPE610_REG_TSC_CTRL) & 0x80)) return 0;

  630. 

  631.     // Get touch data

  632.     uint8_t fifo_size = stmpe610_read_byte(STMPE610_REG_FIFO_SIZE);

  633.     while (fifo_size < 2) {

  634.     	if (!(stmpe610_read_byte(STMPE610_REG_TSC_CTRL) & 0x80)) return 0;

  635.         fifo_size = stmpe610_read_byte(STMPE610_REG_FIFO_SIZE);

  636.     }

  637.     while (fifo_size > 120) {

  638.     	if (!(stmpe610_read_byte(STMPE610_REG_TSC_CTRL) & 0x80)) return 0;

  639.         *x = stmpe610_read_word(STMPE610_REG_TSC_DATA_X);

  640.         *y = stmpe610_read_word(STMPE610_REG_TSC_DATA_Y);

  641.         *z = stmpe610_read_byte(STMPE610_REG_TSC_DATA_Z);

  642.         fifo_size = stmpe610_read_byte(STMPE610_REG_FIFO_SIZE);

  643.     }

  644.     for (uint8_t i=0; i < (fifo_size-1); i++) {

  645.         *x = stmpe610_read_word(STMPE610_REG_TSC_DATA_X);

  646.         *y = stmpe610_read_word(STMPE610_REG_TSC_DATA_Y);

  647.         *z = stmpe610_read_byte(STMPE610_REG_TSC_DATA_Z);

  648.     }

  649. 

  650.     *x = 4096 - *x;

  651.     /*

  652.     // Clear the rest of the fifo

  653.     {

  654.         stmpe610_write_reg(STMPE610_REG_FIFO_STA, 0x01);		// FIFO reset enable

  655.         stmpe610_write_reg(STMPE610_REG_FIFO_STA, 0x00);		// FIFO reset disable

  656.     }

  657.     */

  658. 	return 1;

  659. }

  660. 

  661. // ==== STMPE610 ===========================================================================

  662. 

  663. 

  664. // Find maximum spi clock for successful read from display RAM

  665. // ** Must be used AFTER the display is initialized **

  666. //======================

  667. uint32_t find_rd_speed()

  668. {

  669. 	esp_err_t ret;

  670. 	color_t color;

  671. 	uint32_t max_speed = 1000000;

  672.     uint32_t change_speed, cur_speed;

  673.     int line_check;

  674.     color_t *color_line = NULL;

  675.     uint8_t *line_rdbuf = NULL;

  676.     uint8_t gs = tft_gray_scale;

  677. 

  678.     tft_gray_scale = 0;

  679.     cur_speed = spi_lobo_get_speed(tft_disp_spi);

  680. 

  681. 	color_line = malloc(tft_width*3);

  682.     if (color_line == NULL) goto exit;

  683. 

  684.     line_rdbuf = malloc((tft_width*3)+1);

  685. 	if (line_rdbuf == NULL) goto exit;

  686. 

  687. 	color_t *rdline = (color_t *)(line_rdbuf+1);

  688. 

  689. 	// Fill test line with colors

  690. 	color = (color_t){0xEC,0xA8,0x74};

  691. 	for (int x=0; x<tft_width; x++) {

  692. 		color_line[x] = color;

  693. 	}

  694. 

  695. 	// Find maximum read spi clock

  696. 	for (uint32_t speed=2000000; speed<=cur_speed; speed += 1000000) {

  697. 		change_speed = spi_lobo_set_speed(tft_disp_spi, speed);

  698. 		if (change_speed == 0) goto exit;

  699. 

  700. 		memset(line_rdbuf, 0, tft_width*sizeof(color_t)+1);

  701. 

  702. 		if (disp_select()) goto exit;

  703. 		// Write color line

  704. 		send_data(0, tft_height/2, tft_width-1, tft_height/2, tft_width, color_line);

  705. 		if (disp_deselect()) goto exit;

  706. 

  707. 		// Read color line

  708. 		ret = read_data(0, tft_height/2, tft_width-1, tft_height/2, tft_width, line_rdbuf, 0);

  709. 

  710. 		// Compare

  711. 		line_check = 0;

  712. 		if (ret == ESP_OK) {

  713. 			for (int y=0; y<tft_width; y++) {

  714. 				if ((color_line[y].r & 0xFC) != (rdline[y].r & 0xFC)) line_check = 1;

  715. 				else if ((color_line[y].g & 0xFC) != (rdline[y].g & 0xFC)) line_check = 1;

  716. 				else if ((color_line[y].b & 0xFC) != (rdline[y].b & 0xFC)) line_check =  1;

  717. 				if (line_check) break;

  718. 			}

  719. 		}

  720. 		else line_check = ret;

  721. 

  722. 		if (line_check) break;

  723. 		max_speed = speed;

  724. 	}

  725. 

  726. exit:

  727.     tft_gray_scale = gs;

  728. 	if (line_rdbuf) free(line_rdbuf);

  729. 	if (color_line) free(color_line);

  730. 

  731. 	// restore spi clk

  732. 	change_speed = spi_lobo_set_speed(tft_disp_spi, cur_speed);

  733. 

  734. 	return max_speed;

  735. }

  736. 

  737. //---------------------------------------------------------------------------

  738. // Companion code to the initialization table.

  739. // Reads and issues a series of LCD commands stored in byte array

  740. //---------------------------------------------------------------------------

  741. static void commandList(spi_lobo_device_handle_t spi, const uint8_t *addr) {

  742.   uint8_t  numCommands, numArgs, cmd;

  743.   uint16_t ms;

  744. 

  745.   numCommands = *addr++;				// Number of commands to follow

  746.   while(numCommands--) {				// For each command...

  747.     cmd = *addr++;						// save command

  748.     numArgs  = *addr++;					// Number of args to follow

  749.     ms       = numArgs & TFT_CMD_DELAY;	// If high bit set, delay follows args

  750.     numArgs &= ~TFT_CMD_DELAY;			// Mask out delay bit

  751. 

  752. 	disp_spi_transfer_cmd_data(cmd, (uint8_t *)addr, numArgs);

  753. 

  754. 	addr += numArgs;

  755. 

  756.     if(ms) {

  757.       ms = *addr++;              // Read post-command delay time (ms)

  758.       if(ms == 255) ms = 500;    // If 255, delay for 500 ms

  759. 	  vTaskDelay(ms / portTICK_RATE_MS);

  760.     }

  761.   }

  762. }

  763. 

  764. //==================================

  765. void _tft_setRotation(uint8_t rot) {

  766. 	uint8_t rotation = rot & 3; // can't be higher than 3

  767. 	uint8_t send = 1;

  768. 	uint8_t madctl = 0;

  769. 	uint16_t tmp;

  770. 

  771.     if ((rotation & 1)) {

  772.         // in landscape modes must be width > height

  773.         if (tft_width < tft_height) {

  774.             tmp = tft_width;

  775.             tft_width  = tft_height;

  776.             tft_height = tmp;

  777.         }

  778.     }

  779.     else {

  780.         // in portrait modes must be width < height

  781.         if (tft_width > tft_height) {

  782.             tmp = tft_width;

  783.             tft_width  = tft_height;

  784.             tft_height = tmp;

  785.         }

  786.     }

  787.     #if TFT_INVERT_ROTATION

  788.     switch (rotation) {

  789.         case PORTRAIT:

  790.         madctl = (MADCTL_MV | TFT_RGB_BGR);

  791.         break;

  792.         case LANDSCAPE:

  793.         madctl = (MADCTL_MX | TFT_RGB_BGR);

  794.         break;

  795.         case PORTRAIT_FLIP:

  796.         madctl = (MADCTL_MV | TFT_RGB_BGR);

  797.         break;

  798.         case LANDSCAPE_FLIP:

  799.         madctl = (MADCTL_MY | TFT_RGB_BGR);

  800.         break;

  801.     }

  802.     #elif TFT_INVERT_ROTATION1

  803.     switch (rotation) {

  804.         case PORTRAIT:

  805.         madctl = (MADCTL_MY | MADCTL_MX | TFT_RGB_BGR);

  806.         break;

  807.         case LANDSCAPE:

  808.         madctl = (MADCTL_MY | MADCTL_MV | TFT_RGB_BGR);

  809.         break;

  810.         case PORTRAIT_FLIP:

  811.         madctl = (TFT_RGB_BGR);

  812.         break;

  813.         case LANDSCAPE_FLIP:

  814.         madctl = (MADCTL_MX | MADCTL_MV | TFT_RGB_BGR);

  815.         break;

  816.     }

  817.     #elif TFT_INVERT_ROTATION2

  818.     switch (rotation) {

  819.         case PORTRAIT:

  820.         madctl = (MADCTL_MX | MADCTL_MV | TFT_RGB_BGR);

  821.         break;

  822.         case LANDSCAPE:

  823.         madctl = (TFT_RGB_BGR);

  824.         break;

  825.         case PORTRAIT_FLIP:

  826.         madctl = (MADCTL_MY | MADCTL_MV | TFT_RGB_BGR);

  827.         break;

  828.         case LANDSCAPE_FLIP:

  829.         madctl = (MADCTL_MY | MADCTL_MX | TFT_RGB_BGR);

  830.         break;

  831.     }

  832.     #else

  833.     switch (rotation) {

  834.         case PORTRAIT:

  835.         madctl = (MADCTL_MX | TFT_RGB_BGR);

  836.         break;

  837.         case LANDSCAPE:

  838.         madctl = (MADCTL_MV | TFT_RGB_BGR);

  839.         break;

  840.         case PORTRAIT_FLIP:

  841.         madctl = (MADCTL_MY | TFT_RGB_BGR);

  842.         break;

  843.         case LANDSCAPE_FLIP:

  844.         madctl = (MADCTL_MX | MADCTL_MY | MADCTL_MV | TFT_RGB_BGR);

  845.         break;

  846.     }

  847.     #endif

  848. 	if (send) {

  849. 		if (disp_select() == ESP_OK) {

  850. 			disp_spi_transfer_cmd_data(TFT_MADCTL, &madctl, 1);

  851. 			disp_deselect();

  852. 		}

  853. 	}

  854. 

  855. }

  856. 

  857. //=================

  858. void TFT_PinsInit()

  859. {

  860.     // Route all used pins to GPIO control

  861.     gpio_pad_select_gpio(PIN_NUM_CS);

  862.     gpio_pad_select_gpio(PIN_NUM_MISO);

  863.     gpio_pad_select_gpio(PIN_NUM_MOSI);

  864.     gpio_pad_select_gpio(PIN_NUM_CLK);

  865.     gpio_pad_select_gpio(PIN_NUM_DC);

  866. 

  867.     gpio_set_direction(PIN_NUM_MISO, GPIO_MODE_INPUT);

  868.     gpio_set_pull_mode(PIN_NUM_MISO, GPIO_PULLUP_ONLY);

  869.     gpio_set_direction(PIN_NUM_CS, GPIO_MODE_OUTPUT);

  870.     gpio_set_direction(PIN_NUM_MOSI, GPIO_MODE_OUTPUT);

  871.     gpio_set_direction(PIN_NUM_CLK, GPIO_MODE_OUTPUT);

  872.     gpio_set_direction(PIN_NUM_DC, GPIO_MODE_OUTPUT);

  873.     gpio_set_level(PIN_NUM_DC, 0);

  874. #if USE_TOUCH

  875.     gpio_pad_select_gpio(PIN_NUM_TCS);

  876.     gpio_set_direction(PIN_NUM_TCS, GPIO_MODE_OUTPUT);

  877. #endif

  878. #if PIN_NUM_BCKL

  879.     gpio_pad_select_gpio(PIN_NUM_BCKL);

  880.     gpio_set_direction(PIN_NUM_BCKL, GPIO_MODE_OUTPUT);

  881.     gpio_set_level(PIN_NUM_BCKL, PIN_BCKL_OFF);

  882. #endif

  883. 

  884. #if PIN_NUM_RST

  885.     gpio_pad_select_gpio(PIN_NUM_RST);

  886.     gpio_set_direction(PIN_NUM_RST, GPIO_MODE_OUTPUT);

  887.     gpio_set_level(PIN_NUM_RST, 0);

  888. #endif

  889. }

  890. 

  891. // Initialize the display

  892. // ====================

  893. void TFT_display_init()

  894. {

  895.     esp_err_t ret;

  896. 

  897. #if PIN_NUM_RST

  898.     //Reset the display

  899.     gpio_set_level(PIN_NUM_RST, 0);

  900.     vTaskDelay(20 / portTICK_RATE_MS);

  901.     gpio_set_level(PIN_NUM_RST, 1);

  902.     vTaskDelay(150 / portTICK_RATE_MS);

  903. #endif

  904. 

  905.     ret = disp_select();

  906.     assert(ret==ESP_OK);

  907.     //Send all the initialization commands

  908. 	if (tft_disp_type == DISP_TYPE_ILI9341) {

  909. 		commandList(tft_disp_spi, ILI9341_init);

  910. 	}

  911. 	else if (tft_disp_type == DISP_TYPE_ILI9488) {

  912. 		commandList(tft_disp_spi, ILI9488_init);

  913. 	}

  914. 	else if (tft_disp_type == DISP_TYPE_ST7789V) {

  915. 		commandList(tft_disp_spi, ST7789V_init);

  916. 	}

  917. 	else if (tft_disp_type == DISP_TYPE_ST7735) {

  918. 		commandList(tft_disp_spi, STP7735_init);

  919. 	}

  920. 	else if (tft_disp_type == DISP_TYPE_ST7735R) {

  921. 		commandList(tft_disp_spi, STP7735R_init);

  922. 		commandList(tft_disp_spi, Rcmd2green);

  923. 		commandList(tft_disp_spi, Rcmd3);

  924. 	}

  925. 	else if (tft_disp_type == DISP_TYPE_ST7735B) {

  926. 		commandList(tft_disp_spi, STP7735R_init);

  927. 		commandList(tft_disp_spi, Rcmd2red);

  928. 		commandList(tft_disp_spi, Rcmd3);

  929. 	    uint8_t dt = 0xC0;

  930. 		disp_spi_transfer_cmd_data(TFT_MADCTL, &dt, 1);

  931. 	}

  932. 	else assert(0);

  933. 

  934.     ret = disp_deselect();

  935. 	assert(ret==ESP_OK);

  936. 

  937. 	// Clear screen

  938.     _tft_setRotation(PORTRAIT);

  939. 	TFT_pushColorRep(TFT_STATIC_WIDTH_OFFSET, TFT_STATIC_HEIGHT_OFFSET, tft_width + TFT_STATIC_WIDTH_OFFSET -1, tft_height + TFT_STATIC_HEIGHT_OFFSET -1, (color_t){0,0,0}, (uint32_t)(tft_height*tft_width));

  940. 

  941. 	///Enable backlight

  942. #if PIN_NUM_BCKL

  943.     gpio_set_level(PIN_NUM_BCKL, PIN_BCKL_ON);

  944. #endif

  945. }

  946.