forking lvgl

.gitmodules

@@ -4,7 +4,3 @@
 [submodule "amy"]
  path = amy
  url = https://github.com/bwhitman/amy
-[submodule "lv_binding_micropython"]
- path = lv_binding_micropython
- url = https://github.com/bwhitman/lv_binding_micropython
-

lv_binding_micropython_tulip/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-2021 LVGL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lv_binding_micropython_tulip/bindings.cmake

@@ -0,0 +1,20 @@
+# This file is to be given as "make USER_C_MODULES=..." when building Micropython port
+
+include(${CMAKE_CURRENT_LIST_DIR}/mkrules.cmake)
+
+# lvgl bindings depend on lvgl itself, pull it in
+include(${LVGL_DIR}/CMakeLists.txt)
+
+# lvgl bindings target (the mpy module)
+add_library(usermod_lv_bindings INTERFACE)
+target_sources(usermod_lv_bindings INTERFACE ${LV_SRC})
+target_include_directories(usermod_lv_bindings INTERFACE ${LV_INCLUDE})
+
+target_link_libraries(usermod_lv_bindings INTERFACE lvgl_interface)
+
+# make usermod (target declared by Micropython for all user compiled modules) link to bindings
+# this way the bindings (and transitively lvgl_interface) get proper compilation flags
+target_link_libraries(usermod INTERFACE usermod_lv_bindings)
+
+# create targets for generated files
+all_lv_bindings()

lv_binding_micropython_tulip/driver/esp32/espidf.c

@@ -0,0 +1,255 @@
+#include "../include/common.h"
+#include "py/obj.h"
+#include "py/runtime.h"
+#include "py/gc.h"
+#include "py/stackctrl.h"
+#include "mphalport.h"
+#include "espidf.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+#include "soc/cpu.h"
+
+
+// ESP IDF has some functions that are declared but not implemented.
+// To avoid linking errors, provide empty implementation
+
+inline void gpio_pin_wakeup_disable(void){}
+inline void gpio_pin_wakeup_enable(uint32_t i, GPIO_INT_TYPE intr_state){}
+inline void gpio_intr_ack_high(uint32_t ack_mask){}
+inline void gpio_intr_ack(uint32_t ack_mask){}
+inline uint32_t gpio_intr_pending_high(void){return 0;}
+inline uint32_t gpio_intr_pending(void){return 0;}
+inline void gpio_intr_handler_register(gpio_intr_handler_fn_t fn, void *arg){}
+inline void gpio_init(void){}
+
+void task_delay_ms(int ms)
+{
+ vTaskDelay(ms / portTICK_RATE_MS);
+}
+
+// ISR callbacks handling
+// Can't use mp_sched_schedule because lvgl won't yield to give micropython a chance to run
+// Must run Micropython in ISR itself.
+
+DEFINE_PTR_OBJ_TYPE(spi_transaction_ptr_type, MP_QSTR_spi_transaction_ptr_t);
+
+typedef struct{
+ mp_ptr_t spi_transaction_ptr;
+ mp_obj_t pre_cb;
+ mp_obj_t post_cb;
+} mp_spi_device_callbacks_t;
+
+void *spi_transaction_set_cb(mp_obj_t pre_cb, mp_obj_t post_cb)
+{
+ mp_spi_device_callbacks_t *callbacks = m_new_obj(mp_spi_device_callbacks_t);
+ callbacks->spi_transaction_ptr.base.type = &spi_transaction_ptr_type;
+ callbacks->pre_cb = pre_cb != mp_const_none? pre_cb: NULL;
+ callbacks->post_cb = post_cb != mp_const_none? post_cb: NULL;
+ return callbacks;
+}
+
+STATIC void isr_print_strn(void *env, const char *str, size_t len) {
+ size_t i;
+ (void)env;
+ for (i=0; i<len; i++) ets_write_char_uart(str[i]);
+}
+
+static const mp_print_t mp_isr_print = {NULL, isr_print_strn};
+
+// Called in ISR context!
+//
+static inline void cb_isr(mp_obj_t cb, mp_obj_t arg)
+{
+ if (cb != NULL && cb != mp_const_none) {
+
+ volatile uint32_t sp = (uint32_t)get_sp();
+
+ // Calling micropython from ISR
+ // See: https://github.com/micropython/micropython/issues/4895
+
+ void *old_state = mp_thread_get_state();
+
+ mp_state_thread_t ts; // local thread state for the ISR
+ mp_thread_set_state(&ts);
+ mp_stack_set_top((void*)sp); // need to include in root-pointer scan
+ mp_stack_set_limit(configIDLE_TASK_STACK_SIZE - 1024); // tune based on ISR thread stack size
+ mp_locals_set(mp_state_ctx.thread.dict_locals); // use main thread's locals
+ mp_globals_set(mp_state_ctx.thread.dict_globals); // use main thread's globals
+
+ mp_sched_lock(); // prevent VM from switching to another MicroPython thread
+ gc_lock(); // prevent memory allocation
+
+ nlr_buf_t nlr;
+ if (nlr_push(&nlr) == 0) {
+ mp_call_function_1(cb, arg);
+ nlr_pop();
+ } else {
+ ets_printf("Uncaught exception in IRQ callback handler!\n");
+ mp_obj_print_exception(&mp_isr_print, MP_OBJ_FROM_PTR(nlr.ret_val));
+ }
+
+ gc_unlock();
+ mp_sched_unlock();
+
+ mp_thread_set_state(old_state);
+
+ mp_hal_wake_main_task_from_isr();
+ }
+}
+
+// Called in ISR context!
+void ex_spi_pre_cb_isr(spi_transaction_t *trans)
+{
+ mp_spi_device_callbacks_t *self = (mp_spi_device_callbacks_t*)trans->user;
+ if (self) {
+ self->spi_transaction_ptr.ptr = trans;
+ cb_isr(self->pre_cb, MP_OBJ_FROM_PTR(self));
+ }
+}
+
+// Called in ISR context!
+void ex_spi_post_cb_isr(spi_transaction_t *trans)
+{
+ mp_spi_device_callbacks_t *self = (mp_spi_device_callbacks_t*)trans->user;
+ if (self) {
+ self->spi_transaction_ptr.ptr = trans;
+ cb_isr(self->post_cb, MP_OBJ_FROM_PTR(self));
+ }
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// ILI9xxx flush and ISR implementation in C
+
+#include "lvgl/lvgl.h"
+
+DMA_ATTR static uint8_t dma_buf[4] = {0};
+DMA_ATTR static spi_transaction_t spi_trans = {0};
+
+static void spi_send_value(const uint8_t *value, uint8_t size, spi_device_handle_t spi)
+{
+ spi_trans.length = size*8;
+ spi_trans.tx_buffer = value;
+ spi_trans.user = NULL;
+ spi_device_polling_transmit(spi, &spi_trans);
+}
+
+static inline void ili9xxx_send_cmd(uint8_t cmd, int dc, spi_device_handle_t spi)
+{
+ dma_buf[0] = cmd;
+ gpio_set_level(dc, 0);
+ spi_send_value(dma_buf, 1, spi);
+}
+
+static inline void ili9xxx_send_data(const uint8_t *value, int dc, spi_device_handle_t spi)
+{
+ gpio_set_level(dc, 1);
+ spi_send_value(value, 4, spi);
+}
+
+static void ili9xxx_send_data_dma(void *disp_drv, void *data, size_t size, int dc, spi_device_handle_t spi)
+{
+ gpio_set_level(dc, 1);
+ spi_trans.length = size*8;
+ spi_trans.tx_buffer = data;
+ spi_trans.user = disp_drv;
+ spi_device_queue_trans(spi, &spi_trans, -1);
+}
+
+void ili9xxx_post_cb_isr(spi_transaction_t *trans)
+{
+ if (trans->user)
+ lv_display_flush_ready(trans->user);
+}
+
+
+typedef struct {
+ uint8_t blue;
+ uint8_t green;
+ uint8_t red;
+} color24_t;
+
+#define DISPLAY_TYPE_ILI9341 1
+#define DISPLAY_TYPE_ILI9488 2
+#define DISPLAY_TYPE_GC9A01 3
+#define DISPLAY_TYPE_ST7789 4
+#define DISPLAY_TYPE_ST7735 5
+
+void ili9xxx_flush(void *_disp_drv, const void *_area, void *_color_p)
+{
+ lv_display_t *disp_drv = _disp_drv;
+ const lv_area_t *area = _area;
+ lv_color_t *color_p = _color_p;
+ int start_x = 0;
+ int start_y = 0;
+
+ void *driver_data = lv_display_get_driver_data(disp_drv);
+
+ // We use disp_drv->driver_data to pass data from MP to C
+ // The following lines extract dc and spi
+
+ int dc = mp_obj_get_int(mp_obj_dict_get(driver_data, MP_OBJ_NEW_QSTR(MP_QSTR_dc)));
+ int dt = mp_obj_get_int(mp_obj_dict_get(driver_data, MP_OBJ_NEW_QSTR(MP_QSTR_dt)));
+ mp_buffer_info_t buffer_info;
+ mp_get_buffer_raise(mp_obj_dict_get(driver_data, MP_OBJ_NEW_QSTR(MP_QSTR_spi)), &buffer_info, MP_BUFFER_READ);
+ spi_device_handle_t *spi_ptr = buffer_info.buf;
+
+ // Some devices may need a start_x and start_y offset for displays with LCD screens smaller
+ // than the devices built in frame buffer.
+
+ start_x = mp_obj_get_int(mp_obj_dict_get(driver_data, MP_OBJ_NEW_QSTR(MP_QSTR_start_x)));
+ start_y = mp_obj_get_int(mp_obj_dict_get(driver_data, MP_OBJ_NEW_QSTR(MP_QSTR_start_y)));
+
+ int x1 = area->x1 + start_x;
+ int x2 = area->x2 + start_x;
+ int y1 = area->y1 + start_y;
+ int y2 = area->y2 + start_y;
+
+ // Column addresses
+
+ ili9xxx_send_cmd(0x2A, dc, *spi_ptr);
+ dma_buf[0] = (x1 >> 8) & 0xFF;
+ dma_buf[1] = x1 & 0xFF;
+ dma_buf[2] = (x2 >> 8) & 0xFF;
+ dma_buf[3] = x2 & 0xFF;
+
+ ili9xxx_send_data(dma_buf, dc, *spi_ptr);
+
+ // Page addresses
+
+ ili9xxx_send_cmd(0x2B, dc, *spi_ptr);
+ dma_buf[0] = (y1 >> 8) & 0xFF;
+ dma_buf[1] = y1 & 0xFF;
+ dma_buf[2] = (y2 >> 8) & 0xFF;
+ dma_buf[3] = y2 & 0xFF;
+
+ ili9xxx_send_data(dma_buf, dc, *spi_ptr);
+
+ // Memory write by DMA, disp_flush_ready when finished
+
+ ili9xxx_send_cmd(0x2C, dc, *spi_ptr);
+
+ size_t size = (area->x2 - area->x1 + 1) * (area->y2 - area->y1 + 1);
+ uint8_t color_size = 2;
+
+ bool swap_rgb565_bytes = mp_obj_get_int(mp_obj_dict_get(driver_data, MP_OBJ_NEW_QSTR(MP_QSTR_swap_rgb565_bytes)));
+ if ( swap_rgb565_bytes == true ) {
+ lv_draw_sw_rgb565_swap(color_p, size);
+ }
+
+ if ( dt == DISPLAY_TYPE_ILI9488 ) {
+ color_size = 3;
+ /*Convert ARGB to RGB is required (cut off A-byte)*/
+ size_t i;
+ lv_color32_t* tmp32 = (lv_color32_t*) color_p;
+ color24_t* tmp24 = (color24_t*) color_p;
+
+ for(i=0; i < size; i++) {
+ tmp24[i].red = tmp32[i].red;
+ tmp24[i].green = tmp32[i].green;
+ tmp24[i].blue = tmp32[i].blue;
+ }
+ }
+
+ ili9xxx_send_data_dma(disp_drv, color_p, size * color_size, dc, *spi_ptr);
+}