many improvements to driver

Author: seandepagnier

build

@@ -1,4 +1,6 @@
 PATH=../../../esp/xtensa-esp32-elf/bin/:$PATH ESPIDF=../../../esp-idf/ make USER_C_MODULES=../../../modules CFLAGS_EXTRA="-DMODULE_UGFX_ENABLED=1" all
 
+BOARD=GENERIC_SPIRAM
+
 esptool.py --chip esp32 erase_flash
 esptool.py --baud 921600 --chip esp32  write_flash -z 0x1000 build-GENERIC/firmware.bin

fonts.h

@@ -30,22 +30,40 @@
  before the transaction is sent, the callback will set this line to the correct state.
 */
 
+#define TDISPLAY
+
+#ifdef TDISPLAY
 #define PIN_NUM_MISO 17
 #define PIN_NUM_MOSI 19
 #define PIN_NUM_CLK  18
 #define PIN_NUM_CS   5
 
 #define PIN_NUM_DC   16
 #define PIN_NUM_RST  20
+#define LINE_LEN 136
+
+#else
+
+#define PIN_NUM_MISO 12
+#define PIN_NUM_MOSI 23
+#define PIN_NUM_CLK  18
+#define PIN_NUM_CS   27
+
+#define PIN_NUM_DC   32
+#define PIN_NUM_RST  05
+
+#define LINE_LEN 240
+#endif
+
 #define PIN_NUM_BCKL 4
 
 //To speed up transfers, every SPI transfer sends a bunch of lines. This define specifies how many. More means more memory use,
 //but less overhead for setting up / finishing transfers. Make sure 240 is dividable by this.
-#define PARALLEL_LINES 24 // must divide into 240...
-#define LINE_LEN 136
+#define PARALLEL_LINES 20 // must divide into 240 and 320
 
 static spi_device_handle_t ili_spi;
 static uint16_t *dma_lines[2];
+static uint8_t backlight = 0;
 
 /*
  The LCD needs a bunch of command/argument values to be initialized. They are stored in this struct.
@@ -56,48 +74,6 @@ typedef struct {
     uint8_t databytes; //No of data in data; bit 7 = delay after set; 0xFF = end of cmds.
 } lcd_init_cmd_t;
 
-typedef enum {
-    LCD_TYPE_ILI = 1,
-    LCD_TYPE_ST,
-    LCD_TYPE_MAX,
-} type_lcd_t;
-
-//Place data into DRAM. Constant data gets placed into DROM by default, which is not accessible by DMA.
-DRAM_ATTR static const lcd_init_cmd_t st_init_cmds[]={
-    /* Memory Data Access Control, MX=MV=1, MY=ML=MH=0, RGB=0 */
-    {0x36, {(1<<5)|(1<<6)}, 1},
-    /* Interface Pixel Format, 16bits/pixel for RGB/MCU interface */
-//    {0x3A, {0x55}, 1},
-        {0x3A, {0x66}, 1},
-    /* Porch Setting */
-    {0xB2, {0x0c, 0x0c, 0x00, 0x33, 0x33}, 5},
-    /* Gate Control, Vgh=13.65V, Vgl=-10.43V */
-    {0xB7, {0x45}, 1},
-    /* VCOM Setting, VCOM=1.175V */
-    {0xBB, {0x2B}, 1},
-    /* LCM Control, XOR: BGR, MX, MH */
-    {0xC0, {0x2C}, 1},
-    /* VDV and VRH Command Enable, enable=1 */
-    {0xC2, {0x01, 0xff}, 2},
-    /* VRH Set, Vap=4.4+... */
-    {0xC3, {0x11}, 1},
-    /* VDV Set, VDV=0 */
-    {0xC4, {0x20}, 1},
-    /* Frame Rate Control, 60Hz, inversion=0 */
-    {0xC6, {0x0f}, 1},
-    /* Power Control 1, AVDD=6.8V, AVCL=-4.8V, VDDS=2.3V */
-    {0xD0, {0xA4, 0xA1}, 1},
-    /* Positive Voltage Gamma Control */
-    {0xE0, {0xD0, 0x00, 0x05, 0x0E, 0x15, 0x0D, 0x37, 0x43, 0x47, 0x09, 0x15, 0x12, 0x16, 0x19}, 14},
-    /* Negative Voltage Gamma Control */
-    {0xE1, {0xD0, 0x00, 0x05, 0x0D, 0x0C, 0x06, 0x2D, 0x44, 0x40, 0x0E, 0x1C, 0x18, 0x16, 0x19}, 14},
-    /* Sleep Out */
-    {0x11, {0}, 0x80},
-    /* Display On */
-    {0x29, {0}, 0x80},
-    {0, {0}, 0xff}
-};
-
 #if 0
 DRAM_ATTR static const lcd_init_cmd_t ili_init_cmds[]={
     /* Power contorl B, power control = 0, DC_ENA = 1 */
@@ -158,24 +134,63 @@ DRAM_ATTR static const lcd_init_cmd_t ili_init_cmds[]={
     {0x29, {0}, 0x80},
     {0, {0}, 0xff},
 };
+#elif 1
+DRAM_ATTR static const lcd_init_cmd_t ili_init_cmds[]={
+//    {0x01, {0}, 0}, // software reset
+    {0xCB, {0x39, 0x2C, 0x00, 0x34, 0x02},  5},
+    {0xCF, {0x00, 0X83, 0X30},  3},
+//    {0xEF, {0x03, 0x80, 0x02},  3},
+    {0xE8, {0x84, 0x11, 0x7a},  3},
+    {0xEA, {0x00, 0x00},  2},
+    {0xED, {0x64, 0x03, 0X12, 0X81},  4},
+    {0xF7, {0x30},  1},
+    {0xC0, {0x29},  1},  //Power control VRH[5:0]
+    {0xC1, {0x00},  1},  //Power control SAP[2:0];BT[3:0]
+    {0xC5, {0x31, 0x08},  2},  //VCM control
+    {0xC7, {0xC0},  1},  //VCM control2
+#ifdef TDISPLAY
+    {0x36, {0xC8}, 1},
+    {0x21, {0}, 0}, // invert on
+#else
+    {0x36, {0x48}, 1},
+    {0x20, {0}, 0}, // invert off
+#endif 
+    {0x3A, {0x55},  1},  // *** INTERFACE PIXEL FORMAT: 0x66 -> 18 bit; 0x55 -> 16 bit
+     {0xB1, {0x00, 0x1B},  2},
+     {0xB6, {0x08, 0x82, 0x27, 0x00},  4},  // Display Function Control
+//    {0x30, {0x00, 0x00, 0x01, 0x3F},  4},
+    {0xF2, {0x02},  1},  // 3Gamma Function: Disable (0x02), Enable (0x03)
+    {0xE0, {0x1F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0X87, 0x32, 0x0A, 0x07, 0x02, 0x07, 0x05, 0x00}, 15},
+    {0xE1, {0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05, 0x18, 0x0D, 0x38, 0x3A, 0x1F}, 15},
+//    {0x26, {0x08},  1},  //Gamma curve selected (0x01, 0x02, 0x04, 0x08)
+//    {0xE0, {  	  0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08, 0x4E, 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00},  15},						//Positive Gamma Correction
+//    {0xE1, { 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07, 0x31, 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F},  15},
+    {0x11, {0}, 0x80},    //  Sleep out
+     {0x29, {0}, 0x80},    // Display on
+    {0, {0}, 0xff}
+};
 #else
 DRAM_ATTR static const lcd_init_cmd_t ili_init_cmds[]={
 //    {0x01, {0}, 0}, // software reset
+     {0x20, {0}, 0}, // invert off
     {0xCB, {0x39, 0x2C, 0x00, 0x34, 0x02},  5},
-    {0xCF, {0x00, 0XC1, 0X30},  3},
+    {0xCF, {0x00, 0xC1, 0x30},  3},
     {0xEF, {0x03, 0x80, 0x02},  3},
     {0xE8, {0x85, 0x00, 0x78},  3},
     {0xEA, {0x00, 0x00},  2},
-    {0xED, {0x64, 0x03, 0X12, 0X81},  4},
+    {0xED, {0x64, 0x03, 0x12, 0x81},  4},
     {0xF7, {0x20},  1},
     {0xC0, {0x23},  1},  //Power control VRH[5:0]
     {0xC1, {0x10},  1},  //Power control SAP[2:0];BT[3:0]
     {0xC5, {0x3e, 0x28},  2},  //VCM control
     {0xC7, {0x86},  1},  //VCM control2
+#ifdef TDISPLAY
     {0x36, {0x28}, 1},
+#else
+    {0x36, {0x48}, 1},
+#endif 
     {0x3A, {0x55},  1},  // *** INTERFACE PIXEL FORMAT: 0x66 -> 18 bit; 0x55 -> 16 bit
-     {0x20, {0}, 0}, // invert off
-     {0xB1, {0x00, 0x1B},  2},
+     {0xB1, {0x03, 0x1f},  2},
      {0xB6, {0x08, 0x82, 0x27, 0x00},  4},  // Display Function Control
 //    {0x30, {0x00, 0x00, 0x01, 0x3F},  4},
 //    {0xF2, {0x00},  1},  // 3Gamma Function: Disable (0x02), Enable (0x03)
@@ -186,9 +201,6 @@ DRAM_ATTR static const lcd_init_cmd_t ili_init_cmds[]={
      {0x29, {0}, 0x80},    // Display on
     {0, {0}, 0xff}
 };
-
-
-
 #endif
 
 /* Send a command to the LCD. Uses spi_device_polling_transmit, which waits
@@ -263,52 +275,23 @@ static void lcd_init()
     int cmd=0;
     const lcd_init_cmd_t* lcd_init_cmds;
 
-    //Initialize non-SPI GPIOs
-    gpio_set_direction(PIN_NUM_DC, GPIO_MODE_OUTPUT);
-    gpio_set_direction(PIN_NUM_RST, GPIO_MODE_OUTPUT);
-    gpio_set_direction(PIN_NUM_BCKL, GPIO_MODE_OUTPUT);
 
     //Reset the display
     gpio_set_level(PIN_NUM_RST, 0);
-    vTaskDelay(100 / portTICK_RATE_MS);
+    vTaskDelay(50 / portTICK_RATE_MS);
     gpio_set_level(PIN_NUM_RST, 1);
-    vTaskDelay(100 / portTICK_RATE_MS);
+    vTaskDelay(50 / portTICK_RATE_MS);
 
+    lcd_cmd(TFT_CMD_SWRESET);
+    vTaskDelay(10 / portTICK_RATE_MS);
     lcd_cmd(TFT_CMD_SWRESET);
 
     //detect LCD type
     uint32_t lcd_id = lcd_get_id(ili_spi);
     int lcd_detected_type = 0;
     int lcd_type;
 
-    printf("LCD ID: %08X\n", lcd_id);
-    if ( lcd_id == 0 ) {
-        //zero, ili
-        lcd_detected_type = LCD_TYPE_ILI;
-        printf("ILI9341 detected.\n");
-    } else {
-        // none-zero, ST
-        lcd_detected_type = LCD_TYPE_ST;
-        printf("ST7789V detected.\n");
-    }
-
-    lcd_type = lcd_detected_type;
-#ifdef CONFIG_LCD_TYPE_AUTO
-
-#elif defined( CONFIG_LCD_TYPE_ST7789V )
-    printf("kconfig: force CONFIG_LCD_TYPE_ST7789V.\n");
-    lcd_type = LCD_TYPE_ST;
-#elif defined( CONFIG_LCD_TYPE_ILI9341 )
-    printf("kconfig: force CONFIG_LCD_TYPE_ILI9341.\n");
-    lcd_type = LCD_TYPE_ILI;
-#endif
-    if ( lcd_type == LCD_TYPE_ST ) {
-        printf("LCD ST7789V initialization.\n");
-        lcd_init_cmds = st_init_cmds;
-    } else {
-        printf("LCD ILI9341 initialization.\n");
-        lcd_init_cmds = ili_init_cmds;
-    }
+    lcd_init_cmds = ili_init_cmds;
 
     //Send all the commands
     while (lcd_init_cmds[cmd].databytes!=0xff) {
@@ -319,9 +302,6 @@ static void lcd_init()
         }
         cmd++;
     }
-  
-    ///Enable backlight
-    gpio_set_level(PIN_NUM_BCKL, 1);
 }
 
 
@@ -369,12 +349,18 @@ static void send_lines(int ypos, int line)
         }
         trans[x].flags=SPI_TRANS_USE_TXDATA;
     }
-    ypos += 41;
+#ifdef TDISPLAY
+    const int sx = 52, sy = 41;
+#else
+    const int sx = 0, sy = 1;
+#endif
+    
+    ypos += sy;
     trans[0].tx_data[0]=0x2A;           //Column Address Set
     trans[1].tx_data[0]=0;              //Start Col High
-    trans[1].tx_data[1]=52;             //Start Col Low
-    trans[1].tx_data[2]=(52+LINE_LEN-1)>>8;       //End Col High
-    trans[1].tx_data[3]=(52+LINE_LEN-1)&0xff;     //End Col Low
+    trans[1].tx_data[1]=sx;             //Start Col Low
+    trans[1].tx_data[2]=(sx+LINE_LEN-1)>>8;       //End Col High
+    trans[1].tx_data[3]=(sx+LINE_LEN-1)&0xff;     //End Col Low
     trans[2].tx_data[0]=0x2B;           //Page address set
     trans[3].tx_data[0]=ypos>>8;        //Start page high
     trans[3].tx_data[1]=ypos&0xff;      //start page low
@@ -411,7 +397,7 @@ static void lcd_setup() {
         .max_transfer_sz=PARALLEL_LINES*LINE_LEN*2+8
     };
     spi_device_interface_config_t devcfg={
-        .clock_speed_hz=10*1000*1000,           //Clock out at 10 MHz
+        .clock_speed_hz=20*1000*1000,           //Clock out at 10 MHz
         .mode=0,                                //SPI mode 0
         .spics_io_num=PIN_NUM_CS,               //CS pin
         .queue_size=5,                          //We want to be able to queue 7 transactions at a time
@@ -423,53 +409,98 @@ static void lcd_setup() {
     //Attach the LCD to the SPI bus
     ret=spi_bus_add_device(HSPI_HOST, &devcfg, &ili_spi);
     ESP_ERROR_CHECK(ret);
-    //Initialize the LCD
-    lcd_init(ili_spi);
     //Allocate memory for the pixel buffers
     for (int i=0; i<2; i++) {
         dma_lines[i]=heap_caps_malloc(LINE_LEN*PARALLEL_LINES*sizeof(uint16_t), MALLOC_CAP_DMA);
         memset(dma_lines[i], 0, LINE_LEN*PARALLEL_LINES*sizeof(uint16_t));
     }
+
+    //Initialize non-SPI GPIOs
+    gpio_set_direction(PIN_NUM_DC, GPIO_MODE_OUTPUT);
+    gpio_set_direction(PIN_NUM_RST, GPIO_MODE_OUTPUT);
+    gpio_set_direction(PIN_NUM_BCKL, GPIO_MODE_OUTPUT);
+
+    ///Disable backlight
+    gpio_set_level(PIN_NUM_BCKL, 0);
 }
 
-static uint8_t minc(uint32_t c) {
+static uint8_t minc(int32_t c) {
     if(c > 255)
+        return 255;
+    return c;
+}
+
+static uint8_t nn(int32_t c)
+{
+    if (c<0)
         return 0;
-    return 255-c;
+    return c;
 }
 
-void ili_refresh(int contrast, int hue, int width, int height, char *data)
+
+void ili_refresh(int contrast, int hue, int bl, int width, int height, char *data)
 {
-    static int initialized;
-    if(!initialized) {
+    static int setup, initialized;
+    if(!setup) {
         lcd_setup();
+        setup = 1;
+    }
+    
+    if(bl != backlight) {
+        backlight = !!bl;
+        ///Enable backlight
+        gpio_set_level(PIN_NUM_BCKL, backlight);
+        if(!backlight) {
+            lcd_cmd(TFT_CMD_SWRESET);
+            initialized = 0;
+        }
+    }   
+
+    if(!backlight) {
+        initialized = 0;
+        return;
+    }
+
+    if(!initialized) {
+        lcd_init();
         initialized = 1;
     }
 
+#if 1
+    lcd_cmd(0x36);
+    uint8_t d[1] = {0xC8};
+    lcd_data(d, 1);
+#endif
+    
     // rebuild palette if needed
     static int last_contrast = -1, last_hue = -1;
     static uint16_t palette[256];
+    contrast = 100;
     if(contrast != last_contrast || hue != last_hue) {
-        uint32_t c = contrast, h = hue;
-        uint32_t r, g, b;
+        last_contrast = contrast;
+        last_hue = hue;
+        int32_t c = contrast, h = hue;
+        int32_t r, g, b;
         if(h < 85) {
-            r = 85 - h;
-            g = 85 - r;
-            b = 0;
+            r = 85;
+            g = nn(2*h - 85);
+            b = nn(85 - 2*h);
         } else if(h < 170) {
-            r = 0;
-            g = 170 - h;
-            b = 85 - g;
+            r = nn(85 - 2*(h-85));
+            g = 85;
+            b = nn(2*(h-85) - 85);
         } else {
-            g = 0;
-            b = 255 - h;
-            r = 85 - b;
+            r = nn(2*(h-170) - 85);
+            g = nn(85 - 2*(h-170));
+            b = 85;
         }
+
         for(uint32_t i=0; i<256; i++) {
             uint32_t red = minc(i*c*r/8500);
             uint32_t green = minc(i*c*g/8500);
             uint32_t blue = minc(i*c*b/8500);
 
+
             uint16_t c = ((red&0xF8)<<8) | ((green&0xFC) << 3) | ((blue&0xF8)>>3);
             uint8_t *v = (uint8_t*)&c;
             palette[i] = (v[0]<<8) | v[1];