Fixes RGB Driver

Fixes tearing
Fixes triple image

Author: kdschlosser

ext_mod/lcd_bus/esp32_include/rgb_bus.h

@@ -67,10 +67,10 @@
             uint16_t height;
             uint8_t rotation: 2;
             uint8_t bytes_per_pixel: 2;
+            uint8_t last_update: 1;
 
             rgb_bus_lock_t copy_lock;
             rgb_bus_event_t copy_task_exit;
-            rgb_bus_event_t last_update;
             rgb_bus_lock_t tx_color_lock;
             rgb_bus_event_t swap_bufs;
             rgb_bus_lock_t swap_lock;

ext_mod/lcd_bus/esp32_src/rgb_bus.c

@@ -279,7 +279,7 @@
 
         if (self->view1 != NULL || self->view2 != NULL) {
             mp_raise_msg(&mp_type_MemoryError, MP_ERROR_TEXT("Framebuffers have not been released"));
-            return mp_const_none;
+            return LCD_FAIL;
         }
 
         rgb_bus_lock_acquire(&self->tx_color_lock, -1);
@@ -295,7 +295,6 @@
         rgb_bus_lock_delete(&self->swap_lock);
 
         rgb_bus_event_delete(&self->swap_bufs);
-        rgb_bus_event_delete(&self->last_update);
         rgb_bus_event_delete(&self->copy_task_exit);
 
         return ret;
@@ -481,7 +480,6 @@
         rgb_bus_lock_init(&self->copy_lock);
         rgb_bus_lock_init(&self->tx_color_lock);
         rgb_bus_event_init(&self->copy_task_exit);
-        rgb_bus_event_init(&self->last_update);
         rgb_bus_event_init(&self->swap_bufs);
         rgb_bus_lock_init(&self->swap_lock);
 
@@ -517,14 +515,14 @@
 
         rgb_bus_lock_acquire(&self->tx_color_lock, -1);
 
+        self->last_update = (uint8_t)last_update;
         self->partial_buf = (uint8_t *)color;
         self->x_start = x_start;
         self->y_start = y_start;
         self->x_end = x_end;
         self->y_end = y_end;
         self->rotation = rotation;
 
-        if (last_update) rgb_bus_event_set(&self->last_update);
         rgb_bus_lock_release(&self->copy_lock);
 
         return LCD_OK;

ext_mod/lcd_bus/esp32_src/rgb_bus_rotation.c

@@ -26,17 +26,11 @@
 
     void rgb_bus_event_init(rgb_bus_event_t *event)
     {
-    #if CONFIG_LCD_ENABLE_DEBUG_LOG
-        mp_printf(&mp_plat_print, "rgb_bus_event_init\n");
-    #endif
         event->handle = xEventGroupCreateStatic(&event->buffer);
     }
 
     void rgb_bus_event_delete(rgb_bus_event_t *event)
     {
-    #if CONFIG_LCD_ENABLE_DEBUG_LOG
-        mp_printf(&mp_plat_print, "rgb_bus_event_delete\n");
-    #endif
         xEventGroupSetBits(event->handle, RGB_BIT_0);
         vEventGroupDelete(event->handle);
 
@@ -45,9 +39,6 @@
 
     bool rgb_bus_event_isset(rgb_bus_event_t *event)
     {
-    #if CONFIG_LCD_ENABLE_DEBUG_LOG
-        mp_printf(&mp_plat_print, "rgb_bus_event_isset\n");
-    #endif
         return (bool)(xEventGroupGetBits(event->handle) & RGB_BIT_0);
     }
 
@@ -60,18 +51,12 @@
 
     void rgb_bus_event_set(rgb_bus_event_t *event)
     {
-    #if CONFIG_LCD_ENABLE_DEBUG_LOG
-        mp_printf(&mp_plat_print, "rgb_bus_event_set\n");
-    #endif
         xEventGroupSetBits(event->handle, RGB_BIT_0);
     }
 
 
     void rgb_bus_event_clear(rgb_bus_event_t *event)
     {
-    #if CONFIG_LCD_ENABLE_DEBUG_LOG
-        mp_printf(&mp_plat_print, "rgb_bus_event_clear\n");
-    #endif
         xEventGroupClearBits(event->handle, RGB_BIT_0);
     }
 
@@ -88,18 +73,12 @@
 
     int rgb_bus_lock_acquire(rgb_bus_lock_t *lock, int32_t wait_ms)
     {
-    #if CONFIG_LCD_ENABLE_DEBUG_LOG
-        mp_printf(&mp_plat_print, "rgb_bus_lock_acquire\n");
-    #endif
         return pdTRUE == xSemaphoreTake(lock->handle, wait_ms < 0 ? portMAX_DELAY : pdMS_TO_TICKS((uint16_t)wait_ms));
     }
 
 
     void rgb_bus_lock_release(rgb_bus_lock_t *lock)
     {
-    #if CONFIG_LCD_ENABLE_DEBUG_LOG
-        mp_printf(&mp_plat_print, "rgb_bus_lock_release\n");
-    #endif
         xSemaphoreGive(lock->handle);
     }
 
@@ -112,19 +91,13 @@
 
     void rgb_bus_lock_init(rgb_bus_lock_t *lock)
     {
-    #if CONFIG_LCD_ENABLE_DEBUG_LOG
-        mp_printf(&mp_plat_print, "rgb_bus_lock_init\n");
-    #endif
         lock->handle = xSemaphoreCreateBinaryStatic(&lock->buffer);
         xSemaphoreGive(lock->handle);
     }
 
 
     void rgb_bus_lock_delete(rgb_bus_lock_t *lock)
     {
-    #if CONFIG_LCD_ENABLE_DEBUG_LOG
-        mp_printf(&mp_plat_print, "rgb_bus_lock_delete\n");
-    #endif
         vSemaphoreDelete(lock->handle);
     }
 
@@ -169,6 +142,7 @@
 
         mp_lcd_rgb_bus_obj_t *self = (mp_lcd_rgb_bus_obj_t *)self_in;
 
+        uint8_t *idle_fb;
         copy_func_cb_t func;
         uint8_t bytes_per_pixel = self->bytes_per_pixel;
 
@@ -198,14 +172,13 @@
 
         while (!exit) {
             rgb_bus_lock_acquire(&self->copy_lock, -1);
-            #if CONFIG_LCD_ENABLE_DEBUG_LOG
-                mp_printf(&mp_plat_print, "!rgb_bus_event_isset(&self->copy_task_exit)\n");
-            #endif
 
             if (self->partial_buf == NULL) break;
 
+            idle_fb = self->idle_fb;
+
             copy_pixels(
-                self->idle_fb, self->partial_buf,
+                idle_fb, self->partial_buf,
                 self->x_start, self->y_start,
                 self->x_end, self->y_end,
                 self->width, self->height,
@@ -241,19 +214,12 @@
                 mp_thread_set_state(old_state);
             }
 
-            if (rgb_bus_event_isset(&self->last_update)) {
-                rgb_bus_event_clear(&self->last_update);
+            if (self->last_update) {
                 // the reason why this locked is released this way is to ensure that the partial
                 // buffer has been copied correctly before another one gets into the queue
                 // it is places here after the partial check to ensure the setting of the partial doesn't overlap
                 // with the wrong partial buffer
                 rgb_bus_lock_release(&self->tx_color_lock);
-            #if CONFIG_LCD_ENABLE_DEBUG_LOG
-                mp_printf(&mp_plat_print, "rgb_bus_event_isset(&self->last_update)\n");
-            #endif
-
-                uint8_t *idle_fb = self->idle_fb;
-                rgb_bus_event_set(&self->swap_bufs);
 
                 mp_lcd_err_t ret = esp_lcd_panel_draw_bitmap(
                     self->panel_handle,
@@ -267,8 +233,9 @@
                 if (ret != 0) {
                     mp_printf(&mp_plat_print, "esp_lcd_panel_draw_bitmap error (%d)\n", ret);
                 } else {
+                    rgb_bus_event_set(&self->swap_bufs);
                     rgb_bus_lock_acquire(&self->swap_lock, -1);
-                    memcpy(self->idle_fb, self->active_fb, self->width * self->height * bytes_per_pixel);
+                    memcpy( self->active_fb, self->idle_fb, self->width * self->height * bytes_per_pixel);
                 }
             } else {
                 rgb_bus_lock_release(&self->tx_color_lock);
@@ -283,23 +250,10 @@
     }
 
 
-    void copy_pixels(
-        uint8_t *to,
-        uint8_t *from,
-        uint32_t x_start,
-        uint32_t y_start,
-        uint32_t x_end,
-        uint32_t y_end,
-        uint32_t h_res,
-        uint32_t v_res,
-        uint32_t bytes_per_pixel,
-        copy_func_cb_t func,
-        uint8_t rotate
-    ) {
-    #if CONFIG_LCD_ENABLE_DEBUG_LOG
-        mp_printf(&mp_plat_print, "copy_pixels(to, from, x_start=%lu, y_start=%lu, x_end=%lu, y_end=%lu, h_res=%lu, v_res=%lu, bytes_per_pixel=%lu, func, rotate=%u)\n",
-                x_start, y_start, x_end, y_end, h_res, v_res, bytes_per_pixel, rotate);
-    #endif
+    void copy_pixels(uint8_t *to, uint8_t *from, uint32_t x_start, uint32_t y_start,
+            uint32_t x_end, uint32_t y_end, uint32_t h_res, uint32_t v_res,
+            uint32_t bytes_per_pixel, copy_func_cb_t func, uint8_t rotate)
+    {
         if (rotate == RGB_BUS_ROTATION_90 || rotate == RGB_BUS_ROTATION_270) {
             x_start = MIN(x_start, v_res);
             x_end = MIN(x_end, v_res);
@@ -317,33 +271,26 @@
         uint32_t bytes_per_line = bytes_per_pixel * pixels_per_line;
         size_t offset = y_start * copy_bytes_per_line + x_start * bytes_per_pixel;
 
-    #if CONFIG_LCD_ENABLE_DEBUG_LOG
-        mp_printf(&mp_plat_print, "x_start=%lu, y_start=%lu, x_end=%lu, y_end=%lu, copy_bytes_per_line=%hu, bytes_per_line=%lu, offset=%d\n",
-                x_start, y_start, x_end, y_end, copy_bytes_per_line, bytes_per_line, offset);
-    #endif
+        // mp_printf(&mp_plat_print, "x_start=%lu, y_start=%lu, x_end=%lu, y_end=%lu, copy_bytes_per_line=%u, bytes_per_line=%lu, %lu\n",
+        //         x_start, y_start, x_end, y_end, copy_bytes_per_line, bytes_per_line, (uint32_t)((y_start * h_res + x_start) * bytes_per_pixel));
 
         switch (rotate) {
             case RGB_BUS_ROTATION_0:
-            #if CONFIG_LCD_ENABLE_DEBUG_LOG
-                mp_printf(&mp_plat_print, "RGB_BUS_ROTATION_0\n");
-            #endif
-                uint8_t *fb = to + (y_start * h_res + x_start) * bytes_per_pixel;
+                uint8_t *fb = to + ((y_start * h_res + x_start) * bytes_per_pixel);
 
                 if (x_start == 0 && x_end == (h_res - 1)) {
                     memcpy(fb, from, bytes_per_line * (y_end - y_start + 1));
                 } else {
                     for (int y = y_start; y < y_end; y++) {
-                        memcpy(fb, from, bytes_per_line);
+                        memcpy(fb, from, copy_bytes_per_line);
                         fb += bytes_per_line;
                         from += copy_bytes_per_line;
                     }
                 }
 
                 break;
+
             case RGB_BUS_ROTATION_180:
-            #if CONFIG_LCD_ENABLE_DEBUG_LOG
-                mp_printf(&mp_plat_print, "RGB_BUS_ROTATION_180\n");
-            #endif
                 uint32_t index;
                 for (int y = y_start; y < y_end; y++) {
                     index = ((v_res - 1 - y) * h_res + (h_res - 1 - x_start)) * bytes_per_pixel;
@@ -356,9 +303,6 @@
                 break;
 
             case RGB_BUS_ROTATION_90:
-            #if CONFIG_LCD_ENABLE_DEBUG_LOG
-                mp_printf(&mp_plat_print, "RGB_BUS_ROTATION_90\n");
-            #endif
                 uint32_t j;
                 uint32_t i;
 
@@ -371,12 +315,7 @@
                 }
                 break;
 
-
-
             case RGB_BUS_ROTATION_270:
-            #if CONFIG_LCD_ENABLE_DEBUG_LOG
-                mp_printf(&mp_plat_print, "RGB_BUS_ROTATION_270\n");
-            #endif
                 uint32_t jj;
                 uint32_t ii;