adds debugging messages

Author: kdschlosser

api_drivers/py_api_drivers/frozen/display/display_driver_framework.py

@@ -77,6 +77,8 @@ def __init__(
         rgb565_byte_swap=False
     ):
 
+        print('DisplayDriver: __init__')
+
         if power_on_state not in (STATE_HIGH, STATE_LOW):
             raise RuntimeError(
                 'power on state must be either STATE_HIGH or STATE_LOW'
@@ -93,7 +95,9 @@ def __init__(
                 'STATE_HIGH, STATE_LOW or STATE_PWM'
             )
 
+        print('DisplayDriver: if not lv.is_initialized()')
         if not lv.is_initialized():
+            print('DisplayDriver: if not lv.init()')
             lv.init()
 
         self.display_width = display_width
@@ -122,6 +126,7 @@ def __init__(
         self._invert_colors = False
 
         if data_bus is None:
+            print('DisplayDriver: data_bus is None')
             self._reset_pin = None
             self._power_pin = None
             self._backlight_pin = None
@@ -130,11 +135,13 @@ def __init__(
             self._frame_buffer1 = frame_buffer1
             self._frame_buffer2 = frame_buffer2
         else:
+            print('DisplayDriver: data_bus is not None')
             if reset_pin is None:
                 self._reset_pin = None
             elif not isinstance(reset_pin, int):
                 self._reset_pin = reset_pin
             else:
+                print('DisplayDriver: self._reset_pin = machine.Pin(reset_pin, machine.Pin.OUT)')
                 self._reset_pin = machine.Pin(reset_pin, machine.Pin.OUT)
                 self._reset_pin.value(not reset_state)
 
@@ -143,6 +150,7 @@ def __init__(
             elif not isinstance(power_pin, int):
                 self._power_pin = power_pin
             else:
+                print('DisplayDriver: self._power_pin = machine.Pin(power_pin, machine.Pin.OUT)')
                 self._power_pin = machine.Pin(power_pin, machine.Pin.OUT)
                 self._power_pin.value(not power_on_state)
 
@@ -152,17 +160,24 @@ def __init__(
                 pin = machine.Pin(backlight_pin, machine.Pin.OUT)
                 self._backlight_pin = machine.PWM(pin, freq=38000)
             else:
+                print('DisplayDriver: self._backlight_pin = machine.Pin(backlight_pin, machine.Pin.OUT)')
                 self._backlight_pin = machine.Pin(backlight_pin, machine.Pin.OUT)
                 self._backlight_pin.value(not backlight_on_state)
 
             self._data_bus = data_bus
 
+            print('DisplayDriver: self._disp_drv = lv.display_create(display_width, display_height)')
             self._disp_drv = lv.display_create(display_width, display_height)
 
+            print('DisplayDriver: self._disp_drv.set_color_format(color_space)')
             self._disp_drv.set_color_format(color_space)
+
+            print('DisplayDriver: self._disp_drv.set_driver_data(self)')
             self._disp_drv.set_driver_data(self)
 
             if frame_buffer1 is None:
+                print('DisplayDriver: frame_buffer1 is None')
+
                 buf_size = int(
                     display_width *
                     display_height *
@@ -180,14 +195,17 @@ def __init__(
                     lcd_bus.MEMORY_SPIRAM
                 ):
                     try:
+                        print('DisplayDriver: frame_buffer1 = data_bus.allocate_framebuffer(buf_size, flags)')
                         frame_buffer1 = data_bus.allocate_framebuffer(buf_size, flags)
 
                         if (flags | lcd_bus.MEMORY_DMA) == flags:
+                            print('DisplayDriver: frame_buffer2 = data_bus.allocate_framebuffer(buf_size, flags)')
                             frame_buffer2 = data_bus.allocate_framebuffer(buf_size, flags)
 
                         break
 
                     except MemoryError:
+                        print('DisplayDriver: frame_buffer1 = data_bus.free_framebuffer(frame_buffer1)')
                         frame_buffer1 = data_bus.free_framebuffer(frame_buffer1)
 
                 if frame_buffer1 is None:
@@ -204,6 +222,7 @@ def __init__(
             else:
                 buffer_size = len(frame_buffer1)
 
+            print('DisplayDriver: data_bus.init()')
             data_bus.init(
                 display_width,
                 display_height,
@@ -212,8 +231,10 @@ def __init__(
                 rgb565_byte_swap
             )
 
+            print('DisplayDriver: self._disp_drv.set_flush_cb(self._flush_cb)')
             self._disp_drv.set_flush_cb(self._flush_cb)
 
+            print('DisplayDriver: self._disp_drv.set_buffers()')
             if isinstance(data_bus, lcd_bus.RGBBus):
                 self._disp_drv.set_buffers(
                     frame_buffer2,
@@ -249,13 +270,16 @@ def __init__(
                     render_mode
                 )
 
+            print('DisplayDriver: data_bus.register_callback(self._flush_ready_cb)')
             data_bus.register_callback(self._flush_ready_cb)
 
             self._frame_buffer1 = frame_buffer1
             self._frame_buffer2 = frame_buffer2
 
+            print('DisplayDriver: self.set_default()')
             self.set_default()
 
+            print('DisplayDriver: self._disp_drv.add_event_cb(self._on_size_change, lv.EVENT.RESOLUTION_CHANGED, None)')
             self._disp_drv.add_event_cb(self._on_size_change, lv.EVENT.RESOLUTION_CHANGED, None)  # NOQA
 
         self._displays.append(self)

builder/__init__.py

@@ -312,6 +312,10 @@ def process_output(myproc, out_to_screen, spinner, cmpl, out_queue):
             line += out
             if out == b'\n':
                 line = _convert_line(line.strip())
+                if not line:
+                    line = b''
+                    continue
+
                 out_queue.put(line)
 
                 if not spinner and out_to_screen:
@@ -327,8 +331,11 @@ def process_output(myproc, out_to_screen, spinner, cmpl, out_queue):
                         sys.stdout.write(line + padding)
                         last_line_len = len(line)
                     else:
-                        last_line_len = -1
-                        sys.stdout.write(line + '\n')
+                        if last_line_len == -1:
+                            sys.stdout.write(line + '\n')
+                        else:
+                            sys.stdout.write('\n' + line + '\n')
+                            last_line_len = -1
 
                     sys.stdout.flush()
 
@@ -347,6 +354,10 @@ def process_output(myproc, out_to_screen, spinner, cmpl, out_queue):
             err_line += out
             if out == b'\n':
                 err_line = _convert_line(err_line.strip())
+                if not err_line:
+                    err_line = b''
+                    continue
+
                 out_queue.put(err_line)
                 if out_to_screen and not spinner:
                     sys.stderr.write(err_line + '\n')

builder/esp32.py

@@ -340,6 +340,7 @@ def setup_idf_environ():
     # There were some modifications made with how the environment gets set up
     # @cheops put quite a bit of time in to research the best solution
     # and also with the testing of the code.
+    print('Getting ESP-IDF build Environment')
 
     if sys.platform.startswith('win'):
         return None
@@ -502,6 +503,25 @@ def compile():  # NOQA
             'CONFIG_ESPTOOLPY_FLASHFREQ_80M=y',
             'CONFIG_ESPTOOLPY_AFTER_NORESET=y',
             'CONFIG_PARTITION_TABLE_CUSTOM=y',
+            'BOOTLOADER_LOG_LEVEL_NONE=n',
+            'BOOTLOADER_LOG_LEVEL_ERROR=n',
+            'BOOTLOADER_LOG_LEVEL_WARN=n',
+            'BOOTLOADER_LOG_LEVEL_INFO=n',
+            'BOOTLOADER_LOG_LEVEL_DEBUG=y',
+            'BOOTLOADER_LOG_LEVEL_VERBOSE=n',
+            'CONFIG_LCD_ENABLE_DEBUG_LOG=y',
+            'HAL_LOG_LEVEL_NONE=n',
+            'HAL_LOG_LEVEL_ERROR=n',
+            'HAL_LOG_LEVEL_WARN=n',
+            'HAL_LOG_LEVEL_INFO=n',
+            'HAL_LOG_LEVEL_DEBUG=y',
+            'HAL_LOG_LEVEL_VERBOSE=n',
+            'LOG_DEFAULT_LEVEL_NONE=n',
+            'LOG_DEFAULT_LEVEL_ERROR=n',
+            'LOG_DEFAULT_LEVEL_WARN=n',
+            'LOG_DEFAULT_LEVEL_INFO=n',
+            'LOG_DEFAULT_LEVEL_DEBUG=y',
+            'LOG_DEFAULT_LEVEL_VERBOSE=n'
         ]
 
         if flash_size == '2':

ext_mod/lcd_bus/esp32_src/spi_bus.c

@@ -113,6 +113,7 @@ STATIC mp_obj_t mp_lcd_spi_bus_make_new(const mp_obj_type_t *type, size_t n_args
 
     self->host = host;
     self->panel_io_handle.panel_io = NULL;
+    self->bus_handle = (esp_lcd_spi_bus_handle_t)host;
 
     self->bus_config.sclk_io_num = (int)args[ARG_sclk].u_int;
     self->bus_config.mosi_io_num = (int)args[ARG_mosi].u_int;
@@ -125,6 +126,13 @@ STATIC mp_obj_t mp_lcd_spi_bus_make_new(const mp_obj_type_t *type, size_t n_args
     self->bus_config.data7_io_num = -1;
     self->bus_config.flags = flags;
 
+    printf("host=%d\n", self->host);
+    printf("sclk_io_num=%d\n", self->bus_config.sclk_io_num);
+    printf("mosi_io_num=%d\n", self->bus_config.mosi_io_num);
+    printf("miso_io_num=%d\n", self->bus_config.miso_io_num);
+    printf("quadwp_io_num=%d\n", self->bus_config.quadwp_io_num);
+    printf("quadhd_io_num=%d\n", self->bus_config.quadhd_io_num);
+
     self->panel_io_config.cs_gpio_num = (int)args[ARG_cs].u_int;
     self->panel_io_config.dc_gpio_num = (int)args[ARG_dc].u_int;
     self->panel_io_config.spi_mode = (int)args[ARG_spi_mode].u_int;
@@ -143,6 +151,17 @@ STATIC mp_obj_t mp_lcd_spi_bus_make_new(const mp_obj_type_t *type, size_t n_args
     self->panel_io_handle.init = &spi_init;
     self->panel_io_handle.get_lane_count = &spi_get_lane_count;
 
+    printf("cs_gpio_num=%d\n", self->panel_io_config.cs_gpio_num);
+    printf("dc_gpio_num=%d\n", self->panel_io_config.dc_gpio_num);
+    printf("spi_mode=%d\n", self->panel_io_config.spi_mode);
+    printf("pclk_hz=%d\n", self->panel_io_config.pclk_hz);
+    printf("lcd_cmd_bits=%d\n", self->panel_io_config.lcd_cmd_bits);
+    printf("lcd_param_bits=%d\n", self->panel_io_config.lcd_param_bits);
+    printf("dc_low_on_data=%d\n", self->panel_io_config.flags.dc_low_on_data);
+    printf("sio_mode=%d\n", self->panel_io_config.flags.sio_mode);
+    printf("lsb_first=%d\n", self->panel_io_config.flags.lsb_first);
+    printf("cs_high_active=%d\n", self->panel_io_config.flags.cs_high_active);
+
     return MP_OBJ_FROM_PTR(self);
 }
 
@@ -173,14 +192,19 @@ mp_lcd_err_t spi_init(mp_obj_t obj, uint16_t width, uint16_t height, uint8_t bpp
     } else {
         self->rgb565_byte_swap = false;
     }
+    printf("rgb565_byte_swap=%d\n", self->rgb565_byte_swap);
+
 
     if (self->buffer_flags & MALLOC_CAP_DMA) {
         self->bus_config.max_transfer_sz = buffer_size;
     } else {
         self->bus_config.max_transfer_sz = SOC_SPI_MAXIMUM_BUFFER_SIZE;
     }
+    printf("max_transfer_sz=%d\n", self->bus_config.max_transfer_sz);
 
     self->panel_io_config.trans_queue_depth = 10;
+    printf("trans_queue_depth=%d\n", self->panel_io_config.trans_queue_depth);
+
 
 #if CONFIG_IDF_TARGET_ESP32
     int dma_chan = SPI_DMA_DISABLED;
@@ -193,12 +217,15 @@ mp_lcd_err_t spi_init(mp_obj_t obj, uint16_t width, uint16_t height, uint8_t bpp
 #else
     int dma_chan = SPI_DMA_CH_AUTO;
 #endif
+
+    printf("dma_chan=%d\n", dma_chan);
+
     mp_lcd_err_t ret = spi_bus_initialize(self->host, &self->bus_config, dma_chan);
     if (ret != ESP_OK && ret != ESP_ERR_INVALID_STATE) {
         mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("%d(spi_bus_initialize)"), ret);
     }
 
-    ret = esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)self->host, &self->panel_io_config, &self->panel_io_handle.panel_io);
+    ret = esp_lcd_new_panel_io_spi(self->bus_handle, &self->panel_io_config, &self->panel_io_handle.panel_io);
     if (ret != ESP_OK) {
         mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("%d(esp_lcd_new_panel_io_spi)"), ret);
     }