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

micrOS/source/Espnow.py

@@ -1,25 +1,24 @@
 from aioespnow import AIOESPNow
 from binascii import hexlify
-from Tasks import NativeTask, TaskBase, lm_exec, lm_is_loaded
+from json import load, dump
 import uasyncio as asyncio
-from Network import get_mac
+from Tasks import NativeTask, lm_exec, lm_is_loaded
 from Config import cfgget
 from Debug import syslog
+from Files import OSPath, path_join, is_file
 
 
 # ----------- PARSE AND RENDER MSG PROTOCOL  --------------
 
-def render_response(tid, oper, data, prompt) -> str:
+def render_response(tid:str, oper:str, data:str, prompt:str) -> str:
     """
     Render ESPNow custom message (protocol)
     """
     if oper not in ("REQ", "RSP"):
         syslog(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))
+    tmp = (tmp.replace("{tid}", tid).replace("{oper}", oper)
+           .replace("{data}", str(data)).replace("{prompt}", prompt))
     return tmp
 
 def parse_request(msg:bytes) -> (bool, dict|str):
@@ -85,6 +84,7 @@ class ESPNowSS:
     _instance = None
 
     def __new__(cls, *args, **kwargs):
+        # SINGLETON PATTERN
         if cls._instance is None:
             # first time: actually create it
             cls._instance = super().__new__(cls)
@@ -93,12 +93,27 @@ class ESPNowSS:
     def __init__(self):
         # __init__ still runs each time, so guard if needed
         if not hasattr(self, '_initialized'):
+            self._initialized = True
             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
+            self.peer_cache = path_join(OSPath.DATA, "espnow_peers.app_json")
+            self._load_peers()
+
+    def _load_peers(self):
+        if not is_file(self.peer_cache):
+            return
+        try:
+            with open(self.peer_cache, 'r') as f:
+                devices_map = load(f)
+                self.devices = {bytes(k): v for k, v in devices_map}
+            for mac in self.devices:
+                # PEER REGISTRATION
+                self.espnow.add_peer(mac)
+        except Exception as e:
+            syslog(f"[ERR][ESPNOW] Loading peers: {e}")
 
     # ----------- SERVER METHODS --------------
     def _request_handler(self, msg:bytes, my_task:NativeTask, mac:bytes):
@@ -126,6 +141,11 @@ class ESPNowSS:
         if operation == "REQ":
             command = request["data"].split()
             module = command[0]
+            # 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)
+                return True, rendered_out
+            # COMMAND EXECUTION
             if lm_is_loaded(module):
                 try:
                     state, out = lm_exec(command)
@@ -134,39 +154,43 @@ class ESPNowSS:
                     return state, rendered_out
                 except Exception as e:
                     # Optionally log the exception here.
-                    state, out = False, f"[ERR][_ESPNOW] {command}: {e}"
+                    syslog(f"[ERR][_ESPNOW] {command}: {e}")
+                    state, out = False, ""
             else:
-                state, out = False, f"[WARN][_ESPNOW] NotAllowed {module}"
+                warning_msg = f"[WARN][_ESPNOW] NotAllowed {module}"
+                syslog(warning_msg)
+                rendered_out = render_response(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
-        return False, f"[_ESPNOW] No action, {request}"
+        #syslog(f"[_ESPNOW] No action, {request}")
+        return False, ""
 
     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:
+
+        with NativeTask.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:
+                    reply, response = self._request_handler(msg, my_task, mac)
+                    if reply:
                         await self.__asend_raw(mac, response)
-                    else:
-                        syslog(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':
-                        self.add_peer(mac)
-                        state, response = self._request_handler(msg, my_task, mac)
-                        if state:
+                        # AUTOMATIC PEER REGISTRATION
+                        self.espnow.add_peer(mac)
+                        reply, response = self._request_handler(msg, my_task, mac)
+                        if reply:
                             await self.__asend_raw(mac, response)
-                        else:
-                            syslog(response)
                     else:
                         # Optionally handle or log other OSErrors here.
                         syslog(f"[ERR][NOW SERVER] {err}")
@@ -178,7 +202,7 @@ class ESPNowSS:
         # 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"
+        return {tag: "Starting"} if state else {tag: "Already running"}
 
     #----------- SEND METHODS --------------
     async def __asend_raw(self, mac:bytes, msg:str):
@@ -191,7 +215,7 @@ class ESPNowSS:
         """
         ESPNow client task: send a command to a peer and update task status.
         """
-        with TaskBase.TASKS.get(tag, None) as my_task:
+        with NativeTask.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)
@@ -207,7 +231,7 @@ class ESPNowSS:
         peer = matches[0] if matches else None
         return peer
 
-    def send(self, peer:bytes|str, msg:str) -> str:
+    def send(self, peer:bytes|str, msg:str) -> dict:
         """
         Send a command over ESPNow.
         :param peer: Binary MAC address of another device.
@@ -218,7 +242,7 @@ class ESPNowSS:
             # Peer as device name (prompt)
             _peer = self.mac_by_peer_name(peer)
             if _peer is None:
-                return f"Unknown device: {peer}"
+                return {peer: "Unknown device"}
             peer_name = peer
             peer = _peer
 
@@ -226,24 +250,62 @@ class ESPNowSS:
         task_id = f"con.espnow.{peer_name}"
         # Create an asynchronous sending task.
         state = NativeTask().create(callback=self._asend_task(peer, task_id, msg), tag=task_id)
-        return "Starting" if state else "Already running"
+        return {task_id: "Starting"} if state else {task_id: "Already running"}
+
+    def cluster_send(self, msg):
+        """
+        Send message for all peers
+        """
+        _tasks = []
+        for peer_name in self.devices.values():
+            _tasks.append(self.send(peer_name, msg))
+        return _tasks
 
     # ----------- OTHER METHODS --------------
 
-    def add_peer(self, peer:bytes, devfid:str=None):
+    async def _handshake(self, peer:bytes, tag:str):
         """
-        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
+        Handshake with peer
+        - with device caching
         """
-        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"
+        with NativeTask.TASKS.get(tag, None) as my_task:
+            if self.devices.get(peer) is None:
+                my_task.out = "ESPNow Add Peer"
+                try:
+                    # PEER REGISTRATION
+                    self.espnow.add_peer(peer)
+                except Exception as e:
+                    my_task.out = f"ESPNow Peer Error: {e}"
+                    return
+            my_task.out = "Handshake In Progress..."
+            sender = self.send(peer, "hello")
+            task_key = list(sender.keys())[0]
+            sender_task = NativeTask.TASKS.get(task_key, None)
+            result = await sender_task.await_result(timeout=10)
+            expected_response =  f"hello {self.devfid}"
+            is_ok = False
+            if result == expected_response:
+                try:
+                    with open(self.peer_cache, "w") as f:
+                        dump([[list(k), v] for k, v in self.devices.items()], f)
+                    is_ok = True
+                except Exception as e:
+                    syslog(f"[ERR][ESPNOW] Saving peers: {e}")
+            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"
+        # 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(":"))
+        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('"}
 
     def stats(self):
         """
@@ -260,23 +322,3 @@ class ESPNowSS:
         except Exception as e:
             _peers = str(e)
         return {"stats": _stats, "peers": _peers, "map": self.devices, "ready": self.server_ready}
-
-
-###################################################
-#                   Control functions             #
-###################################################
-INSTANCE = ESPNowSS()
-
-def initialize():
-    # TODO: remove, use ESPNowSS() class instead
-    global INSTANCE
-    if INSTANCE is None:
-        INSTANCE = ESPNowSS()
-    return INSTANCE
-
-
-def mac_address():
-    """
-    Get the binary MAC address.
-    """
-    return get_mac()

micrOS/source/Files.py

@@ -1,26 +1,43 @@
-from uos import ilistdir, remove, stat, getcwd
+"""
+Module is responsible high level micropython file system opeartions
+[IMPORTANT] This module must never use any micrOS specific functions or classes.
+"""
+
+from uos import ilistdir, remove, stat, getcwd, mkdir
+from sys import path as upath
 
 ################################   Helper functions   #####################################
 
-def _is_module(path:str='/', pyprefix:str='*') -> bool:
+def _filter(path:str='/', ext:tuple=None, prefix:tuple=None, hide_core:bool=True) -> bool:
     """
-    Filter application modules, LM_.* (pyprefix) or app data or web resource
+    Filter files
     :param path: file to check
-    :param pyprefix: python resource filter prefix, default: * (all: LM and IO)
+    :param ext: tuple of extensions to filter by, default: None (all)
+    :param hide_core: hide core files (mpy, py), default: True
     """
-    # micrOS file types
-    allowed_exts = ('html', 'js', 'css', 'log', 'cache', 'dat')
-    mod_prefixes = ('LM', "IO")
     fname = path.split("/")[-1]
-    if fname.split("_")[0] in mod_prefixes or fname.split('.')[-1] in allowed_exts:
-        if pyprefix == '*':
-            # MODE: ALL app resources
-            return True
-        if fname.startswith(f"{pyprefix.upper()}_"):
-            # MODE: SELECTED app resources
-            return True
+    _ext = fname.split(".")[-1]
+    if hide_core and _ext in ("mpy", "py") and not (fname.startswith("LM_") or fname.startswith("IO_")):
+        return False
+    if ext is None and prefix is None:
+        return True
+    if isinstance(prefix, tuple) and fname.split("_")[0] in prefix:
+        return True
+    if isinstance(ext, tuple) and fname.split(".")[-1] in ext:
+        return True
     return False
 
+def is_protected(path:str='/') -> bool:
+    """
+    Check is file protected
+        - deny deletion
+    """
+    protected_entities = ("", "node_config.json", "modules", "config", "logs", "web", "data",
+                          "LM_pacman.mpy", "LM_system.mpy")
+    entity = path.split("/")[-1].replace("/", "")
+    if entity in protected_entities:
+        return True
+    return False
 
 def _type_mask_to_str(item_type:int=None) -> str:
     # Map the raw bit-mask to a single character
@@ -33,6 +50,19 @@ def _type_mask_to_str(item_type:int=None) -> str:
     return item_type
 
 ###########################   Public functions   #############################
+def is_dir(path):
+    try:
+        return stat(path)[0] & 0x4000
+    except OSError:
+        return False
+
+
+def is_file(path):
+    try:
+        return stat(path)[0] & 0x8000
+    except OSError:
+        return False
+
 
 def ilist_fs(path:str="/", type_filter:str='*', select:str='*', core:bool=False):
     """
@@ -52,7 +82,8 @@ def ilist_fs(path:str="/", type_filter:str='*', select:str='*', core:bool=False)
         item_type = _type_mask_to_str(item_type)
         if type_filter in ("*", item_type):
             # Mods only
-            if not core and item_type == 'f' and not _is_module(path+item, pyprefix=select):
+            _select = None if select == "*" else (select,)
+            if item_type == 'f' and not _filter(item, prefix=_select, hide_core=not core):
                 continue
             if select != '*' and item_type == 'd':
                 continue
@@ -78,33 +109,19 @@ def remove_fs(path, allow_dir=False):
     :param allow_dir: enable directory deletion, default: False
     """
     # protect some resources
-    if 'pacman.mpy' in path or 'system.mpy' in path or "/" == path.strip():
-        return f'Load module {path} is protected, skip deletion'
-    _is_dir = is_dir(path)
-    if _is_module(path) or (_is_dir and allow_dir):
+    if is_protected(path):
+        return f'{path} is protected, skip deletion'
+    _is_file = is_file(path)
+    if _is_file or allow_dir:
         remove(path)
-        return f"Removed: {path} {'dir' if _is_dir else 'file'}"
-    return f"Protected path: {path}"
-
-
-def is_dir(path):
-    try:
-        return stat(path)[0] & 0x4000
-    except OSError:
-        return False
-
-
-def is_file(path):
-    try:
-        return stat(path)[0] & 0x8000
-    except OSError:
-        return False
+        return f"{path} deleted"
+    return f"Cannot delete {'file' if _is_file else 'dir'}: {path}"
 
 
 def path_join(*parts):
     path = "/".join(part.strip("/") for part in parts if part)
     if parts and parts[0].startswith("/"):
-        path = "/" + path
+        path = path if path.startswith("/") else "/" + path
     return path
 
 
@@ -114,9 +131,28 @@ class OSPath:
     LOGS = path_join(_ROOT, '/logs')        # Logs (.log)
     DATA = path_join(_ROOT,'/data')         # Application data (.dat, .cache, etc.)
     WEB = path_join(_ROOT,'/web')           # Web resources (.html, .css, .js, .json, etc.)
-    MODULES = path_join(_ROOT, '/modules')  # Application modules (.mpy, .py) (todo)
-    CONFIG = path_join(_ROOT, '/config')    # System configuration files (node_config.json, etc.)(todo)
+    MODULES = path_join(_ROOT, '/modules')  # Application modules (.mpy, .py)
+    CONFIG = path_join(_ROOT, '/config')    # System configuration files (node_config.json, etc.)
+
 
-    @property
-    def ROOT(self):
-        return self._ROOT
+def init_micros_dirs():
+    """
+    Init micrOS root file system directories
+    """
+    # ENABLE MODULES ACCESS
+    if OSPath.MODULES not in upath:
+        upath.insert(0, OSPath.MODULES)
+
+    root_dirs = [
+        getattr(OSPath, key)
+        for key in dir(OSPath)
+        if not key.startswith("_") and isinstance(getattr(OSPath, key), str)
+    ]
+    print(f"[BOOT] rootFS validation: {root_dirs}")
+    for dir_path in root_dirs:
+        if not is_dir(dir_path):
+            try:
+                mkdir(dir_path)
+                print(f"[BOOT] init dir: {dir_path}")
+            except Exception as e:
+                print(f"[ERR][BOOT] cannot init dir {dir_path}: {e}")

micrOS/source/Hooks.py

@@ -21,8 +21,6 @@ from Config import cfgget, cfgput
 from microIO import detect_platform
 from Debug import console_write, syslog
 from Tasks import exec_lm_pipe
-from Files import OSPath, is_dir
-from uos import mkdir
 from micropython import mem_info
 from machine import freq
 try:
@@ -45,7 +43,6 @@ def bootup():
     """
     # Execute LMs from boothook config parameter
     console_write("[BOOT] EXECUTION...")
-    _init_micros_dirs()
     bootasks = cfgget('boothook')
     if bootasks is not None and bootasks.lower() != 'n/a':
         console_write(f"|-[BOOT] TASKS: {bootasks}")
@@ -62,25 +59,6 @@ def bootup():
     _tune_performance()
 
 
-def _init_micros_dirs():
-    """
-    Init micrOS root file system directories
-    """
-    root_dirs = [
-        getattr(OSPath, key)
-        for key in dir(OSPath)
-        if not key.startswith("_") and isinstance(getattr(OSPath, key), str)
-    ]
-    console_write(f"|-[BOOT] rootFS validation: {root_dirs}")
-    for dir_path in root_dirs:
-        if not is_dir(dir_path):
-            try:
-                mkdir(dir_path)
-                syslog(f"[BOOT] init dir: {dir_path}")
-            except Exception as e:
-                syslog(f"[ERR][BOOT] cannot init dir {dir_path}: {e}")
-
-
 def _tune_queue_size():
     """
     Tune queue size based on available ram
@@ -96,20 +74,26 @@ def _tune_queue_size():
 
 
 def _tune_performance():
-    # Set boosted (boost mode)
+    # {(platforms, ...): (min_clock, max_clock), ...}
+    cpu_clocks = {
+        ('esp32c3', 'esp32c6'): (80_000_000, 160_000_000),
+        ('esp32',): (160_000_000, 240_000_000),  # default
+    }
     platform = detect_platform()
-    if cfgget('boostmd') is True:
-        console_write(f"[BOOT HOOKS] Set up CPU high Hz - boostmd: {cfgget('boostmd')}")
-        if platform == 'esp32c3':
-            freq(160_000_000)   # 160 Mhz (max)
-        elif 'esp32' in platform:
-            freq(240_000_000)   # 240 Mhz (max)
+    cpu_min_max = cpu_clocks[('esp32',)]
+    for platforms, clocks in cpu_clocks.items():
+        if platform in platforms:
+            cpu_min_max = clocks
+            break
+    # Set boosted (boost mode)
+    if cfgget('boostmd'):
+        max_hz = cpu_min_max[1]
+        console_write(f"[BOOT HOOKS] CPU boost mode ON: {max_hz} Hz")
+        freq(max_hz)
     else:
-        console_write(f"[BOOT HOOKS] Set up CPU low Hz - boostmd: {cfgget('boostmd')}")
-        if platform == 'esp32c3':
-            freq(80_000_000)   # 80 Mhz / Half the max CPU clock
-        elif 'esp32' in platform:
-            freq(160_000_000)   # 160 Mhz / Half the max CPU clock
+        min_hz = cpu_min_max[0]
+        console_write(f"[BOOT HOOKS] CPU boost mode OFF: {min_hz} Hz")
+        freq(min_hz)
 
 
 def profiling_info(label=""):

micrOS/source/Logger.py

@@ -6,7 +6,7 @@ Designed by Marcell Ban aka BxNxM
 """
 from time import localtime
 from re import match
-from uos import remove, mkdir
+from uos import remove
 from Files import OSPath, path_join, ilist_fs, is_dir
 
 #############################################
@@ -16,12 +16,7 @@ from Files import OSPath, path_join, ilist_fs, is_dir
 def _init_logger():
     """ Init /logs folder """
     if not is_dir(OSPath.LOGS):
-        try:
-            mkdir(OSPath.LOGS)
-            syslog(f"[BOOT] log dir {OSPath.LOGS} init")
-        except Exception as e:
-            OSPath.LOGS = OSPath.ROOT
-            syslog(f"[BOOT] log dir {OSPath.LOGS} fallback: {e}")
+        OSPath.LOGS = OSPath._ROOT
     return OSPath.LOGS