micrOSDevToolKit 2.13.0__py3-none-any.whl → 2.17.0__py3-none-any.whl

micrOS/source/modules/LM_mqtt_client.py

@@ -0,0 +1,246 @@
+import json
+import time
+from mqtt_as import MQTTClient, config
+from Config import cfgget
+from Common import micro_task, console, syslog, exec_cmd
+
+
+class MQTT:
+    CLIENT:MQTTClient = None        # MQTT Client (broker) instance
+    QOS: int = None
+    DEBUG: bool = True
+    DEFAULT_TOPIC: str = f"{cfgget('devfid')}/#"
+
+    # Micro Task TGS
+    SUB_TASK = 'mqtt.subscribe'
+    UNSUB_TASK = 'mqtt.unsubscribe'
+    CLIENT_TASK = 'mqtt.client'
+    UP_TASK = 'mqtt.up'
+
+
+######################
+# CORE MQTT HANDLERS #
+######################
+
+
+async def _receiver():
+    """
+    Asynchronous loop that listens for incoming MQTT messages from the subscribed topics.
+    - Decodes topic and message.
+    - Validates JSON payload, runs commands via exec_cmd, and publishes a JSON-formatted response.
+    """
+    async for topic, msg, retained in MQTT.CLIENT.queue:
+        incoming_topic, msg = topic.decode(), msg.decode()
+        console(f'Topic: "{incoming_topic}" Message: "{msg}" Retained: {retained}')
+
+        topic_parts = incoming_topic.split('/')
+        if len(topic_parts) == 3:
+            payload = {}
+            if msg.strip():
+                try:
+                    payload = json.loads(msg)
+                except ValueError:
+                    _publish_error(incoming_topic, f"Invalid payload JSON on topic {incoming_topic}: {msg}")
+                    continue
+
+            args = [f'{k}="{v}"' if isinstance(v, str) else f'{k}={v}' for k, v in payload.items()]
+            
+            cmd_parts = topic_parts[1:] + args
+
+            state, output_json = exec_cmd(cmd=cmd_parts, jsonify=True)
+            try:
+                output = json.loads(output_json)
+            except ValueError:
+                output = output_json
+
+            resp_payload = json.dumps({"state": state, "result": output})
+            publish(topic=f"{incoming_topic}/response", message=resp_payload)
+
+
+def _publish_error(topic: str, error_msg: str):
+    """
+    Publish an error message to the <topic>/response MQTT topic and log it to the console.
+    :param topic: The original MQTT topic where the error occurred.
+    :param error_msg: The error message string.
+    """
+    publish(topic=f"{topic}/response", message=error_msg)
+    console(error_msg)
+
+
+#############################
+# SUBSCRIPTION \ PUBLISHING #
+#############################
+
+
+async def _unsubscribe(topic: str):
+    """
+    Unsubscribe from the specified MQTT topic.
+    :param topic: Topic string to unsubscribe from.
+    """
+    with micro_task(tag=MQTT.UNSUB_TASK) as my_task:
+        my_task.out = "Started"
+        try:
+            console(f"Unsubscribe topic: {topic}")
+            await MQTT.CLIENT.unsubscribe(topic)
+            my_task.out = "Done"
+        except Exception as e:
+            my_task.out = f"Error: {e}"
+
+
+async def _subscribe(topic: str):
+    """
+    Subscribe to the specified MQTT topic with the global QoS.
+    :param topic: Topic string to subscribe to.
+    """
+    with micro_task(tag=MQTT.SUB_TASK) as my_task:
+        my_task.out = "Started"
+        try:
+            console(f"Subscribe topic: {topic}")
+            await MQTT.CLIENT.subscribe(topic, qos=MQTT.QOS)
+            my_task.out = "Done"
+        except Exception as e:
+            my_task.out = f"Error: {e}"
+
+
+async def _publish(tag, message: str, topic: str, retain: bool):
+    """
+    Asynchronously publish a message to the given MQTT topic.
+    :param message: The message payload as a string.
+    :param topic: The MQTT topic string.
+    :param retain: Whether the message should be retained on the broker.
+    """
+    with micro_task(tag) as my_task:
+        await MQTT.CLIENT.publish(topic, message, qos=MQTT.QOS, retain=retain)
+
+
+def publish(topic: str, message: str, retain: bool = False):
+    """
+    Wrapper to publish a message to the specified topic.
+    Creates a micro_task for asynchronous publishing.
+    :param topic: MQTT topic string.
+    :param message: Message string.
+    :param retain: Whether to retain the message on the broker (default False).
+    :return: Status message string.
+    """
+    unique_tag = f'mqtt.publish.{topic}.{time.ticks_ms()}'
+    state = micro_task(tag=unique_tag, task=_publish(unique_tag, message, topic, retain))
+    return f"Message was sent {state}"
+
+
+####################
+# CLIENT LIFECYCLE #
+####################
+
+
+async def _up():
+    """
+    UP Listener task that waits for an MQTT 'up' event (reconnection) and re-subscribes to the default topic.
+    """
+    with micro_task(tag=MQTT.UP_TASK) as my_task:
+        while True:
+            # Wait for UP Event - (re)subscribe
+            my_task.out = "Wait"
+            await MQTT.CLIENT.up.wait()
+            MQTT.CLIENT.up.clear()
+            state = micro_task(tag=MQTT.SUB_TASK, task=_subscribe(MQTT.DEFAULT_TOPIC))
+            my_task.out = f"Re-Subscription {state}"
+            my_task.feed()
+
+
+async def _init_client():
+    """
+    Initialize and connect the MQTT client, subscribe to default topics, 
+    start up-listener, and begin receiving messages.
+    """
+    with micro_task(tag=MQTT.CLIENT_TASK) as my_task:
+        try:
+            await MQTT.CLIENT.connect()
+            my_task.out = "Connection successful."
+        except OSError:
+            my_task.out = "Connection failed."
+            return
+
+        # Wait for mqtt client connected successfully
+        await MQTT.CLIENT.up.wait()
+        MQTT.CLIENT.up.clear()
+        
+        # Initialize mqtt topics
+        if not micro_task(tag=MQTT.SUB_TASK, task=_subscribe(MQTT.DEFAULT_TOPIC)):
+            syslog(f"Failed start mqtt subscribe")
+        if not micro_task(tag=MQTT.UP_TASK, task=_up()):
+            syslog(f"Failed start mqtt up")
+        # Async listener loop
+        await _receiver()
+        my_task.out = "Receiver closed"
+
+    # Close when listener exits
+    MQTT.CLIENT.close()
+
+
+#################
+# CONFIGURATION #
+#################
+
+
+def get_config():
+    """
+    Get configuration for MQTT client.
+    :return: MQTT configuration dict.
+    """
+    return config
+
+
+def _configure(username: str, password: str, server_ip: str, server_port: str):
+    """
+    Build the MQTT client configuration.
+    :param username: Broker username.
+    :param password: Broker password.
+    :param server_ip: Broker IP or hostname.
+    :param server_port: Broker port.
+    :return: Updated configuration dictionary.
+    """
+    config.update({
+        'client_id': cfgget("devfid"),
+        'server': server_ip,
+        'port': server_port,
+        'user': username,
+        'password': password,
+        'ssid': cfgget("staessid"),     # Only supports a single Wi-Fi connection. Multiple SSIDs not handled.
+        'wifi_pw': cfgget("stapwd"),
+        'keepalive': 120,
+        'queue_len': 1,                 # Use event interface with default queue
+        'will': (f'{cfgget("devfid")}/status', '{"status": "offline"}', True, 1)
+    })
+    return config
+
+
+def load(username: str, password: str, server_ip: str, server_port: str='1883', qos: str=1):
+    """
+    Configure, initialize, and start the MQTT client.
+    Requires that the micropython-mqtt package is installed. You can install it with:
+    mpremote mip install github:peterhinch/micropython-mqtt
+    :param username: Broker username.
+    :param password: Broker password.
+    :param server_ip: Broker IP or hostname.
+    :param server_port: MQTT port (default 1883).
+    :param qos: MQTT Quality of Service level (0, 1, or 2). Controls delivery guarantee.
+    :return: Status dict showing whether the client is starting or already running.
+    """
+    MQTTClient.DEBUG = MQTT.DEBUG
+    MQTT.CLIENT = MQTTClient(_configure(username, password, server_ip, server_port))
+    MQTT.QOS = qos
+
+    state = micro_task(tag=MQTT.CLIENT_TASK, task=_init_client())
+    return {MQTT.CLIENT_TASK: "Starting"} if state else {MQTT.CLIENT_TASK: "Already running"}
+
+
+def help(widgets=False):
+    """
+    Show public functions. Return a tuple of public function usage strings for the MQTT module.
+    :param widgets: Unused, reserved for extra help formatting.
+    :return: Tuple of help strings.
+    """
+    return ('load username:str password:str server_ip:str server_port:str="1883"',
+            'get_config',
+            'publish topic:str message:str retain=False')
+

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

@@ -100,7 +100,13 @@ def cycle(speed_ms:int=60, shift:bool=True, batch:bool=True):
     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 rainbow(speed_ms=50, br=15, batch=True):
+    """
+    Rainbow effect animation
+    :param speed_ms: animation speed in milliseconds
+    :param br: Brightness of the pixels (0-100)
+    :param batch: Batch drawing of pixels (True/False)
+    """
     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.
@@ -121,8 +127,7 @@ def rainbow(speed_ms=20, br=15, batch=True):
         :param step: step size
         """
         nonlocal pix_cnt, br
-        color_step = 3
-        for color_wheel in range(0, 255, color_step):
+        for color_wheel in range(0, 255):
             for index in range(0, pix_cnt):
                 rc_index = (index * 256 // pix_cnt) + color_wheel
                 r, g, b = _wheel(rc_index & 255)
@@ -157,6 +162,11 @@ def fire(speed_ms:int=150, br:int=30, batch:bool=True):
 
 
 def shader(offset=0, size=6):
+    """
+    Shader effect on neopixel ring.
+    :param offset: start pixel index
+    :param size: shader size (number of pixels)
+    """
     def effect_shader():
         nonlocal size, offset, neoeffect
         pix_cnt = Data.NEOPIXEL_OBJ.n
@@ -261,7 +271,7 @@ def help(widgets=False):
                              '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',
+                             'rainbow speed_ms=50 br=15 batch=True',
                              'BUTTON rainbow',
                              'fire speed_ms=150 br=30 batch=True',
                              'BUTTON fire speed_ms=150',

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

@@ -1,10 +1,11 @@
+from random import randint
 from neopixel import NeoPixel
 from machine import Pin
 from utime import sleep_ms
 
 from microIO import bind_pin
 from Types import resolve
-from Common import manage_task, AnimationPlayer
+from Common import manage_task, AnimationPlayer, web_dir, syslog, web_endpoint
 
 
 class NeoPixelMatrix(AnimationPlayer):
@@ -18,7 +19,7 @@ class NeoPixelMatrix(AnimationPlayer):
         self.num_pixels = width * height
         self.pixels = NeoPixel(Pin(pin, Pin.OUT), self.num_pixels)
         self._color_buffer = [(0, 0, 0)] * self.num_pixels      # Store original RGB values
-        self._brightness = 0.25                                 # Brightness level, default 25%
+        self._brightness = 0.20                                 # Brightness level, default 20%
         NeoPixelMatrix.INSTANCE = self
 
     def update(self, x:int, y:int, color:tuple[int, int, int]):
@@ -34,6 +35,7 @@ class NeoPixelMatrix(AnimationPlayer):
         for i in range(self.num_pixels):
             # Write pixel buffer before write to ws2812
             self.pixels[i] = (0, 0, 0)
+            self._color_buffer[i] = (0, 0, 0)
         # Send buffer to device
         self.draw()
 
@@ -41,9 +43,11 @@ class NeoPixelMatrix(AnimationPlayer):
         """
         Zigzag layout: even rows left-to-right, odd rows right-to-left
         """
-        if (zigzag is None or zigzag) and y % 2 == 0:
-            return y * self.width + x
-        return y * self.width + (self.width - 1 - x)
+        if zigzag is None or zigzag:
+            if y % 2 == 0:
+                return y * self.width + x
+            return y * self.width + (self.width - 1 - x)
+        return y * self.width + x
 
     def _index_to_coord(self, index: int, zigzag:bool=True) -> tuple[int, int]:
         """
@@ -140,9 +144,21 @@ def load(width=8, height=8):
     """
     if NeoPixelMatrix.INSTANCE is None:
         NeoPixelMatrix(width=width, height=height, pin=bind_pin('neop'))
+        web_endpoint('matrixDraw', _web_endpoint_clb, auto_enable=False)
     return NeoPixelMatrix.INSTANCE
 
 
+def _web_endpoint_clb():
+    try:
+        with open(web_dir('matrix_draw.html'), 'r') as html:
+            html_content = html.read()
+        return 'text/html', html_content
+    except Exception as e:
+        syslog(f"[ERR] neomatrix web: {e}")
+        html_content = None
+    return 'text/plain', f'html_content error: {html_content}'
+
+
 def pixel(x, y, color=None, show=True):
     """
     Set pixel at (x,y) to RGB color.
@@ -205,6 +221,10 @@ def stop():
 
 
 def draw_colormap(bitmap):
+    """
+    Draw colors as a color map
+    [(x, y, (r, g,b)), ...]
+    """
     try:
         load().draw_colormap(bitmap)
     except Exception as e:
@@ -215,12 +235,22 @@ def draw_colormap(bitmap):
 def get_colormap():
     return load().export_colormap()
 
+
+def status():
+    """
+    Get the current status of the matrix
+    """
+    r, g, b = NeoPixelMatrix.DEFAULT_COLOR
+    br = NeoPixelMatrix.INSTANCE._brightness
+    return {'r': r, 'g': g, 'b': b, 'br': int(br*100)}
+
+
 # -----------------------------------------------------------------------------
 # -----------------------------------------------------------------------------
 
 def rainbow(speed_ms=0):
-    def effect_rainbow():
-        def hsv_to_rgb(h, s, v):
+    def _effect_rainbow():
+        def _hsv_to_rgb(h, s, v):
             max_color = 150   #255
             h = float(h)
             s = float(s)
@@ -254,14 +284,14 @@ def rainbow(speed_ms=0):
                 for x in range(width):
                     index = y * width + x
                     hue = ((index + frame) % 64) / 64.0
-                    r, g, b = hsv_to_rgb(hue, 1.0, 0.7)
+                    r, g, b = _hsv_to_rgb(hue, 1.0, 0.7)
                     yield x, y, (r, g, b)
 
-    return load().play(effect_rainbow, speed_ms=speed_ms, bt_draw=True, bt_size=8)
+    return load().play(_effect_rainbow, speed_ms=speed_ms, bt_draw=True, bt_size=8)
 
 
-def snake(speed_ms:int=30, length:int=5):
-    def effect_snake():
+def snake(speed_ms:int=30, length:int=6):
+    def _effect_snake():
         clear_color = (0, 0, 0)
         total_pixels = 8 * 8
         total_steps = total_pixels + length  # run just past the end to clear tail
@@ -283,40 +313,110 @@ def snake(speed_ms:int=30, length:int=5):
                     color = (int(r * br), int(g * br), int(b * br))
                     yield x, y, color
 
-    return load().play(effect_snake, speed_ms=speed_ms, bt_draw=False)
+    return load().play(_effect_snake, speed_ms=speed_ms, bt_draw=False)
 
 
-def cube(speed_ms=10):
-    def effect_cube(max_radius:int = 3):
+def spiral(speed_ms=40):
+    def _effect_spiral(trail=12, hold=6):
         """
-        Generator yielding (x, y, color) for a centered 2×2 square ("cube")
-        that expands outward to `max_radius` then collapses back.
+        Center-out spiral with row-prewarp so the visual is continuous
+        even when set_pixel() applies zigzag=True internally.
         """
-        width, height = 8, 8
-        # Center the 2×2 core in an 8×8 grid
-        cx, cy = width // 2 - 1, height // 2 - 1
-
-        # Expansion phase: radius 0 (2×2) up to max_radius
-        for r in range(0, max_radius + 1):
-            for dx in range(-r, r + 2):
-                for dy in range(-r, r + 2):
-                    x, y = cx + dx, cy + dy
-                    if 0 <= x < width and 0 <= y < height:
-                        yield x, y, NeoPixelMatrix.DEFAULT_COLOR
-        # Clear matrix
+        try:
+            W = NeoPixelMatrix.INSTANCE.width
+            H = NeoPixelMatrix.INSTANCE.height
+        except:
+            W = H = 8
+
+        # --- build center-out spiral path in true matrix coords (x,y) ---
+        # exact center on odd sizes; upper-left of center 2x2 on even sizes
+        cx = (W // 2 - 1) if (W % 2 == 0) else (W // 2)
+        cy = (H // 2 - 1) if (H % 2 == 0) else (H // 2)
+
+        x, y = cx, cy
+        path, seen = [], set()
+
+        def _add(ax, ay):
+            if 0 <= ax < W and 0 <= ay < H and (ax, ay) not in seen:
+                seen.add((ax, ay))
+                path.append((ax, ay))
+
+        _add(x, y)
+        dirs = ((1, 0), (0, 1), (-1, 0), (0, -1))  # R, D, L, U
+        step_len, d = 1, 0
+        while len(path) < W * H:
+            for _ in range(2):
+                dx, dy = dirs[d & 3]
+                for _ in range(step_len):
+                    x += dx; y += dy
+                    _add(x, y)
+                    if len(path) >= W * H: break
+                d += 1
+                if len(path) >= W * H: break
+            step_len += 1
+
+        # --- PREWARP ---
+        # Cancel the internal zigzag mapping: flip x on odd rows so
+        # set_pixel(zigzag=True) flips it back -> visually linear.
+        def _warp(ax, ay):
+            return (W - 1 - ax, ay) if (ay & 1) else (ax, ay)
+
+        off = (0, 0, 0)
+
+        def _shade(k):
+            r0, g0, b0 = NeoPixelMatrix.DEFAULT_COLOR
+            k = max(0.0, min(1.0, k)) ** 0.9
+            return int(r0 * k), int(g0 * k), int(b0 * k)
+
         try:
             NeoPixelMatrix.INSTANCE.clear()
         except:
             pass
-        # Collapse phase: back down, skipping the largest to avoid duplicate
-        for r in range(max_radius - 1, -1, -1):
-            for dx in range(-r, r + 2):
-                for dy in range(-r, r + 2):
-                    x, y = cx + dx, cy + dy
-                    if 0 <= x < width and 0 <= y < height:
-                        yield x, y, NeoPixelMatrix.DEFAULT_COLOR
 
-    return load().play(effect_cube, speed_ms=speed_ms, bt_draw=False)
+        # expand with tail
+        for n in range(len(path)):
+            clear_at = n - trail - 1
+            if clear_at >= 0:
+                cx_, cy_ = _warp(*path[clear_at])
+                yield cx_, cy_, off
+
+            start = 0 if n < trail else (n - trail + 1)
+            span = max(1, n - start + 1)
+            for i in range(start, n + 1):
+                k = (i - start + 1) / span
+                px, py = _warp(*path[i])
+                yield px, py, _shade(k)
+
+        # brief hold
+        hx, hy = _warp(*path[-1])
+        for _ in range(hold):
+            yield hx, hy, _shade(1.0)
+
+        # shrink with fading tail
+        for n in range(len(path) - 1, -1, -1):
+            px, py = _warp(*path[n])
+            yield px, py, off
+            start = max(0, n - trail + 1)
+            span = max(1, n - start)
+            for i in range(start, n):
+                k = (i - start + 1) / span
+                qx, qy = _warp(*path[i])
+                yield qx, qy, _shade(k)
+
+    return load().play(_effect_spiral, speed_ms=speed_ms, bt_draw=True, bt_size=8)
+
+
+def noise(speed_ms:int=85):
+    def _effect_noise():
+        total_steps = 8 * 8
+        for step in range(total_steps):
+            x, y = step % 8, step // 8
+            r, g, b = NeoPixelMatrix.DEFAULT_COLOR
+            br = float(randint(0, 100) * 0.01)              # Generate random brightness
+            color = (int(r * br), int(g * br), int(b * br))
+            yield x, y, color
+
+    return load().play(_effect_noise, speed_ms=speed_ms, bt_draw=True, bt_size=4)
 
 
 def help(widgets=False):
@@ -328,8 +428,10 @@ def help(widgets=False):
                              'BUTTON stop',
                              'BUTTON snake speed_ms=50 length=5',
                              'BUTTON rainbow',
-                             'BUTTON cube speed_ms=10',
+                             'BUTTON spiral speed_ms=40',
+                             'BUTTON noise speed_ms=85',
                              'SLIDER control speed_ms=<1-200-2> bt_draw=None',
                              'draw_colormap bitmap=[(0,0,(10,2,0)),(x,y,color),...]',
-                             'get_colormap'
+                             'get_colormap',
+                             'status'
                     ), widgets=widgets)

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

@@ -341,7 +341,7 @@ class PageUI:
             self.open_intercons.append(host)
             try:
                 # Send CMD to other device & show result
-                state, data_meta = exec_cmd(cmd + [f">>{host}"], jsonify=True, skip_check=True)
+                state, data_meta = exec_cmd(cmd + [f">>{host}"], jsonify=True)
                 if state:
                     self.cmd_task_tag = data_meta['tag']
                     if "Task is Busy" in data_meta['verdict'] and not run:
@@ -386,7 +386,7 @@ class PageUI:
             try:
                 cmd_list = cmd.strip().split()
                 # Send CMD to other device & show result
-                state, out = exec_cmd(cmd_list, skip_check=True)
+                state, out = exec_cmd(cmd_list)
                 try:
                     self.cmd_out = ''.join(out.strip().split()).replace(' ', '')
                 except Exception:

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

@@ -745,7 +745,7 @@ class PageUI:
             try:
                 cmd_list = cmd.strip().split()
                 # Send CMD to other device & show result
-                state, out = exec_cmd(cmd_list, skip_check=True)
+                state, out = exec_cmd(cmd_list)
                 cmd_out = out.strip()
             except Exception as e:
                 cmd_out = str(e)
@@ -780,7 +780,7 @@ class PageUI:
             # Check open host connection
             try:
                 # Send CMD to other device & show result
-                state, data_meta = exec_cmd(cmd + [f">>{host}"], jsonify=True, skip_check=True)
+                state, data_meta = exec_cmd(cmd + [f">>{host}"], jsonify=True)
                 if state:
                     self._cmd_task_tag = data_meta['tag']
                     if "Task is Busy" in data_meta['verdict'] and not run: