Don't get it work ILI9341 and ESP-WROVER-KIT Arduino

ats3788 · May 22, 2021, 1:45pm

Hello I tried a couple of example without success the Display kept black, so I tried an approach like this
I see the Line from the WROVER example but no result after Line 145
Any clue what I’m doing wrong

/***************************************************

  This is our GFX example for the Adafruit ILI9341 Breakout and Shield

  ----> http://www.adafruit.com/products/1651

  Check out the links above for our tutorials and wiring diagrams

  These displays use SPI to communicate, 4 or 5 pins are required to

  interface (RST is optional)

  Adafruit invests time and resources providing this open source code,

  please support Adafruit and open-source hardware by purchasing

  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.

  MIT license, all text above must be included in any redistribution

 ****************************************************/

#include "SPI.h"

#include "Adafruit_GFX.h"

#include "WROVER_KIT_LCD.h"

#include "../lvgl/src/lvgl.h"

#define min(X, Y) (((X) < (Y)) ? (X) : (Y))

WROVER_KIT_LCD tft;

static lv_disp_buf_t disp_buf; //LVGL stuff;

static lv_color_t buf[LV_HOR_RES_MAX * 10];

lv_disp_drv_t disp_drv;

lv_indev_drv_t indev_drv;

lv_obj_t * btn1;

lv_obj_t * btn2;

lv_obj_t *screenMain;

lv_obj_t *label;

static void event_handler_btn(lv_obj_t * obj, lv_event_t event){

    if(event == LV_EVENT_CLICKED) {

        if (obj == btn1)

        lv_label_set_text(label, "Hello");

        else if (obj == btn2){

          lv_label_set_text(label, "Goodbye");

        }

    }

}

void my_disp_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p)

{

    uint32_t w = (area->x2 - area->x1 + 1);

    uint32_t h = (area->y2 - area->y1 + 1);

    uint32_t wh = w*h;

    tft.startWrite();

    tft.setAddrWindow(area->x1, area->y1, w, h);

    while (wh--) tft.pushColor(color_p++->full);//for Adafruit library

    tft.endWrite();

    lv_disp_flush_ready(disp);

}

static void event_handler(lv_obj_t * obj, lv_event_t event)

{

    if(event == LV_EVENT_CLICKED) {

        printf("Clicked\n");

    }

    else if(event == LV_EVENT_VALUE_CHANGED) {

        printf("Toggled\n");

    }

}

void lv_ex_btn_1(void)

{

    lv_obj_t * label;

    lv_obj_t * btn1 = lv_btn_create(lv_scr_act(), NULL);

    lv_obj_set_event_cb(btn1, event_handler);

    lv_obj_align(btn1, NULL, LV_ALIGN_CENTER, 0, -40);

    label = lv_label_create(btn1, NULL);

    lv_label_set_text(label, "Button");

    lv_obj_t * btn2 = lv_btn_create(lv_scr_act(), NULL);

    lv_obj_set_event_cb(btn2, event_handler);

    lv_obj_align(btn2, NULL, LV_ALIGN_CENTER, 0, 40);

    lv_btn_set_checkable(btn2, true);

    lv_btn_toggle(btn2);

    lv_btn_set_fit2(btn2, LV_FIT_NONE, LV_FIT_TIGHT);

    label = lv_label_create(btn2, NULL);

    lv_label_set_text(label, "Toggled");

}

void setup() {

  Serial.begin(115200);

 

unsigned long testLines(uint16_t color);

unsigned long testFastLines(uint16_t color1, uint16_t color2);

unsigned long testFilledRects(uint16_t color1, uint16_t color2);

 lv_init();

  tft.begin();

  tft.setRotation(1);

  uint8_t x = 0;

  uint32_t id = tft.readId();

  if(id){

      Serial.println("======= WROVER ST7789V Display Test ========");

  } else {

      Serial.println("======= WROVER ILI9341 Display Test ========");

  }

  Serial.println("============================================");

  Serial.printf("Display ID:      0x%06X\n", id);

  x = tft.readcommand8(WROVER_RDDST);

  Serial.print("Status:          0x"); Serial.println(x, HEX);

  x = tft.readcommand8(WROVER_RDDPM);

  Serial.print("Power Mode:      0x"); Serial.println(x, HEX);

  x = tft.readcommand8(WROVER_RDDMADCTL);

  Serial.print("MADCTL Mode:     0x"); Serial.println(x, HEX);

  x = tft.readcommand8(WROVER_RDDCOLMOD);

  Serial.print("Pixel Format:    0x"); Serial.println(x, HEX);

  x = tft.readcommand8(WROVER_RDDIM);

  Serial.print("Image Format:    0x"); Serial.println(x, HEX);

  x = tft.readcommand8(WROVER_RDDSDR);

  Serial.print("Self Diagnostic: 0x"); Serial.println(x, HEX);

  

  Serial.println(F("Benchmark                Time (microseconds)"));

  delay(10);

 

  Serial.print(F("Lines                    "));

  Serial.println(testLines(WROVER_CYAN));

  delay(500);

  Serial.print(F("Horiz/Vert Lines         "));

  Serial.println(testFastLines(WROVER_RED, WROVER_BLUE));

  delay(500);

  Serial.println(F("Done!"));

  lv_disp_buf_init(&disp_buf, buf, NULL, LV_HOR_RES_MAX * 10);

    /*Initialize the display*/

    lv_disp_drv_t disp_drv;

    lv_disp_drv_init(&disp_drv);

    disp_drv.hor_res = 320;

    disp_drv.ver_res = 240;

    disp_drv.flush_cb = my_disp_flush;

    disp_drv.buffer = &disp_buf;

    lv_disp_drv_register(&disp_drv);

    /*Initialize the (dummy) input device driver*/

    lv_indev_drv_t indev_drv;

    lv_indev_drv_init(&indev_drv);

    indev_drv.type = LV_INDEV_TYPE_POINTER;

  

    lv_indev_drv_register(&indev_drv);

    /* Try an example from the lv_examples repository

     * https://github.com/lvgl/lv_examples*/

    lv_ex_btn_1();

  Serial.print("<----------------- ********* ------------------>");

}

void loop(void) {

  lv_task_handler();

  delay(1);

}

unsigned long testFillScreen() {

  unsigned long start = micros();

  tft.fillScreen(WROVER_BLACK);

  yield();

  tft.fillScreen(WROVER_RED);

  yield();

  tft.fillScreen(WROVER_GREEN);

  yield();

  tft.fillScreen(WROVER_BLUE);

  yield();

  tft.fillScreen(WROVER_BLACK);

  yield();

  return micros() - start;

}

unsigned long testLines(uint16_t color)

 {

  unsigned long start, t;

  int           x1, y1, x2, y2,

                w = tft.width(),

                h = tft.height();

  tft.fillScreen(WROVER_BLACK);

  yield();

  

  x1 = y1 = 0;

  y2    = h - 1;

  start = micros();

  for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);

  x2    = w - 1;

  for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);

  t     = micros() - start; // fillScreen doesn't count against timing

  yield();

  tft.fillScreen(WROVER_BLACK);

  yield();

  x1    = w - 1;

  y1    = 0;

  y2    = h - 1;

  start = micros();

  for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);

  x2    = 0;

  for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);

  t    += micros() - start;

  yield();

  tft.fillScreen(WROVER_BLACK);

  yield();

  x1    = 0;

  y1    = h - 1;

  y2    = 0;

  start = micros();

  for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);

  x2    = w - 1;

  for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);

  t    += micros() - start;

  yield();

  tft.fillScreen(WROVER_BLACK);

  yield();

  x1    = w - 1;

  y1    = h - 1;

  y2    = 0;

  start = micros();

  for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);

  x2    = 0;

  for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);

  yield();

  return micros() - start;

}

unsigned long testFastLines(uint16_t color1, uint16_t color2) 

{

  unsigned long start;

  int           x, y, w = tft.width(), h = tft.height();

  tft.fillScreen(WROVER_BLACK);

  start = micros();

  for(y=0; y<h; y+=5) tft.drawFastHLine(0, y, w, color1);

  for(x=0; x<w; x+=5) tft.drawFastVLine(x, 0, h, color2);

  return micros() - start;

}

unsigned long testRects(uint16_t color) {

  unsigned long start;

  int           n, i, i2,

                cx = tft.width()  / 2,

                cy = tft.height() / 2;

  tft.fillScreen(WROVER_BLACK);

  n     = min(tft.width(), tft.height());

  start = micros();

  for(i=2; i<n; i+=6) {

    i2 = i / 2;

    tft.drawRect(cx-i2, cy-i2, i, i, color);

  }

  return micros() - start;

}

unsigned long testFilledRects(uint16_t color1, uint16_t color2)

 {

  unsigned long start, t = 0;

  int           n, i, i2,

                cx = tft.width()  / 2 - 1,

                cy = tft.height() / 2 - 1;

  tft.fillScreen(WROVER_BLACK);

  n = min(tft.width(), tft.height());

  for(i=n; i>0; i-=6) {

    i2    = i / 2;

    start = micros();

    tft.fillRect(cx-i2, cy-i2, i, i, color1);

    t    += micros() - start;

    // Outlines are not included in timing results

    tft.drawRect(cx-i2, cy-i2, i, i, color2);

    yield();

  }

  return t;

}

zapta · May 22, 2021, 5:19pm

Do you see any backlight from the display? Is it possible that your backlight is turned off?

dronecz · May 22, 2021, 10:11pm

Can you compile your code?

Did you change this line : * https://github.com/lvgl/lv_examples*/ to this : * https://github.com/lvgl/lv_examples */ ?

What is your pinout for WROVER_KIT_LCD?

ats3788 · May 24, 2021, 7:43am

Thank you
I upload the Code and see the lines see code but how I wrote the lvgl stuff does nothing.

ats3788 · May 24, 2021, 1:31pm

Hello I got it.

void my_disp_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p)

{

    uint32_t w = (area->x2 - area->x1 + 1);

    uint32_t h = (area->y2 - area->y1 + 1);

    uint32_t wh = w*h;

    tft.startWrite();

    tft.setAddrWindow(area->x1, area->y1, w, h);

    Serial.printf("%d - %d - %d - %d", area->x1, area->y1, w, h);

    while (wh--)

    {

       

  //    tft.pushColor(color_p++->full);//for Adafruit library

   tft.writeColor(color_p++->full,1);//for Adafruit library

   //    Serial.printf("--> %d - $%h", wh, color_p++->full );

    }

    tft.endWrite();

    lv_disp_flush_ready(disp);

}

This does not work
tft.pushColor(color_p+±>full);
I replaced it with
tft.writeColor(color_p+±>full,1);
and then it works
thank you for helping anyway.

dronecz · May 24, 2021, 2:55pm

@ats3788 Many thanks for this!! You solved my problem with Adafruit library and I can now use it with LVGL

zapta · May 24, 2021, 9:07pm

Have you considered using a single call to writePixels instead of iterating over the pixels? May speed up the display process.

github.com

adafruit/Adafruit-GFX-Library/blob/master/Adafruit_SPITFT.cpp#L980


                       byte-swapped before issuing to the display (which tend
                       to be big-endian when using SPI or 8-bit parallel).
                       If an application can optimize around this -- for
                       example, a bitmap in a uint16_t array having the byte
                       values already reordered big-endian, this can save
                       some processing time here, ESPECIALLY if using this
                       function's non-blocking DMA mode. Not all cases are
                       covered...this is really here only for SAMD DMA and
                       much forethought on the application side.
*/
void Adafruit_SPITFT::writePixels(uint16_t *colors, uint32_t len, bool block,
                                  bool bigEndian) {

  if (!len)
    return; // Avoid 0-byte transfers

  // avoid paramater-not-used complaints
  (void)block;
  (void)bigEndian;

#if defined(ESP32) // ESP32 has a special SPI pixel-writing function...

dronecz · May 26, 2021, 3:05pm

I tried it like this:

void my_disp_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p)
{
  uint32_t w = (area->x2 - area->x1 + 1);
  uint32_t h = (area->y2 - area->y1 + 1);
  uint32_t wh = w * h; //for Adafruit library

  tft.startWrite();
  tft.setAddrWindow(area->x1, area->y1, w, h);
  //  while (wh--){
  //    tft.writeColor(color_p++->full, 1);
  //  }
  tft.writePixels((uint16_t*)color_p, wh);  //for Adafruit library
  tft.endWrite();

  lv_disp_flush_ready(disp);
}

and FPS dropped from 17 to 4 frames…