micrOSDevToolKit 2.9.1__py3-none-any.whl → 2.26.1__py3-none-any.whl

toolkit/simulator_lib/uasyncio.py

@@ -1,8 +1,16 @@
 import asyncio
+import ssl
 
+ssl_context = ssl.create_default_context()
+ssl_context.check_hostname = False  # Disable hostname check
+ssl_context.verify_mode = ssl.CERT_NONE  # Disable certificate verification
+
+class TimeoutError(Exception):
+    pass
 
 def open_connection(host, port, ssl=False):
-    return asyncio.open_connection(host, port, ssl=ssl)
+    #return asyncio.open_connection(host, port, ssl=ssl)
+    return asyncio.open_connection(host, port, ssl=ssl_context if ssl else None)
 
 
 class Lock(asyncio.Lock):
@@ -13,6 +21,10 @@ class Event(asyncio.Event):
     pass
 
 
+async def wait_for(fut, timeout):
+    return asyncio.wait_for(fut, timeout)
+
+
 async def sleep(sec):
     await asyncio.sleep(sec)
 
@@ -22,7 +34,26 @@ async def sleep_ms(ms):
 
 
 def get_event_loop():
-    return asyncio.get_event_loop()
+    """
+    Returns asyncio.EventLoop
+    """
+    try:
+        # LEGACY: NOT WORKS FROM PYTHON 3.13
+        # BUT THIS IS THE MICROPYTHON WAY...
+        return asyncio.get_event_loop()
+    except Exception as e:
+        print(f"[SIM] get_event_loop exception: {e}")
+    # PYTHON <3.13 NEW WAY
+    try:
+        # Check running event loop
+        # MICROPYTHON HAS A SINGLE EVENT LOOP
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        # Create event loop with new method
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    # return new "singleton" event loop
+    return loop
 
 
 class Event:

toolkit/simulator_lib/uos.py

@@ -0,0 +1,147 @@
+import os
+import stat as py_fs_stat
+
+# https://docs.micropython.org/en/v1.9.2/pyboard/library/uos.html
+# https://docs.micropython.org/en/v1.18/library/os.html
+
+MOCK_SIM = False
+
+def listdir(path=None):
+    if path is None:
+        return os.listdir()
+    path = __mock_sim_dir(path)
+    print(f"[uos.SIM] listdir: {path}")
+    return os.listdir(path)
+
+
+def getcwd():
+    _cwd = os.getcwd()
+    if MOCK_SIM:
+        cwd = f"{_cwd}/../workspace/simulator/"
+        print(f"MOCK PATH: {cwd}")
+    elif "workspace/simulator" not in _cwd:
+        cwd = f"{_cwd}/toolkit/workspace/simulator/"
+        print(f"[uos.SIM] MOCK PATH: {_cwd} -> {cwd}")
+    else:
+        cwd = _cwd
+    return cwd
+
+
+def __mock_sim_dir(path):
+    """
+    micropython sim hack
+    """
+    cwd = getcwd()
+    cwd = cwd if cwd.endswith(os.sep) else f"{cwd}{os.sep}"                 # CHECK AND FIX CWD / ENDING
+    if MOCK_SIM or "workspace/simulator" not in path:
+        path = f"{cwd}{path}"
+        if MOCK_SIM:
+            print(f"[!!!] [uos.SIM][MOCK:{MOCK_SIM}] CWD PATH HACK: {path}")
+    return path
+
+
+def ilistdir(path):
+    buffer = []
+    for filename in listdir(path):
+        _name, _type, _inode = filename, stat(f"{path}/{filename}")[0], 0
+        print(f"[uos.SIM] ilistdir {path}: ({_name}, {_type:#x}, {_inode}")
+        buffer.append((_name, _type, _inode))
+    return tuple(buffer)
+
+
+def mkdir(path):
+    print(f"[uos.SIM] mkdir: {path}")
+    return os.mkdir(path)
+
+
+def remove(path):
+    path = __mock_sim_dir(path)
+    print(f"[uos.SIM] remove: {path}")
+    if "simulator" in path and path.replace('/', '').endswith('simulator'):
+        print(f"\t[uos.SIM] rmdir: Invalid path! {path}")
+        return False
+    return os.remove(path)
+
+
+def rename(old_path, new_path):
+    old_path, new_path = __mock_sim_dir(old_path),  __mock_sim_dir(new_path)
+    print(f"[uos.SIM] rename: {old_path} -> {new_path}")
+    os.rename(old_path, new_path)
+
+
+def _stat_eval(stat_result):
+    """
+    micropython converter
+    """
+    micropython_file_identifier = {'dir': 0x4000, 'file': 0x8000}
+    file_type_0 = 0x0                       # file type
+    file_size_6 = py_fs_stat.ST_SIZE        # bytes
+    file_time_8 = py_fs_stat.ST_MTIME       # file modified time - only on some micropython ports
+    file_time_9 = py_fs_stat.ST_CTIME       # creation time - only on some micropython ports
+    # Check if it's a file
+    if py_fs_stat.S_ISREG(stat_result.st_mode):
+        # FILE
+        file_type_0 = micropython_file_identifier['file']
+    if py_fs_stat.S_ISDIR(stat_result.st_mode):
+        # DIRECTORY
+        file_type_0 = micropython_file_identifier['dir']
+    # https://github.com/micropython/micropython-lib/blob/master/python-stdlib/stat/stat.py
+    #           0       1  2  3  4  5       6       7      8            9
+    return file_type_0, 0, 0, 0, 0, 0, file_size_6, 0, file_time_8, file_time_9
+
+
+def stat(path):
+    path = __mock_sim_dir(path)
+    stat_result = os.stat(path)
+    micropython_stat_result = _stat_eval(stat_result)
+    path_type = 'dir' if micropython_stat_result[0] & 0x4000 else 'file'
+    print(f"[uos.SIM] stat: {path} {path_type}({micropython_stat_result[0]:#x})")
+    return micropython_stat_result
+
+
+def rmdir(path):
+    path = __mock_sim_dir(path)
+    print(f"[uos.SIM] rmdir: {path}")
+    if "simulator" in path and path.replace('/', '').endswith('simulator'):
+        print(f"\t[uos.SIM] rmdir: Invalid path! {path}")
+        return False
+    return os.rmdir(path)
+
+
+def statvfs(path=None):
+    if path is None:
+        return os.statvfs(__mock_sim_dir(path))
+    return os.statvfs(path)
+
+
+def uname():
+    return os.uname()
+
+
+def sync():
+    print("[uos.SIM] sync - dummy")
+
+
+def urandom(n):
+    print(f"[uos.SIM] sync {n}")
+    return os.urandom(n)
+
+
+def dupterm(stream_object):
+    print("[uos.SIM] dupterm - dummy")
+
+
+def mount(*args, **kwargs):
+    print("[uos.SIM] mount - dummy")
+
+
+def umount(*args, **kwargs):
+    print("[uos.SIM] unmount - dummy")
+
+
+if __name__  == "__main__":
+    MOCK_SIM = True
+    print(f"SIM root (mock: {MOCK_SIM}): {__mock_sim_dir('/')}\ngetcwd: {getcwd()}")
+    print(listdir("/"))
+    print(stat('/'))
+    print(ilistdir('/'))

toolkit/simulator_lib/urandom.py

@@ -0,0 +1,4 @@
+import random as _random
+
+def getrandbits(k):
+    return _random.getrandbits(k)

toolkit/socketClient.py

@@ -4,7 +4,6 @@
 import sys
 import socket
 import os
-import select
 import time
 import json
 import threading
@@ -186,8 +185,8 @@ class ConnectionData:
             return None, None, None, None
 
     @staticmethod
-    def nodes_status():
-        spr_offset1 = 30
+    def nodes_status(feature_stat=True):
+        spr_offset1 = 25
         spr_offset2 = 57
 
         def _dev_status(ip, port, fuid, uid):
@@ -200,6 +199,10 @@ class ConnectionData:
                     Colors.WARN, Colors.NC)
                 version_data = '<n/a>'
                 elapsed_time = 'n/a'
+                webui_state = 'n/a'
+                espnow_state  = 'n/a'
+                cron_state = 'n/a'
+                timirq_state = 'n/a'
                 online_ip = None
 
                 # is online
@@ -207,25 +210,40 @@ class ConnectionData:
                     # get version data
                     online_ip = ip
                     try:
+                        connection = SocketDictClient(host=ip, port=port, silent_mode=True, tout=3)
+                        # Get version and elapsed time data
                         start_comm = time.time()
-                        version_data = SocketDictClient(host=ip, port=port, silent_mode=True, tout=3).non_interactive(['version'])
+                        version_data = connection.non_interactive(['version'])
                         elapsed_time = "{:.3f}".format(time.time() - start_comm)
-                    except:
-                        pass
+                        if feature_stat:
+                            # Get active features info
+                            webui_state = connection.non_interactive(['conf', 'webui'])
+                            espnow_state = connection.non_interactive(['conf', 'espnow'])
+                            cron_state = connection.non_interactive(['conf', 'cron'])
+                            timirq_state = connection.non_interactive(['conf', 'timirq'])
+                    except Exception as e:
+                        print(f"Getting device version {fuid}:{uid} error: {e}")
 
                 # Generate line printout
                 base_info = "{uid}{spr1}{fuid}".format(uid=uid, spr1=spacer1, fuid=fuid)
                 spacer1 = " " * (spr_offset2 - len(base_info))
-                data_line_str = "{base}{spr2}{ip}\t{stat}\t\t{version}\t\t{elapt}" \
-                    .format(base=base_info, spr2=spacer1, ip=ip,
-                            stat=is_online, version=version_data, elapt=elapsed_time)
+                spacer2 = "\t" if len(version_data) > 7 else "\t\t"
+                feature_info = ""
+                if feature_stat:
+                    _on_str = f"{Colors.OKGREEN}{Colors.BOLD}ON {Colors.NC}"
+                    _off_str = f"{Colors.BOLD}OFF{Colors.NC}"
+                    _fspacer = " "*6
+                    bool2str = lambda x: _on_str if x.strip() == "True" else _off_str if x != "n/a" else x
+                    feature_info = f"\t\t{bool2str(webui_state)}{_fspacer}{bool2str(espnow_state)}{_fspacer}{bool2str(cron_state)}{_fspacer}{bool2str(timirq_state)}"
+                data_line_str = f"{base_info}{spacer1}{ip}\t{is_online}\t\t{version_data}{spacer2}{elapsed_time}{feature_info}"
                 return data_line_str, online_ip
             return None
 
         nodes_dict = ConnectionData.read_micrOS_device_cache()
-        spacer1 = " " * (spr_offset1 - 14)
-        print("{cols}       [ UID ]{spr1}[ FUID ]\t\t[ IP ]\t\t[ STATUS ]\t[ VERSION ]\t[COMM SEC]{cole}"
-              .format(spr1=spacer1, cols=Colors.OKBLUE + Colors.BOLD, cole=Colors.NC))
+        spacer1 = " " * (spr_offset1 - 8)
+        feature_header_str = "\t[WEBUI | ESPNOW | CRON | TIMIRQ]" if feature_stat else ""
+        print("{cols}[ UID ]{spr1}[ FUID ]\t\t[ IP ]\t\t[ STATUS ]\t[ VERSION ]\t[COMM SEC]{features}{cole}"
+              .format(spr1=spacer1, cols=Colors.OKBLUE + Colors.BOLD, features=feature_header_str, cole=Colors.NC))
 
         # Start parallel status queries
         query_list = []
@@ -341,7 +359,7 @@ class SocketDictClient:
 #########################################################
 
 
-def main(args, host='127.0.0.1', port=9008, timeout=3, pwd=None, verbose=False):
+def main(args, host='127.0.0.1', port=9008, timeout=5, pwd=None, verbose=False):
     """ main connection wrapper function """
     answer_msg = None
 
@@ -388,7 +406,6 @@ def socket_commandline_args(arg_list):
             arg = 'status'
         keywords = list(return_action_dict.keys())
         if arg in keywords:
-            print(arg)
             if return_action_dict[arg] is None:
                 return_action_dict[arg] = arg_list[i+1]
                 _skip = True
@@ -418,25 +435,28 @@ def socket_commandline_args(arg_list):
         print("--list / list\t\t- list mocrOS devices")
         print("HINT:\t\t\t- In non interactive mode just list command(s) as last parameters.\n\t\t\t"
               "Also you can pipe commands with <a> separator.")
-        print("HINT:\t\t\t\t- Example: --dev node01 system clock")
-        print("HINT:\t\t\t\t- Example: --dev node01 --pwd ADmin123 system clock")
+        print("HINT:\t\t\t\t- Example: --dev node01 'system clock'")
+        print("HINT:\t\t\t\t- Example: --dev node01 --pwd ADmin123 'system clock'")
         sys.exit(0)
-    if '<a>' in command_buffer:
-        return ' '.join(command_buffer), return_action_dict
-    return ' <a> '.join(command_buffer), return_action_dict
+    result =  command_buffer, return_action_dict
+    print(f"SocketClient: {result}")
+    return result
 
 
-def run(arg_list=[], timeout=5):
+def run(arg_list=None, timeout=10, verbose=False):
     """ Run from code
         - Handles extra command line arguments
     """
+    if arg_list is None:
+        arg_list = []
     #print("Socket run (raw): {}".format(arg_list))
     args, action = socket_commandline_args(arg_list)
     host, port, fid, uid = ConnectionData.auto_execute(search=action['search'], status=action['status'], dev=action['device_tag'])
     output = False, ''
     try:
         #print("Socket run (args): {}".format(args))
-        output = main(args, host=host, port=port, timeout=timeout, pwd=action['password'], verbose=action['verbose'])
+        verbose = verbose or action['verbose']
+        output = main(args, host=host, port=port, timeout=timeout, pwd=action['password'], verbose=verbose)
     except Exception as e:
         if "TimeOut" in str(e):
             print("Resolve device by host ... {}.local {}:{}:{}".format(fid, host, port, uid))
@@ -451,5 +471,5 @@ def connection_metrics(host):
 
 if __name__ == "__main__":
     """Runs in individual - direct execution mode"""
-    arg_list = sys.argv[1:]
-    run(arg_list=arg_list)
+    arglist = sys.argv[1:]
+    run(arg_list=arglist)

toolkit/user_data/webhooks/generic.py

@@ -2,7 +2,7 @@
 
 """
 Generic webhook for socketClient that can invoke LoadModule calls remotely from any device.
-Example: http://10.0.1.61:5000/webhooks/generic/TinyDevBoard+system+clock
+Example: http://10.0.1.61:5005/webhooks/generic/TinyDevBoard+system+clock
 """
 
 import sys, os

toolkit/user_data/webhooks/macro.py

@@ -3,7 +3,7 @@
 """
 Template for webhook creation
 - replies with basic response message
-Example: http://10.0.1.61:5000/webhooks/template
+Example: http://10.0.1.61:5005/webhooks/template
 """
 
 import sys, os

toolkit/user_data/webhooks/template.py

@@ -3,7 +3,7 @@
 """
 Template for webhook creation
 - replies with basic response message
-Example: http://10.0.1.61:5000/webhooks/template
+Example: http://10.0.1.61:5005/webhooks/template
 """
 
 import sys, os

toolkit/workspace/precompiled/_mpy.version

@@ -1 +1 @@
-1.20.0
+1.24.1

{micrOS/source → toolkit/workspace/precompiled/modules}/LM_L9110_DCmotor.py

@@ -1,4 +1,4 @@
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin,  pinmap_search
 
 #########################################
 #     ANALOG DIMMER CONTROLLER PARAMS   #
@@ -15,8 +15,8 @@ def __l9110_init():
     global __L9110_OBJS
     if len(__L9110_OBJS) == 0:
         from machine import Pin, PWM
-        __L9110_OBJS.append(PWM(Pin(resolve_pin('l9110dir_1')), freq=1024))
-        __L9110_OBJS.append(PWM(Pin(resolve_pin('l9110dir_2')), freq=1024))
+        __L9110_OBJS.append(PWM(Pin(bind_pin('l9110dir_1')), freq=1024))
+        __L9110_OBJS.append(PWM(Pin(bind_pin('l9110dir_2')), freq=1024))
         __L9110_OBJS[0].duty(0)     # Set default speed (PWM)
         __L9110_OBJS[1].duty(0)     # Set default speed (PWM)
     return __L9110_OBJS

toolkit/workspace/precompiled/{LM_VL53L0X.py → modules/LM_VL53L0X.py}

@@ -2,7 +2,7 @@ from micropython import const
 import ustruct
 import utime
 from machine import I2C, Pin
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 
 __TOF_OBJ = None
 
@@ -31,7 +31,7 @@ class TimeoutError(RuntimeError):
 
 class VL53L0X:
     def __init__(self, address=57):
-        self.i2c = I2C(-1, Pin(resolve_pin('i2c_scl')), Pin(resolve_pin('i2c_sda')), freq=9600)
+        self.i2c = I2C(-1, Pin(bind_pin('i2c_scl')), Pin(bind_pin('i2c_sda')), freq=9600)
         self.address = address
         self.init()
         self._started = False
@@ -343,7 +343,7 @@ class VL53L0X:
 
 def measure():
     """
-    Experimental
+    Experimental - Time of Flight Distance Sensor
     """
     global __TOF_OBJ
     if __TOF_OBJ is None:

toolkit/workspace/precompiled/{LM_esp32.py → modules/LM_esp32.py}

@@ -18,6 +18,11 @@ def temp():
     """
     Measure CPU temperature
     """
+    try:
+        cpu_temp = esp32.mcu_temperature()
+        return {'MCU temp [C]': int(cpu_temp)}
+    except:
+        pass
     try:
         raw_temp =  esp32.raw_temperature()
     except Exception as e:

toolkit/workspace/precompiled/modules/LM_espnow.py

@@ -0,0 +1,53 @@
+from Espnow import ESPNowSS
+ESPNOW = ESPNowSS()
+
+
+def send(peer:bytes|str, cmd:str='modules'):
+    """
+    Send message to peer (by mac address)
+    :param peer: mac address of espnow device
+    :param cmd: message string/load module call
+    """
+    return ESPNOW.send(peer, cmd)
+
+def stats():
+    """
+    Get ESPNOW stats
+    """
+    return ESPNOW.stats()
+
+
+def members():
+    """
+    Get ESPNow devices
+    """
+    return ESPNOW.members()
+
+
+def handshake(peer:bytes|str):
+    """
+    Handshake with ESPNow Peer
+    :param peer: mac address of espnow device
+    - device name detection
+    - address:name caching
+    """
+    return ESPNOW.handshake(peer)
+
+
+def remove(peer:bytes):
+    """
+    Remove peer by binary mac address
+    :param peer: binary mac address of espnow device
+    """
+    return ESPNOW.remove_peer(peer)
+
+
+def help():
+    """
+    ESPNOW sender/receiver with LM execution
+    """
+    return ('handshake peer=<mac-address>',
+            'send peer=<peer-name> cmd="hello"',
+            'remove peer=<binary-mac-address>',
+            'stats',
+            'members')

{micrOS/source → toolkit/workspace/precompiled/modules}/LM_i2c.py

@@ -1,4 +1,4 @@
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 
 __I2C = None
 
@@ -7,7 +7,7 @@ def __init():
     global __I2C
     if __I2C is None:
         from machine import Pin, I2C
-        __I2C = I2C(-1, Pin(resolve_pin('i2c_scl')), Pin(resolve_pin('i2c_sda')))
+        __I2C = I2C(-1, Pin(bind_pin('i2c_scl')), Pin(bind_pin('i2c_sda')))
     return __I2C
 
 
@@ -24,8 +24,9 @@ def discover():
     """
     Discover devices
     """
-    known_addresses = {hex(0x0A): "trackball", hex(0x3c): "oled",
-                       hex(0x76): "bme280", hex(0x10): 'veml7700'}
+    known_addresses = {hex(0x0A): "TRACKBALL", hex(0x3c): "OLED",
+                       hex(0x76): "BME280", hex(0x10): 'VEML7700',
+                       hex(0x6b): "QMI8658", hex(0x29): 'TCS3472'}
     devices = scan()
     output = {"unknown": []}
     for k in devices: