21ic电子技术开发论坛 › 单片机与嵌入式系统 › ST MCU › 【NUCLEO-U5A5ZJ-Q测评】硬件SPI驱动LCD屏
返回列表 发新帖我要提问

[STM32U5] 【NUCLEO-U5A5ZJ-Q测评】硬件SPI驱动LCD屏

[复制链接]
 楼主| lulugl 发表于 2023-11-12 21:28 | 显示全部楼层 |阅读模式
<
stm32u5a5i, CD, LCD, NUC, Nucleo, lcd屏
#申请原创# @21小跑堂
【目的】单片机的交互信息，通常是用uart输入串口信息，作为STM32U5A5，他的运行频率为160MHz，而且接口信息丰富，可以用LCD屏来做为输出信息，这样比较直观，再也不用开串口助手来观察了。本文就驱动LCD屏来做为此款开发板试用的第一篇。
【实验的硬件】
  • NUCLEO-U5A5ZJ开发板。

b02a4bf5b30572cd99734670954fbdc3
2、3.5寸SPI串口TFT液晶显示模块LCD触摸屏ILI9488 /6 /1驱动320X480
7d84d0970e66fbbc34914a94f7c50de2
【实验的开发环境】
  • 操作系统：win11。
  • 开发IDE工具：STM32CubeIDE，版本为1.13.2:

99500668123a791b2c8458c63f6348a8
【开发步骤】
1、新建NUCLEO-U5A5ZJ开发板工程，这样开发板可以默认的给我们配轩好了串口、LED等常用的外设。
c8c3b5c5a2df4a7522f84e2ee82b60ef
2、打开spi1，配置spi1的IO为MOSI为PA7，SCK为PA5。
0c8b588440d0d60cbed681a39e39dbac
3、配置开发板上的PF2、PD14、PD15为TFT_DC、TFT_CS、TFT_RST，如下图：
9e3a33af6d0fe8b2d1ffbb917148f29d
4、配置三个IO为上拉，输入为High，如下图所示：
998879095204d5af38e7446488080a6b
5、设置spi为单向发送，传输数据为8bit，分频为4，工作频为40M，同时NSS为软摸拟。
63e520561cbeabf55bc81150aa1474f1
6、配置时钟为160MHz，这样spi的时钟可以达到160M。
a852dc54b8a377d1131ede91d35bbfd4
7、因为ili9488要开启大的空间进行数据传输，所以把栈堆的空间调大一些。
f37e0fbdc5162175f241e89a1b58985b
随后按alt+k生成工程。
【代码】
添加ili9488.h，添加代码如下：
复制
  1. /*
    

  2.  * ili9488.h
    

  3.  *
    

  4.  *  Created on: Dec 14, 2021
    

  5.  *      Author: timagr615
    

  6.  */
    


  7. 

  8. #ifndef INC_ILI9488_H_
    

  9. #define INC_ILI9488_H_
    


  10. 

  11. #include <math.h>
    

  12. #include <stdbool.h>
    


  13. 

  14. #include "main.h"
    

  15. #include <stdlib.h>
    

  16. #include <stdio.h>
    

  17. #include <string.h>
    


  18. 

  19. #define RST_A() HAL_GPIO_WritePin(TFT_RST_GPIO_Port,TFT_RST_Pin,GPIO_PIN_RESET)
    

  20. #define RST_D() HAL_GPIO_WritePin(TFT_RST_GPIO_Port,TFT_RST_Pin,GPIO_PIN_SET)
    

  21. #define CS_A() HAL_GPIO_WritePin(TFT_CS_GPIO_Port,TFT_CS_Pin,GPIO_PIN_RESET)
    

  22. #define CS_D() HAL_GPIO_WritePin(TFT_CS_GPIO_Port,TFT_CS_Pin,GPIO_PIN_SET)
    

  23. #define DC_COMMAND() HAL_GPIO_WritePin(TFT_DC_GPIO_Port,TFT_DC_Pin,GPIO_PIN_RESET)
    

  24. #define DC_DATA() HAL_GPIO_WritePin(TFT_DC_GPIO_Port,TFT_DC_Pin,GPIO_PIN_SET)
    


  25. 

  26. #define ILI9488_TFTWIDTH  320
    

  27. #define ILI9488_TFTHEIGHT 480
    

  28. #define ILI9488_PIXEL_COUNT        ILI9488_TFTWIDTH * ILI9488_TFTHEIGHT
    


  29. 

  30. #define ILI9488_NOP     0x00
    

  31. #define ILI9488_SWRESET 0x01
    

  32. #define ILI9488_RDDID   0x04
    

  33. #define ILI9488_RDDST   0x09
    


  34. 

  35. #define ILI9488_SLPIN   0x10
    

  36. #define ILI9488_SLPOUT  0x11
    

  37. #define ILI9488_PTLON   0x12
    

  38. #define ILI9488_NORON   0x13
    


  39. 

  40. #define ILI9488_RDMODE  0x0A
    

  41. #define ILI9488_RDMADCTL  0x0B
    

  42. #define ILI9488_RDPIXFMT  0x0C
    

  43. #define ILI9488_RDIMGFMT  0x0D
    

  44. #define ILI9488_RDSELFDIAG  0x0F
    


  45. 

  46. #define ILI9488_INVOFF  0x20
    

  47. #define ILI9488_INVON   0x21
    

  48. #define ILI9488_GAMMASET 0x26
    

  49. #define ILI9488_DISPOFF 0x28
    

  50. #define ILI9488_DISPON  0x29
    


  51. 

  52. #define ILI9488_CASET   0x2A
    

  53. #define ILI9488_PASET   0x2B
    

  54. #define ILI9488_RAMWR   0x2C
    

  55. #define ILI9488_RAMRD   0x2E
    


  56. 

  57. #define ILI9488_PTLAR   0x30
    

  58. #define ILI9488_MADCTL  0x36
    

  59. #define ILI9488_PIXFMT  0x3A
    


  60. 

  61. #define ILI9488_FRMCTR1 0xB1
    

  62. #define ILI9488_FRMCTR2 0xB2
    

  63. #define ILI9488_FRMCTR3 0xB3
    

  64. #define ILI9488_INVCTR  0xB4
    

  65. #define ILI9488_DFUNCTR 0xB6
    


  66. 

  67. #define ILI9488_PWCTR1  0xC0
    

  68. #define ILI9488_PWCTR2  0xC1
    

  69. #define ILI9488_PWCTR3  0xC2
    

  70. #define ILI9488_PWCTR4  0xC3
    

  71. #define ILI9488_PWCTR5  0xC4
    

  72. #define ILI9488_VMCTR1  0xC5
    

  73. #define ILI9488_VMCTR2  0xC7
    


  74. 

  75. #define ILI9488_RDID1   0xDA
    

  76. #define ILI9488_RDID2   0xDB
    

  77. #define ILI9488_RDID3   0xDC
    

  78. #define ILI9488_RDID4   0xDD
    


  79. 

  80. #define ILI9488_GMCTRP1 0xE0
    

  81. #define ILI9488_GMCTRN1 0xE1
    

  82. /*
    

  83. #define ILI9488_PWCTR6  0xFC
    

  84. */
    


  85. 

  86. // Color definitions
    

  87. #define ILI9488_BLACK                              0x0000      /*   0,   0,   0 */
    

  88. #define ILI9488_NAVY                                0x000F      /*   0,   0, 128 */
    

  89. #define ILI9488_DARKGREEN                   0x03E0      /*   0, 128,   0 */
    

  90. #define ILI9488_DARKCYAN                    0x03EF      /*   0, 128, 128 */
    

  91. #define ILI9488_MAROON                      0x7800      /* 128,   0,   0 */
    

  92. #define ILI9488_PURPLE                      0x780F      /* 128,   0, 128 */
    

  93. #define ILI9488_OLIVE                               0x7BE0      /* 128, 128,   0 */
    

  94. #define ILI9488_LIGHTGREY                   0xC618      /* 192, 192, 192 */
    

  95. #define ILI9488_DARKGREY                    0x7BEF      /* 128, 128, 128 */
    

  96. #define ILI9488_BLUE                                0x001F      /*   0,   0, 255 */
    

  97. #define ILI9488_GREEN                       0x07E0      /*   0, 255,   0 */
    

  98. #define ILI9488_CYAN                                0x07FF      /*   0, 255, 255 */
    

  99. #define ILI9488_RED                                 0xF800      /* 255,   0,   0 */
    

  100. #define ILI9488_MAGENTA                     0xF81F      /* 255,   0, 255 */
    

  101. #define ILI9488_YELLOW                      0xFFE0      /* 255, 255,   0 */
    

  102. #define ILI9488_WHITE                               0xFFFF      /* 255, 255, 255 */
    

  103. #define ILI9488_ORANGE                      0xFD20      /* 255, 165,   0 */
    

  104. #define ILI9488_GREENYELLOW         0xAFE5      /* 173, 255,  47 */
    

  105. #define ILI9488_PINK                                0xF81F
    


  106. 

  107. #define        TFT9341_BLACK   0x0000
    

  108. #define        TFT9341_BLUE    0x001F
    

  109. #define        TFT9341_RED     0xF800
    

  110. #define        TFT9341_GREEN   0x07E0
    

  111. #define TFT9341_CYAN    0x07FF
    

  112. #define TFT9341_MAGENTA 0xF81F
    

  113. #define TFT9341_YELLOW  0xFFE0
    

  114. #define TFT9341_WHITE   0xFFFF
    

  115. #define MADCTL_MY  0x80
    

  116. #define MADCTL_MX  0x40
    

  117. #define MADCTL_MV  0x20
    

  118. #define MADCTL_ML  0x10
    

  119. #define MADCTL_RGB 0x00
    

  120. #define MADCTL_BGR 0x08
    

  121. #define MADCTL_MH  0x04
    


  122. 


  123. 

  124. #define swap(a, b) { int16_t t = a; a = b; b = t; }
    

  125. #define pgm_read_byte(addr) (*(const unsigned char *)(addr))
    

  126. #define min(a,b) (((a)<(b))?(a):(b))
    


  127. 

  128. //***** Functions prototypes *****//
    

  129. //1. Write Command to LCD
    

  130. void ILI9341_SendCommand(uint8_t com);
    

  131. //2. Write data to LCD
    

  132. void ILI9341_SendData(uint8_t data);
    

  133. //2.2 Write multiple/DMA
    

  134. void ILI9488_SendData_Multi(uint8_t *buff, size_t buff_size);
    


  135. 

  136. //void ILI9488_Init(SPI_HandleTypeDef *spiLcdHandle, GPIO_TypeDef *csPORT, uint16_t csPIN, GPIO_TypeDef *dcPORT, uint16_t dcPIN, GPIO_TypeDef *resetPORT, uint16_t resetPIN);
    

  137. void ILI9488_Init();
    

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

  139. void setScrollArea(uint16_t topFixedArea, uint16_t bottomFixedArea);
    

  140. void scroll(uint16_t pixels);
    

  141. void pushColor(uint16_t color);
    

  142. void pushColors(uint16_t *data, uint8_t len, uint8_t first);
    

  143. void drawImage(const uint8_t* img, uint16_t x, uint16_t y, uint16_t w, uint16_t h);
    

  144. void fillScreen(uint16_t color);
    


  145. 

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

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

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

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

  150. void writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1,uint16_t color);
    

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


  152. 


  153. 

  154. void setRotation(uint8_t r);
    

  155. void invertDisplay(uint8_t  i);
    

  156. uint16_t color565(uint8_t r, uint8_t g, uint8_t b);
    

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

  158. void ILI9488_printText(char text[], int16_t x, int16_t y, uint16_t color, uint16_t bg, uint8_t size);
    


  159. 

  160. void write16BitColor(uint16_t color);
    


  161. 

  162. void testLines(uint8_t color);
    


  163. 


  164. 


  165. 

  166. #endif /* INC_ILI9488_H_ */
    


  167.
2、添加ili9488.c代码如下：
复制
  1. /*
    

  2.  * ili9488.c
    

  3.  *
    

  4.  *  Created on: Nov 12, 2023
    

  5.  *      Author: liujianhua
    

  6.  */
    


  7. 

  8. #include "ili9488.h"
    

  9. #include "FONT.H"
    

  10. extern SPI_HandleTypeDef hspi1;
    

  11. extern UART_HandleTypeDef huart1;
    


  12. 

  13. static uint8_t rotationNum=1;
    

  14. static bool _cp437    = false;
    

  15. static SPI_HandleTypeDef lcdSPIhandle;
    

  16. //Chip Select pin
    

  17. static GPIO_TypeDef  *tftCS_GPIO;
    

  18. static uint16_t tftCS_PIN;
    

  19. //Data Command pin
    

  20. static GPIO_TypeDef  *tftDC_GPIO;
    

  21. static uint16_t tftDC_PIN;
    

  22. //Reset pin
    

  23. static GPIO_TypeDef  *tftRESET_GPIO;
    

  24. static uint16_t tftRESET_PIN;
    

  25. //uint8_t frm_buf[65536] = {0};
    

  26. uint16_t width;
    

  27. uint16_t height;
    


  28. 

  29. static //Text simple font array (You can your own font)
    

  30. const unsigned char font1[] = {
    

  31.         0x00, 0x00, 0x00, 0x00, 0x00,
    

  32.         0x3E, 0x5B, 0x4F, 0x5B, 0x3E,
    

  33.         0x3E, 0x6B, 0x4F, 0x6B, 0x3E,
    

  34.         0x1C, 0x3E, 0x7C, 0x3E, 0x1C,
    

  35.         0x18, 0x3C, 0x7E, 0x3C, 0x18,
    

  36.         0x1C, 0x57, 0x7D, 0x57, 0x1C,
    

  37.         0x1C, 0x5E, 0x7F, 0x5E, 0x1C,
    

  38.         0x00, 0x18, 0x3C, 0x18, 0x00,
    

  39.         0xFF, 0xE7, 0xC3, 0xE7, 0xFF,
    

  40.         0x00, 0x18, 0x24, 0x18, 0x00,
    

  41.         0xFF, 0xE7, 0xDB, 0xE7, 0xFF,
    

  42.         0x30, 0x48, 0x3A, 0x06, 0x0E,
    

  43.         0x26, 0x29, 0x79, 0x29, 0x26,
    

  44.         0x40, 0x7F, 0x05, 0x05, 0x07,
    

  45.         0x40, 0x7F, 0x05, 0x25, 0x3F,
    

  46.         0x5A, 0x3C, 0xE7, 0x3C, 0x5A,
    

  47.         0x7F, 0x3E, 0x1C, 0x1C, 0x08,
    

  48.         0x08, 0x1C, 0x1C, 0x3E, 0x7F,
    

  49.         0x14, 0x22, 0x7F, 0x22, 0x14,
    

  50.         0x5F, 0x5F, 0x00, 0x5F, 0x5F,
    

  51.         0x06, 0x09, 0x7F, 0x01, 0x7F,
    

  52.         0x00, 0x66, 0x89, 0x95, 0x6A,
    

  53.         0x60, 0x60, 0x60, 0x60, 0x60,
    

  54.         0x94, 0xA2, 0xFF, 0xA2, 0x94,
    

  55.         0x08, 0x04, 0x7E, 0x04, 0x08,
    

  56.         0x10, 0x20, 0x7E, 0x20, 0x10,
    

  57.         0x08, 0x08, 0x2A, 0x1C, 0x08,
    

  58.         0x08, 0x1C, 0x2A, 0x08, 0x08,
    

  59.         0x1E, 0x10, 0x10, 0x10, 0x10,
    

  60.         0x0C, 0x1E, 0x0C, 0x1E, 0x0C,
    

  61.         0x30, 0x38, 0x3E, 0x38, 0x30,
    

  62.         0x06, 0x0E, 0x3E, 0x0E, 0x06,
    

  63.         0x00, 0x00, 0x00, 0x00, 0x00,
    

  64.         0x00, 0x00, 0x5F, 0x00, 0x00,
    

  65.         0x00, 0x07, 0x00, 0x07, 0x00,
    

  66.         0x14, 0x7F, 0x14, 0x7F, 0x14,
    

  67.         0x24, 0x2A, 0x7F, 0x2A, 0x12,
    

  68.         0x23, 0x13, 0x08, 0x64, 0x62,
    

  69.         0x36, 0x49, 0x56, 0x20, 0x50,
    

  70.         0x00, 0x08, 0x07, 0x03, 0x00,
    

  71.         0x00, 0x1C, 0x22, 0x41, 0x00,
    

  72.         0x00, 0x41, 0x22, 0x1C, 0x00,
    

  73.         0x2A, 0x1C, 0x7F, 0x1C, 0x2A,
    

  74.         0x08, 0x08, 0x3E, 0x08, 0x08,
    

  75.         0x00, 0x80, 0x70, 0x30, 0x00,
    

  76.         0x08, 0x08, 0x08, 0x08, 0x08,
    

  77.         0x00, 0x00, 0x60, 0x60, 0x00,
    

  78.         0x20, 0x10, 0x08, 0x04, 0x02,
    

  79.         0x3E, 0x51, 0x49, 0x45, 0x3E,
    

  80.         0x00, 0x42, 0x7F, 0x40, 0x00,
    

  81.         0x72, 0x49, 0x49, 0x49, 0x46,
    

  82.         0x21, 0x41, 0x49, 0x4D, 0x33,
    

  83.         0x18, 0x14, 0x12, 0x7F, 0x10,
    

  84.         0x27, 0x45, 0x45, 0x45, 0x39,
    

  85.         0x3C, 0x4A, 0x49, 0x49, 0x31,
    

  86.         0x41, 0x21, 0x11, 0x09, 0x07,
    

  87.         0x36, 0x49, 0x49, 0x49, 0x36,
    

  88.         0x46, 0x49, 0x49, 0x29, 0x1E,
    

  89.         0x00, 0x00, 0x14, 0x00, 0x00,
    

  90.         0x00, 0x40, 0x34, 0x00, 0x00,
    

  91.         0x00, 0x08, 0x14, 0x22, 0x41,
    

  92.         0x14, 0x14, 0x14, 0x14, 0x14,
    

  93.         0x00, 0x41, 0x22, 0x14, 0x08,
    

  94.         0x02, 0x01, 0x59, 0x09, 0x06,
    

  95.         0x3E, 0x41, 0x5D, 0x59, 0x4E,
    

  96.         0x7C, 0x12, 0x11, 0x12, 0x7C,
    

  97.         0x7F, 0x49, 0x49, 0x49, 0x36,
    

  98.         0x3E, 0x41, 0x41, 0x41, 0x22,
    

  99.         0x7F, 0x41, 0x41, 0x41, 0x3E,
    

  100.         0x7F, 0x49, 0x49, 0x49, 0x41,
    

  101.         0x7F, 0x09, 0x09, 0x09, 0x01,
    

  102.         0x3E, 0x41, 0x41, 0x51, 0x73,
    

  103.         0x7F, 0x08, 0x08, 0x08, 0x7F,
    

  104.         0x00, 0x41, 0x7F, 0x41, 0x00,
    

  105.         0x20, 0x40, 0x41, 0x3F, 0x01,
    

  106.         0x7F, 0x08, 0x14, 0x22, 0x41,
    

  107.         0x7F, 0x40, 0x40, 0x40, 0x40,
    

  108.         0x7F, 0x02, 0x1C, 0x02, 0x7F,
    

  109.         0x7F, 0x04, 0x08, 0x10, 0x7F,
    

  110.         0x3E, 0x41, 0x41, 0x41, 0x3E,
    

  111.         0x7F, 0x09, 0x09, 0x09, 0x06,
    

  112.         0x3E, 0x41, 0x51, 0x21, 0x5E,
    

  113.         0x7F, 0x09, 0x19, 0x29, 0x46,
    

  114.         0x26, 0x49, 0x49, 0x49, 0x32,
    

  115.         0x03, 0x01, 0x7F, 0x01, 0x03,
    

  116.         0x3F, 0x40, 0x40, 0x40, 0x3F,
    

  117.         0x1F, 0x20, 0x40, 0x20, 0x1F,
    

  118.         0x3F, 0x40, 0x38, 0x40, 0x3F,
    

  119.         0x63, 0x14, 0x08, 0x14, 0x63,
    

  120.         0x03, 0x04, 0x78, 0x04, 0x03,
    

  121.         0x61, 0x59, 0x49, 0x4D, 0x43,
    

  122.         0x00, 0x7F, 0x41, 0x41, 0x41,
    

  123.         0x02, 0x04, 0x08, 0x10, 0x20,
    

  124.         0x00, 0x41, 0x41, 0x41, 0x7F,
    

  125.         0x04, 0x02, 0x01, 0x02, 0x04,
    

  126.         0x40, 0x40, 0x40, 0x40, 0x40,
    

  127.         0x00, 0x03, 0x07, 0x08, 0x00,
    

  128.         0x20, 0x54, 0x54, 0x78, 0x40,
    

  129.         0x7F, 0x28, 0x44, 0x44, 0x38,
    

  130.         0x38, 0x44, 0x44, 0x44, 0x28,
    

  131.         0x38, 0x44, 0x44, 0x28, 0x7F,
    

  132.         0x38, 0x54, 0x54, 0x54, 0x18,
    

  133.         0x00, 0x08, 0x7E, 0x09, 0x02,
    

  134.         0x18, 0xA4, 0xA4, 0x9C, 0x78,
    

  135.         0x7F, 0x08, 0x04, 0x04, 0x78,
    

  136.         0x00, 0x44, 0x7D, 0x40, 0x00,
    

  137.         0x20, 0x40, 0x40, 0x3D, 0x00,
    

  138.         0x7F, 0x10, 0x28, 0x44, 0x00,
    

  139.         0x00, 0x41, 0x7F, 0x40, 0x00,
    

  140.         0x7C, 0x04, 0x78, 0x04, 0x78,
    

  141.         0x7C, 0x08, 0x04, 0x04, 0x78,
    

  142.         0x38, 0x44, 0x44, 0x44, 0x38,
    

  143.         0xFC, 0x18, 0x24, 0x24, 0x18,
    

  144.         0x18, 0x24, 0x24, 0x18, 0xFC,
    

  145.         0x7C, 0x08, 0x04, 0x04, 0x08,
    

  146.         0x48, 0x54, 0x54, 0x54, 0x24,
    

  147.         0x04, 0x04, 0x3F, 0x44, 0x24,
    

  148.         0x3C, 0x40, 0x40, 0x20, 0x7C,
    

  149.         0x1C, 0x20, 0x40, 0x20, 0x1C,
    

  150.         0x3C, 0x40, 0x30, 0x40, 0x3C,
    

  151.         0x44, 0x28, 0x10, 0x28, 0x44,
    

  152.         0x4C, 0x90, 0x90, 0x90, 0x7C,
    

  153.         0x44, 0x64, 0x54, 0x4C, 0x44,
    

  154.         0x00, 0x08, 0x36, 0x41, 0x00,
    

  155.         0x00, 0x00, 0x77, 0x00, 0x00,
    

  156.         0x00, 0x41, 0x36, 0x08, 0x00,
    

  157.         0x02, 0x01, 0x02, 0x04, 0x02,
    

  158.         0x3C, 0x26, 0x23, 0x26, 0x3C,
    

  159.         0x1E, 0xA1, 0xA1, 0x61, 0x12,
    

  160.         0x3A, 0x40, 0x40, 0x20, 0x7A,
    

  161.         0x38, 0x54, 0x54, 0x55, 0x59,
    

  162.         0x21, 0x55, 0x55, 0x79, 0x41,
    

  163.         0x22, 0x54, 0x54, 0x78, 0x42,
    

  164.         0x21, 0x55, 0x54, 0x78, 0x40,
    

  165.         0x20, 0x54, 0x55, 0x79, 0x40,
    

  166.         0x0C, 0x1E, 0x52, 0x72, 0x12,
    

  167.         0x39, 0x55, 0x55, 0x55, 0x59,
    

  168.         0x39, 0x54, 0x54, 0x54, 0x59,
    

  169.         0x39, 0x55, 0x54, 0x54, 0x58,
    

  170.         0x00, 0x00, 0x45, 0x7C, 0x41,
    

  171.         0x00, 0x02, 0x45, 0x7D, 0x42,
    

  172.         0x00, 0x01, 0x45, 0x7C, 0x40,
    

  173.         0x7D, 0x12, 0x11, 0x12, 0x7D,
    

  174.         0xF0, 0x28, 0x25, 0x28, 0xF0,
    

  175.         0x7C, 0x54, 0x55, 0x45, 0x00,
    

  176.         0x20, 0x54, 0x54, 0x7C, 0x54,
    

  177.         0x7C, 0x0A, 0x09, 0x7F, 0x49,
    

  178.         0x32, 0x49, 0x49, 0x49, 0x32,
    

  179.         0x3A, 0x44, 0x44, 0x44, 0x3A,
    

  180.         0x32, 0x4A, 0x48, 0x48, 0x30,
    

  181.         0x3A, 0x41, 0x41, 0x21, 0x7A,
    

  182.         0x3A, 0x42, 0x40, 0x20, 0x78,
    

  183.         0x00, 0x9D, 0xA0, 0xA0, 0x7D,
    

  184.         0x3D, 0x42, 0x42, 0x42, 0x3D,
    

  185.         0x3D, 0x40, 0x40, 0x40, 0x3D,
    

  186.         0x3C, 0x24, 0xFF, 0x24, 0x24,
    

  187.         0x48, 0x7E, 0x49, 0x43, 0x66,
    

  188.         0x2B, 0x2F, 0xFC, 0x2F, 0x2B,
    

  189.         0xFF, 0x09, 0x29, 0xF6, 0x20,
    

  190.         0xC0, 0x88, 0x7E, 0x09, 0x03,
    

  191.         0x20, 0x54, 0x54, 0x79, 0x41,
    

  192.         0x00, 0x00, 0x44, 0x7D, 0x41,
    

  193.         0x30, 0x48, 0x48, 0x4A, 0x32,
    

  194.         0x38, 0x40, 0x40, 0x22, 0x7A,
    

  195.         0x00, 0x7A, 0x0A, 0x0A, 0x72,
    

  196.         0x7D, 0x0D, 0x19, 0x31, 0x7D,
    

  197.         0x26, 0x29, 0x29, 0x2F, 0x28,
    

  198.         0x26, 0x29, 0x29, 0x29, 0x26,
    

  199.         0x30, 0x48, 0x4D, 0x40, 0x20,
    

  200.         0x38, 0x08, 0x08, 0x08, 0x08,
    

  201.         0x08, 0x08, 0x08, 0x08, 0x38,
    

  202.         0x2F, 0x10, 0xC8, 0xAC, 0xBA,
    

  203.         0x2F, 0x10, 0x28, 0x34, 0xFA,
    

  204.         0x00, 0x00, 0x7B, 0x00, 0x00,
    

  205.         0x08, 0x14, 0x2A, 0x14, 0x22,
    

  206.         0x22, 0x14, 0x2A, 0x14, 0x08,
    

  207.         0x55, 0x00, 0x55, 0x00, 0x55,
    

  208.         0xAA, 0x55, 0xAA, 0x55, 0xAA,
    

  209.         0xFF, 0x55, 0xFF, 0x55, 0xFF,
    

  210.         0x00, 0x00, 0x00, 0xFF, 0x00,
    

  211.         0x10, 0x10, 0x10, 0xFF, 0x00,
    

  212.         0x14, 0x14, 0x14, 0xFF, 0x00,
    

  213.         0x10, 0x10, 0xFF, 0x00, 0xFF,
    

  214.         0x10, 0x10, 0xF0, 0x10, 0xF0,
    

  215.         0x14, 0x14, 0x14, 0xFC, 0x00,
    

  216.         0x14, 0x14, 0xF7, 0x00, 0xFF,
    

  217.         0x00, 0x00, 0xFF, 0x00, 0xFF,
    

  218.         0x14, 0x14, 0xF4, 0x04, 0xFC,
    

  219.         0x14, 0x14, 0x17, 0x10, 0x1F,
    

  220.         0x10, 0x10, 0x1F, 0x10, 0x1F,
    

  221.         0x14, 0x14, 0x14, 0x1F, 0x00,
    

  222.         0x10, 0x10, 0x10, 0xF0, 0x00,
    

  223.         0x00, 0x00, 0x00, 0x1F, 0x10,
    

  224.         0x10, 0x10, 0x10, 0x1F, 0x10,
    

  225.         0x10, 0x10, 0x10, 0xF0, 0x10,
    

  226.         0x00, 0x00, 0x00, 0xFF, 0x10,
    

  227.         0x10, 0x10, 0x10, 0x10, 0x10,
    

  228.         0x10, 0x10, 0x10, 0xFF, 0x10,
    

  229.         0x00, 0x00, 0x00, 0xFF, 0x14,
    

  230.         0x00, 0x00, 0xFF, 0x00, 0xFF,
    

  231.         0x00, 0x00, 0x1F, 0x10, 0x17,
    

  232.         0x00, 0x00, 0xFC, 0x04, 0xF4,
    

  233.         0x14, 0x14, 0x17, 0x10, 0x17,
    

  234.         0x14, 0x14, 0xF4, 0x04, 0xF4,
    

  235.         0x00, 0x00, 0xFF, 0x00, 0xF7,
    

  236.         0x14, 0x14, 0x14, 0x14, 0x14,
    

  237.         0x14, 0x14, 0xF7, 0x00, 0xF7,
    

  238.         0x14, 0x14, 0x14, 0x17, 0x14,
    

  239.         0x10, 0x10, 0x1F, 0x10, 0x1F,
    

  240.         0x14, 0x14, 0x14, 0xF4, 0x14,
    

  241.         0x10, 0x10, 0xF0, 0x10, 0xF0,
    

  242.         0x00, 0x00, 0x1F, 0x10, 0x1F,
    

  243.         0x00, 0x00, 0x00, 0x1F, 0x14,
    

  244.         0x00, 0x00, 0x00, 0xFC, 0x14,
    

  245.         0x00, 0x00, 0xF0, 0x10, 0xF0,
    

  246.         0x10, 0x10, 0xFF, 0x10, 0xFF,
    

  247.         0x14, 0x14, 0x14, 0xFF, 0x14,
    

  248.         0x10, 0x10, 0x10, 0x1F, 0x00,
    

  249.         0x00, 0x00, 0x00, 0xF0, 0x10,
    

  250.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    

  251.         0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
    

  252.         0xFF, 0xFF, 0xFF, 0x00, 0x00,
    

  253.         0x00, 0x00, 0x00, 0xFF, 0xFF,
    

  254.         0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
    

  255.         0x38, 0x44, 0x44, 0x38, 0x44,
    

  256.         0xFC, 0x4A, 0x4A, 0x4A, 0x34,
    

  257.         0x7E, 0x02, 0x02, 0x06, 0x06,
    

  258.         0x02, 0x7E, 0x02, 0x7E, 0x02,
    

  259.         0x63, 0x55, 0x49, 0x41, 0x63,
    

  260.         0x38, 0x44, 0x44, 0x3C, 0x04,
    

  261.         0x40, 0x7E, 0x20, 0x1E, 0x20,
    

  262.         0x06, 0x02, 0x7E, 0x02, 0x02,
    

  263.         0x99, 0xA5, 0xE7, 0xA5, 0x99,
    

  264.         0x1C, 0x2A, 0x49, 0x2A, 0x1C,
    

  265.         0x4C, 0x72, 0x01, 0x72, 0x4C,
    

  266.         0x30, 0x4A, 0x4D, 0x4D, 0x30,
    

  267.         0x30, 0x48, 0x78, 0x48, 0x30,
    

  268.         0xBC, 0x62, 0x5A, 0x46, 0x3D,
    

  269.         0x3E, 0x49, 0x49, 0x49, 0x00,
    

  270.         0x7E, 0x01, 0x01, 0x01, 0x7E,
    

  271.         0x2A, 0x2A, 0x2A, 0x2A, 0x2A,
    

  272.         0x44, 0x44, 0x5F, 0x44, 0x44,
    

  273.         0x40, 0x51, 0x4A, 0x44, 0x40,
    

  274.         0x40, 0x44, 0x4A, 0x51, 0x40,
    

  275.         0x00, 0x00, 0xFF, 0x01, 0x03,
    

  276.         0xE0, 0x80, 0xFF, 0x00, 0x00,
    

  277.         0x08, 0x08, 0x6B, 0x6B, 0x08,
    

  278.         0x36, 0x12, 0x36, 0x24, 0x36,
    

  279.         0x06, 0x0F, 0x09, 0x0F, 0x06,
    

  280.         0x00, 0x00, 0x18, 0x18, 0x00,
    

  281.         0x00, 0x00, 0x10, 0x10, 0x00,
    

  282.         0x30, 0x40, 0xFF, 0x01, 0x01,
    

  283.         0x00, 0x1F, 0x01, 0x01, 0x1E,
    

  284.         0x00, 0x19, 0x1D, 0x17, 0x12,
    

  285.         0x00, 0x3C, 0x3C, 0x3C, 0x3C,
    

  286.         0x00, 0x00, 0x00, 0x00, 0x00
    

  287. };
    

  288. //***** Functions prototypes *****//
    


  289. 


  290. 

  291. //1. Write Command to LCD
    

  292. void ILI9488_SendCommand(uint8_t com)
    

  293. {
    

  294.         //*(__IO uint8_t *)(0x60000000) = com;
    

  295.         uint8_t tmpCmd = com;
    


  296. 

  297.         DC_COMMAND();
    


  298. 

  299.         CS_A();
    

  300.         //Write byte using SPI
    

  301.         HAL_SPI_Transmit(&hspi1, &tmpCmd, 1, 1);
    


  302. 

  303.         CS_D();
    


  304. 

  305. }
    


  306. 

  307. //2. Write data to LCD
    

  308. void ILI9488_SendData(uint8_t data)
    

  309. {
    

  310.         uint8_t tmpCmd = data;
    

  311.         DC_DATA();
    

  312.         CS_A();
    

  313.         HAL_SPI_Transmit(&hspi1, &tmpCmd, 1, 1);
    

  314.         CS_D();
    


  315. 

  316. }
    

  317. //2.2 Write multiple/DMA
    

  318. void ILI9488_SendData_Multi(uint8_t *buff, size_t buff_size){
    

  319.         DC_DATA();
    

  320.         CS_A();
    

  321.         while (buff_size > 0){
    

  322.                 uint16_t chunk_size = buff_size > 32768 ? 32768 : buff_size;
    

  323.                 HAL_SPI_Transmit(&hspi1, buff, chunk_size, HAL_MAX_DELAY);
    

  324.                 buff += chunk_size;
    

  325.                 buff_size -= chunk_size;
    

  326.         }
    

  327.         CS_D();
    

  328. }
    


  329. 


  330. 

  331. void ILI9488_Init()
    

  332. {
    


  333. 

  334.         CS_D();
    

  335.         RST_A();
    

  336.         HAL_Delay(10);
    

  337.         RST_D();
    

  338.          width=ILI9488_TFTWIDTH;
    

  339.          height=ILI9488_TFTHEIGHT;
    

  340.          //CS_A();
    

  341.          ILI9488_SendCommand(0xE0);
    

  342.          ILI9488_SendData(0x00);
    

  343.          ILI9488_SendData(0x03);
    

  344.          ILI9488_SendData(0x09);
    

  345.          ILI9488_SendData(0x08);
    

  346.          ILI9488_SendData(0x16);
    

  347.          ILI9488_SendData(0x0A);
    

  348.          ILI9488_SendData(0x3F);
    

  349.          ILI9488_SendData(0x78);
    

  350.          ILI9488_SendData(0x4C);
    

  351.          ILI9488_SendData(0x09);
    

  352.          ILI9488_SendData(0x0A);
    

  353.          ILI9488_SendData(0x08);
    

  354.          ILI9488_SendData(0x16);
    

  355.          ILI9488_SendData(0x1A);
    

  356.          ILI9488_SendData(0x0F);
    


  357. 

  358.                  ILI9488_SendCommand(0XE1);
    

  359.                  ILI9488_SendData(0x00);
    

  360.                  ILI9488_SendData(0x16);
    

  361.                  ILI9488_SendData(0x19);
    

  362.                  ILI9488_SendData(0x03);
    

  363.                  ILI9488_SendData(0x0F);
    

  364.                  ILI9488_SendData(0x05);
    

  365.                  ILI9488_SendData(0x32);
    

  366.                  ILI9488_SendData(0x45);
    

  367.                  ILI9488_SendData(0x46);
    

  368.                  ILI9488_SendData(0x04);
    

  369.                  ILI9488_SendData(0x0E);
    

  370.                  ILI9488_SendData(0x0D);
    

  371.                  ILI9488_SendData(0x35);
    

  372.                  ILI9488_SendData(0x37);
    

  373.                  ILI9488_SendData(0x0F);
    


  374. 

  375.                  ILI9488_SendCommand(0XC0);      //Power Control 1
    

  376.                  ILI9488_SendData(0x17);    //Vreg1out
    

  377.                  ILI9488_SendData(0x15);    //Verg2out
    


  378. 

  379.                  ILI9488_SendCommand(0xC1);      //Power Control 2
    

  380.                  ILI9488_SendData(0x41);    //VGH,VGL
    


  381. 

  382.                  ILI9488_SendCommand(0xC5);      //Power Control 3
    

  383.                  ILI9488_SendData(0x00);
    

  384.                  ILI9488_SendData(0x12);    //Vcom
    

  385.                  ILI9488_SendData(0x80);
    


  386. 

  387.                  ILI9488_SendCommand(0x36);      //Memory Access
    

  388.                  ILI9488_SendData(0x48);
    


  389. 

  390.                  ILI9488_SendCommand(0x3A);      // Interface Pixel Format
    

  391.                  ILI9488_SendData(0x66);           //18 bit
    


  392. 

  393.                  ILI9488_SendCommand(0XB0);      // Interface Mode Control
    

  394.                  ILI9488_SendData(0x80);                              //SDO NOT USE
    


  395. 

  396.                  ILI9488_SendCommand(0xB1);      //Frame rate
    

  397.                  ILI9488_SendData(0xA0);    //60Hz
    


  398. 

  399.                  ILI9488_SendCommand(0xB4);      //Display Inversion Control
    

  400.                  ILI9488_SendData(0x02);    //2-dot
    


  401. 

  402.                  ILI9488_SendCommand(0XB6); //Display Function Control  RGB/MCU Interface Control
    


  403. 

  404.                  ILI9488_SendData(0x02);    //MCU
    

  405.                  ILI9488_SendData(0x02);    //Source,Gate scan dieection
    


  406. 

  407.                  ILI9488_SendCommand(0XE9);      // Set Image Functio
    

  408.                  ILI9488_SendData(0x00);    // Disable 24 bit data
    


  409. 

  410.                  ILI9488_SendCommand(0xF7);      // Adjust Control
    

  411.                  ILI9488_SendData(0xA9);
    

  412.                  ILI9488_SendData(0x51);
    

  413.                  ILI9488_SendData(0x2C);
    

  414.                  ILI9488_SendData(0x82);    // D7 stream, loose
    


  415. 

  416.                  ILI9488_SendCommand(ILI9488_SLPOUT);    //Exit Sleep
    


  417. 

  418.                  HAL_Delay(120);
    


  419. 

  420.                  ILI9488_SendCommand(ILI9488_DISPON);    //Display on
    


  421. 

  422. }
    


  423. 

  424. void setAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
    

  425. {
    

  426.         /*ILI9488_SendCommand(ILI9488_CASET); // Column addr set
    

  427.         ILI9488_SendData(x0 >> 8);
    

  428.         ILI9488_SendData(x0 & 0xFF);     // XSTART
    

  429.         ILI9488_SendData(x1 >> 8);
    

  430.         ILI9488_SendData(x1 & 0xFF);     // XEND
    

  431.         ILI9488_SendCommand(ILI9488_PASET); // Row addr set
    

  432.         ILI9488_SendData(y0 >> 8);
    

  433.         ILI9488_SendData(y0 & 0xff);     // YSTART
    

  434.         ILI9488_SendData(y1 >> 8);
    

  435.         ILI9488_SendData(y1 & 0xff);     // YEND
    

  436.         ILI9488_SendCommand(ILI9488_RAMWR); // write to RAM*/
    

  437.         ILI9488_SendCommand(ILI9488_CASET); // Column addr set
    

  438.                 {
    

  439.                 uint8_t data[] = {(x0 >> 8) & 0xFF, x0 & 0xFF, (x1 >> 8) & 0xFF, x1 & 0xFF};
    

  440.                 ILI9488_SendData_Multi(data, sizeof(data));
    

  441.                 }
    

  442.                 ILI9488_SendCommand(ILI9488_PASET);
    

  443.                 {
    

  444.                 uint8_t data[] = {(y0 >> 8) & 0xFF, y0 & 0xFF, (y1 >> 8) & 0xFF, y1 & 0xFF};
    

  445.                 ILI9488_SendData_Multi(data, sizeof(data));
    

  446.                 }
    

  447.                 ILI9488_SendCommand(ILI9488_RAMWR); // write to RAM*/
    

  448. }
    


  449. 

  450. void setScrollArea(uint16_t topFixedArea, uint16_t bottomFixedArea)
    

  451. {
    

  452.         ILI9488_SendCommand(0x33); // Vertical scroll definition
    

  453.         ILI9488_SendData(topFixedArea >> 8);
    

  454.         ILI9488_SendData(topFixedArea);
    

  455.         ILI9488_SendData((height - topFixedArea - bottomFixedArea) >> 8);
    

  456.         ILI9488_SendData(height - topFixedArea - bottomFixedArea);
    

  457.         ILI9488_SendData(bottomFixedArea >> 8);
    

  458.         ILI9488_SendData(bottomFixedArea);
    

  459. }
    


  460. 

  461. void scroll(uint16_t pixels)
    

  462. {
    

  463.         ILI9488_SendCommand(0x37); // Vertical scrolling start address
    

  464.         ILI9488_SendData(pixels >> 8);
    

  465.         ILI9488_SendData(pixels);
    

  466. }
    

  467. void pushColor(uint16_t color)
    

  468. {
    

  469.         HAL_GPIO_WritePin(tftDC_GPIO, tftDC_PIN, GPIO_PIN_SET);
    

  470.         HAL_GPIO_WritePin(tftCS_GPIO, tftCS_PIN, GPIO_PIN_RESET);
    

  471.         write16BitColor(color);
    

  472.         HAL_GPIO_WritePin(tftCS_GPIO, tftCS_PIN, GPIO_PIN_SET);
    


  473. 

  474. }
    


  475. 

  476. void pushColors(uint16_t *data, uint8_t len, uint8_t first)
    

  477. {
    

  478.         uint16_t color;
    

  479.         uint8_t buff[len * 3 + 1];
    

  480.         uint16_t count = 0;
    

  481.         uint8_t lencount = len;
    

  482.         HAL_GPIO_WritePin(tftCS_GPIO, tftCS_PIN, GPIO_PIN_RESET);
    


  483. 

  484.         if (first == 1) {
    

  485.                 HAL_GPIO_WritePin(tftDC_GPIO, tftDC_PIN, GPIO_PIN_SET);
    

  486.         }
    

  487.         while (lencount--)
    

  488.         {
    

  489.                 color = *data++;
    

  490.                 buff[count] = (((color & 0xF800) >> 11) * 255) / 31;
    

  491.                 count++;
    

  492.                 buff[count] = (((color & 0x07E0) >> 5) * 255) / 63;
    

  493.                 count++;
    

  494.                 buff[count] = ((color & 0x001F) * 255) / 31;
    

  495.                 count++;
    

  496.         }
    

  497.         HAL_SPI_Transmit(&lcdSPIhandle, buff, len * 3, 100);
    

  498.         HAL_GPIO_WritePin(tftCS_GPIO, tftCS_PIN, GPIO_PIN_SET);
    

  499. }
    


  500. 

  501. void drawImage(const uint8_t* img, uint16_t x, uint16_t y, uint16_t w, uint16_t h)
    

  502. {
    


  503. 

  504.         if ((x >= width) || (y >= height))
    

  505.                 return;
    

  506.         if ((x + w - 1) >= width)
    

  507.                 w = width - x;
    

  508.         if ((y + h - 1) >= height)
    

  509.                 h = height - y;
    

  510.         setAddrWindow(x, y, x + w - 1, y + h - 1);
    

  511.         DC_DATA();
    

  512.         CS_A();
    

  513.         //HAL_GPIO_WritePin(tftDC_GPIO, tftDC_PIN, GPIO_PIN_SET);
    

  514.         //HAL_GPIO_WritePin(tftCS_GPIO, tftCS_PIN, GPIO_PIN_RESET);
    


  515. 

  516.         uint8_t linebuff[w * 3 + 1];
    

  517.         uint32_t count = 0;
    

  518.         for (uint16_t i = 0; i < h; i++) {
    

  519.                 uint16_t pixcount = 0;
    

  520.                 for (uint16_t o = 0; o < w; o++) {
    

  521.                         uint8_t b1 = img[count];
    

  522.                         count++;
    

  523.                         uint8_t b2 = img[count];
    

  524.                         count++;
    

  525.                         uint16_t color = b1 << 8 | b2;
    

  526.                         linebuff[pixcount] = (((color & 0xF800) >> 11) * 255)
    

  527.                                         / 31;
    

  528.                         pixcount++;
    

  529.                         linebuff[pixcount] = (((color & 0x07E0) >> 5) * 255)
    

  530.                                         / 63;
    

  531.                         pixcount++;
    

  532.                         linebuff[pixcount] = ((color & 0x001F) * 255) / 31;
    

  533.                         pixcount++;
    

  534.                 }
    

  535.                 HAL_SPI_Transmit(&lcdSPIhandle, linebuff, w * 3, 100);
    


  536. 

  537.         }
    

  538.         CS_D();
    

  539.         //HAL_GPIO_WritePin(tftCS_GPIO, tftCS_PIN, GPIO_PIN_SET);
    

  540. }
    


  541. 


  542. 

  543. void drawPixel(int16_t x, int16_t y, uint16_t color)
    

  544. {
    

  545.         if ((x < 0) || (x >= width) || (y < 0) || (y >= height))
    

  546.                 return;
    


  547. 

  548.         setAddrWindow(x, y, x + 1, y + 1);
    

  549.         DC_DATA();
    

  550.         CS_A();
    


  551. 

  552.         write16BitColor(color);
    

  553.         CS_D();
    


  554. 

  555. }
    


  556. 

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

  558. {
    


  559. 

  560.         if ((x >= width) || (y >= height))
    

  561.                 return;
    


  562. 

  563.         if ((y + h - 1) >= height)
    

  564.                 h = height - y;
    


  565. 

  566.         setAddrWindow(x, y, x, y + h - 1);
    

  567.         DC_DATA();
    

  568.         CS_A();
    

  569.         //HAL_GPIO_WritePin(tftDC_GPIO, tftDC_PIN, GPIO_PIN_SET);
    

  570.         //HAL_GPIO_WritePin(tftCS_GPIO, tftCS_PIN, GPIO_PIN_RESET);
    


  571. 

  572.         while (h--) {
    

  573.                 write16BitColor(color);
    

  574.         }
    

  575.         CS_D();
    

  576.         //HAL_GPIO_WritePin(tftCS_GPIO, tftCS_PIN, GPIO_PIN_SET);
    


  577. 

  578. }
    


  579. 

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

  581. {
    


  582. 

  583.         if ((x >= width) || (y >= height))
    

  584.                 return;
    

  585.         if ((x + w - 1) >= width)
    

  586.                 w = width - x;
    

  587.         setAddrWindow(x, y, x + w - 1, y);
    

  588.         DC_DATA();
    

  589.         CS_A();
    

  590.         //HAL_GPIO_WritePin(tftDC_GPIO, tftDC_PIN, GPIO_PIN_SET);
    

  591.         //HAL_GPIO_WritePin(tftCS_GPIO, tftCS_PIN, GPIO_PIN_RESET);
    

  592.         while (w--)
    

  593.         {
    

  594.                 write16BitColor(color);
    

  595.         }
    

  596.         CS_D();
    

  597.         //HAL_GPIO_WritePin(tftCS_GPIO, tftCS_PIN, GPIO_PIN_SET);
    

  598. }
    


  599. 

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

  601. {
    

  602.          if (x0 == x1) {
    

  603.             if (y0 > y1)
    

  604.               swap(y0, y1);
    

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

  606.           } else if (y0 == y1) {
    

  607.             if (x0 > x1)
    

  608.               swap(x0, x1);
    

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

  610.           } else {
    


  611. 

  612.             writeLine(x0, y0, x1, y1, color);
    


  613. 

  614.           }
    


  615. 

  616. }
    


  617. 

  618. void writeLine(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color) {
    


  619. 

  620.   int16_t steep = abs(y1 - y0) > abs(x1 - x0);
    

  621.   if (steep) {
    

  622.     swap(x0, y0);
    

  623.     swap(x1, y1);
    

  624.   }
    


  625. 

  626.   if (x0 > x1) {
    

  627.           swap(x0, x1);
    

  628.           swap(y0, y1);
    

  629.   }
    


  630. 

  631.   int16_t dx, dy;
    

  632.   dx = x1 - x0;
    

  633.   dy = abs(y1 - y0);
    


  634. 

  635.   int16_t err = dx / 2;
    

  636.   int16_t ystep;
    


  637. 

  638.   if (y0 < y1) {
    

  639.     ystep = 1;
    

  640.   } else {
    

  641.     ystep = -1;
    

  642.   }
    


  643. 

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

  645.     if (steep) {
    

  646.       drawPixel(y0, x0, color);
    

  647.     } else {
    

  648.       drawPixel(x0, y0, color);
    

  649.     }
    

  650.     err -= dy;
    

  651.     if (err < 0) {
    

  652.       y0 += ystep;
    

  653.       err += dx;
    

  654.     }
    

  655.   }
    

  656. }
    

  657. //6. Fill the entire screen with a background color
    


  658. 

  659. void fillScreen(uint16_t color)
    

  660. {
    

  661.         fillRect(0, 0,  width, height, color);
    

  662. }
    


  663. 

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

  665. {
    


  666. 

  667.         uint32_t i, n, cnt, buf_size;
    

  668.         if ((x >= width) || (y >= height))
    

  669.                 return;
    

  670.         if ((x + w - 1) >= width)
    

  671.                 w = width - x;
    

  672.         if ((y + h - 1) >= height)
    

  673.                 h = height - y;
    

  674.         setAddrWindow(x, y, x + w - 1, y + h - 1);
    

  675.         uint8_t r = (color & 0xF800) >> 11;
    

  676.         uint8_t g = (color & 0x07E0) >> 5;
    

  677.         uint8_t b = color & 0x001F;
    


  678. 

  679.         r = (r * 255) / 31;
    

  680.         g = (g * 255) / 63;
    

  681.         b = (b * 255) / 31;
    


  682. 

  683.         n = w*h*3;
    

  684.         if (n <= 65535){
    

  685.                 cnt = 1;
    

  686.                 buf_size = n;
    

  687.         }
    

  688.         else {
    

  689.                 cnt = n/3;
    

  690.                 buf_size = 3;
    

  691.                 uint8_t min_cnt = n/65535+1;
    

  692.                 for (i=min_cnt; i < n/3; i++){
    

  693.                         if(n%i == 0){
    

  694.                                 cnt = i;
    

  695.                                 buf_size = n/i;
    

  696.                                 break;
    

  697.                         }
    

  698.                 }
    

  699.         }
    

  700.         uint8_t frm_buf[buf_size];
    

  701.         for (i=0; i < buf_size/3; i++)
    

  702.         {
    

  703.                 frm_buf[i*3] = r;
    

  704.                 frm_buf[i*3+1] = g;
    

  705.                 frm_buf[i*3+2] = b;
    

  706.         }
    

  707.         DC_DATA();
    

  708.         CS_A();
    

  709.                 while(cnt>0)
    

  710.                 {
    

  711.                         HAL_SPI_Transmit(&hspi1, frm_buf, buf_size, HAL_MAX_DELAY);
    


  712. 

  713.                         cnt -= 1;
    

  714.                 }
    

  715.                 CS_D();
    


  716. 

  717. }
    


  718. 


  719. 

  720. void setRotation(uint8_t r)
    

  721. {
    


  722. 

  723.         ILI9488_SendCommand(ILI9488_MADCTL);
    

  724.         uint8_t rotation = r % 4; // can't be higher than 3
    

  725.         switch (rotation) {
    

  726.         case 0:
    

  727.                 ILI9488_SendData(MADCTL_MX | MADCTL_BGR);
    

  728.                 width = ILI9488_TFTWIDTH;
    

  729.                 height = ILI9488_TFTHEIGHT;
    

  730.                 break;
    

  731.         case 1:
    

  732.                 ILI9488_SendData(MADCTL_MV | MADCTL_BGR);
    

  733.                 width = ILI9488_TFTHEIGHT;
    

  734.                 height = ILI9488_TFTWIDTH;
    

  735.                 break;
    

  736.         case 2:
    

  737.                 ILI9488_SendData(MADCTL_MY | MADCTL_BGR);
    

  738.                 width = ILI9488_TFTWIDTH;
    

  739.                 height = ILI9488_TFTHEIGHT;
    

  740.                 break;
    

  741.         case 3:
    

  742.                 ILI9488_SendData(MADCTL_MX | MADCTL_MY | MADCTL_MV | MADCTL_BGR);
    

  743.                 width = ILI9488_TFTHEIGHT;
    

  744.                 height = ILI9488_TFTWIDTH;
    

  745.                 break;
    

  746.         }
    


  747. 

  748. }
    


  749. 

  750. void invertDisplay(uint8_t i)
    

  751. {
    


  752. 

  753.         ILI9488_SendCommand(i ? ILI9488_INVON : ILI9488_INVOFF);
    


  754. 

  755. }
    

  756. uint16_t color565(uint8_t r, uint8_t g, uint8_t b)
    

  757. {
    

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

  759. }
    


  760. 

  761. //11. Text printing functions
    

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

  763. {
    

  764.         uint8_t font_size;
    

  765.         font_size = size;
    

  766.         if(rotationNum == 1 || rotationNum ==3)
    

  767.         {
    

  768.                 if((x >= ILI9488_TFTWIDTH)            || // Clip right
    

  769.      (y >= ILI9488_TFTHEIGHT)           || // Clip bottom
    

  770.      ((x + 6 * font_size - 1) < 0) || // Clip left
    

  771.      ((y + 8 * font_size - 1) < 0))   // Clip top
    

  772.     return;
    

  773.         }
    

  774.         else
    

  775.         {
    

  776.                 if((y >= ILI9488_TFTWIDTH)            || // Clip right
    

  777.      (x >= ILI9488_TFTHEIGHT)           || // Clip bottom
    

  778.      ((y + 6 * font_size - 1) < 0) || // Clip left
    

  779.      ((x + 8 * font_size - 1) < 0))   // Clip top
    

  780.     return;
    

  781.         }
    


  782. 


  783. 

  784.   if(!_cp437 && (c >= 176)) c++; // Handle 'classic' charset behavior
    


  785. 

  786.   for (int8_t i=0; i<6; i++ ) {
    

  787.     uint8_t line;
    

  788.     if (i == 5)
    

  789.       line = 0x0;
    

  790.     else
    

  791.       line = pgm_read_byte(font1+(c*5)+i);
    

  792.     for (int8_t j = 0; j<8; j++) {
    

  793.       if (line & 0x1) {
    

  794.         if (font_size == 1) // default size
    

  795.                 drawPixel(x+i, y+j, color);
    

  796.         else {  // big size
    

  797.                 fillRect(x+(i*font_size), y+(j*font_size), font_size, font_size, color);
    

  798.         }
    

  799.       } else if (bg != color) {
    

  800.         if (font_size == 1) // default size
    

  801.                 drawPixel(x+i, y+j, bg);
    

  802.         else {  // big size
    

  803.                 fillRect(x+(i*font_size), y+(j*font_size), font_size, font_size, bg);
    

  804.         }
    

  805.       }
    

  806.       line >>= 1;
    

  807.     }
    

  808.   }
    

  809. }
    

  810. void ILI9488_printText(char text[], int16_t x, int16_t y, uint16_t color, uint16_t bg, uint8_t size)
    

  811. {
    

  812.         int16_t offset;
    

  813.         offset = size*6;
    


  814. 

  815.         for(uint16_t i=0; i<40 && text[i]!=NULL; i++)
    

  816.         {
    

  817.                 drawChar(x+(offset*i), y, text[i],color,bg,size);
    

  818.         }
    

  819. }
    

  820. void testLines(uint8_t color)
    

  821. {
    


  822. 

  823.         unsigned long start, t;
    

  824.         int x1, y1, x2, y2, w = width, h = height;
    

  825.         fillScreen(ILI9488_BLACK);
    


  826. 

  827.         x1 = y1 = 0;
    

  828.         y2 = h - 1;
    


  829. 

  830.         for (x2 = 0; x2 < w; x2 += 6)
    

  831.                 drawLine(x1, y1, x2, y2, color);
    

  832.         x2 = w - 1;
    

  833.         for (y2 = 0; y2 < h; y2 += 6)
    

  834.                 drawLine(x1, y1, x2, y2, color);
    

  835.         fillScreen(ILI9488_BLACK);
    


  836. 

  837.         x1 = w - 1;
    

  838.         y1 = 0;
    

  839.         y2 = h - 1;
    


  840. 

  841.         for (x2 = 0; x2 < w; x2 += 6)
    

  842.                 drawLine(x1, y1, x2, y2, color);
    

  843.         x2 = 0;
    

  844.         for (y2 = 0; y2 < h; y2 += 6)
    

  845.                 drawLine(x1, y1, x2, y2, color);
    


  846. 

  847.         fillScreen(ILI9488_BLACK);
    


  848. 

  849.         x1 = 0;
    

  850.         y1 = h - 1;
    

  851.         y2 = 0;
    


  852. 

  853.         for (x2 = 0; x2 < w; x2 += 6)
    

  854.                 drawLine(x1, y1, x2, y2, color);
    

  855.         x2 = w - 1;
    

  856.         for (y2 = 0; y2 < h; y2 += 6)
    

  857.                 drawLine(x1, y1, x2, y2, color);
    


  858. 

  859.         fillScreen(ILI9488_BLACK);
    


  860. 

  861.         x1 = w - 1;
    

  862.         y1 = h - 1;
    

  863.         y2 = 0;
    


  864. 

  865.         for (x2 = 0; x2 < w; x2 += 6)
    

  866.                 drawLine(x1, y1, x2, y2, color);
    

  867.         x2 = 0;
    

  868.         for (y2 = 0; y2 < h; y2 += 6)
    

  869.                 drawLine(x1, y1, x2, y2, color);
    

  870. }
    


  871. 

  872. void write16BitColor(uint16_t color)
    

  873. {
    


  874. 

  875.           uint8_t r = (color & 0xF800) >> 11;
    

  876.           uint8_t g = (color & 0x07E0) >> 5;
    

  877.           uint8_t b = color & 0x001F;
    


  878. 

  879.           r = (r * 255) / 31;
    

  880.           g = (g * 255) / 63;
    

  881.           b = (b * 255) / 31;
    

  882.           uint8_t data[3] = {r, g, b};
    

  883.           ILI9488_SendData_Multi(data, 3);
    

  884.           //HAL_SPI_Transmit(&hspi1, (uint8_t *)&r, 1, 10);
    

  885.           //HAL_SPI_Transmit(&hspi1, (uint8_t *)&g, 1, 10);
    

  886.           //HAL_SPI_Transmit(&hspi1, (uint8_t *)&b, 1, 10);
    


  887. 

  888. }
    


  889. 


  890. 


  891.

3、添加测试函数如下：
复制
  1.   /* USER CODE BEGIN 2 */
    

  2.   ILI9488_Init();
    


  3. 


  4. 

  5.     HAL_Delay(1000);
    

  6.     setRotation(0);
    

  7.     char badmpu[] = "HELLO 21IC";
    

  8.           fillScreen(ILI9488_BLACK);
    

  9.     fillScreen(ILI9488_WHITE);
    

  10.           ILI9488_printText(badmpu,10,10,ILI9488_BLACK,ILI9488_WHITE,1);
    

  11.           ILI9488_printText(badmpu,10,20,ILI9488_BLUE,ILI9488_WHITE,2);
    

  12.           ILI9488_printText(badmpu,10,50,ILI9488_GREEN,ILI9488_WHITE,3);
    

  13.           ILI9488_printText(badmpu,10,50,ILI9488_RED,ILI9488_WHITE,4);
    

  14.           testLines(ILI9488_BLUE);
    

  15.   /* USER CODE END 2 */

【实验效果】
2a4f6c2aaf1811661ad1810c5ae8d89c
【总结】
1.stm32u5系列拥有高频率、大内存，运行速超级快.
2. stm32拥有超级好用的stm32CubeIDE，配置、只要运行在hal库下面的驱动，可以实现少量代码的修改后，轻松移植到不同的芯片上的工程中。
3. 在实现LCD的驱动后，我们运行ADC、PWM、UART等信息，可以实时的显示到LCD屏上，实现交互信息的方便查看等。
【工程源码】
U5A5ZQ_tft.zip (1.53 MB, 下载次数: 12)

回复 赏

收藏2 举报

相关帖子
SophiaOP 发表于 2023-12-13 14:32 来自手机 | 显示全部楼层
s
这屏幕从哪买的啊？
回复 赏

收藏2 举报

yangjiaxu 发表于 2023-12-13 14:33 | 显示全部楼层
s
其实可以移植一下lvgl的或者其他的GUI，比如GFX这种，都是很不错的选择
回复 赏

收藏2 举报

埃娃 发表于 2023-12-13 14:42 | 显示全部楼层
s
堆栈调大有什么好处啊？
回复 赏

收藏2 举报

亚瑟 发表于 2023-12-13 15:00 | 显示全部楼层
s
刷新率怎么样啊？
回复 赏

收藏2 举报

 楼主| lulugl 发表于 2023-12-13 20:07 | 显示全部楼层
s
埃娃 发表于 2023-12-13 14:42
堆栈调大有什么好处啊？

太小了的话，如果申请不到内容，就会挂机。
回复 赏

收藏2 举报

 楼主| lulugl 发表于 2023-12-13 20:08 | 显示全部楼层
s
SophiaOP 发表于 2023-12-13 14:32
这屏幕从哪买的啊？

很久以前的了，某宝有，好象也不贵吧。
回复 赏

收藏2 举报

 楼主| lulugl 发表于 2023-12-13 20:08 | 显示全部楼层
s
yangjiaxu 发表于 2023-12-13 14:33
其实可以移植一下lvgl的或者其他的GUI，比如GFX这种，都是很不错的选择

后面的帖子已经移植好了LVGL了，touchGFX的话还没有动手。
回复 赏

收藏2 举报

 楼主| lulugl 发表于 2023-12-13 20:09 | 显示全部楼层
s
亚瑟 发表于 2023-12-13 15:00
刷新率怎么样啊？

没有做全屏的刷新，如果处理好，应该30FPS没有问题。
回复 赏

收藏2 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

lulugl Image

180

主题

830

帖子

12

粉丝
快速回复 在线客服 返回列表 返回顶部