Refactor smartdisplay_init to return display handle and update function signature

Author: rzeldent

README.md

@@ -375,10 +375,11 @@ To include it globally, the define must be (for the include directory):
 
 The library exposes the following functions.
 
-### void smartdisplay_init()
+### lv_display_t * smartdisplay_init()
 
 This is the first function that needs to be called.
 It initializes the display controller and touch controller and will turn on the display at 50% brightness.
+The return value is the display handle.
 
 ### void smartdisplay_lcd_set_backlight(float duty)
 

include/esp32_smartdisplay.h

@@ -31,7 +31,7 @@ extern "C"
     } touch_calibration_data_t;
 
     // Initialize the display and touch
-    void smartdisplay_init();
+    lv_display_t* smartdisplay_init();
 #ifdef BOARD_HAS_TOUCH
     // Touch calibration
     extern touch_calibration_data_t touch_calibration_data;

include/lvgl_panel_common.h

@@ -108,68 +108,11 @@ static inline void lv_flush_oled(lv_display_t *display, const lv_area_t *area, u
     //  More information about the monochrome, please refer to https://docs.lvgl.io/9.2/porting/display.html#monochrome-displays
     px_map += 8;
 
-    //     log_v("Converting to tiled format for OLED");
-    // #define LVGL_OLED_BIT_ORDER_LSB true
-    //     // lv_draw_sw_i1_convert_to_vtiled(px_map, area_buf_size, w, h, oled_buffer, area_buf_size, LVGL_OLED_BIT_ORDER_LSB);
-    //     //  - The output buffer (oled_buffer) must be at least as large as the input buffer, and is statically allocated for the full display size.
-    //     //  - The function assumes that both width and height are multiples of 8, as required by LVGL for monochrome tiled rendering.
-    //     //  - If the area is not aligned to 8x8, or the buffer sizes are insufficient, the function may assert or produce incorrect output.
-    //     log_v("Convert to vtiled: w=%d, h=%d, buf_size=%d", w, h, px_buf_size);
-    //     lv_draw_sw_i1_convert_to_vtiled(px_map, px_buf_size, w, h, &oled_buffer, px_buf_size, LVGL_OLED_BIT_ORDER_LSB);
-    uint32_t hor_res = lv_display_get_physical_horizontal_resolution(display);
-    int32_t x1 = area->x1;
-    int32_t x2 = area->x2;
-    int32_t y1 = area->y1;
-    int32_t y2 = area->y2;
-
-    for (int y = y1; y <= y2; y++)
-    {
-        for (int32_t x = x1; x <= x2; x++)
-        {
-            /* The order of bits is MSB first
-                        MSB           LSB
-               bits      7 6 5 4 3 2 1 0
-               pixels    0 1 2 3 4 5 6 7
-                        Left         Right
-            */
-            bool chroma_color = (px_map[(hor_res >> 3) * y + (x >> 3)] & 1 << (7 - x % 8));
-            /* Write to the buffer as required for the display.
-             * It writes only 1-bit for monochrome displays mapped vertically.*/
-            uint8_t *buf = oled_buffer + hor_res * (y >> 3) + (x);
-            if (chroma_color)
-                *buf &= ~(1 << (y % 8));
-            else
-                *buf |= (1 << (y % 8));
-        }
-    }
+    const size_t px_buf_size = lv_display_get_draw_buf_size(display);
+    lv_draw_sw_i1_convert_to_vtiled(px_map, px_buf_size, LVGL_HOR_RES, LVGL_VER_RES, oled_buffer, sizeof(oled_buffer), false);
 
     // pass the draw buffer to the driver
-    esp_lcd_panel_draw_bitmap(panel_handle, area->x1, area->y1, area->x2 + 1, area->y2 + 1, oled_buffer);
-
-
-
-//       // To use LV_COLOR_FORMAT_I1, we need an extra buffer to hold the converted data
-//     int32_t w = area->x2 - area->x1 + 1;
-//     int32_t h = area->y2 - area->y1 + 1;
-//     size_t area_buf_size = (w * h) / 8;
-//     uint8_t *oled_buffer = (uint8_t *)heap_caps_malloc(area_buf_size, LVGL_BUFFER_MALLOC_FLAGS);
-//     assert(oled_buffer != NULL);
-
-//     // This is necessary because LVGL reserves 2 x 4 bytes in the buffer, as these are assumed to be used as a palette. Skip the palette here
-//     // More information about the monochrome, please refer to https://docs.lvgl.io/9.2/porting/display.html#monochrome-displays
-//     px_map += 8;
-
-// #define LVGL_OLED_BIT_ORDER_LSB true
-//     // lv_draw_sw_i1_convert_to_vtiled(px_map, area_buf_size, w, h, oled_buffer, area_buf_size, LVGL_OLED_BIT_ORDER_LSB);
-//     //  - The output buffer (oled_buffer) must be at least as large as the input buffer, and is statically allocated for the full display size.
-//     //  - The function assumes that both width and height are multiples of 8, as required by LVGL for monochrome tiled rendering.
-//     //  - If the area is not aligned to 8x8, or the buffer sizes are insufficient, the function may assert or produce incorrect output.
-//     lv_draw_sw_i1_convert_to_vtiled(px_map, area_buf_size, w, h, oled_buffer, area_buf_size, true);
-
-//     // pass the draw buffer to the driver
-//     esp_lcd_panel_draw_bitmap(panel_handle, area->x1, area->y1, area->x2, area->y2 , oled_buffer);
-
-//     free(oled_buffer);
+    esp_lcd_panel_draw_bitmap(panel_handle, 0,0, LVGL_HOR_RES, LVGL_VER_RES, oled_buffer);
 }
 
 static inline void lvgl_setup_panel(esp_lcd_panel_handle_t panel_handle)

src/esp32_smartdisplay.c

@@ -13,10 +13,7 @@
 extern lv_display_t *lvgl_lcd_init();
 extern lv_indev_t *lvgl_touch_init();
 
-lv_display_t *display;
-
 #ifdef BOARD_HAS_TOUCH
-lv_indev_t *indev;
 touch_calibration_data_t touch_calibration_data;
 void (*driver_touch_read_cb)(lv_indev_t *indev, lv_indev_data_t *data);
 #endif
@@ -160,7 +157,7 @@ touch_calibration_data_t smartdisplay_compute_touch_calibration(const lv_point_t
 };
 #endif
 
-void smartdisplay_init()
+lv_display_t *smartdisplay_init()
 {
   log_d("smartdisplay_init");
 #ifdef BOARD_HAS_RGB_LED
@@ -203,30 +200,32 @@ void smartdisplay_init()
 #endif
 #endif
   // Setup TFT display
-  display = lvgl_lcd_init();
+  lv_display_t *display = lvgl_lcd_init();
 
 #ifndef LVGL_DISPLAY_SOFTWARE_ROTATION
   // Register callback for hardware rotation
-  lv_display_add_event_cb(display, lvgl_display_resolution_changed_callback, LV_EVENT_RESOLUTION_CHANGED, NULL);
+  lv_display_add_event_cb(display, lvgl_display_resolution_changed_callback, LV_EVENT_RESOLUTION_CHANGED, display);
 #endif
 
   //  Clear screen
   lv_obj_clean(lv_scr_act());
-#if DISPLAY_BCKL  
+#if DISPLAY_BCKL
   // Turn backlight on (50%)
   smartdisplay_lcd_set_backlight(0.5f);
 #endif
 
 // If there is a touch controller defined
 #ifdef BOARD_HAS_TOUCH
   // Setup touch
-  indev = lvgl_touch_init();
-  indev->disp = display;
+  lv_indev_t* indev = lvgl_touch_init();
+  lv_indev_set_display(indev, display);
   // Intercept callback
-  driver_touch_read_cb = indev->read_cb;
-  indev->read_cb = lvgl_touch_calibration_transform;
+  driver_touch_read_cb = lv_indev_get_read_cb(indev);
+  lv_indev_set_read_cb(indev, lvgl_touch_calibration_transform);
   lv_indev_enable(indev, true);
 #endif
+
+  return display;
 }
 
 #ifndef LVGL_DISPLAY_SOFTWARE_ROTATION
@@ -236,7 +235,8 @@ void smartdisplay_init()
 // So, LV_DISPLAY_ROTATION_90 means you rotate the hardware 90 degrees clockwise, and the display rotates 90 degrees counterclockwise to compensate.
 static void lvgl_display_resolution_changed_callback(lv_event_t *event)
 {
-  const esp_lcd_panel_handle_t panel_handle = display->user_data;
+  lv_display_t *display = lv_event_get_target(event);
+  const esp_lcd_panel_handle_t panel_handle = lv_display_get_user_data(display);
   switch (display->rotation)
   {
   case LV_DISPLAY_ROTATION_0:

src/lvgl_panel_axa15231b_qspi.c src/lvgl_panel_axs15231b_qspi.csrc/lvgl_panel_axa15231b_qspi.c renamed to src/lvgl_panel_axs15231b_qspi.c

@@ -53,6 +53,12 @@ lv_display_t *lvgl_lcd_init()
     esp_lcd_panel_handle_t panel_handle;
     ESP_ERROR_CHECK(esp_lcd_new_panel_ssd1306(io_handle, &panel_dev_config, &panel_handle));
 
+    if ((res = esp_lcd_panel_io_rx_param(th->io, 0x81, (const uint8_t[]){0x8F}, 1)) != ESP_OK)  // SSD1306_SETCONTRAST (0x81), 0x8F is a reasonable default contrast value
+    {
+        log_e("Unable to set brightness");
+        return res;
+    }
+
     lvgl_setup_panel(panel_handle);
     lv_display_set_user_data(display, panel_handle);
     lv_display_set_flush_cb(display, lv_flush_oled);