micrOSDevToolKit 2.13.1__py3-none-any.whl → 2.17.1__py3-none-any.whl

micrOS/source/Network.py

@@ -20,6 +20,7 @@ from network import AP_IF, STA_IF, WLAN
 from machine import unique_id
 from Config import cfgget, cfgput
 from Debug import console_write, syslog
+from microIO import detect_platform
 
 
 class NW:
@@ -48,23 +49,36 @@ def ifconfig():
 
 
 def set_dev_uid():
+    if detect_platform() == "esp32c6":
+        # ESP32-C6: unique_id() not unique (can return same ID on different boards)
+        try:
+            sta = WLAN(STA_IF)
+            was = sta.active()
+            if not was: sta.active(True)
+            uid = hexlify(sta.config('mac')).decode()
+            if not was: sta.active(False)
+            cfgput('hwuid', f"micr{uid}OS")
+            return
+        except Exception as e:
+            syslog(f"[ERR] set_dev_uid (esp32c6): {e}")
+    # Legacy micrOS device UID generation (+fallback)
     try:
         cfgput('hwuid', f'micr{hexlify(unique_id()).decode("utf-8")}OS')
     except Exception as e:
-        syslog(f"[ERR] set_dev_uid error: {e}")
+        syslog(f"[ERR] set_dev_uid: {e}")
 
 
 def get_mac():
-    return WLAN().config('mac')
+    """ Get AP/STA mac address as raw binary data"""
+    return NW.NIF.config('mac')
 
 #################################################################
 #                       SET WIFI STA MODE                       #
 #################################################################
 
 
-def __select_available_wifi_nw(sta_if, raw_essid, raw_pwd):
+def _select_available_wifi_nw(raw_essid:str, raw_pwd:str):
     """
-    raw_essid: essid parameter, in case of multiple values separator is ;
     raw_pwd: essid pwd parameter,  in case of multiple values separator is ;
     return detected essid with corresponding password
     """
@@ -72,7 +86,7 @@ def __select_available_wifi_nw(sta_if, raw_essid, raw_pwd):
         essid = essid.strip()
         # Scan wifi network - retry workaround
         for _ in range(0, 2):
-            if essid in (wifispot[0].decode('utf-8') for wifispot in sta_if.scan()):
+            if essid in (wifispot[0].decode('utf-8') for wifispot in NW.NIF.scan()):
                 console_write(f'\t| - [NW: STA] ESSID WAS FOUND: {essid}')
                 try:
                     return essid, str(raw_pwd.split(';')[idx]).strip()
@@ -82,8 +96,8 @@ def __select_available_wifi_nw(sta_if, raw_essid, raw_pwd):
     return None, ''
 
 
-def set_wifi(essid, pwd, timeout=60):
-    console_write(f'[NW: STA] SET WIFI STA NW {essid}')
+def set_wifi(essid:str, pwd:str, timeout=60):
+    console_write('[NW: STA] Enable')
 
     # Disable AP mode
     ap_if = WLAN(AP_IF)
@@ -94,18 +108,25 @@ def set_wifi(essid, pwd, timeout=60):
     # Set STA and Connect
     sta_if = WLAN(STA_IF)
     sta_if.active(True)
+    NW.NIF = sta_if
     # Handle rsp2-w limitation (try)
     try:
         # Set custom DHCP hostname for dhcp name resolve
         sta_if.config(dhcp_hostname=cfgget('devfid'))
     except Exception as e:
-        console_write(f"dhcp_hostname conf error: {e}")
+        syslog(f"[ERR] STA dhcp_hostname: {e}")
+    if cfgget("espnow"):
+        try:
+            # prevents Wi-Fi PS from dropping ESP-NOW frames while STA is connected.
+            sta_if.config(pm=sta_if.PM_NONE)
+        except Exception as e:
+            syslog(f"[ERR] ESPNow STA PM_NONE: {e}")
     # Check are we already connected
     if sta_if.isconnected():
         console_write(f"\t| [NW: STA] ALREADY CONNECTED TO {essid}")
     else:
         # Multiple essid and pwd handling with retry mechanism
-        essid, pwd = __select_available_wifi_nw(sta_if, essid, pwd)
+        essid, pwd = _select_available_wifi_nw(essid, pwd)
 
         # Connect to the located wifi network
         if essid is not None:
@@ -118,7 +139,7 @@ def set_wifi(essid, pwd, timeout=60):
                 timeout -= 1
                 sleep_ms(500)
             # Set static IP - here because some data comes from connection. (subnet, etc.)
-            if sta_if.isconnected() and __set_wifi_dev_static_ip(sta_if):
+            if sta_if.isconnected() and _set_wifi_dev_static_ip(sta_if):
                 sta_if.disconnect()
                 del sta_if
                 return set_wifi(essid, pwd)
@@ -131,11 +152,10 @@ def set_wifi(essid, pwd, timeout=60):
     # Store STA IP (make it static ip)
     cfgput("devip", str(sta_if.ifconfig()[0]))
     set_dev_uid()
-    NW.NIF = sta_if
     return sta_if.isconnected()
 
 
-def __set_wifi_dev_static_ip(sta_if):
+def _set_wifi_dev_static_ip(sta_if:STA_IF):
     console_write("[NW: STA] Set device static IP.")
     stored_ip = cfgget('devip')
     if 'n/a' not in stored_ip.lower() and '.' in stored_ip:
@@ -162,7 +182,7 @@ def __set_wifi_dev_static_ip(sta_if):
 #################################################################
 
 
-def set_access_point(_essid, _pwd, _authmode=3):
+def set_access_point(_essid:str, _pwd:str, _authmode:int=3):
     console_write(f"[NW: AP] SET AP MODE: {_essid} - {_pwd} - auth mode: {_authmode} (if possible)")
 
     sta_if = WLAN(STA_IF)
@@ -171,6 +191,7 @@ def set_access_point(_essid, _pwd, _authmode=3):
 
     ap_if = WLAN(AP_IF)
     ap_if.active(True)
+    NW.NIF = ap_if
     # Set WiFi access point name (formally known as ESSID) and WiFi authmode (3): WPA2-PSK
     try:
         # Config #1 (esp)
@@ -189,7 +210,6 @@ def set_access_point(_essid, _pwd, _authmode=3):
         syslog("[ERR][AP] error")
     console_write(f"\t|\t| [NW: AP] network config: {str(ap_if.ifconfig())}")
     set_dev_uid()
-    NW.NIF = ap_if
     return ap_if.active()
 
 #################################################################
@@ -228,7 +248,7 @@ def sta_high_avail():
         raw_essid = cfgget("staessid")
         wifi_avail = False
         # [CHECK 2] check known network is available
-        for idx, essid in enumerate(raw_essid.split(';')):
+        for essid in raw_essid.split(';'):
             essid = essid.strip()
             # Scan wifi network - retry workaround
             for _ in range(0, 2):
@@ -241,7 +261,7 @@ def sta_high_avail():
         if wifi_avail or not ap_if.active():
             # ACTION: Restart micrOS node (boot phase automatically detects nw mode)
             from machine import reset
-            console_write("[Restart] network repair")
+            syslog("[WARN] Restart, network repair")
             reset()
         return f'{cfgget("nwmd")} mode NOK, wifi avail: {wifi_avail}'
     return f'{cfgget("nwmd")} mode OK'

micrOS/source/Server.py

@@ -27,7 +27,7 @@ except:
 if cfgget('webui'):
     from Web import WebEngine
 else:
-    # Create dummy web engine - Laizy loading
+    # Create dummy web engine - Lazy loading
     class WebEngine:
         __slots__ = []
         def __init__(self, *args, **kwargs):
@@ -142,7 +142,7 @@ class Client:
         if Client.ACTIVE_CLIS.get(client_id, None) is not None:
             Client.ACTIVE_CLIS.pop(client_id)
         # Update server task output (? test ?)
-        Manager().server_task_msg(','.join(list(Client.ACTIVE_CLIS)))
+        Manager().task_msg('server', ','.join(list(Client.ACTIVE_CLIS)))
 
     def __del__(self):
         """Client GC collect"""
@@ -158,7 +158,7 @@ class WebCli(Client, WebEngine):
 
     async def run_web(self):
         # Update server task output
-        Manager().server_task_msg(','.join(list(Client.ACTIVE_CLIS)))
+        Manager().task_msg('server', ','.join(list(Client.ACTIVE_CLIS)))
 
         # Run async connection handling
         while self.connected:
@@ -167,7 +167,8 @@ class WebCli(Client, WebEngine):
                 state, request = await self.read()
                 if state:
                     break
-                await self.response(request)
+                if not await self.response(request):
+                    break
             except Exception as e:
                 syslog(f"[ERR] Client.run_web: {e}")
                 break
@@ -175,14 +176,27 @@ class WebCli(Client, WebEngine):
         await self.close()
 
     @staticmethod
-    def register(endpoint, callback):
+    def register(endpoint:str, callback:callable, method:str='GET', auto_enable:bool=True):
+        """
+        :param endpoint: name of the endpoint
+        :param callback: callback function (WebEngine compatible: return:  html_type, content)
+        :param method: HTTP method name
+        :param auto_enable: enable webui when register (endpoint)
+        """
+        if method not in WebEngine.METHODS:
+            raise ValueError(f"method must be one of {WebEngine.METHODS}")
+
+        if cfgget('webui'):
+            if not endpoint in WebEngine.ENDPOINTS:
+                WebEngine.ENDPOINTS[endpoint] = {}
+            WebEngine.ENDPOINTS[endpoint][method] = callback
+            return
         # AUTO ENABLE webui when register (endpoint) called and webui is False
-        if not cfgget('webui'):
+        if auto_enable:
             from Config import cfgput
             if cfgput('webui', True):  # SET webui to True
                 from machine import reset
                 reset()  # HARD RESET (REBOOT)
-        WebEngine.ENDPOINTS[endpoint] = callback
 
 
 class ShellCli(Client, Shell):
@@ -245,7 +259,7 @@ class ShellCli(Client, Shell):
 
     async def run_shell(self):
         # Update server task output
-        Manager().server_task_msg(','.join(list(Client.ACTIVE_CLIS)))
+        Manager().task_msg('server', ','.join(list(Client.ACTIVE_CLIS)))
         # Init prompt
         await self.a_send(self.prompt())
         # Run async connection handling

micrOS/source/Shell.py

@@ -14,7 +14,7 @@ Designed by Marcell Ban aka BxNxM
 from sys import modules
 from machine import reset as hard_reset, soft_reset
 from Config import cfgget, cfgput
-from Files import ilist_fs
+from Files import OSPath, ilist_fs, path_join
 from Tasks import lm_exec
 from Debug import syslog
 
@@ -25,7 +25,7 @@ from Debug import syslog
 
 class Shell:
     __slots__ = ['__devfid', '__auth_mode', '__hwuid', '__auth_ok', '__conf_mode']
-    MICROS_VERSION = '2.13.0-0'
+    MICROS_VERSION = '2.17.1-0'
 
     def __init__(self):
         """
@@ -177,8 +177,8 @@ class Shell:
             await self.a_send("  Postfix hints:")
             await self.a_send("    ... &<x>            - start one-shot task")
             await self.a_send("    ... &&<x>           - start periodic task, where <x>: delay ms [x min: 20ms]")
-            await self.a_send("    ... >>hostname      - remote command execution (intercon)")
             await self.a_send("    ... >json           - request json formatted output")
+            await self.a_send("    ... >>hostname      - remote command execution (intercon)")
             await self.a_send("  help lm           - list ALL available LoadModules")
             if "lm" in str(msg_list):
                 return await Shell._show_lm_funcs(msg_obj=self.a_send)
@@ -257,6 +257,7 @@ class Shell:
         Dump LM module with help function call - in case of [mpy] files
         """
         async def _help(mods):
+            nonlocal mpath
             for lm_path in mods:
                 lm_name = lm_path.replace('LM_', '').split('.')[0]
                 try:
@@ -264,7 +265,7 @@ class Shell:
                     if lm_path.endswith('.mpy'):
                         await msg_obj(f"  {' ' * len(lm_path.replace('LM_', '').split('.')[0])}help")
                         continue
-                    with open(lm_path, 'r') as f:
+                    with open(path_join(mpath, lm_path), 'r') as f:
                         line = "micrOSisTheBest"
                         while line:
                             line = f.readline()
@@ -278,12 +279,14 @@ class Shell:
 
         await msg_obj("")
         # [1] list active modules (default in shell)
+        mpath = OSPath.MODULES
         if active_only:
             mod_keys = modules.keys()
-            active_modules = (dir_mod for dir_mod in ilist_fs(type_filter='f', select="LM") if dir_mod.split('.')[0] in mod_keys)
+            active_modules = (dir_mod for dir_mod in ilist_fs(path=mpath, type_filter='f', select="LM")
+                              if dir_mod.split('.')[0] in mod_keys)
             return await _help(active_modules)
         # [2] list all LMs on file system (ALL - help lm) - manual
-        return await _help(ilist_fs(type_filter='f', select="LM"))
+        return await _help(ilist_fs(path=mpath, type_filter='f', select="LM"))
 
     @staticmethod
     async def webrepl(msg_obj, update=False):

micrOS/source/Tasks.py

@@ -65,6 +65,17 @@ class TaskBase:
                 del TaskBase.TASKS[passive[i]]
             collect()  # GC collect
 
+    @staticmethod
+    async def feed(sleep_ms=1):
+        """
+        Feed event loop
+        :param sleep_ms: in millisecond
+        """
+        # TODO: feed WDT - preemptive cooperative multitasking aka reboot if no feed until X time period
+        if sleep_ms <= 0:
+            return await asyncio.sleep(0.000_000_1)     # 0 means: 100ns (Absolute minimum)
+        return await asyncio.sleep_ms(sleep_ms)
+
     def cancel(self) -> bool:
         """
         Cancel task (+cleanup)
@@ -94,16 +105,16 @@ class TaskBase:
                 del TaskBase.TASKS[self.tag]
         collect()                           # GC collect
 
-    @staticmethod
-    async def feed(sleep_ms=1):
+    async def await_result(self, timeout:int=5):
         """
-        Feed event loop
-        :param sleep_ms: in millisecond
+        Wait for task completion with timeout
+        :param timeout: in seconds
         """
-        # TODO: feed WDT - preemptive cooperative multitasking aka reboot if no feed until X time period
-        if sleep_ms <= 0:
-            return await asyncio.sleep(0.000_000_1)     # 0 means: 100ns (Absolute minimum)
-        return await asyncio.sleep_ms(sleep_ms)
+        try:
+            await asyncio.wait_for(self.done.wait(), timeout)
+        except asyncio.TimeoutError:
+            return "Timeout has beed exceeded"
+        return self.out
 
     def __del__(self):
         try:
@@ -404,11 +415,19 @@ class Manager:
             asyncio.get_event_loop().close()
 
     @staticmethod
-    def server_task_msg(msg):
-        server_task = TaskBase.TASKS.get('server', None)
-        if server_task is None:
-            return
-        server_task.out = msg
+    def task_msg(tag:str, msg:str=None) -> bool|str:
+        """
+        Set/Get task message (for server virtual task, etc.)
+        """
+        _task = TaskBase.TASKS.get(tag, None)
+        if _task is None:
+            return False
+        # Get task output
+        if tag is None:
+            return _task.out
+        # Set task output
+        _task.out = msg
+        return True
 
 
 #################################################################
@@ -467,6 +486,8 @@ def exec_builtins(func):
 
             # Call the decorated function with the additional flag
             return func(arg_list, json_flag)
+        return False, None
+
     return wrapper
 
 

micrOS/source/Web.py

@@ -9,7 +9,7 @@ Built-in-function:
     - "virtual" endpoints                           - to reply from script on a defined endpoint
         - stream                                    - stream data (jpeg) function
 
-Designed by Marcell Ban aka BxNxM
+Designed by Marcell Ban aka BxNxM and szeka9 (GitHub)
 """
 
 from json import dumps, loads
@@ -18,6 +18,10 @@ from Tasks import lm_exec, NativeTask, lm_is_loaded
 from Debug import syslog, console_write
 from Config import cfgget
 from Files import OSPath, path_join
+try:
+    from gc import mem_free, collect
+except:
+    from simgc import mem_free, collect  # simulator mode
 
 
 class WebEngine:
@@ -36,13 +40,18 @@ class WebEngine:
                      "jpeg": "image/jpeg",
                      "png": "image/png",
                      "gif": "image/gif"}
+    METHODS = ("GET", "POST")
+    MEM_LIMITED = (None, 0)
 
     def __init__(self, client, version):
         self.client = client
         WebEngine.VERSION = version
 
+    async def a_send(self, response:str, encode:str='utf8'):
+        raise NotImplementedError("Child class must implement a_send coroutine.")
+
     @staticmethod
-    def file_type(path):
+    def file_type(path:str):
         """File dynamic Content-Type handling"""
         default_type = "text/plain"
         # Extract the file extension
@@ -50,58 +59,78 @@ class WebEngine:
         # Return the content type based on the file extension
         return WebEngine.CONTENT_TYPES.get(ext, default_type)
 
-    async def response(self, request):
-        """HTTP GET REQUEST - WEB INTERFACE"""
-        # Parse request line (first line)
-        _method, url, _version = request.split('\n')[0].split()
-        # Protocol validation
-        if _method != "GET" and _version.startswith('HTTP'):
-            _err = f"Bad Request: not GET HTTP but {_version}"
-            await self.client.a_send(self.REQ400.format(len=len(_err), data=_err))
-            return
+    @staticmethod
+    def is_mem_limited() -> (bool, int):
+        """Check if memory is limited for the FE"""
+        if WebEngine.MEM_LIMITED[0] is None:
+            collect()
+            mfree = int(mem_free() * 0.001)
+            WebEngine.MEM_LIMITED = (mfree < 50, mfree)        # 50 kb memory requirement
+        return WebEngine.MEM_LIMITED
+
+    async def response(self, request:str) -> bool:
+        """HTTP GET/POST REQUEST - WEB INTERFACE"""
+        # [0] PROTOCOL VALIDATION AND PARSING
+        lines = request.splitlines()
+        if not lines:
+            _err = "Empty request"
+            await self.a_send(self.REQ400.format(len=len(_err), data=_err))
+            return True
+        request_parts = lines[0].split()
+        if len(request_parts) != 3:
+            if request_parts[0] not in self.METHODS:
+                # INVALID REQUEST - REQUEST OVERFLOW - NO RESPONSE
+                syslog(f"[WARN] WebCli REQ Overflow: {len(lines[0])}")
+                return False                    # Close connection...
+            _err = "Malformed request line"
+            await self.a_send(self.REQ400.format(len=len(_err), data=_err))
+            return True
+        _method, url, _version = request_parts
+        if _method not in self.METHODS or not _version.startswith('HTTP/'):
+            _err = f"Unsupported method: {_method} {_version}"
+            await self.a_send(self.REQ400.format(len=len(_err), data=_err))
+            return True
 
         # [1] REST API GET ENDPOINT [/rest]
-        if url.startswith('/rest'):
+        if url.startswith('/rest') and _method == "GET":
             self.client.console("[WebCli] --- /rest ACCEPT")
             try:
                 await self.client.a_send(WebEngine.rest(url))
             except Exception as e:
                 await self.client.a_send(self.REQ404.format(len=len(str(e)), data=e))
-            return
+            return True
         # [2] DYNAMIC/USER ENDPOINTS (from Load Modules)
-        if await self.endpoints(url):
-            return
+        payload = lines if _method == "POST" else []
+        if await self.endpoints(url, _method, payload):
+            return True
+        mem_limited, free = self.is_mem_limited()
+        if mem_limited:
+            _err = f"Low memory ({free} kb): serving API only."
+            await self.a_send(self.REQ400.format(len=len(_err), data=_err))
+            return True
         # [3] HOME/PAGE ENDPOINT(s) [default: / -> /index.html]
-        if url.startswith('/'):
+        if url.startswith('/') and _method == "GET":
             resource = 'index.html' if url == '/' else url.replace('/', '')
             web_resource = path_join(OSPath.WEB, resource)                  # Redirect path to web folder
             self.client.console(f"[WebCli] --- {url} ACCEPT -> {web_resource}")
             if resource.split('.')[-1] not in tuple(self.CONTENT_TYPES.keys()):
                 await self.client.a_send(self.REQ404.format(len=27, data='404 Not supported file type'))
-                return
+                return True
             try:
                 # SEND RESOURCE CONTENT: HTML, JS, CSS (WebEngine.CONTENT_TYPES)
                 with open(web_resource, 'r') as file:
                     data = file.read()
                 response = self.REQ200.format(dtype=WebEngine.file_type(resource), len=len(data), data=data)
-                # Send entire response data
+                # Send entire response data (implement chunking if necessary)
                 await self.client.a_send(response)
-
-                # Send chunks of response data (experimental)
-                #response_len, chunk_size, position = len(response), 300, 0
-                #while position < response_len:
-                #    # Calculate the size of the next chunk
-                #    next_chunk_size = min(chunk_size, response_len - position)
-                #    chunk = response[position:position + next_chunk_size]
-                #    await self.client.a_send(chunk)
-                #    position += next_chunk_size
             except Exception as e:
                 if 'memory allocation failed' in str(e):
                     syslog(f"[ERR] WebCli {resource}: {e}")
                 await self.client.a_send(self.REQ404.format(len=13, data='404 Not Found'))
-            return
+            return True
         # INVALID/BAD REQUEST
         await self.client.a_send(self.REQ400.format(len=15, data='400 Bad Request'))
+        return True
 
     @staticmethod
     def rest(url):
@@ -130,9 +159,9 @@ class WebEngine:
         response = dumps(resp_schema)
         return WebEngine.REQ200.format(dtype='text/html', len=len(response), data=response)
 
-    async def endpoints(self, url):
+    async def endpoints(self, url:str, method:str, payload:list):
         url = url[1:]  # Cut first / char
-        if url in WebEngine.ENDPOINTS:
+        if url in WebEngine.ENDPOINTS and method in WebEngine.ENDPOINTS[url]:
             console_write(f"[WebCli] endpoint: {url}")
             # Registered endpoint was found - exec callback
             try:
@@ -141,7 +170,16 @@ class WebEngine:
                 #   one-shot (simple MIME types):    image/jpeg | text/html | text/plain              - data: raw
                 #       task (streaming MIME types): multipart/x-mixed-replace | multipart/form-data  - data: dict{callback,content-type}
                 #                                                                                       content-type: image/jpeg | audio/l16;*
-                dtype, data = WebEngine.ENDPOINTS[url]()
+                if method == "POST":
+                    try:
+                        blank_index = payload.index("")
+                        body_lines = payload[blank_index + 1:]
+                    except ValueError:
+                        body_lines = []
+                    dtype, data = WebEngine.ENDPOINTS[url][method]("\n".join(body_lines))
+                else:
+                    dtype, data = WebEngine.ENDPOINTS[url][method]()
+
                 if dtype == 'image/jpeg':
                     resp = f"HTTP/1.1 200 OK\r\nContent-Type: {dtype}\r\nContent-Length:{len(data)}\r\n\r\n".encode('utf8') + data
                     await self.client.a_send(resp, encode=None)

micrOS/source/micrOS.py

@@ -4,6 +4,13 @@ dedicated to micrOS framework.
 
 Designed by Marcell Ban aka BxNxM
 """
+
+#################################################################
+#                           INIT FS                             #
+#################################################################
+from Files import init_micros_dirs
+init_micros_dirs()
+
 #################################################################
 #                           IMPORTS                             #
 #################################################################

micrOS/source/micrOSloader.py

@@ -1,5 +1,6 @@
 """
 Module is responsible for invoke micrOS or recovery webrepl mode
+[IMPORTANT] This module must never use any micrOS specific functions in main scope.
 
 Designed by Marcell Ban aka BxNxM
 """
@@ -11,11 +12,6 @@ try:
     import traceback
 except:
     traceback = None
-try:
-    from Debug import syslog
-except Exception as e:
-    print(f"[loader] Import error: {e}")
-    syslog = None
 from machine import reset
 
 
@@ -59,6 +55,8 @@ def _is_micrOS():
 
 def __recovery_mode():
     # Recovery/Update mode (webrepl) - dependencies: Network, ConfigHandler
+    from sys import path
+    path.insert(0, "/modules")
     from Network import auto_nw_config
     from Config import cfgget
     pwd = cfgget('appwd')                       # Get pwd from config
@@ -70,9 +68,7 @@ def __recovery_mode():
         import webrepl
         webrepl.start(password=pwd)
     except Exception as e:
-        if callable(syslog):
-            syslog(f"[ERR][micrOSloader] webrepl failed: {e}")
-        print("[loader] Reset .if_mode to micros and reboot")
+        print(f"[loader] webrepl failed: {e} - Reset .if_mode to micros and reboot")
         with open('.if_mode', 'w') as f:
             f.write("micros")
         # Reboot machine
@@ -126,8 +122,6 @@ def main():
             # Handle micrOS system crash (never happened...but) -> webrepl mode default pwd: ADmin123
             print(f"[loader][main mode] micrOS start failed: {e}")
             print("[loader][main mode] -> [recovery mode]")
-            if callable(syslog):
-                syslog(f"[ERR][micrOSloader] start failed: {e}")
     # Recovery aka webrepl mode
     __recovery_mode()
     __auto_restart_event()

micrOS/source/microIO.py

@@ -11,7 +11,7 @@ Designed by Marcell Ban aka BxNxM
 #################################################################
 from sys import platform
 from uos import uname
-from Files import ilist_fs
+from Files import ilist_fs, OSPath
 from Logger import syslog
 
 #################################################################
@@ -68,7 +68,7 @@ def set_pinmap(map_data=None):
 
     # SELECT LOOKUP TABLE BASED ON PLATFORM / User input
     if isinstance(io_file, str) and io_file != 'n/a':
-        if f"IO_{io_file}" in [io.split('.')[0] for io in ilist_fs(type_filter='f', select="IO")]:
+        if f"IO_{io_file}" in [io.split('.')[0] for io in ilist_fs(OSPath.MODULES, type_filter='f', select="IO")]:
             PinMap.MAPPING_LUT = io_file
             return PinMap.MAPPING_LUT
     PinMap.MAPPING_LUT = detect_platform()