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

micrOS/release_info/micrOS_ReleaseInfo/system_analysis_sum.json

@@ -4,6 +4,10 @@
             9.16,
             7
         ],
+        "Files.py": [
+            9.6,
+            4
+        ],
         "micrOSloader.py": [
             7.33,
             1
@@ -21,23 +25,23 @@
             1
         ],
         "Tasks.py": [
-            9.55,
+            9.38,
             12
         ],
         "Config.py": [
             9.48,
-            17
+            18
         ],
         "reset.py": [
             10.0,
             0
         ],
         "Shell.py": [
-            9.11,
+            9.36,
             1
         ],
         "Notify.py": [
-            8.46,
+            9.74,
             3
         ],
         "Types.py": [
@@ -45,16 +49,16 @@
             29
         ],
         "Logger.py": [
-            8.85,
+            8.9,
             4
         ],
         "Common.py": [
-            8.71,
-            34
+            9.78,
+            35
         ],
         "InterConnect.py": [
-            9.4,
-            1
+            9.41,
+            3
         ],
         "Debug.py": [
             8.4,
@@ -65,7 +69,7 @@
             8
         ],
         "Espnow.py": [
-            8.86,
+            9.49,
             1
         ],
         "Scheduler.py": [
@@ -73,7 +77,7 @@
             1
         ],
         "microIO.py": [
-            9.42,
+            9.43,
             42
         ],
         "micrOS.py": [
@@ -89,7 +93,7 @@
             0
         ],
         "urequests.py": [
-            8.99,
+            8.96,
             5
         ],
         "LM_roboarm.py": [
@@ -101,7 +105,7 @@
             1
         ],
         "LM_pacman.py": [
-            8.94,
+            8.92,
             0
         ],
         "LM_genIO.py": [
@@ -109,11 +113,11 @@
             0
         ],
         "LM_oled_ui.py": [
-            9.02,
+            8.64,
             0
         ],
         "LM_system.py": [
-            8.26,
+            8.28,
             5
         ],
         "LM_robustness.py": [
@@ -233,15 +237,15 @@
             0
         ],
         "LM_oledui.py": [
-            8.16,
+            7.95,
             0
         ],
         "LM_espnow.py": [
-            7.5,
+            7.89,
             0
         ],
         "LM_telegram.py": [
-            9.57,
+            9.58,
             0
         ],
         "LM_OV2640.py": [
@@ -261,7 +265,7 @@
             0
         ],
         "LM_light_sensor.py": [
-            8.97,
+            9.17,
             0
         ],
         "LM_rp2w.py": [
@@ -269,9 +273,13 @@
             0
         ],
         "LM_presence.py": [
-            8.77,
+            8.9,
             4
         ],
+        "LM_mqtt_pro.py": [
+            9.35,
+            0
+        ],
         "LM_trackball.py": [
             8.31,
             1
@@ -298,7 +306,7 @@
         ],
         "LM_intercon.py": [
             8.18,
-            4
+            0
         ],
         "LM_ds18.py": [
             6.0,
@@ -315,12 +323,12 @@
     },
     "summary": {
         "core": [
-            3367,
-            23
+            3550,
+            24
         ],
         "load": [
-            9087,
-            55
+            9217,
+            56
         ],
         "core_dep": [
             true,
@@ -328,10 +336,10 @@
         ],
         "load_dep": [
             true,
-            5
+            6
         ],
-        "core_score": 9.09,
-        "load_score": 8.21,
-        "version": "2.9.9-0"
+        "core_score": 9.24,
+        "load_score": 8.23,
+        "version": "2.10.5-0"
     }
 }

micrOS/source/Common.py

@@ -2,7 +2,6 @@
 micrOS Load Module programming Official API-s
     Designed by Marcell Ban aka BxNxM
 """
-
 from Server import Server, WebCli
 from Debug import errlog_add, console_write
 from Logger import logger, log_get
@@ -126,18 +125,19 @@ def manage_task(tag, operation):
     raise Exception(f"Invalid operation: {operation}")
 
 
-def exec_cmd(cmd, skip_check=False):
+def exec_cmd(cmd:list, jsonify:bool=None, skip_check=False):
     """
     [LM] Single (sync) LM execution
-    :param cmd: command string list
+    :param cmd: command string list, ex.: ['system', 'clock']
+    :param jsonify: request json output
     :param skip_check: skip cmd type check, micropython bug
     return state, output
     """
     # [BUG] Solution with isinstance/type is not reliable... micropython 1.22
     #          Invalid type, must be list: <class list>" ...
     if skip_check:
-        return lm_exec(cmd)
-    return lm_exec(cmd) if isinstance(cmd, list) else False, f"Invalid type, must be list: {type(cmd)}"
+        return lm_exec(cmd, jsonify=jsonify)
+    return lm_exec(cmd, jsonify=jsonify) if isinstance(cmd, list) else False, f"CMD {type(cmd)}, must be list!"
 
 
 def notify(text=None) -> bool:

micrOS/source/Espnow.py

@@ -1,157 +1,279 @@
 from aioespnow import AIOESPNow
 from binascii import hexlify
 from Tasks import NativeTask, TaskBase, lm_exec, lm_is_loaded
+import uasyncio as asyncio
 from Network import get_mac
 from Config import cfgget
 from Debug import errlog_add
 
-# Configuration values and globals
-_INSTANCE = None
-_DEVFID = cfgget('devfid')  # for example, "node01"
 
-async def asend(now, mac, msg):
+# ----------- PARSE AND RENDER MSG PROTOCOL  --------------
+
+def render_response(tid, oper, data, prompt) -> str:
     """
-    Send a message over ESPNow. The sent message will be extended with the server prompt.
-    The prompt indicates the end-of-message with a '$' marker.
+    Render ESPNow custom message (protocol)
     """
-    prompt = f"{_DEVFID}$"  # '$' symbol is the ACK (end of message)!
-    # Append a newline and the server prompt to the message.
-    full_msg = f"{msg}\n{prompt}".encode("utf-8")
-    return await now.asend(mac, full_msg)
+    if oper not in ("REQ", "RSP"):
+        errlog_add(f"[ERR] espnow render_response, unknown oper: {oper}")
+    tmp = "{tid}|{oper}|{data}|{prompt}$"
+    tmp = tmp.replace("{tid}", str(tid))
+    tmp = tmp.replace("{oper}", str(oper))
+    tmp = tmp.replace("{data}", str(data))
+    tmp = tmp.replace("{prompt}", str(prompt))
+    return tmp
 
-def _serv_execute(msg, my_task):
+def parse_request(msg:bytes) -> (bool, dict|str):
     """
-    Process an incoming command and return a tuple (ready, response).
-
-    The function decodes the message, strips any trailing '$' (which marks the prompt),
-    and then interprets the message as a command. The command is split into tokens where
-    the first token is considered the module/command. If the module is allowed (lm_is_loaded),
-    the command is executed with lm_exec; otherwise, "NotAllowed" is returned.
+    Parse ESPNow custom message protocol
     """
     try:
-        command_line = msg.decode('utf-8').strip()
+        msg = msg.decode('utf-8').strip()
     except UnicodeError:
-        my_task.out = "[NOW SERVE] Invalid encoding"
         return False, "Invalid encoding"
+    # strip the trailing '$' then split on '|'
+    parts = msg.rstrip("$").split("|")
+    if len(parts) == 4:
+        return True, {"tid": parts[0],
+                      "oper": parts[1],
+                      "data": parts[2],
+                      "prompt": parts[3]}
+    return False, f"Missing 4 args: {msg}"
+
+
+# ----------- ESPNOW SESSION SERVER - LISTENER AND SENDER  --------------
+class ResponseRouter:
+    """
+    Response Router (by mac address)
+    to connect sender task with receiver loop (aka server)
+    """
+    _routes: dict[bytes, "ResponseRouter"] = {}
+
+    def __init__(self, mac: bytes):
+        self.mac = mac
+        self.response = None
+        self._event = asyncio.Event()
+        ResponseRouter._routes[mac] = self
 
-    # Split the command into tokens.
-    tokens = command_line.split()
-    if not tokens:
-        return False, "[NOW SERVE] Empty command"
-    # Remove trailing prompt marker if present.
-    client_token = "?$"
-    if tokens[-1].endswith("$"):
-        client_token = tokens[-1]
-        tokens = tokens[:-1]
-    my_task.out = f"[NOW SERVE] {' '.join(tokens)} (from {client_token})"
-    # Check if the module/command is allowed.
-    module = tokens[0]
-    if lm_is_loaded(module):
+    async def get_response(self, timeout:int=10) -> str|dict:
+        """Wait for one response, then clear the event for reuse."""
         try:
-            state, out = lm_exec(tokens)
-        except Exception as e:
-            # Optionally log the exception here.
-            state, out = False, f"[ERR][NOW SERVE] {tokens}: {e}"
-    else:
-        state, out = False, f"[WARN][NOW SERVE] NotAllowed {tokens[0]}"
-    return state, out
+            await asyncio.wait_for(self._event.wait(), timeout)
+        except asyncio.TimeoutError:
+            return "Timeout has beed exceeded"
+        self._event.clear()
+        return self.response
+
+    @staticmethod
+    def update_response(mac: bytes, response: str) -> None:
+        # USE <tid> for proper session response mapping
+        router = ResponseRouter._routes.get(mac)
+        if router is None:
+            errlog_add(f"[WARN][ESPNOW] No response route for {mac}")
+            return
+        router.response = response
+        router._event.set()
+
+    def close(self) -> None:
+        """Remove routing entry when done."""
+        ResponseRouter._routes.pop(self.mac, None)
 
-async def _server(now):
+
+class ESPNowSS:
     """
-    ESPNow server task that continuously waits for incoming messages and processes commands.
+    ESPNow Session Server
     """
-    with TaskBase.TASKS.get('espnow.server', None) as my_task:
-        async for mac, msg in now:
-            try:
-                state, response = _serv_execute(msg, my_task)
-                if state:
-                    await asend(now, mac, response)
-                else:
-                    errlog_add(response)
-            except OSError as err:
-                # If the peer is not yet added, add it and retry.
-                if len(err.args) > 1 and err.args[1] == 'ESP_ERR_ESPNOW_NOT_FOUND':
-                    now.add_peer(mac)
-                    state, response = _serv_execute(msg, my_task)
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            # first time: actually create it
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        # __init__ still runs each time, so guard if needed
+        if not hasattr(self, '_initialized'):
+            self.espnow = AIOESPNow()                   # Instance with async support
+            self.espnow.active(True)
+            self.devfid = cfgget('devfid')
+            self.devices: dict[bytes, str] = {}         # mapping for { "mac address": "devfid" } pairs
+            self._initialized = True
+            self.server_ready = False
+
+    # ----------- SERVER METHODS --------------
+    def _request_handler(self, msg:bytes, my_task:NativeTask, mac:bytes):
+        """
+        Handle server input message (request), with REQ/RSP types (oper)
+            oper==REQ   - command execution
+            oper==RSP   - command response
+        :param msg: valid message format> "{tid}|{oper}|{data}|{prompt}$", {data} is the user input
+        :param my_task: Server task instance, for my_task.out update
+        :param mac: sender binary mac address
+        """
+
+        state, request = parse_request(msg)
+        if not state:
+            my_task.out = f"[_ESPNOW] {request}"
+            return state, request
+
+        # parsed request: {"tid": "n/a", "oper": "n/a", "data": "n/a", "prompt": "n/a"}
+        operation, prompt, tid = request["oper"], request["prompt"], request["tid"]
+        my_task.out = f"[{tid}] {operation} from {prompt}"
+        # Update known devices
+        self.devices[mac] = request["prompt"]
+
+        # Check if the module/command is allowed., check oper==REQ/RSP
+        if operation == "REQ":
+            command = request["data"].split()
+            module = command[0]
+            if lm_is_loaded(module):
+                try:
+                    state, out = lm_exec(command)
+                    # rendered_output: "{tid}|{oper}|{data}|{prompt}$"
+                    rendered_out = render_response(tid="?", oper="RSP", data=out, prompt=self.devfid)
+                    return state, rendered_out
+                except Exception as e:
+                    # Optionally log the exception here.
+                    state, out = False, f"[ERR][_ESPNOW] {command}: {e}"
+            else:
+                state, out = False, f"[WARN][_ESPNOW] NotAllowed {module}"
+            return state, out
+        if operation == "RSP":
+            resp_data = request["data"]
+            ResponseRouter.update_response(mac, resp_data)          # USE <tid> for proper session response mapping
+        return False, f"[_ESPNOW] No action, {request}"
+
+    async def _server(self, tag:str):
+        """
+        ESPnow async listener task
+        :param tag: micro_task tag for task access
+        """
+        with TaskBase.TASKS.get(tag, None) as my_task:
+            self.server_ready = True
+            my_task.out = "ESPNow receiver running"
+            async for mac, msg in self.espnow:
+                try:
+                    state, response = self._request_handler(msg, my_task, mac)
                     if state:
-                        await asend(now, mac, response)
+                        await self.__asend_raw(mac, response)
                     else:
                         errlog_add(response)
-                else:
-                    # Optionally handle or log other OSErrors here.
-                    errlog_add(f"[ERR][NOW SERVER] {err}")
+                except OSError as err:
+                    # If the peer is not yet added, add it and retry.
+                    if len(err.args) > 1 and err.args[1] == 'ESP_ERR_ESPNOW_NOT_FOUND':
+                        self.add_peer(mac)
+                        state, response = self._request_handler(msg, my_task, mac)
+                        if state:
+                            await self.__asend_raw(mac, response)
+                        else:
+                            errlog_add(response)
+                    else:
+                        # Optionally handle or log other OSErrors here.
+                        errlog_add(f"[ERR][NOW SERVER] {err}")
+
+    def start_server(self):
+        """
+        Start the async ESPNow receiver server.
+        """
+        # Create an asynchronous task with tag 'espnow.server'
+        tag = 'espnow.server'
+        state = NativeTask().create(callback=self._server(tag), tag=tag)
+        return "Starting" if state else "Already running"
+
+    #----------- SEND METHODS --------------
+    async def __asend_raw(self, mac:bytes, msg:str):
+        """
+        ESPnow send message to mac address
+        """
+        return await self.espnow.asend(mac, msg.encode("utf-8"))
+
+    async def _asend_task(self, peer:bytes, tag:str, msg:str):
+        """
+        ESPNow client task: send a command to a peer and update task status.
+        """
+        with TaskBase.TASKS.get(tag, None) as my_task:
+            router = ResponseRouter(peer)
+            # rendered_output: "{tid}|{oper}|{data}|{prompt}$"
+            rendered_out = render_response(tid="?", oper="REQ", data=msg, prompt=self.devfid)
+            if await self.__asend_raw(peer, rendered_out):
+                my_task.out = f"[ESPNOW SEND] {rendered_out}"
+                my_task.out = await router.get_response()
+            else:
+                my_task.out = "[ESPNOW SEND] Peer not responding"
+            router.close()
+
+    def mac_by_peer_name(self, peer_name:str) -> bytes|None:
+        matches = [k for k, v in self.devices.items() if v == peer_name]
+        peer = matches[0] if matches else None
+        return peer
+
+    def send(self, peer:bytes|str, msg:str) -> str:
+        """
+        Send a command over ESPNow.
+        :param peer: Binary MAC address of another device.
+        :param msg: String command message to send.
+        """
+        peer_name = None
+        if isinstance(peer, str):
+            # Peer as device name (prompt)
+            _peer = self.mac_by_peer_name(peer)
+            if _peer is None:
+                return f"Unknown device: {peer}"
+            peer_name = peer
+            peer = _peer
+
+        peer_name = hexlify(peer, ':').decode() if peer_name is None else peer_name
+        task_id = f"con.espnow.{peer_name}"
+        # Create an asynchronous sending task.
+        state = NativeTask().create(callback=INSTANCE._asend_task(peer, task_id, msg), tag=task_id)
+        return "Starting" if state else "Already running"
+
+    # ----------- OTHER METHODS --------------
+
+    def add_peer(self, peer:bytes, devfid:str=None):
+        """
+        Add a peer given its MAC address.
+        :param peer: Binary MAC address of a peer (e.g. b'\xbb\xbb\xbb\xbb\xbb\xbb').
+        :param devfid: optional parameter to register dev uid for mac address
+        """
+        try:
+            self.espnow.add_peer(peer)
+            if devfid is not None:
+                # Update known devices
+                self.devices[peer] = devfid
+        except Exception as e:
+            return f"Peer error: {e}"
+        return "Peer register done"
+
+    def stats(self):
+        """
+        Return stats for ESPNow peers.
+        stats: tx_pkts, tx_responses, tx_failures, rx_packets, rx_dropped_packets.
+        peers: peer, rssi, time_ms.
+        """
+        try:
+            _stats = self.espnow.stats()
+        except Exception as e:
+            _stats = str(e)
+        try:
+            _peers = self.espnow.peers_table
+        except Exception as e:
+            _peers = str(e)
+        return {"stats": _stats, "peers": _peers, "map": self.devices, "ready": self.server_ready}
 
-async def _send(now, peer, tag, msg):
-    """
-    ESPNow client task: send a command to a peer and update task status.
-    """
-    with TaskBase.TASKS.get(tag, None) as my_task:
-        if not await asend(now, peer, msg):
-            my_task.out = "[NOW SEND] Peer not responding"
-        else:
-            my_task.out = f"[NOW SEND] {msg}"
 
 ###################################################
 #                   Control functions             #
 ###################################################
-def initialize():
-    """
-    Initialize the ESPNow protocol. (WLAN must be active.)
-    """
-    global _INSTANCE
-    if _INSTANCE is None:
-        now = AIOESPNow()  # Instance with async support
-        now.active(True)
-        _INSTANCE = now
-    return _INSTANCE
-
-def add_peer(now, peer):
-    """
-    Add a peer given its MAC address.
-    :param now: ESPNow instance.
-    :param peer: Binary MAC address of a peer (e.g. b'\xbb\xbb\xbb\xbb\xbb\xbb').
-    """
-    now.add_peer(peer)
-    return "Peer register done"
+INSTANCE = ESPNowSS()
 
-def espnow_server():
-    """
-    Start the async ESPNow receiver server.
-    """
-    now = initialize()
-    # Create an asynchronous task with tag 'espnow.server'
-    state = NativeTask().create(callback=_server(now), tag='espnow.server')
-    return "Starting" if state else "Already running"
+def initialize():
+    # TODO: remove, use ESPNowSS() class instead
+    global INSTANCE
+    if INSTANCE is None:
+        INSTANCE = ESPNowSS()
+    return INSTANCE
 
-def espnow_send(peer, msg):
-    """
-    Send a command over ESPNow.
-    :param peer: Binary MAC address of another device.
-    :param msg: String command message to send.
-    """
-    now = initialize()
-    mac_str = hexlify(peer, ':').decode()
-    task_id = f"espnow.cli.{mac_str}"
-    # Create an asynchronous sending task.
-    state = NativeTask().create(callback=_send(now, peer, task_id, msg), tag=task_id)
-    return "Starting" if state else "Already running"
-
-def stats():
-    """
-    Return stats for ESPNow peers.
-    stats: tx_pkts, tx_responses, tx_failures, rx_packets, rx_dropped_packets.
-    peers: peer, rssi, time_ms.
-    """
-    now = initialize()
-    try:
-        _stats = now.stats()
-    except Exception as e:
-        _stats = str(e)
-    try:
-        _peers = now.peers_table
-    except Exception as e:
-        _peers = str(e)
-    return {"stats": _stats, "peers": _peers}
 
 def mac_address():
     """