micrOSDevToolKit 2.10.5__py3-none-any.whl → 2.11.0__py3-none-any.whl

micrOS/source/LM_dimmer.py

@@ -1,6 +1,6 @@
 from sys import platform
 from microIO import bind_pin, pinmap_search
-from Common import transition_gen, micro_task
+from Common import transition_gen, micro_task, data_dir
 from utime import sleep_ms
 from Types import resolve
 
@@ -15,6 +15,7 @@ class Data:
     PERSISTENT_CACHE = False
     DIMM_TASK_TAG = "dimmer._tran"
     TASK_STATE = False
+    FILE_CACHE = data_dir('dimmer.cache')
 
 
 #########################################
@@ -34,7 +35,7 @@ def __dimmer_init():
 
 def __persistent_cache_manager(mode='r'):
     """
-    pds - persistent data structure
+    File cache
     modes:
         r - recover, s - save
     """
@@ -42,12 +43,12 @@ def __persistent_cache_manager(mode='r'):
         return
     if mode == 's':
         # SAVE CACHE
-        with open('dimmer.pds', 'w') as f:
+        with open(Data.FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in Data.DIMMER_CACHE]))
         return
     try:
         # RESTORE CACHE
-        with open('dimmer.pds', 'r') as f:
+        with open(Data.FILE_CACHE, 'r') as f:
             Data.DIMMER_CACHE = [int(data) for data in f.read().strip().split(',')]
     except:
         pass
@@ -71,7 +72,7 @@ def load(cache=None):
     """
     Initialize dimmer module
     :param cache bool: file state machine cache: True/False/None(default: automatic True)
-    - Load .pds (state machine cache) for this load module
+    - Load .cache (state machine cache) for this load module
     - Apply loaded states to gpio pins (boot function)
     :return str: Cache state
     """

micrOS/source/LM_espnow.py

@@ -2,10 +2,24 @@ import Espnow
 
 def load():
     """
-    Initialize ESPNOW protocal
+    OBSOLETE - remove
+    [DEBUG ONLY] ENABLE ESPNOW IN NODE CONFIG INSTEAD OF HERE!
+        Initialize ESPNOW protocal
     """
     return Espnow.initialize()
 
+def start_server():
+    """
+    OBSOLETE - remove
+    [DEBUG ONLY] ENABLE ESPNOW IN NODE CONFIG INSTEAD OF HERE!
+        Start ESPNOW server/listener
+        - this can receive espnow messages
+        - it includes Load Module execution logic (beta)
+    """
+    now = Espnow.initialize()
+    return now.start_server()
+
+
 def send(peer:bytes|str, msg:str='modules'):
     """
     Send message to peer (by mac address)
@@ -15,15 +29,6 @@ def send(peer:bytes|str, msg:str='modules'):
     now = Espnow.initialize()
     return now.send(peer, msg)
 
-def start_server():
-    """
-    Start ESPNOW server/listener
-    - this can receive espnow messages
-    - it includes Load Module execution logic (beta)
-    """
-    now = Espnow.initialize()
-    return now.start_server()
-
 def stats():
     """
     Get ESPNOW stats

micrOS/source/LM_i2c.py

@@ -24,8 +24,9 @@ def discover():
     """
     Discover devices
     """
-    known_addresses = {hex(0x0A): "trackball", hex(0x3c): "oled",
-                       hex(0x76): "bme280", hex(0x10): 'veml7700'}
+    known_addresses = {hex(0x0A): "TRACKBALL", hex(0x3c): "OLED",
+                       hex(0x76): "BME280", hex(0x10): 'VEML7700',
+                       hex(0x6b): "QMI8658"}
     devices = scan()
     output = {"unknown": []}
     for k in devices:

micrOS/source/LM_neoeffects.py

@@ -1,167 +1,107 @@
-from LM_neopixel import load, segment, Data, status, pinmap as pm
+from LM_neopixel import load as neoload, segment, Data, status, pinmap as pm
 from random import randint
 from Types import resolve
-from Common import manage_task
+from Common import manage_task, AnimationPlayer
 
 
 #################################
 #  NEOPIXEL EFFECT DRAWER CLASS #
 #################################
 
-class DrawEffect:
-    __instance = None
-
-    def __new__(cls, pixcnt=24):
-        if DrawEffect.__instance is None:
-            DrawEffect.__instance = super().__new__(cls)
-            DrawEffect.__instance.pix_cnt = None
-            DrawEffect.__instance.index_offset = 0
-            DrawEffect.__instance.color_wheel = 0
-            DrawEffect.__instance.__init_effect(pixcnt)
-            DrawEffect.__instance.offset_gen = None
-            DrawEffect.__instance.auto_shift = False
-        return DrawEffect.__instance
-
-    def __init_effect(cls, ledcnt):
-        """
-        Set neopixel object & store pixel cnt
-        """
-        if Data.NEOPIXEL_OBJ is None:
-            load(ledcnt=ledcnt)
-            cls.pix_cnt = Data.NEOPIXEL_OBJ.n
-        if cls.pix_cnt is None:
-            cls.pix_cnt = Data.NEOPIXEL_OBJ.n
-        return cls.pix_cnt
-
-    def __offset(cls, shift):
-        def _gen():
-            while True:
-                if cls.auto_shift:
-                    # Step rotation cycle - shift True
-                    cls.index_offset += 1
-                    if cls.index_offset > cls.pix_cnt - 1:
-                        cls.index_offset = 0
-                for k in range(cls.index_offset, cls.pix_cnt):
-                    yield k
-                for k in range(0, cls.index_offset):
-                    yield k
-        cls.auto_shift = shift
-        if cls.offset_gen is None:
-            cls.offset_gen = _gen()
-        return cls.offset_gen
-
-    def draw(cls, iterable, shift=False):
-        """
-        DRAW GENERATED COLORS (RGB)
-        HELPER FUNCTION with auto shift (offset) sub function
-        :param iterable: Colors generator object / iterable
-        :param shift: automatic color map rotation
-        :return: None
-        """
-        offset_gen = cls.__offset(shift=shift)
-        r, g, b, i = 0, 0, 0, 0
-        for r, g, b in iterable:
-            # Handle index offset - rotate effect
-            i = next(offset_gen)
-            # Write data to neopixel - write / segment :)
-            segment(int(r), int(g), int(b), s=i, cache=False, write=False)
-        segment(int(r), int(g), int(b), s=i, cache=False, write=True)
-        return True
-
-
-def __color_input(r, g, b):
-    _r, _g, _b, _ = Data.DCACHE
-    r = _r if r is None else r
-    g = _g if g is None else g
-    b = _b if b is None else b
-    return r, g, b
-
-
-#################################
-#         DEFINE EFFECTS        #
-#################################
-
-def meteor(r=None, g=None, b=None, shift=True, ledcnt=24):
+class DrawEffectV2(AnimationPlayer):
+    INSTANCE = None
+
+    def __init__(self, pix_cnt=24):
+        super().__init__(tag="neoeffects")
+        neoload(ledcnt=pix_cnt)
+        DrawEffectV2.INSTANCE = self
+
+    @staticmethod
+    def normalize_index(value) -> int:
+        return value % Data.NEOPIXEL_OBJ.n
+
+    @staticmethod
+    def color_code(r:int=None, g:int=None, b:int=None) -> tuple[float, float, float]:
+        _r, _g, _b, _ = Data.DCACHE
+        r = _r if r is None else r
+        g = _g if g is None else g
+        b = _b if b is None else b
+        return r, g, b
+
+    def update(self, index:int, r:int|float, g:int|float, b:int|float):
+        # Animation player will call this method to update pixels.
+        segment(r=int(r), g=int(g), b=int(b), s=index, cache=False, write=False)
+
+    def draw(self):
+        # Animation player will call this method to update pixels.
+        Data.NEOPIXEL_OBJ.write()
+
+    def clear(self):
+        # Animation player will call this method to update pixels.
+        for i in range(0, Data.NEOPIXEL_OBJ.n):
+            self.update(i, 0, 0, 0)
+        self.draw()
+
+##################################################################################
+#                                  EFFECTS                                       #
+##################################################################################
+
+def meteor(speed_ms:int=60, shift:bool=True, batch:bool=True):
     """
     Meteor effect
-    :param r int: red value 0-1000
-    :param g int: green value 0-1000
-    :param b int: blue value 0-1000
-    :param shift bool: automatic effect shifting
-    :param ledcnt int: number of neopixel elements in chain (default: 24)
+    :param speed_ms: animation speed in milliseconds
+    :param shift: automatic effect rotation
+    :param batch: batch mode
     :return str: verdict
     """
-    def __effect(r, g, b, pixel):
+    def effect_meteor():
         """
         Describe one full length color map
-        :param r: red target color
-        :param g: green target color
-        :param b: blue target color
-        :param pixel: number of led segments
         :return: yield tuple with r,g,b
         """
-        step = float(0.9 / pixel)
-        for k in range(0, pixel):
-            fade = (k+1) * step
-            data = round(r * fade), round(g * fade), round(b * fade)
-            yield data
+        nonlocal shift, pix_cnt
+        max_offset = pix_cnt if shift else 1
+        for offset in range(0, max_offset):
+            r, g, b = DrawEffectV2.color_code()
+            for pixel in range(0, pix_cnt):
+                br, norm = 0.6, pixel/pix_cnt
+                fade = br * norm ** 0.9         # exponent < 1 simulates log-like curve
+                yield DrawEffectV2.normalize_index(pixel+offset), r*fade, g*fade, b*fade
 
-    # Conditional value load - with neopixel cache
-    r, g, b = __color_input(r, g, b)
-
-    # Init custom params
-    effect = DrawEffect(pixcnt=ledcnt)
-    # Create effect data
-    cgen = __effect(r, g, b, effect.pix_cnt)
-    # Draw effect data
-    effect.draw(cgen, shift=shift)
-    return 'Meteor R{}:G{}:B{} N:{}'.format(r, g, b, effect.pix_cnt)
+    neoeffect = load()
+    pix_cnt = Data.NEOPIXEL_OBJ.n
+    return neoeffect.play(effect_meteor, speed_ms=speed_ms, bt_draw=batch, bt_size=pix_cnt)
 
 
-def cycle(r=None, g=None, b=None, shift=True, ledcnt=24):
+def cycle(speed_ms:int=60, shift:bool=True, batch:bool=True):
     """
     Cycle effect
-    :param r int: red value 0-1000
-    :param g int: green value 0-1000
-    :param b int: blue value 0-1000
-    :param shift bool: automatic effect shifting
-    :param ledcnt int: number of neopixel elements in chain (default: 24)
-    :return str: verdict
+    :param speed_ms: animation speed in milliseconds
+    :param shift: automatic effect rotation
+    :param batch: enable/disable batch update mode
     """
-    def __effect(r, g, b, pixel):
+    def effect_cycle():
         """
         Describe one full length color map
-        :param r: red target color
-        :param g: green target color
-        :param b: blue target color
-        :param pixel: number of led segments
-        :return: yield tuple with r,g,b
+        :return: yield tuple with index, r,g,b
         """
-        lightrgb = round(r*0.1), round(g*0.1), round(b*0.1)
-        yield lightrgb
-        yield r, g, b
-        yield lightrgb
-        for i in range(3, pixel):
-            yield 0, 0, 0
-
-    # Conditional value load - with neopixel cache
-    r, g, b = __color_input(r, g, b)
-
-    effect = DrawEffect(pixcnt=ledcnt)
-    cgen = __effect(r, g, b, effect.pix_cnt)
-    effect.draw(cgen, shift=shift)
-    return 'Cycle R{}:G{}:B{} N:{}'.format(r, g, b, effect.pix_cnt)
-
-
-def rainbow(step=1, br=50, ledcnt=24):
-    """
-    Rainbow effect
-    :param step int: color weel resolution in step (default: 1)
-    :param br int: brightness in percentage
-    :param ledcnt int: number of neopixel elements in chain (default: 24)
-    :return str: verdict
-    """
-    def __wheel(pos):
+        nonlocal shift
+        max_offset = Data.NEOPIXEL_OBJ.n if shift else 1
+        for offset in range(0, max_offset):
+            r, g, b = DrawEffectV2.color_code()
+            lr, lg, lb = int(r * 0.1), int(g * 0.1), int(b * 0.1)
+            # Clean last pixel
+            yield DrawEffectV2.normalize_index(offset-1), 0, 0, 0
+            # Draw pattern
+            yield DrawEffectV2.normalize_index(offset), lr, lg, lb
+            yield DrawEffectV2.normalize_index(offset + 1), r, g, b
+            yield DrawEffectV2.normalize_index(offset + 2), lr, lg, lb
+
+    return load().play(effect_cycle, speed_ms=speed_ms, bt_draw=batch, bt_size=4)
+
+
+def rainbow(speed_ms=20, br=15, batch=True):
+    def _wheel(pos):
         # Input a value 0 to 255 to get a color value.
         # The colours are a transition r - g - b - back to r.
         if pos < 0 or pos > 255:
@@ -174,59 +114,84 @@ def rainbow(step=1, br=50, ledcnt=24):
         pos -= 170
         return pos * 3, 0, 255 - pos * 3
 
-    def __effect(cnt, step, br):
+    def effect_rainbow():
         """
         :param cnt: led segment count
         :param br: max brightness 0-100%
         :param step: step size
         """
-        cw = DrawEffect().color_wheel
-        DrawEffect().color_wheel = 0 if cw >= 255 else cw+step
-        for i in range(0, cnt):
-            rc_index = (i * 256 // cnt) + DrawEffect().color_wheel
-            r, g, b = __wheel(rc_index & 255)
-            yield round(r*br*0.01), round(g*br*0.01), round(b*br*0.01)
+        nonlocal pix_cnt, br
+        color_step = 3
+        for color_wheel in range(0, 255, color_step):
+            for index in range(0, pix_cnt):
+                rc_index = (index * 256 // pix_cnt) + color_wheel
+                r, g, b = _wheel(rc_index & 255)
+                yield DrawEffectV2.normalize_index(index+color_wheel), round(r*br*0.01), round(g*br*0.01), round(b*br*0.01)
 
-    effect = DrawEffect(pixcnt=ledcnt)
-    cgen = __effect(effect.pix_cnt, step=step, br=br)
-    effect.draw(cgen, shift=True)
-    return 'Rainbow'
+    neoeffect = load()
+    pix_cnt = Data.NEOPIXEL_OBJ.n
+    return neoeffect.play(effect_rainbow, speed_ms=speed_ms, bt_draw=batch, bt_size=pix_cnt)
 
 
-def shader(size=6, offset=0, shift=False, ledcnt=24):
+def fire(speed_ms:int=150, br:int=30, batch:bool=True):
     """
-    Shader for ring lamp
-    :param size int: shader size (disabled LEDs)
-    :param offset int: rotate shader 0-(ledcnt-1)
-    :param shift bool: auto shift shader effect (False)
-    :param ledcnt int: number of neopixel elements in chain (default: 24)
-    :return str: verdict
+    Fire effect
+    :param speed_ms: animation speed in milliseconds
+    :param br: max brightness 0-100%
+    :param batch: batch update
     """
-    def __effect(size, offset, pixcnt):
+    def effect_fire():
+        nonlocal pix_cnt, br
+        max_value = int(255 * (br/100))
+        for index in range(pix_cnt):
+            r, g, b = DrawEffectV2.color_code()
+            rand_percent = float(round(randint(1, max_value)/max_value, 2))
+            new_r = min(max(int(r * rand_percent), 0), max_value)
+            new_g = min(max(int(g * rand_percent), 0), max_value)
+            new_b = min(max(int(b * rand_percent), 0), max_value)
+            yield index, new_r, new_g, new_b
+
+    neoeffect = load()
+    pix_cnt = Data.NEOPIXEL_OBJ.n
+    return neoeffect.play(effect_fire, speed_ms=speed_ms, bt_draw=batch, bt_size=pix_cnt)
+
+
+def shader(offset=0, size=6):
+    def effect_shader():
+        nonlocal size, offset, neoeffect
+        pix_cnt = Data.NEOPIXEL_OBJ.n
         # Conditional value load - with neopixel cache
-        r, g, b, _ = Data.DCACHE
+        r, g, b = DrawEffectV2.color_code()
         # calculate 0->24 range
-        _slice1 = pixcnt if size + offset > pixcnt else size + offset
+        _slice1 = pix_cnt if size + offset > pix_cnt else size + offset
         # calculate 24->0-> range (overflow)
-        _slice2 = size + offset - pixcnt if size + offset > pixcnt else 0
-        for i in range(0, pixcnt):
-            if offset < i < _slice1:
-                yield 0, 0, 0
-            elif 0 <= i < _slice2:
-                yield 0, 0, 0
+        _slice2 = size + offset - pix_cnt if size + offset > pix_cnt else 0
+        for i in range(0, pix_cnt):
+            if offset <= i < _slice1 or 0 <= i < _slice2:
+                neoeffect.update(i, 0, 0, 0)
             else:
-                yield r, g, b
+                neoeffect.update(i, r, g, b)
+        neoeffect.draw()
 
-    # Init custom params
-    effect = DrawEffect(pixcnt=ledcnt)
-    # Create effect data
-    if size < effect.pix_cnt:
-        cgen = __effect(size, offset, effect.pix_cnt)
-        # Draw effect data
-        effect.index_offset = 0     # reset auto shift offset
-        effect.draw(cgen, shift=shift)
-        return 'Shader size: {} ->{} ({})'.format(size, offset, effect.pix_cnt)
-    return 'Shader invalid size: {} ({})'.format(size, effect.pix_cnt)
+    neoeffect = load()
+    effect_shader()
+    return "Shader was set."
+
+
+def color(r:int=None, g:int=None, b:int=None):
+    """
+    Set color buffer - for runtime effect color change
+    :param r: red channel 0-255 (default: None - cached value)
+    :param g: green channel 0-255 (default: None - cached value)
+    :param b: blue channel 0-255 (default: None - cached value)
+    :return dict: rgb status - states: R, G, B, S
+    """
+    # Conditional value load - with neopixel cache
+    r, g, b = DrawEffectV2.color_code(r, g, b)
+    Data.DCACHE[0] = r
+    Data.DCACHE[1] = g
+    Data.DCACHE[2] = b
+    return status()
 
 
 def random(max_val=255):
@@ -244,55 +209,30 @@ def random(max_val=255):
     return "Set random: R:{} G: B:{}".format(r, g, b)
 
 
-def color(r=None, g=None, b=None):
+def stop():
     """
-    Set color buffer - for runtime effect color change
-    :param r int: red channel 0-255 (default: None - cached value)
-    :param g int: green channel 0-255 (default: None - cached value)
-    :param b int: blue channel 0-255 (default: None - cached value)
-    :return dict: rgb status - states: R, G, B, S
+    Stop all running (neo)effects tasks
     """
-    # Conditional value load - with neopixel cache
-    r, g, b = __color_input(r, g, b)
-    Data.DCACHE[0] = r
-    Data.DCACHE[1] = g
-    Data.DCACHE[2] = b
-    return status()
-
-
-def fire(r=None, g=None, b=None, ledcnt=24):
-
-    def __effect(r, g, b, pixcnt):
-        for _ in range(pixcnt):
-            rand_percent = round(randint(1, 200)/100, 2)
-
-            rgb = [
-                r * rand_percent,
-                g * rand_percent,
-                b * rand_percent
-            ]
+    player_info = load().stop()
+    random_task = manage_task("neoeffects.random", "kill")
+    return f"{player_info}\n{random_task}"
 
-            for i, color in enumerate(rgb):
-                if color > 255:
-                    rgb[i] = 255
-                if color < 0:
-                    rgb[i] = 0
-            yield rgb
-
-    # Conditional value load - with neopixel cache
-    r, g, b = __color_input(r, g, b)
-
-    effect = DrawEffect(pixcnt=ledcnt)
-    cgen = __effect(r, g, b, effect.pix_cnt)
-    effect.draw(cgen, shift=False)
-    return 'fire R{}:G{}:B{} N:{}'.format(r, g, b, effect.pix_cnt)
+def control(speed_ms=None, batch:bool=None):
+    """
+    Change the speed of frame generation for animations.
+    """
+    data = load().control(play_speed_ms=speed_ms, bt_draw=batch)
+    _speed_ms = data.get("player_speed", None)
+    return f"Control state: {data} (speed: {_speed_ms}ms)"
 
 
-def stop_effects():
+def load(pixel_cnt=24):
     """
-    Stop all running (neo)effects tasks
+    Load LM_neopixel and DrawEffectV2
     """
-    return manage_task("neoeffects.*", "kill")
+    if DrawEffectV2.INSTANCE is None:
+        DrawEffectV2(pix_cnt=pixel_cnt)
+    return DrawEffectV2.INSTANCE
 
 #######################
 # LM helper functions #
@@ -316,16 +256,19 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return resolve(('meteor r=<0-255> g=<0-255> b=<0-255> shift=True ledcnt=24',
-                             'BUTTON meteor &&',
-                             'cycle r g b shift=True ledcnt=24',
-                             'BUTTON cycle &&50',
-                             'rainbow step=1 br=<5-100> ledcnt=24 &&',
-                             'BUTTON rainbow br=50 &&',
-                             'fire r=None g=None b=None ledcnt=24',
-                             'BUTTON fire &&200',
-                             'BUTTON stop_effects',
-                             'shader size=4 offset=0 shift=True ledcnt=24',
+    return resolve(('load pixel_cnt=24',
+                             'meteor speed_ms=60 shift=True batch=True',
+                             'BUTTON meteor speed_ms=60',
+                             'cycle speed_ms=60 shift=True batch=True',
+                             'BUTTON cycle speed_ms=60',
+                             'rainbow speed_ms=20 br=15 batch=True',
+                             'BUTTON rainbow',
+                             'fire speed_ms=150 br=30 batch=True',
+                             'BUTTON fire speed_ms=150',
+                             'BUTTON stop',
+                             'shader offset=0 size=6',
+                             'control speed_ms=None batch=None',
                              'random max_val=255',
                              'pinmap',
-                             'COLOR color r=<0-255-10> g b'), widgets=widgets)
+                             'COLOR color r=<0-255-10> g b'
+                    ), widgets=widgets)