messing with SPI and rotation

Author: kdschlosser

api_drivers/py_api_drivers/frozen/display/display_driver_framework.py

@@ -45,34 +45,6 @@
 class DisplayDriver:
     _INVON = 0x21
     _INVOFF = 0x20
-
-    # Default values of "power" and "backlight" are reversed logic! 0 means ON.
-    # You can change this by setting backlight_on and power_on arguments.
-    #
-    # For the ESP32 the allocation of the frame buffers can be done one of 2
-    # ways depending on what is wanted in terms of performance VS memory use
-    # If a single frame buffer is used then using a DMA transfer is pointless
-    # to do. The frame buffer in this casse can be allocated as simple as
-    #
-    # buf = bytearray(buffer_size)
-    #
-    # If the user wants to be able to specify if the frame buffer is to be
-    # created in internal memory (SRAM) or in external memory (PSRAM/SPIRAM)
-    # this can be done using the heap_caps module.
-    #
-    # internal memory:
-    # buf = heap_caps.malloc(buffer_size, heap_caps.CAP_INTERNAL)
-    #
-    # external memory:
-    # buf = heap_caps.malloc(buffer_size, heap_caps.CAP_SPIRAM)
-    #
-    # If wanting to use DMA memory then use the bitwise OR "|" operator to add
-    # the DMA flag to the last parameter of the malloc function
-    #
-    # buf = heap_caps.malloc(
-    #     buffer_size, heap_caps.CAP_INTERNAL | heap_caps.CAP_DMA
-    # )
-
     _displays = []
 
     @staticmethod
@@ -223,10 +195,7 @@ def __init__(
                         f'Unable to allocate memory for frame buffer ({buf_size})'
                     )
 
-            if frame_buffer2 is None and isinstance(data_bus, lcd_bus.SPIBus):
-                buffer_size = data_bus.SPI_MAXIMUM_BUFFER_SIZE
-
-            elif isinstance(data_bus, lcd_bus.RGBBus):
+            if isinstance(data_bus, lcd_bus.RGBBus):
                 buffer_size = int(
                     display_width *
                     display_height *
@@ -287,8 +256,9 @@ def __init__(
 
             self.set_default()
 
+            self._disp_drv.add_event_cb(self._on_size_change, lv.EVENT.RESOLUTION_CHANGED, None)  # NOQA
+
         self._displays.append(self)
-        self._disp_drv.add_event_cb(self._on_size_change, lv.EVENT.RESOLUTION_CHANGED, None)  # NOQA
 
     def _on_size_change(self, _):
         rotation = self._disp_drv.get_rotation()

api_drivers/py_api_drivers/frozen/indev/_indev_base.py

@@ -36,9 +36,8 @@ def __init__(self):  # NOQA
                 'Display driver needs to initilized before indev driver'
             )
 
-        self._width = self._orig_width = self._disp_drv.get_horizontal_resolution()
-        self._height = self._orig_height = self._disp_drv.get_vertical_resolution()
-        self._rotation = self._disp_drv.get_rotation()
+        self._width = self._disp_drv.get_horizontal_resolution()
+        self._height = self._disp_drv.get_vertical_resolution()
         self._current_state = self.RELEASED
 
         indev_drv = lv.indev_create()

api_drivers/py_api_drivers/frozen/indev/pointer_framework.py

@@ -22,6 +22,14 @@ def __init__(self, touch_cal=None):  # NOQA
         self._cal = touch_cal
 
         self._set_type(lv.INDEV_TYPE.POINTER)  # NOQA
+
+        self._orig_width = self._disp_drv.get_horizontal_resolution()
+        self._orig_height = self._disp_drv.get_vertical_resolution()
+        self._rotation = self._disp_drv.get_rotation()
+
+        if self._rotation in (lv.DISPLAY_ROTATION._90, lv.DISPLAY_ROTATION._270):  # NOQA
+            self._orig_height, self._orig_width = self._orig_width, self._orig_height  # NOQA
+
         self._disp_drv.add_event_cb(self._on_size_change, lv.EVENT.RESOLUTION_CHANGED, None)  # NOQA
 
     def _on_size_change(self, e):
@@ -57,16 +65,13 @@ def _read(self, drv, data):  # NOQA
         if coords is None:  # ignore no touch & multi touch
             if self._current_state != self.RELEASED:
                 self._current_state = self.RELEASED
-                res = True
-            else:
-                res = False
 
             data.point.x = self._last_x
             data.point.y = self._last_y
             data.state = self._current_state
             # print("raw(x={0}, y={1}) point(x={2} y={3})".format(-1, -1, data.point.x, data.point.y))  # NOQA
             data.continue_reading = False
-            return res
+            return
 
         state, x, y = coords
 
@@ -91,43 +96,24 @@ def _read(self, drv, data):  # NOQA
                 xpos = _remap(x, left, right, 0, self._orig_width)
                 ypos = _remap(y, top, bottom, 0, self._orig_height)
             elif rotation == lv.DISPLAY_ROTATION._90:  # NOQA
-                xpos = _remap(y, top, bottom, 0, self._orig_width)
-                ypos = _remap(x, right, left, 0, self._orig_height)
-            elif rotation == lv.DISPLAY_ROTATION._270:  # NOQA
+                xpos = _remap(y, bottom, top, 0, self._orig_height)
+                ypos = _remap(x, left, right, 0,  self._orig_width)
+            elif rotation == lv.DISPLAY_ROTATION._180:  # NOQA
                 xpos = _remap(x, right, left, 0, self._orig_width)
                 ypos = _remap(y, bottom, top, 0, self._orig_height)
-            elif rotation == lv.DISPLAY_ROTATION._180:  # NOQA
-                xpos = _remap(y, bottom, top, 0, self._orig_width)
-                ypos = _remap(x, left, right, 0, self._orig_height)
+            elif rotation == lv.DISPLAY_ROTATION._270:  # NOQA
+                xpos = _remap(y, top, bottom, 0, self._orig_height)
+                ypos = _remap(x, right, left, 0, self._orig_width)
             else:
                 raise RuntimeError
 
             self._last_x = xpos
             self._last_y = ypos
 
-        if state is not None:
-            if self._current_state == state == self.RELEASED:
-                res = False
-                data.continue_reading = False
-            else:
-                res = True
-                data.continue_reading = True
-
-            self._current_state = state
-
-        elif self._current_state == self.RELEASED:
-            res = False
-            data.continue_reading = False
-        else:
-            data.continue_reading = True
-            res = True
-
         data.state = self._current_state
         data.point.x = self._last_x
         data.point.y = self._last_y
 
-        return res
-
     def get_vect(self, point):
         self._indev_drv.get_vect(point)
 

builder/__init__.py

@@ -312,6 +312,9 @@ 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:
+                    continue
+
                 out_queue.put(line)
 
                 if not spinner and out_to_screen:

builder/esp32.py

@@ -367,7 +367,7 @@ def setup_idf_environ():
             env['IDF_PATH'] = idf_path
 
             cmds = [
-                [f'export "IDF_PATH={os.path.abspath(env["IDF_PATH"])}"'],
+                [f'export "IDF_PATH={idf_path}"'],
                 ['cd', idf_path],
                 ['. ./export.sh'],
                 ['printenv']
@@ -660,6 +660,7 @@ def compile():  # NOQA
 
     if not sys.platform.startswith('win'):
         cmds = [
+            [f'export "IDF_PATH={os.path.abspath(env["IDF_PATH"])}"'],
             ['cd', 'lib/esp-idf'],
             ['. ./export.sh'],
             ['cd ../..'],

ext_mod/lcd_bus/esp32_include/spi_bus.h

@@ -30,7 +30,9 @@
         lcd_panel_io_t panel_io_handle;
         esp_lcd_panel_io_spi_config_t panel_io_config;
         spi_bus_config_t bus_config;
-        spi_host_device_t bus_handle;
+        esp_lcd_spi_bus_handle_t bus_handle;
+
+        int host;
 
     } mp_lcd_spi_bus_obj_t;
 

ext_mod/lcd_bus/esp32_src/spi_bus.c

@@ -153,7 +153,8 @@ STATIC mp_obj_t mp_lcd_spi_bus_make_new(const mp_obj_type_t *type, size_t n_args
 
     self->callback = mp_const_none;
 
-    self->bus_handle = (spi_host_device_t)host;
+    self->host = host;
+    self->bus_handle = (esp_lcd_spi_bus_handle_t)((uint32_t)host);
 
     self->bus_config.sclk_io_num = clk;
     self->bus_config.mosi_io_num = mosi;
@@ -229,35 +230,27 @@ mp_lcd_err_t spi_init(mp_obj_t obj, uint16_t width, uint16_t height, uint8_t bpp
     }
 
     size_t max_trans_size;
-    uint8_t double_buffer;
 
     if ((self->buffer_flags ^ MALLOC_CAP_DMA) && (self->buf2 != NULL)) {
         max_trans_size = SPI_LL_DMA_MAX_BIT_LEN / 8;
-        double_buffer = 1;
     } else {
         max_trans_size = SPI_LL_CPU_MAX_BIT_LEN / 8;
-        double_buffer = 0;
     }
 
     if (buffer_size <= max_trans_size) {
         self->bus_config.max_transfer_sz = buffer_size;
-        self->panel_io_config.trans_queue_depth = 1;
-    } else if (double_buffer) {
-        self->bus_config.max_transfer_sz = max_trans_size;
-        self->panel_io_config.trans_queue_depth = buffer_size / max_trans_size;
-        if ((float)self->panel_io_config.trans_queue_depth != ((float)buffer_size / (float)max_trans_size)) {
-            self->panel_io_config.trans_queue_depth++;
-        }
     } else {
-        self->panel_io_config.trans_queue_depth = 10;
+        self->bus_config.max_transfer_sz = max_trans_size;
     }
 
-    mp_lcd_err_t ret = spi_bus_initialize(self->bus_handle, &self->bus_config, SPI_DMA_CH_AUTO);
+    self->panel_io_config.trans_queue_depth = 10;
+
+    mp_lcd_err_t ret = spi_bus_initialize(self->host, &self->bus_config, SPI_DMA_CH_AUTO);
     if (ret != 0) {
         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->bus_handle, &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 != 0) {
         mp_raise_msg_varg(&mp_type_ValueError, MP_ERROR_TEXT("%d(esp_lcd_new_panel_io_spi)"), ret);
     }