micrOSDevToolKit 2.1.5__py3-none-any.whl → 2.26.1__py3-none-any.whl

micrOS/source/{LM_oled_ui.py → modules/LM_oled_ui.py}

@@ -1,28 +1,27 @@
+"""
+micrOS simple OLED UI (irq or single task based refresh)
+    - with page generation
+Designed by Marcell Ban aka BxNxM
+"""
+
 from Config import cfgget
 from utime import localtime
 from network import WLAN, STA_IF
-from microIO import physical_pin, pinmap_dump
+from microIO import bind_pin, pinmap_search
 from Network import ifconfig
-from Debug import errlog_add
+from Common import syslog, exec_cmd, manage_task
 from machine import Pin
-from Tasks import lm_exec, Manager
+from Types import resolve
 try:
-    from LM_system import memory_usage
+    from LM_system import memory_usage, hosts
 except:
     memory_usage = None         # Optional function handling
-try:
-    import LM_intercon as InterCon
-except:
-    InterCon = None             # Optional function handling
-try:
-    from LM_genIO import get_adc
-except:
-    get_adc = None              # Optional function handling
 try:
     from LM_gameOfLife import next_gen as gol_nextgen, reset as gol_reset
 except:
     gol_nextgen = None          # Optional function handling
 
+from utime import ticks_ms, ticks_diff     # For IRQ joystick handling
 
 #################################
 # PAGE MANAGER CLASS DEFINITION #
@@ -32,7 +31,7 @@ class PageUI:
     PAGE_UI_OBJ = None
     DISPLAY = None
 
-    def __init__(self, page_callbacks, w, h, page=0, pwr_sec=None, oled_type='ssd1306'):
+    def __init__(self, page_callbacks, w, h, page=0, pwr_sec=None, oled_type='ssd1306', joystick=False):
         """
         :param page_callbacks: callback function list to show on UI
         :param page: start page index, default 0 (+fallback)
@@ -40,6 +39,7 @@ class PageUI:
         :param h: screen height
         :param pwr_sec: auto screen off after this sec
         :param oled_type: type of oled display: ssd1306 / sh1106
+        :param joystick: enable joystick IRQ-s
         """
         if oled_type.strip() in ('ssd1306', 'sh1106'):
             if oled_type.strip() == 'ssd1306':
@@ -48,7 +48,7 @@ class PageUI:
                 import LM_oled_sh1106 as oled
             PageUI.DISPLAY = oled
         else:
-            errlog_add(f"Oled UI unknown oled_type: {oled_type}")
+            syslog(f"Oled UI unknown oled_type: {oled_type}")
             Exception(f"Oled UI unknown oled_type: {oled_type}")
         self.page_callback_list = page_callbacks
         self.active_page = page
@@ -68,7 +68,8 @@ class PageUI:
         # Create built-in button IRQ - OK button (center)
         self.bttn_press_callback = None
         self.irq_ok = False
-        self.__create_button_irq()
+        if joystick:
+            self.__create_joystick_irq()
 
         # Power saver state machine - turn off sec, deltaT (timirq executor seq loop), counter
         self.pwr_saver_state = [pwr_sec, round(cfgget('timirqseq') / 1000, 2), pwr_sec]
@@ -105,13 +106,13 @@ class PageUI:
             pass
 
         ltime = localtime()
-        h = "0{}".format(ltime[-5]) if len(str(ltime[-5])) < 2 else ltime[-5]
-        m = "0{}".format(ltime[-4]) if len(str(ltime[-4])) < 2 else ltime[-4]
-        s = "0{}".format(ltime[-3]) if len(str(ltime[-3])) < 2 else ltime[-3]
+        h = f"0{ltime[-5]}" if len(str(ltime[-5])) < 2 else ltime[-5]
+        m = f"0{ltime[-4]}" if len(str(ltime[-4])) < 2 else ltime[-4]
+        s = f"0{ltime[-3]}" if len(str(ltime[-3])) < 2 else ltime[-3]
         nwmd = ifconfig()[0]
         nwmd = nwmd[0] if len(nwmd) > 0 else "0"
         irq_ok = ' ' if self.bttn_press_callback is None else '*' if self.irq_ok else '!'
-        PageUI.DISPLAY.text("{} {} {}:{}:{}".format(nwmd, irq_ok, h, m, s), 0, 0)
+        PageUI.DISPLAY.text(f"{nwmd} {irq_ok} {h}:{m}:{s}", 0, 0)
 
     def __page_bar(self):
         """Generates page indicator bar"""
@@ -150,19 +151,37 @@ class PageUI:
         PageUI.DISPLAY.text(msg, 15, 40)
         return True
 
-    def __create_button_irq(self, pinkey='oleduibttn'):
-        """Create button press IRQ for OK/Center button"""
-        try:
-            pin = physical_pin(pinkey)
-        except Exception as e:
-            msg = '[ERR] Button IRQ:{} {}'.format(pinkey, e)
+    def __create_joystick_irq(self):
+        """Create Joystick buttons IRQs"""
+        def _set(pin_tag, callback):
             pin = None
-            errlog_add(msg)
-        if pin:
-            pin_obj = Pin(pin, Pin.IN, Pin.PULL_DOWN)
-            # [IRQ] - event type setup
-            pin_obj.irq(trigger=Pin.IRQ_RISING, handler=lambda pin: self.control('press'))
-            self.irq_ok = True
+            try:
+                pin = bind_pin(pin_tag)
+            except Exception as e:
+                syslog(f'[ERR] {pin_tag} IRQ: {e}')
+            if pin:
+                pin_obj = Pin(pin, Pin.IN, Pin.PULL_DOWN)
+                # [IRQ] - event type setup
+                pin_obj.irq(trigger=Pin.IRQ_FALLING, handler=callback)
+
+        def _event_handler(control_command, prell_ms=150):
+            nonlocal  _p_last
+            _last = _p_last.get(control_command)
+            last = 0 if _last is None else _last
+            # Calculate time difference between last trigger action and now tick.
+            diff = ticks_diff(ticks_ms(), last)
+            if abs(diff) > prell_ms:
+                # Save now tick - last trigger action
+                _p_last[control_command] = ticks_ms()
+                self.control(control_command)
+
+        _p_last = {}
+        _set("js_right", lambda pin: _event_handler('next'))
+        _set("js_left", lambda pin: _event_handler('prev'))
+        _set("js_up", lambda pin: _event_handler('on'))
+        _set("js_down", lambda pin: _event_handler('off'))
+        _set("js_press", lambda pin: _event_handler('press'))
+        self.irq_ok = True
 
     def __power_save(self):
         """
@@ -223,6 +242,7 @@ class PageUI:
                     else:
                         self.page_callback_list[self.active_page]()             # <== Execute page functions
                 except Exception as e:
+                    syslog(f"oled_ui render error: {e}")
                     PageUI.PAGE_UI_OBJ.show_msg = f"Err: {e}"                   # Show page error in msgbox
             PageUI.DISPLAY.show()
             self.__power_save()
@@ -266,7 +286,7 @@ class PageUI:
                 PageUI.DISPLAY.show()
             self.oled_state = False             # Off main page logic
             self.bttn_press_callback = None
-        return "page: {} pwr: {}".format(self.active_page, self.oled_state)
+        return f"page: {self.active_page} pwr: {self.oled_state}"
 
     def _page_button_press(self):
         """
@@ -318,39 +338,47 @@ class PageUI:
     #####################################
     #           PAGE GENERATORS         #
     #####################################
-    def intercon_page(self, host, cmd, run=False):
+    def intercon_page(self, cmd:str, run=False):
         """Generic interconnect page core - create multiple page with it"""
         posx, posy = 5, 12
 
         def _button():
+            nonlocal host, _cmd
             # BUTTON CALLBACK - INTERCONNECT execution
             self.open_intercons.append(host)
             try:
                 # Send CMD to other device & show result
-                data_meta = InterCon.send_cmd(host, cmd)
-                self.cmd_task_tag = data_meta['tag']
-                if "Task is Busy" in data_meta['verdict'] and not run:
-                    self.cmd_out = data_meta['verdict']     # Otherwise the task start output not relevant on UI
+                state, data_meta = exec_cmd(_cmd, jsonify=True)
+                if state:
+                    self.cmd_task_tag = list(data_meta.keys())[0]
+                    verdict = list(data_meta.values())[0]
+                    if "Already running" in verdict and not run:
+                        self.cmd_out = verdict     # Otherwise the task start output not relevant on UI
+                else:
+                    self.cmd_out = f"Error: {data_meta}"
             except Exception as e:
                 self.cmd_out = str(e)
             self.open_intercons.remove(host)
 
         # Check open host connection
-        if host in self.open_intercons:
-            return
+        _cmd = cmd.strip().split()
+        host = _cmd[-1].replace(">", "").replace("&", "")
         # Draw host + cmd details
-        PageUI.DISPLAY.text(host, 0, posy)
-        PageUI.DISPLAY.text(cmd, posx, posy+10)
+        PageUI.DISPLAY.text(' '.join(_cmd[0:-1]), 0, posy)
+        PageUI.DISPLAY.text(_cmd[-1], posx, posy+10)
+        self._cmd_text(posx, posy + 10)
+
         # Update display output with retrieved task result (by TaskID)
         if self.cmd_task_tag is not None:
-            task_buffer = str(Manager().show(tag=self.cmd_task_tag)).replace(' ', '')
+            task_buffer = manage_task(self.cmd_task_tag, 'show').replace(' ', '')
             if task_buffer is not None and len(task_buffer) > 0:
                 # Set display out to task buffered data
                 self.cmd_out = task_buffer
-                # Kill task - clean
-                Manager().kill(tag=self.cmd_task_tag)
-                # data gathered - remove tag - skip re-read
-                self.cmd_task_tag = None
+                if not manage_task(self.cmd_task_tag, 'isbusy'):
+                    # Kill task - clean
+                    manage_task(self.cmd_task_tag, 'kill')
+                    # data gathered - remove tag - skip re-read
+                    self.cmd_task_tag = None
         # Show self.cmd_out value on display
         self._cmd_text(posx, posy+10)
         # Run button event at page init
@@ -360,7 +388,7 @@ class PageUI:
             # Set button press callback (+draw button)
             self.set_press_callback(_button)
 
-    def cmd_call_page(self, cmd, run=False):
+    def cmd_call_page(self, cmd:str, run=False):
         """Generic LoadModule execution page core - create multiple page with it"""
         posx, posy = 5, 12
 
@@ -369,7 +397,7 @@ class PageUI:
             try:
                 cmd_list = cmd.strip().split()
                 # Send CMD to other device & show result
-                state, out = lm_exec(cmd_list)
+                state, out = exec_cmd(cmd_list)
                 try:
                     self.cmd_out = ''.join(out.strip().split()).replace(' ', '')
                 except Exception:
@@ -387,43 +415,16 @@ class PageUI:
             # Set button press callback (+draw button)
             self.set_press_callback(_button)
 
-    def adc_visualize_page(self, pin):
-        """Generic ADC value visualization page - create multiple page with it"""
-
-        def __visualize(p):
-            max_w = 50
-            percent = p * 0.01
-            size = round(percent * max_w)
-            size = 1 if size < 1 else size
-            # Visualize percentage
-            PageUI.DISPLAY.rect(0, 9, size, size, fill=True)
-            # Visualize percentages scale
-            steps = int(max_w / 10)
-            for scale in range(steps, max_w + 1, steps):
-                if scale < size:
-                    PageUI.DISPLAY.rect(0, 9, scale, scale, state=0)
-                else:
-                    PageUI.DISPLAY.rect(0, 9, scale, scale, state=1)
-
-        data = {'percent': 'null', 'volt': 'null'}
-        if get_adc is not None:
-            data = get_adc(pin)
-        __visualize(p=data['percent'])
-        PageUI.DISPLAY.text("{} %".format(data['percent']), 65, 20)
-        PageUI.DISPLAY.text("{} V".format(data['volt']), 65, 40)
-        return True
-
-
-#################################
-#        PAGE DEFINITIONS       #
-#################################
+####################################
+#        UI PAGE DEFINITIONS       #
+####################################
 
 def _sys_page():
     """
     System basic information page
     """
     PageUI.DISPLAY.text(cfgget("devfid"), 0, 15)
-    PageUI.DISPLAY.text("  {}".format(ifconfig()[1][0]), 0, 25)
+    PageUI.DISPLAY.text(f"  {ifconfig()[1][0]}", 0, 25)
     if memory_usage is not None:
         mem = memory_usage()
         PageUI.DISPLAY.text(f"  {mem['percent']}% ({int(mem['mem_used']/1000)}kb)", 0, 35)
@@ -432,16 +433,21 @@ def _sys_page():
 
 
 def _intercon_cache(line_limit=3):
-    if InterCon is None:
-        return False
     line_start = 15
     line_cnt = 1
     PageUI.DISPLAY.text("InterCon cache", 0, line_start)
-    if sum([1 for _ in InterCon.host_cache()]) > 0:
-        for key, val in InterCon.host_cache().items():
-            key = key.split('.')[0]
-            val = '.'.join(val.split('.')[-2:])
-            PageUI.DISPLAY.text(" {} {}".format(val, key), 0, line_start+(line_cnt*10))
+    cache = hosts()["intercon"]
+    if sum([1 for _ in cache]) > 0:
+        for key, val in cache.items():
+            if '.' in key:
+                # IP splitting
+                key = key.split('.')[0]
+                val = '.'.join(val.split('.')[-2:])
+            else:
+                # MAC splitting
+                key = key.split(':')[0]
+                val = ':'.join(val.split(':')[-2:])
+            PageUI.DISPLAY.text(f" {val} {key}", 0, line_start+(line_cnt*10))
             line_cnt += 1
             if line_cnt > line_limit:
                 break
@@ -471,24 +477,36 @@ def _micros_welcome():
         return str(e)
     return True
 
-#################################
-# PAGE GUI CONTROLLER FUNCTIONS #
-#   USED IN MICROS SHELL/IRQs   #
-#################################
-
+#############################################################################
+#                       PAGE GUI CONTROLLER FUNCTIONS                       #
+#                         USED IN MICROS SHELL/IRQs                         #
+#############################################################################
 
-def pageui(pwr_sec=None, oled_type='ssd1306', page=0):
+def load(pwr_sec=None, oled_type='ssd1306', page=0, width=128, height=64, joystick=True):
     """
-    Init&RUN PageUI
-    - add page definitions here - interface from code
-    :param pwr_sec: power down oled after given sec - power safe
+    Init PageUI
+    :param pwr_sec: power down oled after given sec -> screensaver
     :param oled_type: oled type selection: ssd1306 or sh1106
-    :param page: start page index, start from 0
+    :param page: start page index, default: 0
+    :param width: width in pixels
+    :param height: height in pixels
+    :param joystick: init joystick irq pin-s (default: True)
     """
     if PageUI.PAGE_UI_OBJ is None:
         pages = [_sys_page, _intercon_cache, _micros_welcome]  # <== Add page function HERE
-        PageUI(pages, 128, 64, page=page, pwr_sec=pwr_sec, oled_type=oled_type)
+        PageUI(pages, width, height, page=page, pwr_sec=pwr_sec, oled_type=oled_type, joystick=joystick)
+    PageUI.PAGE_UI_OBJ.render_page()
+    return f"OLED: {oled_type}: {width}x{height} initialized."
+
+
+def draw():
+    """
+    Refresh page on PageUI
+    """
+    if PageUI.PAGE_UI_OBJ is None:
+        return "Module uninitialized, run: oled_ui load pwr_sec=None oled_type='ssd1306' page=0 width=128 height=64"
     PageUI.PAGE_UI_OBJ.render_page()
+    return f"refreshed..."
 
 
 def control(cmd='next'):
@@ -500,7 +518,7 @@ def control(cmd='next'):
     valid_cmd = ('next', 'prev', 'press', 'on', 'off')
     if cmd in valid_cmd:
         return PageUI.PAGE_UI_OBJ.control(cmd)
-    return 'Invalid command {}! Hint: {}'.format(cmd, valid_cmd)
+    return f'Invalid command {cmd}! Hint: {valid_cmd}'
 
 
 def msgbox(msg='micrOS msg'):
@@ -512,8 +530,7 @@ def msgbox(msg='micrOS msg'):
     PageUI.PAGE_UI_OBJ.render_page()
     return 'Show msg'
 
-
-def intercon_genpage(cmd=None, run=False):
+def genpage(cmd:str=None, run=False):
     """
     Create intercon pages dynamically :)
     - based on cmd value.
@@ -521,40 +538,15 @@ def intercon_genpage(cmd=None, run=False):
     :param run: run button event at page init: True/False
     :return: page creation verdict
     """
-    raw = cmd.split()
-    host = raw[0]
-    cmd = ' '.join(raw[1:])
-    if PageUI.PAGE_UI_OBJ is None:
-        # Auto init UI
-        pageui()
-    try:
-        # Create page for intercon command
-        PageUI.PAGE_UI_OBJ.add_page(lambda: PageUI.PAGE_UI_OBJ.intercon_page(host, cmd, run=run))
-    except Exception as e:
-        errlog_add(f'[ERR] intercon_genpage: {e}')
-        return str(e)
-    return True
-
-
-def cmd_genpage(cmd=None, run=False):
-    """
-    Create load module execution pages dynamically :)
-    - based on cmd value: load_module function (args)
-    :param cmd: 'load_module function (args)' string
-    :param run: run button event at page init: True/False
-    :return: page creation verdict
-    """
-    if not isinstance(cmd, str):
-        return False
-
-    if PageUI.PAGE_UI_OBJ is None:
-        # Auto init UI
-        pageui()
     try:
-        # Create page for intercon command
-        PageUI.PAGE_UI_OBJ.add_page(lambda: PageUI.PAGE_UI_OBJ.cmd_call_page(cmd, run=run))
+        if ">>" in cmd or "&" in cmd:
+            # Create page for intercon/task background command
+            PageUI.PAGE_UI_OBJ.add_page(lambda: PageUI.PAGE_UI_OBJ.intercon_page(cmd, run=run))
+        else:
+            # Create page for realtime command
+            PageUI.PAGE_UI_OBJ.add_page(lambda: PageUI.PAGE_UI_OBJ.cmd_call_page(cmd, run=run))
     except Exception as e:
-        errlog_add(f'[ERR] cmd_genpage: {e}')
+        syslog(f'[ERR] genpage: {e}')
         return str(e)
     return True
 
@@ -570,35 +562,11 @@ def function_genpage(func):
     if not callable(func):
         return "Provided <func> not callable, input must be python function (coding interface)"
 
-    if PageUI.PAGE_UI_OBJ is None:
-        # Auto init UI
-        pageui()
     try:
         # Create custom page
         PageUI.PAGE_UI_OBJ.add_page(lambda: func(display=PageUI.DISPLAY))
     except Exception as e:
-        errlog_add(f'[ERR] function_genpage: {e}')
-        return str(e)
-    return True
-
-
-def adc_genpage(pin=33):
-    """
-    Create ADC visualization pages dynamically :)
-    :param pin: pin number for ADC read, default: 33
-    :return: page creation verdict
-    """
-    if not isinstance(pin, int):
-        return False
-
-    if PageUI.PAGE_UI_OBJ is None:
-        # Auto init UI
-        pageui()
-    try:
-        # Create page for intercon command
-        PageUI.PAGE_UI_OBJ.add_page(lambda: PageUI.PAGE_UI_OBJ.adc_visualize_page(pin=pin))
-    except Exception as e:
-        errlog_add(f'[ERR] adc_genpage: {e}')
+        syslog(f'[ERR] function_genpage: {e}')
         return str(e)
     return True
 
@@ -606,15 +574,6 @@ def adc_genpage(pin=33):
 # LM helper functions #
 #######################
 
-def lmdep():
-    """
-    Show Load Module dependency
-    - List of load modules used by this application
-    :return: tuple
-    """
-    return 'oled', 'intercon', 'genIO'
-
-
 def pinmap():
     """
     [i] micrOS LM naming convention
@@ -623,7 +582,7 @@ def pinmap():
     :return dict: pin name (str) - pin value (int) pairs
     """
     pin_map = PageUI.DISPLAY.pinmap()
-    pin_map.update(pinmap_dump('oleduibttn'))
+    pin_map.update(pinmap_search(["js_right", "js_left", "js_up", "js_down", "js_press"]))
     return pin_map
 
 
@@ -634,10 +593,9 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return 'pageui page=0 pwr_sec=None/int(sec) oled_type="ssd1306 or sh1106"',\
-           'control next/prev/press/on/off',\
-           'msgbox "msg"',\
-           'intercon_genpage "host" "cmd" run=False',\
-           'cmd_genpage "cmd" run=False',\
-           'adc_genpage pin=33',\
-           'pinmap'
+    return resolve(('load pwr_sec=None/int(sec) oled_type="ssd1306 or sh1106" page=0 width=128 height=64 joystick=True',
+                             'draw',
+                             'BUTTON control cmd=<prev,press,next,on,off>',
+                             'msgbox "msg"',
+                             'genpage "cmd" run=False',
+                             'pinmap'), widgets=widgets)