feat(scripts): support lvgl running on the unix

Author: Lzw655

modules/lv_binding_micropython

@@ -9,3 +9,5 @@
 
 #define MICROPY_HW_I2C0_SCL                 (9)
 #define MICROPY_HW_I2C0_SDA                 (8)
+
+#define MICROPY_LV_USE_LOG                  (1)

ports/esp32/boards/ESP32_S3_BOX_3/mpconfigboard.h

@@ -0,0 +1,138 @@
+import usys as sys
+sys.path.append('') # See: https://github.com/micropython/micropython/issues/6419
+
+import lvgl as lv
+
+try:
+    import lv_utils
+    lv_utils_available = True
+except:
+    lv_utils_available = False
+
+ORIENT_LANDSCAPE = False
+ORIENT_PORTRAIT  = True
+
+class driver:
+    
+    def __init__(self,width=420,height=320,orientation=ORIENT_PORTRAIT, asynchronous=False, exception_sink=None, defaultGroup=True):
+
+        if not lv.is_initialized():
+            lv.init()
+
+        self.group = lv.group_create()
+        if defaultGroup:
+            self.group.set_default()
+
+        self.width = width
+        self.height = height
+        self.orientation = orientation
+        self.asynchronous = asynchronous
+        self.exception_sink = exception_sink
+        self.disp = None
+        self.touch = None
+        self.type = None
+        if not (lv_utils_available and lv_utils.event_loop.is_running()):
+            self.init_gui()
+
+    def init_gui_SDL(self):
+        if lv_utils_available:
+            self.event_loop = lv_utils.event_loop(asynchronous=self.asynchronous, exception_sink=self.exception_sink)
+
+        lv.sdl_window_create(self.width, self.height)
+        self.mouse = lv.sdl_mouse_create()
+        self.keyboard = lv.sdl_keyboard_create()
+        self.keyboard.set_group(self.group)
+        self.type = "SDL"
+        print("Running the SDL lvgl version")
+        
+    def init_gui_ili9341(self):
+
+        # Initialize ILI9341 display
+
+        from ili9XXX import ili9341,LANDSCAPE
+        from xpt2046 import xpt2046
+        import espidf as esp
+
+        if lv_utils_available:
+            self.event_loop = lv_utils.event_loop(asynchronous=self.asynchronous, exception_sink=self.exception_sink)
+
+        if self.orientation == ORIENT_PORTRAIT:
+            print ("Running the ili9341 lvgl version in portrait mode")
+
+            # Initialize ILI9341 display in prtrait mode
+            # the following are the settings for the Lolin tft 2.4 display
+            # self.disp = ili9341(miso=19,mosi=23,clk=18, cs=26, dc=5, rst=-1, power=-1, backlight=-1, spihost=esp.VSPI_HOST)
+            # self.touch = xpt2046(spihost=esp.VSPI_HOST,cal_x0=3751, cal_x1 = 210, cal_y0=3906, cal_y1 = 283, transpose=True)
+            
+            self.disp = ili9341()
+            self.touch = xpt2046()
+
+        elif self.orientation == ORIENT_LANDSCAPE:
+            print ("Running the ili9341 lvgl version in landscape mode")
+            # Initialize ILI9341 display
+            # the following are the settings for the Lolin tft 2.4 display
+            # self.disp = ili9341(miso=19,mosi=23,clk=18, cs=26, dc=5, rst=-1, power=-1, backlight=-1, backlight_on=0,
+            #                     spihost=esp.VSPI_HOST, width=320, height=240, rot=LANDSCAPE)
+            # self.touch = xpt2046(spihost=esp.VSPI_HOST,cal_x0=3799, cal_x1 = 353, cal_y0=220, cal_y1 = 3719, transpose=False)
+            
+            # Register xpt2046 touch driver
+            self.disp = ili9341(width=320, height=240, rot=LANDSCAPE)
+            self.touch = xpt2046(cal_x0=3799, cal_x1 = 353, cal_y0=220, cal_y1 = 3719,transpose = False)
+
+        else:
+            raise RuntimeError("Invalid orientation")
+
+        self.type="ili9341"
+        
+        '''
+        # Register raw resistive touch driver (remove xpt2046 initialization first)
+        import rtch
+        touch = rtch.touch(xp = 32, yp = 33, xm = 25, ym = 26, touch_rail = 27, touch_sense = 33)
+        touch.init()
+        self.indev_drv = lv.indev_create()
+        self.indev_drv.set_type(lv.INDEV_TYPE.POINTER)
+        self.indev_drv.set_read_cb(touch.read)
+        '''
+
+    def init_gui_twatch(self):
+
+            import ttgo
+            from axp_constants import AXP202_VBUS_VOL_ADC1,AXP202_VBUS_CUR_ADC1,AXP202_BATT_CUR_ADC1,AXP202_BATT_VOL_ADC1
+                
+            watch = ttgo.Watch()
+            tft = watch.tft
+            power = watch.pmu
+            power.adc1Enable(AXP202_VBUS_VOL_ADC1
+                             | AXP202_VBUS_CUR_ADC1 
+                             | AXP202_BATT_CUR_ADC1
+                             | AXP202_BATT_VOL_ADC1, True)
+            watch.lvgl_begin()
+            watch.tft.backlight_fade(100)
+
+            self.type="t-watch"            
+            print("Running lvgl on the LilyGo t-watch 2020")
+            
+    def init_gui(self):
+        
+        # Identify platform and initialize it
+
+        try:
+            self.init_gui_twatch()
+            return
+        except:
+            pass
+
+        try:
+            self.init_gui_ili9341()
+            return
+        except ImportError:
+            pass
+            
+        try:
+            self.init_gui_SDL()
+            return
+        except ImportError:
+            pass
+
+        raise RuntimeError("Could not find a suitable display driver!")
+

scripts/display_driver_utils.py

@@ -0,0 +1,80 @@
+# LVGL indev driver for evdev mouse device
+# (for the unix micropython port)
+
+import ustruct
+import select
+import lvgl as lv
+
+# Default crosshair cursor
+class crosshair_cursor:
+    def __init__(self, scr=None):
+        self.scr = scr if scr else lv.scr_act()
+        self.hor_res = self.scr.get_width()
+        self.ver_res = self.scr.get_height()
+        self.cursor_style = lv.style_t()
+        self.cursor_style.set_line_width(1)
+        self.cursor_style.set_line_dash_gap(5)
+        self.cursor_style.set_line_dash_width(1)
+        self.cursor_hor = lv.line(self.scr)
+        self.cursor_hor.add_style(self.cursor_style, lv.PART.MAIN)
+        self.cursor_ver = lv.line(self.scr)
+        self.cursor_ver.add_style(self.cursor_style, lv.PART.MAIN)
+
+    def __call__(self, data):
+        # print("%d : %d:%d" % (data.state, data.point.x, data.point.y))
+        self.cursor_hor.set_points([{'x':0,'y':data.point.y},{'x':self.hor_res,'y':data.point.y}],2)
+        self.cursor_ver.set_points([{'y':0,'x':data.point.x},{'y':self.ver_res,'x':data.point.x}],2)
+
+    def delete(self):
+        self.cursor_hor.delete()
+        self.cursor_ver.delete()
+
+# evdev driver for mouse
+class mouse_indev:
+    def __init__(self, scr=None, cursor=None, device='/dev/input/mice'):
+
+        # Open evdev and initialize members
+        self.evdev = open(device, 'rb')
+        self.poll = select.poll()
+        self.poll.register(self.evdev.fileno())
+        self.scr = scr if scr else lv.scr_act()
+        self.cursor = cursor if cursor else crosshair_cursor(self.scr)
+        self.hor_res = self.scr.get_width()
+        self.ver_res = self.scr.get_height()
+
+        # Register LVGL indev driver
+        self.indev = lv.indev_create()
+        self.indev.set_type(lv.INDEV_TYPE.POINTER)
+        self.indev.set_read_cb(self.mouse_read)
+
+    def mouse_read(self, indev, data) -> int:
+        
+        # Check if there is input to be read from evdev
+        if not self.poll.poll()[0][1] & select.POLLIN:
+            return 0
+
+        # Read and parse evdev mouse data
+        mouse_data = ustruct.unpack('bbb',self.evdev.read(3))
+
+        # Data is relative, update coordinates
+        data.point.x += mouse_data[1]
+        data.point.y -= mouse_data[2]
+
+        # Handle coordinate overflow cases
+        data.point.x = min(data.point.x, self.hor_res - 1)
+        data.point.y = min(data.point.y, self.ver_res - 1)
+        data.point.x = max(data.point.x, 0)
+        data.point.y = max(data.point.y, 0)
+
+        # Update "pressed" status
+        data.state = lv.INDEV_STATE.PRESSED if ((mouse_data[0] & 1) == 1) else lv.INDEV_STATE.RELEASED
+
+        # Draw cursor, if needed
+        if self.cursor: self.cursor(data)
+        return 0
+
+    def delete(self):
+        self.evdev.close()
+        if self.cursor and hasattr(self.cursor, 'delete'):
+            self.cursor.delete()
+        self.indev.enable(False)

scripts/evdev.py

@@ -0,0 +1,92 @@
+'''
+Original author: mhepp(https://forum.lvgl.io/u/mhepp/summary)
+'''
+
+import lvgl as lv
+import ustruct as struct
+
+def fs_open_cb(drv, path, mode):
+
+    if mode == lv.FS_MODE.WR:
+        p_mode = 'wb'
+    elif mode == lv.FS_MODE.RD:
+        p_mode = 'rb'
+    elif mode == lv.FS_MODE.WR | lv.FS_MODE.RD:
+        p_mode = 'rb+'
+    else:
+        raise RuntimeError("fs_open_callback() - open mode error, %s is invalid mode" % mode)
+
+    try:
+        f = open(path, p_mode)
+
+    except OSError as e:
+        raise RuntimeError("fs_open_callback(%s) exception: %s" % (path, e))
+
+    return {'file' : f, 'path': path}
+
+
+def fs_close_cb(drv, fs_file):
+    try:
+        fs_file.__cast__()['file'].close()
+    except OSError as e:
+        raise RuntimeError("fs_close_callback(%s) exception: %s" % (fs_file.__cast__()['path'], e))
+
+    return lv.FS_RES.OK
+
+
+def fs_read_cb(drv, fs_file, buf, btr, br):
+    try:
+        tmp_data = fs_file.__cast__()['file'].read(btr)
+        buf.__dereference__(btr)[0:len(tmp_data)] = tmp_data
+        br.__dereference__(4)[0:4] = struct.pack("<L", len(tmp_data))
+    except OSError as e:
+        raise RuntimeError("fs_read_callback(%s) exception %s" % (fs_file.__cast__()['path'], e))
+
+    return lv.FS_RES.OK
+
+
+def fs_seek_cb(drv, fs_file, pos, whence):
+    try:
+        fs_file.__cast__()['file'].seek(pos, whence)
+    except OSError as e:
+        raise RuntimeError("fs_seek_callback(%s) exception %s" % (fs_file.__cast__()['path'], e))
+
+    return lv.FS_RES.OK
+
+
+def fs_tell_cb(drv, fs_file, pos):
+    try:
+        tpos = fs_file.__cast__()['file'].tell()
+        pos.__dereference__(4)[0:4] = struct.pack("<L", tpos)
+    except OSError as e:
+        raise RuntimeError("fs_tell_callback(%s) exception %s" % (fs_file.__cast__()['path'], e))
+
+    return lv.FS_RES.OK
+
+
+def fs_write_cb(drv, fs_file, buf, btw, bw):
+    try:
+        wr = fs_file.__cast__()['file'].write(buf.__dereference__(btw)[0:btw])
+        bw.__dereference__(4)[0:4] = struct.pack("<L", wr)
+    except OSError as e:
+        raise RuntimeError("fs_write_callback(%s) exception %s" % (fs_file.__cast__()['path'], e))
+
+    return lv.FS_RES.OK
+
+
+def fs_register(fs_drv, letter, cache_size=500):
+
+    fs_drv.init()
+    fs_drv.letter = ord(letter)
+    fs_drv.open_cb = fs_open_cb
+    fs_drv.read_cb = fs_read_cb
+    fs_drv.write_cb = fs_write_cb
+    fs_drv.seek_cb = fs_seek_cb
+    fs_drv.tell_cb = fs_tell_cb
+    fs_drv.close_cb = fs_close_cb
+
+    if cache_size >= 0:
+        fs_drv.cache_size = cache_size
+
+    fs_drv.register()
+

scripts/fs_driver.py

@@ -0,0 +1,24 @@
+import lvgl as lv
+def LV_COLOR_MAKE(r,g,b):
+#    return lv.color_hex(r<<16| g<<8 |b)
+    return lv.color_make(r,g,b)
+
+class lv_colors:
+    WHITE=LV_COLOR_MAKE(0xFF, 0xFF, 0xFF)
+    SILVER=LV_COLOR_MAKE(0xC0, 0xC0, 0xC0)
+    GRAY=LV_COLOR_MAKE(0x80, 0x80, 0x80)
+    BLACK=LV_COLOR_MAKE(0x00, 0x00, 0x00)
+    RED=LV_COLOR_MAKE(0xFF, 0x00, 0x00)
+    MAROON=LV_COLOR_MAKE(0x80, 0x00, 0x00)
+    YELLOW=LV_COLOR_MAKE(0xFF, 0xFF, 0x00)
+    OLIVE=LV_COLOR_MAKE(0x80, 0x80, 0x00)
+    LIME=LV_COLOR_MAKE(0x00, 0xFF, 0x00)
+    GREEN=LV_COLOR_MAKE(0x00, 0x80, 0x00)
+    CYAN=LV_COLOR_MAKE(0x00, 0xFF, 0xFF)
+    AQUA=CYAN
+    TEAL=LV_COLOR_MAKE(0x00, 0x80, 0x80)
+    BLUE=LV_COLOR_MAKE(0x00, 0x00, 0xFF)
+    NAVY=LV_COLOR_MAKE(0x00, 0x00, 0x80)
+    MAGENTA=LV_COLOR_MAKE(0xFF, 0x00, 0xFF)
+    PURPLE=LV_COLOR_MAKE(0x80, 0x00, 0x80)
+    ORANGE=LV_COLOR_MAKE(0xFF, 0xA5, 0x00)