ST7701 Help - Paid commission

[showdown]

Hey friends,

I've been banging my head against this for a few weeks and I'm completely lost and need some help. I'm happy to pay someone to get to the bottom of my issue(s).

I am working with:

Waveshare ESP32-S3 LCD Driver Board: https://www.waveshare.com/wiki/ESP32-S3-LCD-Driver-Board
A 2.8" round LCD screen: GX028-40RB-A1(RGB).pdf
LVGL
Arduino GFX

I have been able to build code that compiles and loads, runs well and SOMETIMES displays properly on the LCD. Sometimes the colors are off (red and blue are swapped) and sometimes nothing is displayed. Then sometimes when I unplug and power off the board the screen displays when plugged back in, sometimes not. It's seemingly random and I can't figure out why it's happening. I've tried every permutation and it's just not regular and that's a massive problem.

I can of course swap Red and Blue channels and get the correct image to display so that's not the end of the world but it'd be nice to not have to do that... ;)

So, if you can figure this out for/with me, I'm happy to pay you for your time and expertise.

Here's my code:

#include <Arduino_GFX_Library.h>
#include <lvgl.h>
#include <Rotary.h>

Arduino_DataBus *bus = new Arduino_SWSPI(GFX_NOT_DEFINED, 42, 2, 1, GFX_NOT_DEFINED);
Arduino_ESP32RGBPanel *rgbpanel = new Arduino_ESP32RGBPanel(
  40 /* DE */, 39 /* VSYNC */, 38 /* HSYNC */, 41 /* PCLK */,
  5 /* R0 */, 45 /* R1 */, 48 /* R2 */, 47 /* R3 */, 21 /* R4 */,
  14 /* G0 */, 13 /* G1 */, 12 /* G2 */, 11 /* G3 */, 10 /* G4 */, 9 /* G5 */,
  46 /* B0 */, 3 /* B1 */, 8 /* B2 */, 18 /* B3 */, 17 /* B4 */,
  1 /* hsync_polarity */, 22 /* hsync_front_porch */, 24 /* hsync_pulse_width */, 6 /* hsync_back_porch */,
  1 /* vsync_polarity */, 16 /* vsync_front_porch */, 4 /* vsync_pulse_width */, 10 /* vsync_back_porch */);


Arduino_RGB_Display *gfx = new Arduino_RGB_Display(
  480 /* width */, 480 /* height */, rgbpanel, 0 /* rotation */, true /* auto_flush */,
  bus, GFX_NOT_DEFINED /* RST */, st7701_type6_init_operations, sizeof(st7701_type6_init_operations));

/* Change to your screen resolution */
static uint32_t screenWidth;
static uint32_t screenHeight;
static uint32_t bufSize;
static lv_disp_draw_buf_t draw_buf;
static lv_color_t *disp_draw_buf;
static lv_disp_drv_t disp_drv;

/* Display flushing */
void my_disp_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p) {
 #ifndef DIRECT_MODE
  uint32_t w = (area->x2 - area->x1 + 1);
  uint32_t h = (area->y2 - area->y1 + 1);

 #if (LV_COLOR_16_SWAP != 0)
  gfx->draw16bitBeRGBBitmap(area->x1, area->y1, (uint16_t *)&color_p->full, w, h);
 #else
  gfx->draw16bitRGBBitmap(area->x1, area->y1, (uint16_t *)&color_p->full, w, h);
 #endif
 #endif  // #ifndef DIRECT_MODE

  lv_disp_flush_ready(disp);
}

//Button
const int screenButton = 42; int lastScreenButtonState = LOW; int currentScreenButtonState;
//const int minuteButton = 16; int minuteButtonState = 0; 

//Rotary encoder
#define ROTARY_PIN1 17
#define ROTARY_PIN2 7
#define CLICKS_PER_STEP   4
Rotary r;

// Screens
static lv_obj_t *screen1; //gauge
static lv_obj_t *screen2; //clock

// Meters
static lv_obj_t *meter1; //gauge
static lv_obj_t *meter2; //clock

//Clock hands
lv_meter_indicator_t * indic_min;
lv_meter_indicator_t * indic_hour;

//Clock time values
int minValue = 0;
float hourValue = 0.0;

uint32_t looper5;

void create_screens() {
 // Screen 1 Gauge
 LV_IMG_DECLARE(face);
 screen1 = lv_obj_create(NULL);  // Create a blank 
 lv_obj_set_size(screen1, 480, 480);
 lv_obj_align(screen1, LV_ALIGN_CENTER, 0, 0);

 lv_obj_set_style_bg_img_src(screen1, &face, LV_PART_MAIN | LV_STATE_DEFAULT);
 meter1 = lv_meter_create(screen1);  // Create the meter
 lv_obj_center(meter1);  // Center it on the screen
 lv_obj_remove_style(meter1, NULL, LV_PART_MAIN);
 lv_obj_remove_style(meter1, NULL, LV_PART_INDICATOR);
 lv_obj_set_size(meter1, 480, 480);

 LV_IMG_DECLARE(needle);

 /*Add AFR scale */
 lv_meter_scale_t * scaleAFR = lv_meter_add_scale(meter1);
 lv_meter_set_scale_ticks(meter1, scaleAFR, 0, 0, 0, lv_color_black());
 lv_meter_set_scale_range(meter1, scaleAFR, 10, 18, 60, 60);

 /*Add TPS scale */
 lv_meter_scale_t * scaleTPS = lv_meter_add_scale(meter1);
 lv_meter_set_scale_ticks(meter1, scaleTPS, 0, 0, 0, lv_color_black());
 lv_meter_set_scale_range(meter1, scaleTPS, 0, 100, 60, 330);

 /*Add VOLT scale */
 lv_meter_scale_t * scaleVOLT = lv_meter_add_scale(meter1);
 lv_meter_set_scale_ticks(meter1, scaleVOLT, 0, 0, 0, lv_color_black());
 lv_meter_set_scale_range(meter1, scaleVOLT, 9, 15, 60, 240);

  /*Add MAP scale */
 lv_meter_scale_t * scaleMAP = lv_meter_add_scale(meter1);
 lv_meter_set_scale_ticks(meter1, scaleMAP, 0, 0, 0, lv_color_black());
 lv_meter_set_scale_range(meter1, scaleMAP, 0, 100, 60, 151);
  
 /* Add AFR needle */
 lv_meter_indicator_t * indic1;
 indic1 = lv_meter_add_needle_img(meter1, scaleAFR, &needle, 0, 0);
 lv_meter_set_indicator_value(meter1, indic1, 14);

 /* Add TPS needle */
 lv_meter_indicator_t * indic2;
 indic2 = lv_meter_add_needle_img(meter1, scaleTPS, &needle, 0, 0);
 lv_meter_set_indicator_value(meter1, indic2, 100);

 /* Add VOLT needle */
 lv_meter_indicator_t * indic3;
 indic3 = lv_meter_add_needle_img(meter1, scaleVOLT, &needle, 0, 0);
 lv_meter_set_indicator_value(meter1, indic3, 12);

 /* Add MAP needle */
 lv_meter_indicator_t * indic4;
 indic4 = lv_meter_add_needle_img(meter1, scaleMAP, &needle, 0, 0);
 lv_meter_set_indicator_value(meter1, indic4, 0);


 // Screen 2 Clock
 LV_IMG_DECLARE(clockFace);
 screen2 = lv_obj_create(NULL);  // Create a blank 
 lv_obj_set_size(screen2, 480, 480);
 lv_obj_align(screen2, LV_ALIGN_CENTER, 0, 0);
 lv_obj_set_style_bg_img_src(screen2, &clockFace, LV_PART_MAIN | LV_STATE_DEFAULT);
 meter2 = lv_meter_create(screen2);  // Create the meter
 lv_obj_center(meter2);  // Center it on the screen
 lv_obj_remove_style(meter2, NULL, LV_PART_MAIN);
 lv_obj_remove_style(meter2, NULL, LV_PART_INDICATOR);
 lv_obj_set_size(meter2, 480, 480);

 /*Create a scale for the minutes*/
 /*61 ticks in a 360 degrees range (the last and the first line overlaps)*/
 lv_meter_scale_t * scale_min = lv_meter_add_scale(meter2);
 lv_meter_set_scale_ticks(meter2, scale_min, 0, 0, 0, lv_color_black());
 lv_meter_set_scale_range(meter2, scale_min, 0, 60, 360, 270);

 /*Create an other scale for the hours. It's only visual and contains only major ticks*/
 lv_meter_scale_t * scale_hour = lv_meter_add_scale(meter2);
 lv_meter_set_scale_ticks(meter2, scale_hour, 0, 0, 0, lv_color_black());
 lv_meter_set_scale_range(meter2, scale_hour, 1, 12, 330, 300);       /*[1..12] values in an almost full circle*/

 LV_IMG_DECLARE(minute)
 LV_IMG_DECLARE(hour)

 /*Add a the hands from images*/
 indic_min = lv_meter_add_needle_img(meter2, scale_min, &minute, -2, 11);
 indic_hour = lv_meter_add_needle_img(meter2, scale_min, &hour, -2, 11);
 lv_meter_set_indicator_value(meter2, indic_min, minValue);
 lv_meter_set_indicator_value(meter2, indic_hour, hourValue);


}

void setup() {
  delay (200);
  Serial.begin(115200);
  //Serial.setDebugOutput(true);
  //while(!Serial);
  Serial.println("911 Gauge");

 #ifdef GFX_EXTRA_PRE_INIT
  GFX_EXTRA_PRE_INIT();
 #endif

  // Init Display
  if (!gfx->begin()) {
    Serial.println("gfx->begin() failed!");
  }
  gfx->fillScreen(BLACK);

 #ifdef GFX_BL
  pinMode(GFX_BL, OUTPUT);
  digitalWrite(GFX_BL, HIGH);
 #endif

  lv_init();

  screenWidth = gfx->width();
  screenHeight = gfx->height();

 #ifdef DIRECT_MODE
  bufSize = screenWidth * screenHeight;
 #else
  bufSize = screenWidth * 40;
 #endif

 #ifdef ESP32
  disp_draw_buf = (lv_color_t *)heap_caps_malloc(sizeof(lv_color_t) * bufSize, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
  if (!disp_draw_buf) {
    // remove MALLOC_CAP_INTERNAL flag try again
    disp_draw_buf = (lv_color_t *)heap_caps_malloc(sizeof(lv_color_t) * bufSize, MALLOC_CAP_8BIT);
  }
 #else
  disp_draw_buf = (lv_color_t *)malloc(sizeof(lv_color_t) * bufSize);
 #endif
  if (!disp_draw_buf) {
    Serial.println("LVGL disp_draw_buf allocate failed!");
  } else {
    lv_disp_draw_buf_init(&draw_buf, disp_draw_buf, NULL, bufSize);

   /* Initialize the display */
   lv_disp_drv_init(&disp_drv);
   /* Change the following line to your display resolution */
   disp_drv.hor_res = screenWidth;
   disp_drv.ver_res = screenHeight;
   disp_drv.flush_cb = my_disp_flush;
   disp_drv.draw_buf = &draw_buf;
 #ifdef DIRECT_MODE
    disp_drv.direct_mode = true;
 #endif
    lv_disp_drv_register(&disp_drv);



 /* Initialize the (dummy) input device driver */
 static 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);

 // Create the two screens
 create_screens();

 // Set screen1 as the initial screen
 lv_scr_load(screen2);

 //Read button
 pinMode(screenButton, INPUT_PULLUP);

 //Rotary encoder
 r.begin(ROTARY_PIN1, ROTARY_PIN2, CLICKS_PER_STEP);
 r.setChangedHandler(rotate);
 r.setLeftRotationHandler(showDirection);
 r.setRightRotationHandler(showDirection); 

 Serial.println("Setup done");
  }
}

void changeScreens () {
   if(lv_scr_act() == screen1) {
     lv_scr_load(screen2);
   } else {
     lv_scr_load(screen1);
   }
}


void rotate(Rotary& r) {
  //Serial.println(r.getPosition());
}

void showDirection(Rotary& r) {
 //Serial.println(r.getDirection());
 if (r.getDirection() == 1 ) {
   minValue = (minValue + 1) % 60;
   hourValue = (hourValue + .084); //might not be needed as the Rtc updates mins and hours automatically with rollover
   if (hourValue > 60.48) {
     hourValue = 0;
   }
   //modify += 60; // add 60 seconds
   //Rtc.SetDateTime(modify); // apply that modified instance to the RTC module
   lv_meter_set_indicator_value(meter2, indic_min, minValue);
   lv_meter_set_indicator_value(meter2, indic_hour, hourValue);
 } else {
  minValue = (minValue - 1) % 60;
   //modify -= 60; // subtract 60 seconds
   //Rtc.SetDateTime(modify); // apply that modified instance to the RTC module
   lv_meter_set_indicator_value(meter2, indic_min, minValue);
   lv_meter_set_indicator_value(meter2, indic_hour, hourValue);
 }
}

void uitasks() {
 //Read the buttons 
 currentScreenButtonState = digitalRead(screenButton);

 //Screen button
 if (lastScreenButtonState == HIGH && currentScreenButtonState == LOW) {
   changeScreens();
 } else {
 }
 lastScreenButtonState = currentScreenButtonState;
}

void loop() {
   lv_timer_handler(); /* let the GUI do its work */
 #ifdef DIRECT_MODE
 #if (LV_COLOR_16_SWAP != 0)
  gfx->draw16bitBeRGBBitmap(0, 0, (uint16_t *)disp_draw_buf, screenWidth, screenHeight);
 #else
  gfx->draw16bitRGBBitmap(0, 0, (uint16_t *)disp_draw_buf, screenWidth, screenHeight);
 #endif
 #endif  // #ifdef DIRECT_MODE
 #ifdef CANVAS
  gfx->flush();
 #endif

 delay(5);
 r.loop();
 looper5++;
 if((looper5%20) == 0) uitasks(); 
}