micrOSDevToolKit 2.19.0__py3-none-any.whl → 2.21.0__py3-none-any.whl

micrOS/release_info/micrOS_ReleaseInfo/system_analysis_sum.json

@@ -4,9 +4,13 @@
             9.34,
             6
         ],
+        "Pacman.py": [
+            9.75,
+            1
+        ],
         "Files.py": [
-            9.64,
-            10
+            9.68,
+            11
         ],
         "micrOSloader.py": [
             7.06,
@@ -25,11 +29,11 @@
             1
         ],
         "Tasks.py": [
-            9.46,
+            9.48,
             12
         ],
         "Config.py": [
-            9.43,
+            9.44,
             19
         ],
         "reset.py": [
@@ -54,22 +58,22 @@
         ],
         "Common.py": [
             9.85,
-            35
+            34
         ],
         "InterConnect.py": [
-            9.62,
+            9.63,
             2
         ],
         "Debug.py": [
             7.37,
-            17
+            18
         ],
         "Network.py": [
             9.81,
             8
         ],
         "Espnow.py": [
-            9.48,
+            9.87,
             4
         ],
         "Scheduler.py": [
@@ -97,7 +101,7 @@
             5
         ],
         "modules/LM_roboarm.py": [
-            7.78,
+            7.83,
             0
         ],
         "modules/LM_stepper.py": [
@@ -109,7 +113,7 @@
             0
         ],
         "modules/LM_pacman.py": [
-            7.95,
+            7.61,
             0
         ],
         "modules/LM_genIO.py": [
@@ -117,7 +121,7 @@
             0
         ],
         "modules/LM_oled_ui.py": [
-            9.2,
+            9.22,
             0
         ],
         "modules/LM_system.py": [
@@ -125,7 +129,7 @@
             0
         ],
         "modules/LM_robustness.py": [
-            8.36,
+            8.33,
             0
         ],
         "modules/LM_qmi8658.py": [
@@ -137,7 +141,7 @@
             0
         ],
         "modules/LM_rest.py": [
-            8.18,
+            8.6,
             0
         ],
         "modules/LM_tcs3472.py": [
@@ -161,7 +165,7 @@
             0
         ],
         "modules/LM_buzzer.py": [
-            9.11,
+            9.09,
             0
         ],
         "modules/LM_switch.py": [
@@ -189,11 +193,11 @@
             0
         ],
         "modules/LM_neopixel.py": [
-            7.78,
+            7.77,
             0
         ],
         "modules/LM_cct.py": [
-            9.04,
+            9.03,
             0
         ],
         "modules/LM_L9110_DCmotor.py": [
@@ -220,10 +224,6 @@
             7.62,
             0
         ],
-        "modules/LM_pet_feeder.py": [
-            7.94,
-            0
-        ],
         "modules/LM_rencoder.py": [
             8.65,
             0
@@ -245,7 +245,7 @@
             0
         ],
         "modules/LM_oledui.py": [
-            8.94,
+            9.05,
             0
         ],
         "modules/LM_espnow.py": [
@@ -253,7 +253,7 @@
             0
         ],
         "modules/LM_telegram.py": [
-            9.63,
+            9.62,
             0
         ],
         "modules/LM_OV2640.py": [
@@ -265,7 +265,7 @@
             0
         ],
         "modules/LM_distance.py": [
-            8.87,
+            8.86,
             0
         ],
         "modules/LM_VL53L0X.py": [
@@ -273,7 +273,7 @@
             0
         ],
         "modules/LM_light_sensor.py": [
-            9.17,
+            9.12,
             0
         ],
         "modules/LM_rp2w.py": [
@@ -281,7 +281,7 @@
             0
         ],
         "modules/LM_presence.py": [
-            8.9,
+            8.89,
             0
         ],
         "modules/LM_trackball.py": [
@@ -289,7 +289,7 @@
             0
         ],
         "modules/LM_mqtt_client.py": [
-            8.45,
+            8.68,
             0
         ],
         "modules/LM_dashboard_be.py": [
@@ -297,7 +297,7 @@
             0
         ],
         "modules/LM_dimmer.py": [
-            8.33,
+            8.32,
             0
         ],
         "modules/LM_gameOfLife.py": [
@@ -309,7 +309,7 @@
             0
         ],
         "modules/LM_i2s_mic.py": [
-            8.43,
+            8.42,
             0
         ],
         "modules/LM_sdcard.py": [
@@ -323,12 +323,12 @@
     },
     "summary": {
         "core": [
-            4004,
-            24
+            4171,
+            25
         ],
         "load": [
-            9988,
-            56
+            9869,
+            55
         ],
         "core_dep": [
             true,
@@ -338,8 +338,8 @@
             true,
             4
         ],
-        "core_score": 9.25,
-        "load_score": 8.4,
-        "version": "2.19.0-0"
+        "core_score": 9.29,
+        "load_score": 8.41,
+        "version": "2.21.0-0"
     }
 }

micrOS/source/Common.py

@@ -15,7 +15,7 @@ from Notify import Notify
 #####################################################################################
 #                                     SYSTEM                                        #
 #####################################################################################
-def micro_task(tag: str, task=None, _wrap=False):
+def micro_task(tag:str, task=None, _wrap=False):
     """
     [LM] Async task manager.
     Modes:
@@ -37,21 +37,14 @@ def micro_task(tag: str, task=None, _wrap=False):
     """
     # --- CREATE (original) ---
     if task is not None:
-        if TaskBase.is_busy(tag):
-            return None     # task already running
         return Manager().create_task(callback=task, tag=tag)
 
     # --- CREATE WITH DECORATOR FACTORY (simplified) ---
     if _wrap:
         def _decorator(async_fn):
             task_tag = f"{tag}._{async_fn.__name__}"
-            _launcher = (
-                lambda *args, **kwargs:
-                None if TaskBase.is_busy(task_tag)
-                else Manager().create_task(
-                    callback=async_fn(task_tag, *args, **kwargs),
-                    tag=task_tag)
-            )
+            _launcher = (lambda *args, **kwargs: Manager().create_task(callback=async_fn(task_tag, *args, **kwargs),
+                                                              tag=task_tag))
             return _launcher
         return _decorator
 
@@ -404,9 +397,8 @@ class AnimationPlayer:
         # Ensure async loop set up correctly. (After stop operation, it is needed)
         self.__running = True
         # [!] ASYNC TASK CREATION
-        raw_state:bool = micro_task(tag=self._task_tag, task=self._player())
-        state = "starting" if raw_state else "running"
-        settings["state"] = state
+        state:dict = micro_task(tag=self._task_tag, task=self._player())
+        settings["state"] = list(state.values())[0]
         return settings
 
     def stop(self):

micrOS/source/Config.py

@@ -84,8 +84,11 @@ class Data:
         Data.__inject_default_conf()
         # [!!!] Init selected pinmap - default pinmap calculated by platform
         if callable(set_pinmap):
-            pinmap = set_pinmap(Data.CONFIG_CACHE['cstmpmap'])
-            console_write(f"[PIN MAP] {pinmap}")
+            try:
+                pinmap = set_pinmap(Data.CONFIG_CACHE['cstmpmap'])
+                console_write(f"[PIN MAP] {pinmap}")
+            except Exception as e:
+                console_write(f"\n[PIN MAP] !!! SETUP ERROR !!!: {e}\n")
         # SET dbg based on config settings (inject user conf)
         DebugCfg.DEBUG = Data.CONFIG_CACHE['dbg']
         if DebugCfg.DEBUG:

micrOS/source/Espnow.py

@@ -1,7 +1,23 @@
-from aioespnow import AIOESPNow
+"""
+ESPNow Session Server and Protocol Utilities
+
+This module implements:
+- Custom ESPNow message protocol with transaction IDs (tid) for secure, session-aware communication.
+- Asynchronous server and client logic for sending and receiving ESPNow messages.
+- Response routing using both MAC address and transaction ID to ensure correct delivery to tasks.
+- Peer management, handshake routines, and statistics reporting for ESPNow devices.
+
+Designed for MicroPython environments with async support.
+"""
+
+
 from binascii import hexlify
 from json import load, dump
 import uasyncio as asyncio
+import urandom
+
+from aioespnow import AIOESPNow
+
 from Tasks import NativeTask, lm_exec, lm_is_loaded
 from Config import cfgget
 from Debug import syslog
@@ -10,7 +26,7 @@ from Files import OSPath, path_join, is_file
 
 # ----------- PARSE AND RENDER MSG PROTOCOL  --------------
 
-def render_response(tid:str, oper:str, data:str, prompt:str) -> str:
+def render_packet(tid: str, oper: str, data: str, prompt: str) -> str:
     """
     Render ESPNow custom message (protocol)
     """
@@ -21,7 +37,7 @@ def render_response(tid:str, oper:str, data:str, prompt:str) -> str:
            .replace("{data}", str(data)).replace("{prompt}", prompt))
     return tmp
 
-def parse_request(msg:bytes) -> (bool, dict|str):
+def parse_packet(msg: bytes) -> tuple[bool, dict | str]:
     """
     Parse ESPNow custom message protocol
     """
@@ -39,21 +55,43 @@ def parse_request(msg:bytes) -> (bool, dict|str):
     return False, f"Missing 4 args: {msg}"
 
 
+def get_command_module(request):
+    if isinstance(request, dict):
+        command = request["data"].split()
+        module = command[0]
+    elif isinstance(request, str):
+        command = request.split()
+        module = command[0]
+    else:
+        command = []
+        module = ""
+    return command, module
+
+
+def generate_tid() -> str:
+    """
+    Generate a secure, random transaction ID (tid).
+    Returns an 8-byte hex string.
+    """
+    return hexlify(bytes([urandom.getrandbits(8) for _ in range(8)])).decode()
+
+
 # ----------- 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"] = {}
+    _routes: dict[tuple[bytes, str], "ResponseRouter"] = {}
 
-    def __init__(self, mac: bytes):
+    def __init__(self, mac: bytes, tid: str):
         self.mac = mac
+        self.tid = tid
         self.response = None
         self._event = asyncio.Event()
-        ResponseRouter._routes[mac] = self
+        ResponseRouter._routes[(mac, tid)] = self
 
-    async def get_response(self, timeout:int=10) -> str|dict:
+    async def get_response(self, timeout: int=10) -> str|dict:
         """Wait for one response, then clear the event for reuse."""
         try:
             await asyncio.wait_for(self._event.wait(), timeout)
@@ -63,18 +101,17 @@ class ResponseRouter:
         return self.response
 
     @staticmethod
-    def update_response(mac: bytes, response: str) -> None:
-        # USE <tid> for proper session response mapping
-        router = ResponseRouter._routes.get(mac)
+    def update_response(mac: bytes, tid: str, response: str) -> None:
+        router = ResponseRouter._routes.get((mac, tid), None)
         if router is None:
-            syslog(f"[WARN][ESPNOW] No response route for {mac}")
+            syslog(f"[WARN][ESPNOW] No response route for {(mac, tid)}")
             return
         router.response = response
         router._event.set()
 
     def close(self) -> None:
         """Remove routing entry when done."""
-        ResponseRouter._routes.pop(self.mac, None)
+        ResponseRouter._routes.pop((self.mac, self.tid), None)
 
 
 class ESPNowSS:
@@ -106,7 +143,7 @@ class ESPNowSS:
         if not is_file(self.peer_cache_path):
             return
         try:
-            with open(self.peer_cache_path, 'r') as f:
+            with open(self.peer_cache_path, 'r', encoding='utf-8') as f:
                 devices_map = load(f)
                 self.devices = {bytes(k): v for k, v in devices_map}
             for mac in self.devices:
@@ -116,7 +153,7 @@ class ESPNowSS:
             syslog(f"[ERR][ESPNOW] Loading peers: {e}")
 
     # ----------- SERVER METHODS --------------
-    def _request_handler(self, msg:bytes, my_task:NativeTask, mac:bytes):
+    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
@@ -126,7 +163,7 @@ class ESPNowSS:
         :param mac: sender binary mac address
         """
 
-        state, request = parse_request(msg)
+        state, request = parse_packet(msg)
         if not state:
             my_task.out = f"[_ESPNOW] {request}"
             return state, request
@@ -139,18 +176,17 @@ class ESPNowSS:
 
         # Check if the module/command is allowed., check oper==REQ/RSP
         if operation == "REQ":
-            command = request["data"].split()
-            module = command[0]
+            command, module = get_command_module(request)
             # Handle default hello - handshake message
             if len(command) == 1 and module == "hello":
-                rendered_out = render_response(tid="?", oper="RSP", data=f"hello {prompt}", prompt=self.devfid)
+                rendered_out = render_packet(tid=tid, oper="RSP", data=f"hello {prompt}", prompt=self.devfid)
                 return True, rendered_out
             # COMMAND EXECUTION
             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)
+                    rendered_out = render_packet(tid=tid, oper="RSP", data=out, prompt=self.devfid)
                     return state, rendered_out
                 except Exception as e:
                     # Optionally log the exception here.
@@ -159,17 +195,17 @@ class ESPNowSS:
             else:
                 warning_msg = f"[WARN][_ESPNOW] NotAllowed {module}"
                 syslog(warning_msg)
-                rendered_out = render_response(tid="?", oper="RSP", data=warning_msg,
+                rendered_out = render_packet(tid=tid, oper="RSP", data=warning_msg,
                                                prompt=self.devfid)
                 state, out = True, rendered_out
             return state, out
         if operation == "RSP":
             resp_data = request["data"]
-            ResponseRouter.update_response(mac, resp_data)          # USE <tid> for proper session response mapping
+            ResponseRouter.update_response(mac, tid, resp_data)          # USE <tid> for proper session response mapping
         #syslog(f"[_ESPNOW] No action, {request}")
         return False, ""
 
-    async def _server(self, tag:str):
+    async def _server(self, tag: str):
         """
         ESPnow async listener task
         :param tag: micro_task tag for task access
@@ -201,24 +237,23 @@ class ESPNowSS:
         """
         # Create an asynchronous task with tag 'espnow.server'
         tag = 'espnow.server'
-        state = NativeTask().create(callback=self._server(tag), tag=tag)
-        return {tag: "Starting"} if state else {tag: "Already running"}
+        return NativeTask().create(callback=self._server(tag), tag=tag)
 
     #----------- SEND METHODS --------------
-    async def __asend_raw(self, mac:bytes, msg:str):
+    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):
+    async def _asend_task(self, tid: str, peer: bytes, tag: str, msg: str):
         """
         ESPNow client task: send a command to a peer and update task status.
         """
         with NativeTask.TASKS.get(tag, None) as my_task:
-            router = ResponseRouter(peer)
+            router = ResponseRouter(peer, tid)
             # rendered_output: "{tid}|{oper}|{data}|{prompt}$"
-            rendered_out = render_response(tid="?", oper="REQ", data=msg, prompt=self.devfid)
+            rendered_out = render_packet(tid=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()
@@ -226,12 +261,12 @@ class ESPNowSS:
                 my_task.out = "[ESPNOW SEND] Peer not responding"
             router.close()
 
-    def mac_by_peer_name(self, peer_name:str) -> bytes|None:
+    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) -> dict:
+    def send(self, peer: bytes | str, msg: str) -> dict:
         """
         Send a command over ESPNow.
         :param peer: Binary MAC address of another device.
@@ -247,10 +282,11 @@ class ESPNowSS:
             peer = _peer
 
         peer_name = hexlify(peer, ':').decode() if peer_name is None else peer_name
-        task_id = f"con.espnow.{peer_name}"
+        _, module_name = get_command_module(msg)
+        task_id = f"con.espnow.{peer_name}.{module_name}"
+        tid = generate_tid()
         # Create an asynchronous sending task.
-        state = NativeTask().create(callback=self._asend_task(peer, task_id, msg), tag=task_id)
-        return {task_id: "Starting"} if state else {task_id: "Already running"}
+        return NativeTask().create(callback=self._asend_task(tid, peer, task_id, msg), tag=task_id)
 
     def cluster_send(self, msg):
         """
@@ -264,14 +300,14 @@ class ESPNowSS:
     # ----------- OTHER METHODS --------------
     def save_peers(self):
         try:
-            with open(self.peer_cache_path, "w") as f:
+            with open(self.peer_cache_path, "w", encoding="utf-8") as f:
                 dump([[list(k), v] for k, v in self.devices.items()], f)
             return True
         except Exception as e:
             syslog(f"[ERR][ESPNOW] Saving peers: {e}")
         return False
 
-    async def _handshake(self, peer:bytes, tag:str):
+    async def _handshake(self, peer: bytes, tag: str):
         """
         Handshake with peer
         - with device caching
@@ -297,17 +333,34 @@ class ESPNowSS:
             my_task.out = f"Handshake: {result} from {self.devices.get(peer)} [{'OK' if is_ok else 'NOK'}]"
             sender_task.cancel()    # Delete sender task (cleanup)
 
-    def handshake(self, peer:bytes|str):
-        task_id = f"con.espnow.handshake"
+    def _mac_str_to_bytes(self, mac_str: str) -> bytes|None:
+        """
+        Convert MAC address string (e.g., '50:02:91:86:34:28') to bytes.
+        """
+        try:
+            mac_bytes = bytes(int(x, 16) for x in mac_str.split(":"))
+            if len(mac_bytes) != 6:
+                return None
+            return mac_bytes
+        except Exception:
+            return None
+
+    def handshake(self, peer: bytes | str):
+        """
+        Initiate a handshake with a peer device over ESPNow.
+
+        :param peer: The peer device's MAC address as bytes or a string in the format '50:02:91:86:34:28'.
+        :return: A dictionary with error information or a NativeTask instance for the handshake operation.
+        """
+        task_id = "con.espnow.handshake"
         # Create an asynchronous sending task.
         if isinstance(peer, str) and ":" in peer:
-            # Convert 50:02:91:86:34:28 format to b'P\x02\x91\x864(' bytes
-            peer = bytes(int(x, 16) for x in peer.split(":"))
+            peer_bytes = self._mac_str_to_bytes(peer)
+            if peer_bytes is not None:
+                peer = peer_bytes
         if isinstance(peer, bytes):
-            state = NativeTask().create(callback=self._handshake(peer, task_id), tag=task_id)
-            return {task_id: "Starting"} if state else {task_id: "Already running"}
-        else:
-            return {None: "Invalid MAC address format. Use 50:02:91:86:34:28 or b'P\\x02\\x91\\x864('"}
+            return NativeTask().create(callback=self._handshake(peer, task_id), tag=task_id)
+        return {None: "Invalid MAC address format. Use 50:02:91:86:34:28 or b'P\\x02\\x91\\x864('"}
 
     def stats(self):
         """
@@ -324,11 +377,14 @@ class ESPNowSS:
         except Exception as e:
             _peers = str(e)
         return {"stats": _stats, "peers": _peers, "ready": self.server_ready}
-    
+
     def members(self):
+        """
+        Returns the list of devices that are members of the current group.
+        """
         return self.devices
 
-    def remove_peer(self, peer:bytes) -> bool:
+    def remove_peer(self, peer: bytes) -> bool:
         """
         Remove peer from ESPNow devices
         :param peer: MAC address as bytes to remove