micrOSDevToolKit 2.17.2__py3-none-any.whl → 2.20.0__py3-none-any.whl

toolkit/workspace/precompiled/modules/LM_espnow.py

@@ -17,6 +17,13 @@ def stats():
     return ESPNOW.stats()
 
 
+def members():
+    """
+    Get ESPNow devices
+    """
+    return ESPNOW.members()
+
+
 def handshake(peer:bytes|str):
     """
     Handshake with ESPNow Peer
@@ -27,10 +34,20 @@ def handshake(peer:bytes|str):
     return ESPNOW.handshake(peer)
 
 
+def remove(peer:bytes):
+    """
+    Remove peer by binary mac address
+    :param peer: binary mac address of espnow device
+    """
+    return ESPNOW.remove_peer(peer)
+
+
 def help():
     """
     ESPNOW sender/receiver with LM execution
     """
     return ('handshake peer=<mac-address>',
             'send peer=<peer-name> cmd="hello"',
-            'stats')
+            'remove peer=<binary-mac-address>',
+            'stats',
+            'members')

toolkit/workspace/precompiled/modules/LM_robustness.py

@@ -83,8 +83,7 @@ def create_task():
     """
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
     task_tag = "microtask.run"
-    state = micro_task(tag=task_tag, task=__task(tag=task_tag, period_ms=5))
-    return "Starting" if state else "Already running"
+    return micro_task(tag=task_tag, task=__task(tag=task_tag, period_ms=5))
 
 
 @micro_task("microtask", _wrap=True)

toolkit/workspace/precompiled/modules/LM_tcs3472.py

@@ -6,26 +6,54 @@ Copyright (c) 2021 tti0
 Licensed under the MIT License
 """
 
-from machine import I2C, Pin
+from struct import unpack
+from time import sleep
+from machine import I2C, Pin, PWM
 from microIO import bind_pin, pinmap_search
-import struct
+from Types import resolve
 
+from LM_neopixel import load as neo_load, color as neo_color, toggle as neo_toggle    # local neopixel light indicator
+from LM_cluster import run as cluster_run                                             # DEMO: neomatrix cluster
+
+CURRENT_ANIMATION_INDEX = 0                                                           # DEMO: neomatrix cluster animation
 
 class TCS3472:
     INSTANCE = None
 
-    def __init__(self, bus, address=0x29):
-        self._bus = bus
+    def __init__(self, address=0x29, led_pin=None):
+        self._bus = I2C(sda=Pin(bind_pin('i2c_sda')), scl=Pin(bind_pin('i2c_scl')))
         self._i2c_address = address
         self._bus.writeto(self._i2c_address, b'\x80\x03')
         self._bus.writeto(self._i2c_address, b'\x81\x2b')
+        self.led = PWM(Pin(bind_pin('led', led_pin), Pin.OUT), freq=20480)
+        self.led_brightness = 20
         TCS3472.INSTANCE = self
 
-    def scaled(self):
-        crgb = self.raw()
-        if crgb[0] > 0:
-            return tuple(float(x) / crgb[0] for x in crgb[1:])
-        return 0, 0, 0
+    def scaled(self, saturation=1.5):
+        """
+        Normalize by strongest color, then adjust saturation.
+        saturation = 1.0 -> normal
+        saturation > 1.0 -> more vibrant
+        saturation < 1.0 -> more pastel
+        """
+        _, r, g, b = self.raw()
+        m = max(r, g, b)
+        if m == 0:
+            return 0.0, 0.0, 0.0
+
+        # Normalize by strongest channel
+        r, g, b = r / m, g / m, b / m
+
+        # Grayscale = average of channels
+        gray = (r + g + b) / 3
+
+        # Interpolate between gray and color
+        r = gray + (r - gray) * saturation
+        g = gray + (g - gray) * saturation
+        b = gray + (b - gray) * saturation
+
+        # Clamp to 0..1
+        return max(0, min(1, r)), max(0, min(1, g)), max(0, min(1, b))
 
     def rgb(self):
         return tuple(int(x * 255) for x in self.scaled())
@@ -42,32 +70,118 @@ class TCS3472:
 
     def raw(self):
         self._bus.writeto(self._i2c_address, b'\xb4')
-        return struct.unpack("<HHHH", self._bus.readfrom(self._i2c_address, 8))
+        return unpack("<HHHH", self._bus.readfrom(self._i2c_address, 8))
 
 
 ############################ Exposed functions ############################
 
-def load():
+def load(led_pin=20):
     """
     Load the TCS3472 Color sensor instance.
     """
     if TCS3472.INSTANCE is None:
-        bus = I2C(sda=Pin(bind_pin('i2c_sda')), scl=Pin(bind_pin('i2c_scl')))
-        TCS3472.INSTANCE = TCS3472(bus)
+        TCS3472(led_pin=led_pin)
+        neo_load(ledcnt=1)
+        led(False)
     return TCS3472.INSTANCE
 
 
 def pinmap():
-    return pinmap_search(['i2c_scl', 'i2c_sda'])
+    """
+    Show used pin mapping for this module.
+    """
+    return pinmap_search(['i2c_scl', 'i2c_sda', 'led'])
 
 
 def measure():
+    """
+    MEASURE sensor
+    """
+    sensor = load()
+    measurement = {"rgb": sensor.rgb(), "light": sensor.light(), "brightness": sensor.brightness()}
+    return measurement
+
+
+def led(state:bool=None, br:int=None):
+    """
+    SENSOR LED toggle
+    :param state: None-automatic, True-ON, False-OFF
+    :param br: brightness 0-100
+    """
+    def _set_duty(_br):
+        _br = sensor.led_brightness if _br is None else _br
+        sensor.led.duty(int(_br * 10))
+        if _br != 0:
+            sensor.led_brightness = _br
+
     sensor = load()
-    return {"rgb": sensor.rgb(), "light": sensor.light(), "brightness": sensor.brightness()}
+    if state is None:
+        # INVERT STATE
+        led_current_state = sensor.led.duty() > 0
+        if led_current_state:
+            _set_duty(br)
+            _set_duty(0)
+            neo_toggle(False)
+        else:
+            _set_duty(br)
+            neo_toggle(True)
+    else:
+        # SET STATE: ON/OFF
+        if state:
+            _set_duty(br)
+            neo_toggle(True)
+        else:
+            _set_duty(br)
+            _set_duty(0)
+            neo_toggle(False)
+    return f"LED on, {sensor.led_brightness}%" if sensor.led.duty()>0 else f"LED off"
+
+
+def indicator(br=5):
+    """
+    Color indicator Neopixel LED update
+    :param br: brightness 0-100
+    """
+    r, g, b = measure()['rgb']
+    br = float(br / 100)
+    _r, _g, _b = int(r*br), int(g*br), int(b*br)
+    neo_color(_r, _g, _b, smooth=False)
+    return r, g, b
+
+
+def neomatrix_update():
+    """
+    DEMO - Send color codes for all neomatrix devices over espnow cluster
+    """
+    r, g, b = indicator()
+    command = f"neomatrix color_fill {r} {g} {b}"
+    cluster_run(command)
+    return {"cmd": command, "cluster": "task show con.espnow.*"}
+
+
+def neomatrix_animation():
+    """
+    DEMO - Set random animation on neomatrix espnow cluster
+    """
+    global CURRENT_ANIMATION_INDEX
+    animations = ('spiral', 'snake', 'noise')
+
+    next_animation = CURRENT_ANIMATION_INDEX + 1
+    CURRENT_ANIMATION_INDEX = 0 if next_animation >= len(animations) else next_animation
+    command = f"neomatrix {animations[CURRENT_ANIMATION_INDEX]}"
+    cluster_run(command)
+    return {"cmd": command, "cluster": "task show con.espnow.*"}
 
 
-def help(widgest=False):
+def help(widgets=False):
     """
     TCS3472 Color sensor
     """
-    return 'load', 'measure'
+    return resolve(('load led_pin=20',
+                    'TEXTBOX measure',
+                    'BUTTON led state=<True,False>',
+                    'SLIDER led state=True br=<0-100-5>',
+                    'indicator br=<0-100>',
+                    'BUTTON neomatrix_update',
+                    'BUTTON neomatrix_animation',
+                    'pinmap'), widgets=widgets)

micrOS/source/modules/LM_pet_feeder.py

@@ -1,78 +0,0 @@
-from LM_servo import sduty, deinit, pinmap as servo_pinmap
-from LM_stepper import step, pinmap as stepper_pinmap
-from Common import micro_task
-
-
-class Data:
-    TASK_TAG = "pet_feeder.portion"
-
-
-async def __portion_task(portion, posmin, posmax):
-    # ASYNC TASK ADAPTER [*2] with automatic state management
-    #   [micro_task->Task] TaskManager access to task internals (out, done attributes)
-    with micro_task(tag=Data.TASK_TAG) as my_task:
-        for p in range(0, portion):
-            # [1]Run pos fill up
-            for pos in range(posmin, posmax):
-                sduty(pos)
-                await my_task.feed(sleep_ms=15)
-            # [2]Wait between fill up / food out
-            await my_task.feed(sleep_ms=500)
-            # [3]Run pos food out
-            for pos in range(posmax, posmin, -1):
-                sduty(pos)
-                await my_task.feed(sleep_ms=20)
-            my_task.out = "{}/{} serving".format(p+1, portion)
-    deinit()
-    my_task.out += ": {} task done".format(Data.TASK_TAG)
-
-
-def serve(portion=1, posmin=65, posmax=97):
-    """
-    Pet feeder - with servo motor
-    :param portion: number of portions (min/max positions to repeat)
-    :param posmin: servo "start" position
-    :param posmax: servo "stop" position
-    """
-    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.TASK_TAG, task=__portion_task(portion=portion, posmin=posmin, posmax=posmax))
-    return "Starting" if state else "Already running"
-
-
-def serve_w_stepper(portion=1, forward=135, back=10):
-    """
-    Pet feeder (beta) - with stepper motor
-    :param count: number of portions
-    :param forward: s
-    :param back:
-    """
-    for _ in range(portion):
-        # portion move
-        step(forward)
-        # Safety anti-block solution?
-        step(-back)
-        step(back)
-        step(-back)
-        step(back)
-
-
-def pinmap():
-    """
-    [i] micrOS LM naming convention
-    Shows logical pins - pin number(s) used by this Load module
-    - info which pins to use for this application
-    :return dict: pin name (str) - pin value (int) pairs
-    """
-    p = servo_pinmap()
-    p.update(stepper_pinmap())
-    return p
-
-
-def help(widgets=False):
-    """
-    [i] micrOS LM naming convention - built-in help message
-    :return tuple:
-        (widgets=False) list of functions implemented by this application
-        (widgets=True) list of widget json for UI generation
-    """
-    return 'serve portion=1 \t\t[info] servo control',  'serve_w_stepper portion=1 \t[info] stepper control'

toolkit/workspace/precompiled/modules/LM_pet_feeder.py

@@ -1,78 +0,0 @@
-from LM_servo import sduty, deinit, pinmap as servo_pinmap
-from LM_stepper import step, pinmap as stepper_pinmap
-from Common import micro_task
-
-
-class Data:
-    TASK_TAG = "pet_feeder.portion"
-
-
-async def __portion_task(portion, posmin, posmax):
-    # ASYNC TASK ADAPTER [*2] with automatic state management
-    #   [micro_task->Task] TaskManager access to task internals (out, done attributes)
-    with micro_task(tag=Data.TASK_TAG) as my_task:
-        for p in range(0, portion):
-            # [1]Run pos fill up
-            for pos in range(posmin, posmax):
-                sduty(pos)
-                await my_task.feed(sleep_ms=15)
-            # [2]Wait between fill up / food out
-            await my_task.feed(sleep_ms=500)
-            # [3]Run pos food out
-            for pos in range(posmax, posmin, -1):
-                sduty(pos)
-                await my_task.feed(sleep_ms=20)
-            my_task.out = "{}/{} serving".format(p+1, portion)
-    deinit()
-    my_task.out += ": {} task done".format(Data.TASK_TAG)
-
-
-def serve(portion=1, posmin=65, posmax=97):
-    """
-    Pet feeder - with servo motor
-    :param portion: number of portions (min/max positions to repeat)
-    :param posmin: servo "start" position
-    :param posmax: servo "stop" position
-    """
-    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.TASK_TAG, task=__portion_task(portion=portion, posmin=posmin, posmax=posmax))
-    return "Starting" if state else "Already running"
-
-
-def serve_w_stepper(portion=1, forward=135, back=10):
-    """
-    Pet feeder (beta) - with stepper motor
-    :param count: number of portions
-    :param forward: s
-    :param back:
-    """
-    for _ in range(portion):
-        # portion move
-        step(forward)
-        # Safety anti-block solution?
-        step(-back)
-        step(back)
-        step(-back)
-        step(back)
-
-
-def pinmap():
-    """
-    [i] micrOS LM naming convention
-    Shows logical pins - pin number(s) used by this Load module
-    - info which pins to use for this application
-    :return dict: pin name (str) - pin value (int) pairs
-    """
-    p = servo_pinmap()
-    p.update(stepper_pinmap())
-    return p
-
-
-def help(widgets=False):
-    """
-    [i] micrOS LM naming convention - built-in help message
-    :return tuple:
-        (widgets=False) list of functions implemented by this application
-        (widgets=True) list of widget json for UI generation
-    """
-    return 'serve portion=1 \t\t[info] servo control',  'serve_w_stepper portion=1 \t[info] stepper control'