From 025b71530fa01de27031849c2fa4c1b68c0d2199 Mon Sep 17 00:00:00 2001 From: NU-LL <1125934312@qq.com> Date: Fri, 15 Oct 2021 00:49:17 +0800 Subject: [PATCH] add lcd driver --- bsp/tkm32F499/applications/main.c | 3 - bsp/tkm32F499/drivers/Kconfig | 8 + bsp/tkm32F499/drivers/SConscript | 6 + bsp/tkm32F499/drivers/board.c | 4 +- bsp/tkm32F499/drivers/drv_gpio.h | 2 +- bsp/tkm32F499/drivers/drv_lcd.c | 298 ++++++++ bsp/tkm32F499/drivers/lcd/lcd.c | 1184 +++++++++++++++++++++++++++++ bsp/tkm32F499/drivers/lcd/lcd.h | 75 ++ bsp/tkm32F499/drivers/lcd_port.h | 34 + 9 files changed, 1608 insertions(+), 6 deletions(-) create mode 100644 bsp/tkm32F499/drivers/drv_lcd.c create mode 100644 bsp/tkm32F499/drivers/lcd/lcd.c create mode 100644 bsp/tkm32F499/drivers/lcd/lcd.h create mode 100644 bsp/tkm32F499/drivers/lcd_port.h diff --git a/bsp/tkm32F499/applications/main.c b/bsp/tkm32F499/applications/main.c index 539f6e55f7..416ec08f16 100644 --- a/bsp/tkm32F499/applications/main.c +++ b/bsp/tkm32F499/applications/main.c @@ -16,7 +16,6 @@ #include "drv_gpio.h" -#define LED_PIN GET_PIN(D, 8) #define LED0_PIN GET_PIN(B, 14) #define LED1_PIN GET_PIN(B, 15) @@ -24,11 +23,9 @@ int main(void) { /* set LED pin mode to output */ - rt_pin_mode(LED_PIN, PIN_MODE_OUTPUT); rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT); rt_pin_mode(LED1_PIN, PIN_MODE_OUTPUT); - rt_pin_write(LED_PIN, PIN_LOW); rt_pin_write(LED0_PIN, PIN_LOW); rt_pin_write(LED1_PIN, PIN_LOW); diff --git a/bsp/tkm32F499/drivers/Kconfig b/bsp/tkm32F499/drivers/Kconfig index 870c473f9b..4e7e9a19d6 100644 --- a/bsp/tkm32F499/drivers/Kconfig +++ b/bsp/tkm32F499/drivers/Kconfig @@ -136,6 +136,14 @@ menu "On-chip Peripheral Drivers" select RT_USING_DFS default n + config BSP_USING_LCD + bool "Enable LCD" + select BSP_USING_GPIO + select BSP_USING_PWM + select BSP_USING_PWM2 + select BSP_USING_PWM2_CH1 + default n + endmenu diff --git a/bsp/tkm32F499/drivers/SConscript b/bsp/tkm32F499/drivers/SConscript index 861b449735..e8e9e7de78 100644 --- a/bsp/tkm32F499/drivers/SConscript +++ b/bsp/tkm32F499/drivers/SConscript @@ -17,7 +17,13 @@ if GetDepend('RT_USING_SERIAL'): if GetDepend(['RT_USING_PIN']): src += ['drv_gpio.c'] +# add lcd driver code +if GetDepend(['BSP_USING_LCD']): + src += Glob('./lcd/*.c') + src += ['drv_lcd.c'] + CPPPATH = [cwd] +CPPPATH += [cwd+'/lcd'] group = DefineGroup('Drivers', src, depend = [''], CPPPATH = CPPPATH) diff --git a/bsp/tkm32F499/drivers/board.c b/bsp/tkm32F499/drivers/board.c index 6e5eb5791d..b11afa8f16 100644 --- a/bsp/tkm32F499/drivers/board.c +++ b/bsp/tkm32F499/drivers/board.c @@ -26,8 +26,8 @@ MSH_CMD_EXPORT(reboot, Reboot System); static void bsp_clock_config(void) { RemapVtorTable(); - SystemClk_HSEInit(RCC_PLLMul_20);//启动PLL时钟，12MHz*20=240MHz - NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//2：2，全局性函数，仅需设置一次 + SystemClk_HSEInit(RCC_PLLMul_20);//启动PLL时钟，12MHz*20=240MHz + NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//2：2，全局性函数，仅需设置一次 uint32_t sysclk = 0; getSystemClock(&sysclk); diff --git a/bsp/tkm32F499/drivers/drv_gpio.h b/bsp/tkm32F499/drivers/drv_gpio.h index 1f52cacba5..50eac81e17 100644 --- a/bsp/tkm32F499/drivers/drv_gpio.h +++ b/bsp/tkm32F499/drivers/drv_gpio.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006-2021, RT-Thread Development Team + * Copyright (c) 2006-2018, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * diff --git a/bsp/tkm32F499/drivers/drv_lcd.c b/bsp/tkm32F499/drivers/drv_lcd.c new file mode 100644 index 0000000000..0857d5210d --- /dev/null +++ b/bsp/tkm32F499/drivers/drv_lcd.c @@ -0,0 +1,298 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-10-14 spaceman first version + */ + +#include + +#ifdef BSP_USING_LCD +#include +#include "lcd.h" +#include "drv_gpio.h" + +#define DRV_DEBUG +#define LOG_TAG "drv.lcd" +#include + +#define LCD_DEVICE(dev) (struct drv_lcd_device*)(dev) + + +static __align(256) volatile rt_uint32_t LTDC_Buf1[LCD_WIDTH * LCD_HEIGHT] = {0x00}; +static __align(256) volatile rt_uint32_t LTDC_Buf2[LCD_WIDTH * LCD_HEIGHT] = {0x00}; + + +struct drv_lcd_device +{ + struct rt_device parent; + + struct rt_device_graphic_info lcd_info; + + struct rt_semaphore lcd_lock; + + /* 0:front_buf is being used 1: back_buf is being used*/ + rt_uint8_t cur_buf; + rt_uint8_t *front_buf; + rt_uint8_t *back_buf; +}; + +struct drv_lcd_device _lcd; + +static rt_err_t drv_lcd_init(struct rt_device *device) +{ + struct drv_lcd_device *lcd = LCD_DEVICE(device); + /* nothing, right now */ + lcd = lcd; + return RT_EOK; +} + +static rt_err_t drv_lcd_control(struct rt_device *device, int cmd, void *args) +{ + struct drv_lcd_device *lcd = LCD_DEVICE(device); + + switch (cmd) + { + case RTGRAPHIC_CTRL_RECT_UPDATE: + { + /* update */ + if (_lcd.cur_buf) + { + /* back_buf is being used */ + _lcd.lcd_info.framebuffer = _lcd.back_buf; + /* Configure the color frame buffer start address */ + LTDC->DP_SWT = 0; + _lcd.cur_buf = 0; + } + else + { + /* front_buf is being used */ + _lcd.lcd_info.framebuffer = _lcd.front_buf; + /* Configure the color frame buffer start address */ + LTDC->DP_SWT = 1; + _lcd.cur_buf = 1; + } + rt_sem_take(&_lcd.lcd_lock, RT_TICK_PER_SECOND / 20); + } + break; + + case RTGRAPHIC_CTRL_GET_INFO: + { + struct rt_device_graphic_info *info = (struct rt_device_graphic_info *)args; + + RT_ASSERT(info != RT_NULL); + info->pixel_format = lcd->lcd_info.pixel_format; + info->bits_per_pixel = LCD_BITS_PER_PIXEL; + info->width = lcd->lcd_info.width; + info->height = lcd->lcd_info.height; + info->framebuffer = lcd->lcd_info.framebuffer; + } + break; + } + + return RT_EOK; +} + + + + + +rt_err_t stm32_lcd_init(struct drv_lcd_device *lcd) +{ + LCD_Initial((rt_uint32_t)lcd->front_buf, (rt_uint32_t)lcd->back_buf); + return RT_EOK; +} +#if defined(LCD_BACKLIGHT_USING_PWM) +void turn_on_lcd_backlight(void) +{ + struct rt_device_pwm *pwm_dev; + + /* turn on the LCD backlight */ + pwm_dev = (struct rt_device_pwm *)rt_device_find(LCD_PWM_DEV_NAME); + /* pwm frequency:100K = 10000ns */ + rt_pwm_set(pwm_dev, LCD_PWM_DEV_CHANNEL, 10000, 10000); + rt_pwm_enable(pwm_dev, LCD_PWM_DEV_CHANNEL); +} +#elif defined(LCD_BACKLIGHT_USING_GPIO) +void turn_on_lcd_backlight(void) +{ + rt_pin_mode(LCD_BL_GPIO_NUM, PIN_MODE_OUTPUT); + rt_pin_mode(LCD_DISP_GPIO_NUM, PIN_MODE_OUTPUT); + + rt_pin_write(LCD_DISP_GPIO_NUM, PIN_HIGH); + rt_pin_write(LCD_BL_GPIO_NUM, PIN_HIGH); +} +#else +void turn_on_lcd_backlight(void) +{ + +} +#endif + +#ifdef RT_USING_DEVICE_OPS +const static struct rt_device_ops lcd_ops = +{ + drv_lcd_init, + RT_NULL, + RT_NULL, + RT_NULL, + RT_NULL, + drv_lcd_control +}; +#endif + + +void Lcd_ColorBox(struct drv_lcd_device *lcd, rt_uint16_t xStart, rt_uint16_t yStart, rt_uint16_t xLong, rt_uint16_t yLong, rt_uint32_t Color) +{ + rt_uint16_t i, j; + rt_uint32_t temp; + rt_uint32_t *LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer; + temp = lcd->lcd_info.height * xStart; + for (i = 0; i < yLong; i++) + { + for (j = 0; j < xLong; j++) + LTDC_Buf[yStart + i + lcd->lcd_info.height * j + temp] = Color; + } + lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL); +} + +void LCD_Fill_Pic(struct drv_lcd_device *lcd, rt_uint16_t x, rt_uint16_t y, rt_uint16_t pic_H, rt_uint16_t pic_V, rt_uint32_t *pic) +{ + rt_uint32_t *LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer; + rt_uint16_t i, j; + rt_uint32_t Xstart, k = 0; + Xstart = lcd->lcd_info.height * x; + for (i = 0; i < pic_V; i++) + { + for (j = 0; j < pic_H; j++) + LTDC_Buf[Xstart + i + lcd->lcd_info.height * j + y] = pic[k++]; + } +} + +void DrawPixel(struct drv_lcd_device *lcd, rt_uint16_t x, rt_uint16_t y, int Color) +{ + rt_uint32_t *LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer; + LTDC_Buf[y + lcd->lcd_info.height * x] = Color; +} + + + + +int drv_lcd_hw_init(void) +{ + rt_err_t result = RT_EOK; + struct rt_device *device = &_lcd.parent; + + /* memset _lcd to zero */ + rt_memset(&_lcd, 0x00, sizeof(_lcd)); + + /* init lcd_lock semaphore */ + result = rt_sem_init(&_lcd.lcd_lock, "lcd_lock", 0, RT_IPC_FLAG_FIFO); + if (result != RT_EOK) + { + LOG_E("init semaphore failed!\n"); + result = -RT_ENOMEM; + goto __exit; + } + + /* config LCD dev info */ + _lcd.lcd_info.height = LCD_HEIGHT; + _lcd.lcd_info.width = LCD_WIDTH; + _lcd.lcd_info.bits_per_pixel = LCD_BITS_PER_PIXEL; + _lcd.lcd_info.pixel_format = LCD_PIXEL_FORMAT; + + /* malloc memory for Triple Buffering */ + _lcd.back_buf = (rt_uint8_t *)LTDC_Buf1; + _lcd.front_buf = (rt_uint8_t *)LTDC_Buf2; + _lcd.lcd_info.framebuffer = _lcd.back_buf; + if (_lcd.lcd_info.framebuffer == RT_NULL || _lcd.back_buf == RT_NULL || _lcd.front_buf == RT_NULL) + { + LOG_E("init frame buffer failed!\n"); + result = -RT_ENOMEM; + goto __exit; + } + + /* memset buff to 0xFF */ + rt_memset(_lcd.back_buf, 0xFF, LCD_BUF_SIZE); + rt_memset(_lcd.front_buf, 0xFF, LCD_BUF_SIZE); + + device->type = RT_Device_Class_Graphic; +#ifdef RT_USING_DEVICE_OPS + device->ops = &lcd_ops; +#else + device->init = drv_lcd_init; + device->control = drv_lcd_control; +#endif + + /* register lcd device */ + rt_device_register(device, "lcd", RT_DEVICE_FLAG_RDWR); + + /* init stm32 LTDC */ + if (stm32_lcd_init(&_lcd) != RT_EOK) + { + result = -RT_ERROR; + goto __exit; + } + else + { + turn_on_lcd_backlight(); + } + LOG_D("lcd register successful!"); + +__exit: + if (result != RT_EOK) + { + rt_sem_detach(&_lcd.lcd_lock); + } + return result; +} +INIT_DEVICE_EXPORT(drv_lcd_hw_init); + +#ifdef DRV_DEBUG +#ifdef FINSH_USING_MSH +int lcd_test() +{ + struct drv_lcd_device *lcd; + lcd = (struct drv_lcd_device *)rt_device_find("lcd"); + if(lcd == RT_NULL) + { + LOG_E("find lcd device failed!\n"); + return -1; + } + rt_uint32_t *LTDC_Buf = RT_NULL; + + LOG_D("red"); + /* red */ + LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer; + for (int i = 0; i < LCD_BUF_SIZE / 4; i++) + LTDC_Buf[i] = Red; + lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL); + rt_thread_mdelay(1000); + LOG_D("green"); + /* green */ + LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer; + for (int i = 0; i < LCD_BUF_SIZE / 4; i++) + LTDC_Buf[i] = Green; + lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL); + rt_thread_mdelay(1000); + LOG_D("blue"); + /* blue */ + LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer; + for (int i = 0; i < LCD_BUF_SIZE / 4; i++) + LTDC_Buf[i] = Blue; + lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL); + + return 0; +} +MSH_CMD_EXPORT(lcd_test, lcd_test); + + + + + +#endif /* FINSH_USING_MSH */ +#endif /* DRV_DEBUG */ +#endif /* BSP_USING_LCD */ diff --git a/bsp/tkm32F499/drivers/lcd/lcd.c b/bsp/tkm32F499/drivers/lcd/lcd.c new file mode 100644 index 0000000000..e0bbb22521 --- /dev/null +++ b/bsp/tkm32F499/drivers/lcd/lcd.c @@ -0,0 +1,1184 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-10-14 spaceman first version + */ + +#include "lcd.h" + +// __align(256) rt_uint32_t LTDC_Buf[XSIZE_PHYS * YSIZE_PHYS]; + +volatile void LCD_delay(volatile int time) //简单软件延时 +{ + // volatile rt_uint32_t i; + // while (time--) + // for (i = 500; i > 0; i--) + // ; + rt_thread_mdelay(time); +} +void LTDC_Clock_Set(void) //设置LTDC时钟 +{ + RCC->AHB1ENR |= 1 << 31; + RCC->CR |= 1 << 28; + RCC->PLLDCKCFGR = 0x1 << 16; //分频系数 0~3 --> 2,4,6,8 + RCC->PLLLCDCFGR = 6 << 6; //倍频系数 +} +void GPIO_RGB_INIT(void) +{ + GPIO_InitTypeDef GPIO_InitStructure; //定义GPIO初始化结构体变量 + + RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB | RCC_AHBPeriph_GPIOD | RCC_AHBPeriph_GPIOE, ENABLE); + + //DE=PB4, PCLK=PB5, HSYNC=PB6, VSYNC=PB7 + GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; + GPIO_Init(GPIOB, &GPIO_InitStructure); + + //lcd_reset:PD6 LCD_Black_Light On Off :PD8 + GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_8; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; + GPIO_Init(GPIOD, &GPIO_InitStructure); + + // GPIO模拟SPI初始化液晶屏 SPI_SDA SPI_DCLK LCD_SPI_CS + GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_9 | GPIO_Pin_11; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; + GPIO_Init(GPIOB, &GPIO_InitStructure); + + GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All; + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; + GPIO_Init(GPIOE, &GPIO_InitStructure); + + GPIO_PinAFConfig(GPIOB, GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7, GPIO_AF_LTDC); //PB4~7复用为LTDC的同步信号线 + GPIO_PinAFConfig(GPIOE, GPIO_Pin_All, GPIO_AF_LTDC); //GPIOE所有的IO全部复用为LTDC的数据线 +} +static void LCD_Reset(void) +{ + //注意，现在科学发达，有的屏不用复位也行 + LCD_RST(0); + LCD_delay(200); + LCD_RST(1); + LCD_delay(200); +} +void set_resolutionXX(LCD_FORM_TypeDef *LCD_FORM) +{ + rt_uint32_t aHorStart; + rt_uint32_t aHorEnd; + rt_uint32_t aVerStart; + rt_uint32_t aVerEnd; + + aHorStart = LCD_FORM->blkHorEnd + 1; + aHorEnd = aHorStart + LCD_FORM->aHorLen; + aVerStart = LCD_FORM->blkVerEnd + 1; + aVerEnd = aVerStart + LCD_FORM->aVerLen; + + LTDC->P_HOR = aHorEnd; //总宽度 + LTDC->HSYNC = (LCD_FORM->sHsyncStart << 16) | LCD_FORM->sHsyncEnd; //水平同步信号起始和结束，位于背景色中间 + LTDC->A_HOR = (aHorStart << 16) | aHorEnd; //水平激活起始和结束 + LTDC->A_HOR_LEN = LCD_FORM->aHorLen; //水平激活域宽度 + LTDC->BLK_HOR = (0 << 16) | LCD_FORM->blkHorEnd; //背景开始和结束宽度0~激活地址 + LTDC->P_VER = aVerEnd; + LTDC->VSYNC = (LCD_FORM->sVsyncStart << 16) | LCD_FORM->sVsyncEnd; + LTDC->A_VER = (aVerStart << 16) | aVerEnd; + LTDC->A_VER_LEN = LCD_FORM->aVerLen; + LTDC->BLK_VER = (0 << 16) | LCD_FORM->blkVerEnd; +} + +void Set_LCD_Timing_to_LTDC(rt_uint32_t LTDC_Buf1, rt_uint32_t LTDC_Buf2) +{ + LCD_FORM_TypeDef LCD_FORM; + LTDC->OUT_EN = 0; + LTDC->DP_ADDR0 = LTDC_Buf1; //第0层地址 + LTDC->DP_ADDR1 = LTDC_Buf2;//第一层地址 + LTDC->BLK_DATA = 0x0000; //背景色 + + LCD_FORM.sHsyncStart = 0x2; //水平激活起始 + LCD_FORM.sHsyncEnd = 0x3; //水平激活结束 + LCD_FORM.aHorLen = 480 - 1; //水平分辨率 + LCD_FORM.blkHorEnd = 0xf; //水平消隐 + + LCD_FORM.sVsyncStart = 0x2; //垂直激活起始 + LCD_FORM.sVsyncEnd = 0x3; //垂直激活结束 + LCD_FORM.aVerLen = 800 - 1; //垂直分辨率 + LCD_FORM.blkVerEnd = 0xF; //垂直消隐 + + set_resolutionXX(&LCD_FORM); + + LTDC->VI_FORMAT = 0; + LTDC->POL_CTL = 0x8 + 3; + LTDC->OUT_EN |= 0x107; +} +void LTDC_IRQHandler(void) +{ + LTDC->INTR_CLR = 2; + LTDC->DP_SWT ^= 1; //连续显示两幅图片 + if (LTDC->DP_SWT != 0) + { + // fun_test(SDRAM_RGB_ADD); + } + else + { + // fun_test(SDRAM_RGB_ADD+SDRAM_RGB_OFFSET); + } + // if(LTDC->INTR_STA & 2) + // { + + // } +} + +void LCD_WriteByteSPI(unsigned char byte) +{ + unsigned char n; + + for (n = 0; n < 8; n++) + { + if (byte & 0x80) + SPI_SDA(1) + else + SPI_SDA(0) + byte <<= 1; + + SPI_DCLK(0); + SPI_DCLK(1); + } +} +void SPI_WriteComm(rt_uint16_t CMD) +{ + LCD_SPI_CS(0); + LCD_WriteByteSPI(0X20); + LCD_WriteByteSPI(CMD >> 8); + LCD_WriteByteSPI(0X00); + LCD_WriteByteSPI(CMD); + + LCD_SPI_CS(1); +} +void SPI_WriteData(rt_uint16_t tem_data) +{ + LCD_SPI_CS(0); + LCD_WriteByteSPI(0x40); + LCD_WriteByteSPI(tem_data); + LCD_SPI_CS(1); +} +void BlockWrite(unsigned int Xstart, unsigned int Xend, unsigned int Ystart, unsigned int Yend) +{ + SPI_WriteComm(0x2a00); + SPI_WriteData(Xstart >> 8); + SPI_WriteComm(0x2a01); + SPI_WriteData(Xstart & 0xff); + SPI_WriteComm(0x2a02); + SPI_WriteData(Xend >> 8); + SPI_WriteComm(0x2a03); + SPI_WriteData(Xend & 0xff); + + SPI_WriteComm(0x2b00); + SPI_WriteData(Ystart >> 8); + SPI_WriteComm(0x2b01); + SPI_WriteData(Ystart & 0xff); + SPI_WriteComm(0x2b02); + SPI_WriteData(Yend >> 8); + SPI_WriteComm(0x2b03); + SPI_WriteData(Yend & 0xff); + + SPI_WriteComm(0x2c00); + // for(Xstart=0;Xstart<1000;Xstart++)SPI_WriteData(0x55); +} +void Lcd_Initialize(void) +{ + LCD_SPI_CS(1); + LCD_delay(20); + LCD_SPI_CS(0); + LCD_Reset(); + + //ENABLE PAGE 1 + SPI_WriteComm(0xF000); + SPI_WriteData(0x55); + SPI_WriteComm(0xF001); + SPI_WriteData(0xAA); + SPI_WriteComm(0xF002); + SPI_WriteData(0x52); + SPI_WriteComm(0xF003); + SPI_WriteData(0x08); + SPI_WriteComm(0xF004); + SPI_WriteData(0x01); + + //GAMMA SETING RED + SPI_WriteComm(0xD100); + SPI_WriteData(0x00); + SPI_WriteComm(0xD101); + SPI_WriteData(0x00); + SPI_WriteComm(0xD102); + SPI_WriteData(0x1b); + SPI_WriteComm(0xD103); + SPI_WriteData(0x44); + SPI_WriteComm(0xD104); + SPI_WriteData(0x62); + SPI_WriteComm(0xD105); + SPI_WriteData(0x00); + SPI_WriteComm(0xD106); + SPI_WriteData(0x7b); + SPI_WriteComm(0xD107); + SPI_WriteData(0xa1); + SPI_WriteComm(0xD108); + SPI_WriteData(0xc0); + SPI_WriteComm(0xD109); + SPI_WriteData(0xee); + SPI_WriteComm(0xD10A); + SPI_WriteData(0x55); + SPI_WriteComm(0xD10B); + SPI_WriteData(0x10); + SPI_WriteComm(0xD10C); + SPI_WriteData(0x2c); + SPI_WriteComm(0xD10D); + SPI_WriteData(0x43); + SPI_WriteComm(0xD10E); + SPI_WriteData(0x57); + SPI_WriteComm(0xD10F); + SPI_WriteData(0x55); + SPI_WriteComm(0xD110); + SPI_WriteData(0x68); + SPI_WriteComm(0xD111); + SPI_WriteData(0x78); + SPI_WriteComm(0xD112); + SPI_WriteData(0x87); + SPI_WriteComm(0xD113); + SPI_WriteData(0x94); + SPI_WriteComm(0xD114); + SPI_WriteData(0x55); + SPI_WriteComm(0xD115); + SPI_WriteData(0xa0); + SPI_WriteComm(0xD116); + SPI_WriteData(0xac); + SPI_WriteComm(0xD117); + SPI_WriteData(0xb6); + SPI_WriteComm(0xD118); + SPI_WriteData(0xc1); + SPI_WriteComm(0xD119); + SPI_WriteData(0x55); + SPI_WriteComm(0xD11A); + SPI_WriteData(0xcb); + SPI_WriteComm(0xD11B); + SPI_WriteData(0xcd); + SPI_WriteComm(0xD11C); + SPI_WriteData(0xd6); + SPI_WriteComm(0xD11D); + SPI_WriteData(0xdf); + SPI_WriteComm(0xD11E); + SPI_WriteData(0x95); + SPI_WriteComm(0xD11F); + SPI_WriteData(0xe8); + SPI_WriteComm(0xD120); + SPI_WriteData(0xf1); + SPI_WriteComm(0xD121); + SPI_WriteData(0xfa); + SPI_WriteComm(0xD122); + SPI_WriteData(0x02); + SPI_WriteComm(0xD123); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD124); + SPI_WriteData(0x0b); + SPI_WriteComm(0xD125); + SPI_WriteData(0x13); + SPI_WriteComm(0xD126); + SPI_WriteData(0x1d); + SPI_WriteComm(0xD127); + SPI_WriteData(0x26); + SPI_WriteComm(0xD128); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD129); + SPI_WriteData(0x30); + SPI_WriteComm(0xD12A); + SPI_WriteData(0x3c); + SPI_WriteComm(0xD12B); + SPI_WriteData(0x4A); + SPI_WriteComm(0xD12C); + SPI_WriteData(0x63); + SPI_WriteComm(0xD12D); + SPI_WriteData(0xea); + SPI_WriteComm(0xD12E); + SPI_WriteData(0x79); + SPI_WriteComm(0xD12F); + SPI_WriteData(0xa6); + SPI_WriteComm(0xD130); + SPI_WriteData(0xd0); + SPI_WriteComm(0xD131); + SPI_WriteData(0x20); + SPI_WriteComm(0xD132); + SPI_WriteData(0x0f); + SPI_WriteComm(0xD133); + SPI_WriteData(0x8e); + SPI_WriteComm(0xD134); + SPI_WriteData(0xff); + //GAMMA SETING GREEN + SPI_WriteComm(0xD200); + SPI_WriteData(0x00); + SPI_WriteComm(0xD201); + SPI_WriteData(0x00); + SPI_WriteComm(0xD202); + SPI_WriteData(0x1b); + SPI_WriteComm(0xD203); + SPI_WriteData(0x44); + SPI_WriteComm(0xD204); + SPI_WriteData(0x62); + SPI_WriteComm(0xD205); + SPI_WriteData(0x00); + SPI_WriteComm(0xD206); + SPI_WriteData(0x7b); + SPI_WriteComm(0xD207); + SPI_WriteData(0xa1); + SPI_WriteComm(0xD208); + SPI_WriteData(0xc0); + SPI_WriteComm(0xD209); + SPI_WriteData(0xee); + SPI_WriteComm(0xD20A); + SPI_WriteData(0x55); + SPI_WriteComm(0xD20B); + SPI_WriteData(0x10); + SPI_WriteComm(0xD20C); + SPI_WriteData(0x2c); + SPI_WriteComm(0xD20D); + SPI_WriteData(0x43); + SPI_WriteComm(0xD20E); + SPI_WriteData(0x57); + SPI_WriteComm(0xD20F); + SPI_WriteData(0x55); + SPI_WriteComm(0xD210); + SPI_WriteData(0x68); + SPI_WriteComm(0xD211); + SPI_WriteData(0x78); + SPI_WriteComm(0xD212); + SPI_WriteData(0x87); + SPI_WriteComm(0xD213); + SPI_WriteData(0x94); + SPI_WriteComm(0xD214); + SPI_WriteData(0x55); + SPI_WriteComm(0xD215); + SPI_WriteData(0xa0); + SPI_WriteComm(0xD216); + SPI_WriteData(0xac); + SPI_WriteComm(0xD217); + SPI_WriteData(0xb6); + SPI_WriteComm(0xD218); + SPI_WriteData(0xc1); + SPI_WriteComm(0xD219); + SPI_WriteData(0x55); + SPI_WriteComm(0xD21A); + SPI_WriteData(0xcb); + SPI_WriteComm(0xD21B); + SPI_WriteData(0xcd); + SPI_WriteComm(0xD21C); + SPI_WriteData(0xd6); + SPI_WriteComm(0xD21D); + SPI_WriteData(0xdf); + SPI_WriteComm(0xD21E); + SPI_WriteData(0x95); + SPI_WriteComm(0xD21F); + SPI_WriteData(0xe8); + SPI_WriteComm(0xD220); + SPI_WriteData(0xf1); + SPI_WriteComm(0xD221); + SPI_WriteData(0xfa); + SPI_WriteComm(0xD222); + SPI_WriteData(0x02); + SPI_WriteComm(0xD223); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD224); + SPI_WriteData(0x0b); + SPI_WriteComm(0xD225); + SPI_WriteData(0x13); + SPI_WriteComm(0xD226); + SPI_WriteData(0x1d); + SPI_WriteComm(0xD227); + SPI_WriteData(0x26); + SPI_WriteComm(0xD228); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD229); + SPI_WriteData(0x30); + SPI_WriteComm(0xD22A); + SPI_WriteData(0x3c); + SPI_WriteComm(0xD22B); + SPI_WriteData(0x4a); + SPI_WriteComm(0xD22C); + SPI_WriteData(0x63); + SPI_WriteComm(0xD22D); + SPI_WriteData(0xea); + SPI_WriteComm(0xD22E); + SPI_WriteData(0x79); + SPI_WriteComm(0xD22F); + SPI_WriteData(0xa6); + SPI_WriteComm(0xD230); + SPI_WriteData(0xd0); + SPI_WriteComm(0xD231); + SPI_WriteData(0x20); + SPI_WriteComm(0xD232); + SPI_WriteData(0x0f); + SPI_WriteComm(0xD233); + SPI_WriteData(0x8e); + SPI_WriteComm(0xD234); + SPI_WriteData(0xff); + + //GAMMA SETING BLUE + SPI_WriteComm(0xD300); + SPI_WriteData(0x00); + SPI_WriteComm(0xD301); + SPI_WriteData(0x00); + SPI_WriteComm(0xD302); + SPI_WriteData(0x1b); + SPI_WriteComm(0xD303); + SPI_WriteData(0x44); + SPI_WriteComm(0xD304); + SPI_WriteData(0x62); + SPI_WriteComm(0xD305); + SPI_WriteData(0x00); + SPI_WriteComm(0xD306); + SPI_WriteData(0x7b); + SPI_WriteComm(0xD307); + SPI_WriteData(0xa1); + SPI_WriteComm(0xD308); + SPI_WriteData(0xc0); + SPI_WriteComm(0xD309); + SPI_WriteData(0xee); + SPI_WriteComm(0xD30A); + SPI_WriteData(0x55); + SPI_WriteComm(0xD30B); + SPI_WriteData(0x10); + SPI_WriteComm(0xD30C); + SPI_WriteData(0x2c); + SPI_WriteComm(0xD30D); + SPI_WriteData(0x43); + SPI_WriteComm(0xD30E); + SPI_WriteData(0x57); + SPI_WriteComm(0xD30F); + SPI_WriteData(0x55); + SPI_WriteComm(0xD310); + SPI_WriteData(0x68); + SPI_WriteComm(0xD311); + SPI_WriteData(0x78); + SPI_WriteComm(0xD312); + SPI_WriteData(0x87); + SPI_WriteComm(0xD313); + SPI_WriteData(0x94); + SPI_WriteComm(0xD314); + SPI_WriteData(0x55); + SPI_WriteComm(0xD315); + SPI_WriteData(0xa0); + SPI_WriteComm(0xD316); + SPI_WriteData(0xac); + SPI_WriteComm(0xD317); + SPI_WriteData(0xb6); + SPI_WriteComm(0xD318); + SPI_WriteData(0xc1); + SPI_WriteComm(0xD319); + SPI_WriteData(0x55); + SPI_WriteComm(0xD31A); + SPI_WriteData(0xcb); + SPI_WriteComm(0xD31B); + SPI_WriteData(0xcd); + SPI_WriteComm(0xD31C); + SPI_WriteData(0xd6); + SPI_WriteComm(0xD31D); + SPI_WriteData(0xdf); + SPI_WriteComm(0xD31E); + SPI_WriteData(0x95); + SPI_WriteComm(0xD31F); + SPI_WriteData(0xe8); + SPI_WriteComm(0xD320); + SPI_WriteData(0xf1); + SPI_WriteComm(0xD321); + SPI_WriteData(0xfa); + SPI_WriteComm(0xD322); + SPI_WriteData(0x02); + SPI_WriteComm(0xD323); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD324); + SPI_WriteData(0x0b); + SPI_WriteComm(0xD325); + SPI_WriteData(0x13); + SPI_WriteComm(0xD326); + SPI_WriteData(0x1d); + SPI_WriteComm(0xD327); + SPI_WriteData(0x26); + SPI_WriteComm(0xD328); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD329); + SPI_WriteData(0x30); + SPI_WriteComm(0xD32A); + SPI_WriteData(0x3c); + SPI_WriteComm(0xD32B); + SPI_WriteData(0x4A); + SPI_WriteComm(0xD32C); + SPI_WriteData(0x63); + SPI_WriteComm(0xD32D); + SPI_WriteData(0xea); + SPI_WriteComm(0xD32E); + SPI_WriteData(0x79); + SPI_WriteComm(0xD32F); + SPI_WriteData(0xa6); + SPI_WriteComm(0xD330); + SPI_WriteData(0xd0); + SPI_WriteComm(0xD331); + SPI_WriteData(0x20); + SPI_WriteComm(0xD332); + SPI_WriteData(0x0f); + SPI_WriteComm(0xD333); + SPI_WriteData(0x8e); + SPI_WriteComm(0xD334); + SPI_WriteData(0xff); + + //GAMMA SETING RED + SPI_WriteComm(0xD400); + SPI_WriteData(0x00); + SPI_WriteComm(0xD401); + SPI_WriteData(0x00); + SPI_WriteComm(0xD402); + SPI_WriteData(0x1b); + SPI_WriteComm(0xD403); + SPI_WriteData(0x44); + SPI_WriteComm(0xD404); + SPI_WriteData(0x62); + SPI_WriteComm(0xD405); + SPI_WriteData(0x00); + SPI_WriteComm(0xD406); + SPI_WriteData(0x7b); + SPI_WriteComm(0xD407); + SPI_WriteData(0xa1); + SPI_WriteComm(0xD408); + SPI_WriteData(0xc0); + SPI_WriteComm(0xD409); + SPI_WriteData(0xee); + SPI_WriteComm(0xD40A); + SPI_WriteData(0x55); + SPI_WriteComm(0xD40B); + SPI_WriteData(0x10); + SPI_WriteComm(0xD40C); + SPI_WriteData(0x2c); + SPI_WriteComm(0xD40D); + SPI_WriteData(0x43); + SPI_WriteComm(0xD40E); + SPI_WriteData(0x57); + SPI_WriteComm(0xD40F); + SPI_WriteData(0x55); + SPI_WriteComm(0xD410); + SPI_WriteData(0x68); + SPI_WriteComm(0xD411); + SPI_WriteData(0x78); + SPI_WriteComm(0xD412); + SPI_WriteData(0x87); + SPI_WriteComm(0xD413); + SPI_WriteData(0x94); + SPI_WriteComm(0xD414); + SPI_WriteData(0x55); + SPI_WriteComm(0xD415); + SPI_WriteData(0xa0); + SPI_WriteComm(0xD416); + SPI_WriteData(0xac); + SPI_WriteComm(0xD417); + SPI_WriteData(0xb6); + SPI_WriteComm(0xD418); + SPI_WriteData(0xc1); + SPI_WriteComm(0xD419); + SPI_WriteData(0x55); + SPI_WriteComm(0xD41A); + SPI_WriteData(0xcb); + SPI_WriteComm(0xD41B); + SPI_WriteData(0xcd); + SPI_WriteComm(0xD41C); + SPI_WriteData(0xd6); + SPI_WriteComm(0xD41D); + SPI_WriteData(0xdf); + SPI_WriteComm(0xD41E); + SPI_WriteData(0x95); + SPI_WriteComm(0xD41F); + SPI_WriteData(0xe8); + SPI_WriteComm(0xD420); + SPI_WriteData(0xf1); + SPI_WriteComm(0xD421); + SPI_WriteData(0xfa); + SPI_WriteComm(0xD422); + SPI_WriteData(0x02); + SPI_WriteComm(0xD423); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD424); + SPI_WriteData(0x0b); + SPI_WriteComm(0xD425); + SPI_WriteData(0x13); + SPI_WriteComm(0xD426); + SPI_WriteData(0x1d); + SPI_WriteComm(0xD427); + SPI_WriteData(0x26); + SPI_WriteComm(0xD428); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD429); + SPI_WriteData(0x30); + SPI_WriteComm(0xD42A); + SPI_WriteData(0x3c); + SPI_WriteComm(0xD42B); + SPI_WriteData(0x4A); + SPI_WriteComm(0xD42C); + SPI_WriteData(0x63); + SPI_WriteComm(0xD42D); + SPI_WriteData(0xea); + SPI_WriteComm(0xD42E); + SPI_WriteData(0x79); + SPI_WriteComm(0xD42F); + SPI_WriteData(0xa6); + SPI_WriteComm(0xD430); + SPI_WriteData(0xd0); + SPI_WriteComm(0xD431); + SPI_WriteData(0x20); + SPI_WriteComm(0xD432); + SPI_WriteData(0x0f); + SPI_WriteComm(0xD433); + SPI_WriteData(0x8e); + SPI_WriteComm(0xD434); + SPI_WriteData(0xff); + + //GAMMA SETING GREEN + SPI_WriteComm(0xD500); + SPI_WriteData(0x00); + SPI_WriteComm(0xD501); + SPI_WriteData(0x00); + SPI_WriteComm(0xD502); + SPI_WriteData(0x1b); + SPI_WriteComm(0xD503); + SPI_WriteData(0x44); + SPI_WriteComm(0xD504); + SPI_WriteData(0x62); + SPI_WriteComm(0xD505); + SPI_WriteData(0x00); + SPI_WriteComm(0xD506); + SPI_WriteData(0x7b); + SPI_WriteComm(0xD507); + SPI_WriteData(0xa1); + SPI_WriteComm(0xD508); + SPI_WriteData(0xc0); + SPI_WriteComm(0xD509); + SPI_WriteData(0xee); + SPI_WriteComm(0xD50A); + SPI_WriteData(0x55); + SPI_WriteComm(0xD50B); + SPI_WriteData(0x10); + SPI_WriteComm(0xD50C); + SPI_WriteData(0x2c); + SPI_WriteComm(0xD50D); + SPI_WriteData(0x43); + SPI_WriteComm(0xD50E); + SPI_WriteData(0x57); + SPI_WriteComm(0xD50F); + SPI_WriteData(0x55); + SPI_WriteComm(0xD510); + SPI_WriteData(0x68); + SPI_WriteComm(0xD511); + SPI_WriteData(0x78); + SPI_WriteComm(0xD512); + SPI_WriteData(0x87); + SPI_WriteComm(0xD513); + SPI_WriteData(0x94); + SPI_WriteComm(0xD514); + SPI_WriteData(0x55); + SPI_WriteComm(0xD515); + SPI_WriteData(0xa0); + SPI_WriteComm(0xD516); + SPI_WriteData(0xac); + SPI_WriteComm(0xD517); + SPI_WriteData(0xb6); + SPI_WriteComm(0xD518); + SPI_WriteData(0xc1); + SPI_WriteComm(0xD519); + SPI_WriteData(0x55); + SPI_WriteComm(0xD51A); + SPI_WriteData(0xcb); + SPI_WriteComm(0xD51B); + SPI_WriteData(0xcd); + SPI_WriteComm(0xD51C); + SPI_WriteData(0xd6); + SPI_WriteComm(0xD51D); + SPI_WriteData(0xdf); + SPI_WriteComm(0xD51E); + SPI_WriteData(0x95); + SPI_WriteComm(0xD51F); + SPI_WriteData(0xe8); + SPI_WriteComm(0xD520); + SPI_WriteData(0xf1); + SPI_WriteComm(0xD521); + SPI_WriteData(0xfa); + SPI_WriteComm(0xD522); + SPI_WriteData(0x02); + SPI_WriteComm(0xD523); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD524); + SPI_WriteData(0x0b); + SPI_WriteComm(0xD525); + SPI_WriteData(0x13); + SPI_WriteComm(0xD526); + SPI_WriteData(0x1d); + SPI_WriteComm(0xD527); + SPI_WriteData(0x26); + SPI_WriteComm(0xD528); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD529); + SPI_WriteData(0x30); + SPI_WriteComm(0xD52A); + SPI_WriteData(0x3c); + SPI_WriteComm(0xD52B); + SPI_WriteData(0x4a); + SPI_WriteComm(0xD52C); + SPI_WriteData(0x63); + SPI_WriteComm(0xD52D); + SPI_WriteData(0xea); + SPI_WriteComm(0xD52E); + SPI_WriteData(0x79); + SPI_WriteComm(0xD52F); + SPI_WriteData(0xa6); + SPI_WriteComm(0xD530); + SPI_WriteData(0xd0); + SPI_WriteComm(0xD531); + SPI_WriteData(0x20); + SPI_WriteComm(0xD532); + SPI_WriteData(0x0f); + SPI_WriteComm(0xD533); + SPI_WriteData(0x8e); + SPI_WriteComm(0xD534); + SPI_WriteData(0xff); + + //GAMMA SETING BLUE + SPI_WriteComm(0xD600); + SPI_WriteData(0x00); + SPI_WriteComm(0xD601); + SPI_WriteData(0x00); + SPI_WriteComm(0xD602); + SPI_WriteData(0x1b); + SPI_WriteComm(0xD603); + SPI_WriteData(0x44); + SPI_WriteComm(0xD604); + SPI_WriteData(0x62); + SPI_WriteComm(0xD605); + SPI_WriteData(0x00); + SPI_WriteComm(0xD606); + SPI_WriteData(0x7b); + SPI_WriteComm(0xD607); + SPI_WriteData(0xa1); + SPI_WriteComm(0xD608); + SPI_WriteData(0xc0); + SPI_WriteComm(0xD609); + SPI_WriteData(0xee); + SPI_WriteComm(0xD60A); + SPI_WriteData(0x55); + SPI_WriteComm(0xD60B); + SPI_WriteData(0x10); + SPI_WriteComm(0xD60C); + SPI_WriteData(0x2c); + SPI_WriteComm(0xD60D); + SPI_WriteData(0x43); + SPI_WriteComm(0xD60E); + SPI_WriteData(0x57); + SPI_WriteComm(0xD60F); + SPI_WriteData(0x55); + SPI_WriteComm(0xD610); + SPI_WriteData(0x68); + SPI_WriteComm(0xD611); + SPI_WriteData(0x78); + SPI_WriteComm(0xD612); + SPI_WriteData(0x87); + SPI_WriteComm(0xD613); + SPI_WriteData(0x94); + SPI_WriteComm(0xD614); + SPI_WriteData(0x55); + SPI_WriteComm(0xD615); + SPI_WriteData(0xa0); + SPI_WriteComm(0xD616); + SPI_WriteData(0xac); + SPI_WriteComm(0xD617); + SPI_WriteData(0xb6); + SPI_WriteComm(0xD618); + SPI_WriteData(0xc1); + SPI_WriteComm(0xD619); + SPI_WriteData(0x55); + SPI_WriteComm(0xD61A); + SPI_WriteData(0xcb); + SPI_WriteComm(0xD61B); + SPI_WriteData(0xcd); + SPI_WriteComm(0xD61C); + SPI_WriteData(0xd6); + SPI_WriteComm(0xD61D); + SPI_WriteData(0xdf); + SPI_WriteComm(0xD61E); + SPI_WriteData(0x95); + SPI_WriteComm(0xD61F); + SPI_WriteData(0xe8); + SPI_WriteComm(0xD620); + SPI_WriteData(0xf1); + SPI_WriteComm(0xD621); + SPI_WriteData(0xfa); + SPI_WriteComm(0xD622); + SPI_WriteData(0x02); + SPI_WriteComm(0xD623); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD624); + SPI_WriteData(0x0b); + SPI_WriteComm(0xD625); + SPI_WriteData(0x13); + SPI_WriteComm(0xD626); + SPI_WriteData(0x1d); + SPI_WriteComm(0xD627); + SPI_WriteData(0x26); + SPI_WriteComm(0xD628); + SPI_WriteData(0xaa); + SPI_WriteComm(0xD629); + SPI_WriteData(0x30); + SPI_WriteComm(0xD62A); + SPI_WriteData(0x3c); + SPI_WriteComm(0xD62B); + SPI_WriteData(0x4A); + SPI_WriteComm(0xD62C); + SPI_WriteData(0x63); + SPI_WriteComm(0xD62D); + SPI_WriteData(0xea); + SPI_WriteComm(0xD62E); + SPI_WriteData(0x79); + SPI_WriteComm(0xD62F); + SPI_WriteData(0xa6); + SPI_WriteComm(0xD630); + SPI_WriteData(0xd0); + SPI_WriteComm(0xD631); + SPI_WriteData(0x20); + SPI_WriteComm(0xD632); + SPI_WriteData(0x0f); + SPI_WriteComm(0xD633); + SPI_WriteData(0x8e); + SPI_WriteComm(0xD634); + SPI_WriteData(0xff); + + //AVDD VOLTAGE SETTING + SPI_WriteComm(0xB000); + SPI_WriteData(0x05); + SPI_WriteComm(0xB001); + SPI_WriteData(0x05); + SPI_WriteComm(0xB002); + SPI_WriteData(0x05); + //AVEE VOLTAGE SETTING + SPI_WriteComm(0xB100); + SPI_WriteData(0x05); + SPI_WriteComm(0xB101); + SPI_WriteData(0x05); + SPI_WriteComm(0xB102); + SPI_WriteData(0x05); + + //AVDD Boosting + SPI_WriteComm(0xB600); + SPI_WriteData(0x34); + SPI_WriteComm(0xB601); + SPI_WriteData(0x34); + SPI_WriteComm(0xB603); + SPI_WriteData(0x34); + //AVEE Boosting + SPI_WriteComm(0xB700); + SPI_WriteData(0x24); + SPI_WriteComm(0xB701); + SPI_WriteData(0x24); + SPI_WriteComm(0xB702); + SPI_WriteData(0x24); + //VCL Boosting + SPI_WriteComm(0xB800); + SPI_WriteData(0x24); + SPI_WriteComm(0xB801); + SPI_WriteData(0x24); + SPI_WriteComm(0xB802); + SPI_WriteData(0x24); + //VGLX VOLTAGE SETTING + SPI_WriteComm(0xBA00); + SPI_WriteData(0x14); + SPI_WriteComm(0xBA01); + SPI_WriteData(0x14); + SPI_WriteComm(0xBA02); + SPI_WriteData(0x14); + //VCL Boosting + SPI_WriteComm(0xB900); + SPI_WriteData(0x24); + SPI_WriteComm(0xB901); + SPI_WriteData(0x24); + SPI_WriteComm(0xB902); + SPI_WriteData(0x24); + //Gamma Voltage + SPI_WriteComm(0xBc00); + SPI_WriteData(0x00); + SPI_WriteComm(0xBc01); + SPI_WriteData(0xa0); //vgmp=5.0 + SPI_WriteComm(0xBc02); + SPI_WriteData(0x00); + SPI_WriteComm(0xBd00); + SPI_WriteData(0x00); + SPI_WriteComm(0xBd01); + SPI_WriteData(0xa0); //vgmn=5.0 + SPI_WriteComm(0xBd02); + SPI_WriteData(0x00); + //VCOM Setting + SPI_WriteComm(0xBe01); + SPI_WriteData(0x3d); //3 + //ENABLE PAGE 0 + SPI_WriteComm(0xF000); + SPI_WriteData(0x55); + SPI_WriteComm(0xF001); + SPI_WriteData(0xAA); + SPI_WriteComm(0xF002); + SPI_WriteData(0x52); + SPI_WriteComm(0xF003); + SPI_WriteData(0x08); + SPI_WriteComm(0xF004); + SPI_WriteData(0x00); + //Vivid Color Function Control + SPI_WriteComm(0xB400); + SPI_WriteData(0x10); + //Z-INVERSION + SPI_WriteComm(0xBC00); + SPI_WriteData(0x05); + SPI_WriteComm(0xBC01); + SPI_WriteData(0x05); + SPI_WriteComm(0xBC02); + SPI_WriteData(0x05); + + //*************** add on 20111021**********************// + SPI_WriteComm(0xB700); + SPI_WriteData(0x22); //GATE EQ CONTROL + SPI_WriteComm(0xB701); + SPI_WriteData(0x22); //GATE EQ CONTROL + + SPI_WriteComm(0xC80B); + SPI_WriteData(0x2A); //DISPLAY TIMING CONTROL + SPI_WriteComm(0xC80C); + SPI_WriteData(0x2A); //DISPLAY TIMING CONTROL + SPI_WriteComm(0xC80F); + SPI_WriteData(0x2A); //DISPLAY TIMING CONTROL + SPI_WriteComm(0xC810); + SPI_WriteData(0x2A); //DISPLAY TIMING CONTROL + //*************** add on 20111021**********************// + //PWM_ENH_OE =1 + SPI_WriteComm(0xd000); + SPI_WriteData(0x01); + //DM_SEL =1 + SPI_WriteComm(0xb300); + SPI_WriteData(0x10); + //VBPDA=07h + SPI_WriteComm(0xBd02); + SPI_WriteData(0x07); + //VBPDb=07h + SPI_WriteComm(0xBe02); + SPI_WriteData(0x07); + //VBPDc=07h + SPI_WriteComm(0xBf02); + SPI_WriteData(0x07); + //ENABLE PAGE 2 + SPI_WriteComm(0xF000); + SPI_WriteData(0x55); + SPI_WriteComm(0xF001); + SPI_WriteData(0xAA); + SPI_WriteComm(0xF002); + SPI_WriteData(0x52); + SPI_WriteComm(0xF003); + SPI_WriteData(0x08); + SPI_WriteComm(0xF004); + SPI_WriteData(0x02); + //SDREG0 =0 + SPI_WriteComm(0xc301); + SPI_WriteData(0xa9); + //DS=14 + SPI_WriteComm(0xfe01); + SPI_WriteData(0x94); + //OSC =60h + SPI_WriteComm(0xf600); + SPI_WriteData(0x60); + //TE ON + SPI_WriteComm(0x3500); + SPI_WriteData(0x00); + + SPI_WriteComm(0x3600); + SPI_WriteData(0x0048); + SPI_WriteComm(0x1100); + LCD_delay(120); + + SPI_WriteComm(0x2900); + + SPI_WriteComm(0x2c00); + SPI_WriteComm(0x3c00); +} +void LCD_Initial(rt_uint32_t LTDC_Buf1, rt_uint32_t LTDC_Buf2) //LCD初始化函数 +{ + GPIO_RGB_INIT(); //初始化液晶屏相关GPIO + LCD_Reset(); //复位液晶屏 + + LTDC_Clock_Set(); + Set_LCD_Timing_to_LTDC(LTDC_Buf1, LTDC_Buf2); + Lcd_Initialize(); + Lcd_Light_ON; //打开背光 +} + + + +/********************************************** +函数名：Lcd矩形填充函数 + +入口参数：xStart x方向的起始点 + ySrart y方向的终止点 + xLong 要选定矩形的x方向长度 + yLong 要选定矩形的y方向长度 +返回值：无 +***********************************************/ +// void Lcd_ColorBox(rt_uint16_t xStart, rt_uint16_t yStart, rt_uint16_t xLong, rt_uint16_t yLong, rt_uint32_t Color) +// { +// rt_uint16_t i, j; +// rt_uint32_t temp; +// temp = YSIZE_PHYS * xStart; +// for (i = 0; i < yLong; i++) +// { +// for (j = 0; j < xLong; j++) +// LTDC_Buf[yStart + i + YSIZE_PHYS * j + temp] = Color; +// } + +// // rt_uint16_t i,j; +// // rt_uint32_t temp; +// // temp = XSIZE_PHYS*yStart; +// // for(i=0;i"~" +fColor 前景色 +bColor 背景色 +flag: 有背景色(1)无背景色(0) +*********************************************/ +// void SPILCD_ShowChar(unsigned short x, unsigned short y, unsigned char num, unsigned int fColor, unsigned int bColor, unsigned char flag) +// { +// unsigned char temp; +// unsigned int pos, i, j; + +// num = num - ' '; //得到偏移后的值 +// i = num * 16; +// for (pos = 0; pos < 16; pos++) +// { +// temp = nAsciiDot[i + pos]; //调通调用ASCII字体 +// for (j = 0; j < 8; j++) +// { +// if (temp & 0x80) +// DrawPixel(x + j, y, fColor); +// else if (flag) +// DrawPixel(x + j, y, bColor); //如果背景色标志flag为1 +// temp <<= 1; +// } +// y++; +// } +// } + +/**********写一个16x16的汉字***************** +(x,y): 显示汉字的起始坐标 +c[2]: 要显示的汉字 +fColor 前景色 +bColor 背景色 +flag: 有背景色(1)无背景色(0) +*********************************************/ +// void PutGB1616(unsigned short x, unsigned short y, unsigned char c[2], unsigned int fColor, unsigned int bColor, unsigned char flag) +// { +// unsigned int i, j, k; +// unsigned short m; +// for (k = 0; k < 64; k++) +// { //64标示自建汉字库中的个数，循环查询内码 +// if ((codeGB_16[k].Index[0] == c[0]) && (codeGB_16[k].Index[1] == c[1])) +// { +// for (i = 0; i < 32; i++) +// { +// m = codeGB_16[k].Msk[i]; +// for (j = 0; j < 8; j++) +// { +// if ((m & 0x80) == 0x80) +// { +// DrawPixel(x + j, y, fColor); +// } +// else +// { +// if (flag) +// DrawPixel(x + j, y, bColor); +// } +// m = m << 1; +// } +// if (i % 2) +// { +// y++; +// x = x - 8; +// } +// else +// x = x + 8; +// } +// } +// } +// } +/**********显示一串字***************** +(x,y): 字符串的起始坐标 +*s: 要显示的字符串指针 +fColor 前景色 +bColor 背景色 +flag: 有背景色(1)无背景色(0) +*********************************************/ +// void LCD_PutString(unsigned short x, unsigned short y, char *s, unsigned int fColor, unsigned int bColor, unsigned char flag) +// { +// unsigned char l = 0; +// while (*s) +// { +// if (*s < 0x80) +// { +// SPILCD_ShowChar(x + l * 8, y, *s, fColor, bColor, flag); +// s++; +// l++; +// } +// else +// { +// PutGB1616(x + l * 8, y, (unsigned char *)s, fColor, bColor, flag); +// s += 2; +// l += 2; +// } +// } +// } diff --git a/bsp/tkm32F499/drivers/lcd/lcd.h b/bsp/tkm32F499/drivers/lcd/lcd.h new file mode 100644 index 0000000000..9bdb147b6e --- /dev/null +++ b/bsp/tkm32F499/drivers/lcd/lcd.h @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-10-14 spaceman first version + */ + +#include + +// #define XSIZE_PHYS 800 +// #define YSIZE_PHYS 480 +// extern __align(256) rt_uint32_t LTDC_Buf[XSIZE_PHYS*YSIZE_PHYS]; +#define LCD_SPI_CS(a) \ + if (a) \ + GPIOB->BSRR = GPIO_Pin_11; \ + else \ + GPIOB->BRR = GPIO_Pin_11; +#define SPI_DCLK(a) \ + if (a) \ + GPIOB->BSRR = GPIO_Pin_9; \ + else \ + GPIOB->BRR = GPIO_Pin_9; +#define SPI_SDA(a) \ + if (a) \ + GPIOB->BSRR = GPIO_Pin_0; \ + else \ + GPIOB->BRR = GPIO_Pin_0; + +#define LCD_RST(a) \ + if (a) \ + GPIOD->BSRR = GPIO_Pin_6; \ + else \ + GPIOD->BRR = GPIO_Pin_6; +#define Set_Rst GPIOD->BSRR = GPIO_Pin_6 +#define Clr_Rst GPIOD->BRR = GPIO_Pin_6 +#define Lcd_Light_ON GPIOD->BSRR = GPIO_Pin_8 //PD8为高电平 背光打开 +#define Lcd_Light_OFF GPIOD->BRR = GPIO_Pin_8 //PD8为低电平 背光关闭 + +//************* 24位色（1600万色）定义 *************// +#define White 0xFFFFFF +#define Black 0x000000 +#define Blue 0xFF0000 +#define Blue2 0xFF3F3F +#define Red 0x0000FF +#define Magenta 0xFF00FF +#define Green 0x00FF00 +#define Cyan 0xFFFF00 +#define Yellow 0x00FFFF + +//************* 16位色定义 *************// +//#define White 0xFFFF +//#define Black 0x0000 +//#define Blue 0x001F +//#define Blue2 0x051F +//#define Red 0xF800 +//#define Magenta 0xF81F +//#define Green 0x07E0 +//#define Cyan 0x7FFF +//#define Yellow 0xFFE0 + + + +void LCD_Initial(rt_uint32_t LTDC_Buf1, rt_uint32_t LTDC_Buf2); //LCD初始化函数 +// volatile void LCD_delay(volatile int time); +// void WriteComm(unsigned char CMD); +// void WriteData(rt_uint32_t dat); +// void LCD_WR_REG(rt_uint16_t Index,rt_uint16_t CongfigTemp); +// void Lcd_ColorBox(rt_uint16_t xStart,rt_uint16_t yStart,rt_uint16_t xLong,rt_uint16_t yLong,rt_uint32_t Color); +//void SPILCD_DrawLine(unsigned short x1,unsigned short y1,unsigned short x2,unsigned short y2,unsigned short color); +//void SPILCD_ShowChar(unsigned short x,unsigned short y,unsigned char num, unsigned int fColor, unsigned int bColor,unsigned char flag) ; +// void LCD_PutString(unsigned short x, unsigned short y, char *s, unsigned int fColor, unsigned int bColor,unsigned char flag); +// void LCD_Fill_Pic(rt_uint16_t x, rt_uint16_t y,rt_uint16_t pic_H, rt_uint16_t pic_V, rt_uint32_t* pic); diff --git a/bsp/tkm32F499/drivers/lcd_port.h b/bsp/tkm32F499/drivers/lcd_port.h new file mode 100644 index 0000000000..e11e757b93 --- /dev/null +++ b/bsp/tkm32F499/drivers/lcd_port.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2006-2021, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-10-14 spaceman first version + */ + +#ifndef __LCD_PORT_H__ +#define __LCD_PORT_H__ + +/* TK043F1508 RM68120 5 inch screen, 800 * 480 */ +#define LCD_WIDTH 800 +#define LCD_HEIGHT 480 +#define LCD_BITS_PER_PIXEL 32 +#define LCD_BUF_SIZE (LCD_WIDTH * LCD_HEIGHT * LCD_BITS_PER_PIXEL / 8) +#define LCD_PIXEL_FORMAT RTGRAPHIC_PIXEL_FORMAT_RGB565 + +#define LCD_HSYNC_WIDTH 96 +#define LCD_VSYNC_HEIGHT 2 +#define LCD_HBP 10 +#define LCD_VBP 10 +#define LCD_HFP 10 +#define LCD_VFP 10 + +#define LCD_BACKLIGHT_USING_GPIO +#define LCD_BL_GPIO_NUM -1 +#define LCD_DISP_GPIO_NUM -1 + +/* TK043F1508 RM68120 5 inch screen, 800 * 480 */ + +#endif /* __LCD_PORT_H__ */