micrOSDevToolKit 2.9.6__py3-none-any.whl → 2.9.8__py3-none-any.whl

micrOS/release_info/micrOS_ReleaseInfo/system_analysis_sum.json

@@ -58,14 +58,14 @@
         ],
         "Debug.py": [
             8.4,
-            17
+            18
         ],
         "Network.py": [
             9.71,
             8
         ],
         "Espnow.py": [
-            9.01,
+            8.86,
             1
         ],
         "Scheduler.py": [
@@ -73,7 +73,7 @@
             1
         ],
         "microIO.py": [
-            9.38,
+            9.42,
             42
         ],
         "micrOS.py": [
@@ -105,7 +105,7 @@
             0
         ],
         "LM_genIO.py": [
-            9.19,
+            9.12,
             0
         ],
         "LM_oled_ui.py": [
@@ -149,7 +149,7 @@
             0
         ],
         "LM_buzzer.py": [
-            8.88,
+            8.8,
             0
         ],
         "LM_switch.py": [
@@ -177,11 +177,11 @@
             0
         ],
         "LM_neopixel.py": [
-            7.57,
+            7.54,
             2
         ],
         "LM_cct.py": [
-            8.82,
+            9.03,
             1
         ],
         "LM_L9110_DCmotor.py": [
@@ -249,7 +249,7 @@
             0
         ],
         "LM_rgb.py": [
-            8.65,
+            8.82,
             1
         ],
         "LM_distance.py": [
@@ -315,11 +315,11 @@
     },
     "summary": {
         "core": [
-            3305,
+            3358,
             23
         ],
         "load": [
-            9060,
+            9061,
             55
         ],
         "core_dep": [
@@ -332,6 +332,6 @@
         ],
         "core_score": 9.13,
         "load_score": 8.23,
-        "version": "2.9.6-0"
+        "version": "2.9.8-0"
     }
 }

micrOS/source/Espnow.py

@@ -1,112 +1,146 @@
-import uasyncio as asyncio
 from aioespnow import AIOESPNow
 from binascii import hexlify
-from Tasks import NativeTask, TaskBase
+from Tasks import NativeTask, TaskBase, lm_exec, lm_is_loaded
 from Network import get_mac
 from Config import cfgget
+from Debug import errlog_add
 
-# https://docs.micropython.org/en/latest/library/espnow.html
+# Configuration values and globals
 _INSTANCE = None
-_DEVFID = cfgget('devfid')
-
+_DEVFID = cfgget('devfid')  # for example, "node01"
 
 async def asend(now, mac, msg):
-    prompt = f"{_DEVFID}$"
-    msg = f"{msg}\n{prompt}".encode("utf-8")
-    return await now.asend(mac, msg)
-
+    """
+    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.
+    """
+    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)
 
-def execute(msg, my_task):
-    msg_in = msg.decode('utf-8')
-    if msg_in.strip().endswith("$"):
-        my_task.out = f"MSG-IN: {msg_in}"
-        data = msg_in.split("\n")
-        prompt, command = data[0], data[1]
-        msg_out = f"RUN CMD: {command} ON {prompt.replace('$', '')}"
-        # TODO: execute command
-        return True, msg_out
-    return False, ""
+def _serv_execute(msg, my_task):
+    """
+    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.
+    """
+    try:
+        command_line = msg.decode('utf-8').strip()
+    except UnicodeError:
+        my_task.out = "[NOW SERVE] Invalid encoding"
+        return False, "Invalid encoding"
+
+    # 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):
+        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
 
-# Echo any received messages back to the sender
 async def _server(now):
+    """
+    ESPNow server task that continuously waits for incoming messages and processes commands.
+    """
     with TaskBase.TASKS.get('espnow.server', None) as my_task:
         async for mac, msg in now:
             try:
-                msg_ready, msg = execute(msg, my_task)
-                if msg_ready:
-                    await asend(now, mac, msg)
+                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)
-                    msg_ready, msg = execute(msg, my_task)
-                    if msg_ready:
-                        await asend(now, mac, msg)
+                    state, response = _serv_execute(msg, my_task)
+                    if state:
+                        await asend(now, mac, response)
+                    else:
+                        errlog_add(response)
+                else:
+                    # Optionally handle or log other OSErrors here.
+                    errlog_add(f"[ERR][NOW SERVER] {err}")
 
-
-# Send a periodic ping to a peer
 async def _send(now, peer, tag, msg):
-    with TaskBase.TASKS.get(tag) as my_task:
+    """
+    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 = "Peer not responding"
+            my_task.out = "[NOW SEND] Peer not responding"
         else:
-            my_task.out = f"send msg: {msg}"
-
+            my_task.out = f"[NOW SEND] {msg}"
 
 ###################################################
 #                   Control functions             #
 ###################################################
 def initialize():
     """
-    Initialize ESPNow protocol
+    Initialize the ESPNow protocol. (WLAN must be active.)
     """
-    # Network module: WLAN interface must be active to send()/recv()
     global _INSTANCE
     if _INSTANCE is None:
-        now = AIOESPNow()  # Returns AIOESPNow enhanced with async support
+        now = AIOESPNow()  # Instance with async support
         now.active(True)
         _INSTANCE = now
     return _INSTANCE
 
-
 def add_peer(now, peer):
     """
-    Add peer by mac address
-    :param now: espnow instance
-    :param peer: binary mac address of a peer, like b'\xbb\xbb\xbb\xbb\xbb\xbb'
+    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').
     """
-    return now.add_peer(peer)
-
+    now.add_peer(peer)
+    return "Peer register done"
 
 def espnow_server():
     """
-    Start async ESPNow receiver server
+    Start the async ESPNow receiver server.
     """
     now = initialize()
-    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
+    # 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 espnow_send(peer, msg):
     """
-    Send message/command over ESPNow protocol
-    :param peer: binary mac address of another device
-    :param msg: string message to send
+    Send a command over ESPNow.
+    :param peer: Binary MAC address of another device.
+    :param msg: String command message to send.
     """
     now = initialize()
-    mac = hexlify(peer, ':').decode()
-    task_id = f"espnow.cli.{mac}"
-    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
+    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
+    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:
@@ -119,9 +153,8 @@ def stats():
         _peers = str(e)
     return {"stats": _stats, "peers": _peers}
 
-
 def mac_address():
     """
-    Get binary mac address
+    Get the binary MAC address.
     """
     return get_mac()

micrOS/source/LM_L298N_DCmotor.py

@@ -1,5 +1,5 @@
 from machine import Pin, PWM
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 
 #########################################
 #     ANALOG DIMMER CONTROLLER PARAMS   #
@@ -15,9 +15,9 @@ __L298N_OBJS = []
 def __l298n_init():
     global __L298N_OBJS
     if len(__L298N_OBJS) == 0:
-        __L298N_OBJS.append(PWM(Pin(resolve_pin('l298speed')), freq=50))
-        __L298N_OBJS.append(Pin(resolve_pin('l298dir_1'), Pin.OUT))
-        __L298N_OBJS.append(Pin(resolve_pin('l298dir_2'), Pin.OUT))
+        __L298N_OBJS.append(PWM(Pin(bind_pin('l298speed')), freq=50))
+        __L298N_OBJS.append(Pin(bind_pin('l298dir_1'), Pin.OUT))
+        __L298N_OBJS.append(Pin(bind_pin('l298dir_2'), Pin.OUT))
         __L298N_OBJS[0].duty(0)     # Set default speed (PWM)
         __L298N_OBJS[1].value(0)    # Set default direction for dc motor1
         __L298N_OBJS[2].value(1)    # Set default direction for dc motor1

micrOS/source/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

micrOS/source/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

micrOS/source/LM_aht10.py

@@ -1,5 +1,5 @@
 from machine import I2C, Pin
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Common import syslog
 from time import sleep
 from binascii import hexlify
@@ -24,7 +24,7 @@ def _handle_connection_error(f):
 
 class AHT10:
     def __init__(self, address = 0x38):
-        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
         if not self.init_sensor():
             raise Exception("Could not initialize the sensor!")

micrOS/source/LM_bme280.py

@@ -6,7 +6,7 @@ https://randomnerdtutorials.com/micropython-bme280-esp32-esp8266/
 
 import utime as time
 from machine import Pin, I2C
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Common import notify
 from Types import resolve
 
@@ -299,7 +299,7 @@ class BME280:
 def __init_bme280_i2c():
     global BME280_OBJ
     if BME280_OBJ is None:
-        i2c = I2C(scl=Pin(resolve_pin('i2c_scl')), sda=Pin(resolve_pin('i2c_sda')), freq=10000)
+        i2c = I2C(scl=Pin(bind_pin('i2c_scl')), sda=Pin(bind_pin('i2c_sda')), freq=10000)
         BME280_OBJ = BME280(i2c=i2c)
     return BME280_OBJ
 

micrOS/source/LM_buzzer.py

@@ -1,6 +1,6 @@
 from sys import platform
 from utime import sleep
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Common import micro_task, notify
 from Types import resolve
 
@@ -175,15 +175,15 @@ def _builtin_tones(tone=None):
 #########################################
 
 
-def __buzzer_init():
+def __buzzer_init(pin=None):
+    """
+    :param pin: optional number to overwrite default pin
+    """
     global __BUZZER_OBJ
     if __BUZZER_OBJ is None:
         from machine import Pin, PWM
-        dimmer_pin = Pin(resolve_pin('buzzer'))
-        if platform == 'esp8266':
-            __BUZZER_OBJ = PWM(dimmer_pin, freq=600)
-        else:
-            __BUZZER_OBJ = PWM(dimmer_pin, freq=600)
+        dimmer_pin = Pin(bind_pin('buzzer', number=pin))
+        __BUZZER_OBJ = PWM(dimmer_pin, freq=600)
         __BUZZER_OBJ.duty(512)      # 50%
     return __BUZZER_OBJ
 
@@ -283,23 +283,20 @@ def list_tones():
     return '\n'.join(list(_builtin_tones()))
 
 
-def load(cache=None, check_notify=False):
+def load(check_notify=False, pin=None, cache=True):
     """
     Initialize buzzer module
-    :param cache bool: file state machine cache: True/False/None(default: automatic True)
-    - Load .pds (state machine cache) for this load module
-    - Apply loaded states to gpio pins (boot function)
     :param check_notify: check notify enabled/disabled - make noise if enabled only
+    :param pin: optional number to overwrite default pin
+    :param cache: default True, store stages on disk (.pds)
     :return str: Verdict
     """
     from sys import platform
     global __PERSISTENT_CACHE, CHECK_NOTIFY
-    if cache is None:
-        __PERSISTENT_CACHE = False if platform == 'esp8266' else True
-    else:
-        __PERSISTENT_CACHE = cache
+    __PERSISTENT_CACHE = cache
     __persistent_cache_manager('r')
     CHECK_NOTIFY = check_notify
+    __buzzer_init(pin=pin)
     return f"CACHE: {__PERSISTENT_CACHE}, check notify: {CHECK_NOTIFY}"
 
 

micrOS/source/LM_cct.py

@@ -5,7 +5,7 @@ from machine import Pin, PWM
 from sys import platform
 from utime import sleep_ms
 from Common import transition_gen, micro_task
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from random import randint
 from Types import resolve
 
@@ -24,10 +24,10 @@ class Data:
 #      ANALOG CCT WITH 2 channel PWM    #
 #########################################
 
-def __cwww_init():
+def __cwww_init(pin_warm=None, pin_cold=None):
     if Data.CWWW_OBJS[0] is None or Data.CWWW_OBJS[1] is None:
-        cw = Pin(resolve_pin('cwhite'))
-        ww = Pin(resolve_pin('wwhite'))
+        cw = Pin(bind_pin('cwhite', pin_cold))
+        ww = Pin(bind_pin('wwhite', pin_warm))
         if platform == 'esp8266':
             Data.CWWW_OBJS = (PWM(cw, freq=1024),
                               PWM(ww, freq=1024))
@@ -72,19 +72,16 @@ def __state_machine(c, w):
 # Application functions #
 #########################
 
-def load(cache=None):
+def load(pin_warm=None, pin_cold=None, cache=True):
     """
     Initialize Cold white / Warm white LED module
-    :param cache bool: file state machine cache: True/False/None(default: automatic True)
-    - Load .pds (state machine cache) for this load module
-    - Apply loaded states to gpio pins (boot function)
+    :param pin_warm: optional number to overwrite default pin
+    :param pin_cold: optional number to overwrite default pin
+    :param cache: save/load state machine to disk (.pds)
     :return str: Cache state
     """
-    from sys import platform
-    if cache is None:
-        Data.PERSISTENT_CACHE = False if platform == 'esp8266' else True
-    else:
-        Data.PERSISTENT_CACHE = cache
+    __cwww_init(pin_warm, pin_cold)
+    Data.PERSISTENT_CACHE = cache
     __persistent_cache_manager('r')        # recover data cache
     if Data.CWWW_CACHE[2] == 1:
         Data.CWWW_CACHE[2] = 0             # Force ON at boot

micrOS/source/LM_co2.py

@@ -1,7 +1,7 @@
 from math import pow
 from sys import platform
 from machine import ADC, Pin
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Types import resolve
 
 #########################################
@@ -20,10 +20,10 @@ def __get_resistance():
     global __ADC, __ADC_PROP
     if __ADC is None:
         if 'esp8266' in platform:
-            __ADC = ADC(resolve_pin('co2'))      # 1V measure range
+            __ADC = ADC(bind_pin('co2'))      # 1V measure range
             __ADC_PROP = (1023, 1.0)
         else:
-            __ADC = ADC(Pin(resolve_pin('co2')))
+            __ADC = ADC(Pin(bind_pin('co2')))
             __ADC.atten(ADC.ATTN_11DB)                          # 3.6V measure range
             __ADC.width(ADC.WIDTH_10BIT)                        # Default 10 bit ADC
             __ADC_PROP = (1023, 3.6)

micrOS/source/LM_dht11.py

@@ -1,4 +1,4 @@
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Common import data_logger
 from Types import resolve
 
@@ -14,7 +14,7 @@ def __init_DHT11():
     if __DHT_OBJ is None:
         from dht import DHT11
         from machine import Pin
-        __DHT_OBJ = DHT11(Pin(resolve_pin('dhtpin')))
+        __DHT_OBJ = DHT11(Pin(bind_pin('dhtpin')))
     return __DHT_OBJ
 
 

micrOS/source/LM_dht22.py

@@ -1,4 +1,4 @@
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Common import data_logger
 from Types import resolve
 
@@ -14,7 +14,7 @@ def __init_DHT22():
     if __DHT_OBJ is None:
         from dht import DHT22
         from machine import Pin
-        __DHT_OBJ = DHT22(Pin(resolve_pin('dhtpin')))
+        __DHT_OBJ = DHT22(Pin(bind_pin('dhtpin')))
     return __DHT_OBJ
 
 

micrOS/source/LM_dimmer.py

@@ -1,5 +1,5 @@
 from sys import platform
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Common import transition_gen, micro_task
 from utime import sleep_ms
 from Types import resolve
@@ -24,7 +24,7 @@ class Data:
 def __dimmer_init():
     if Data.DIMMER_OBJ is None:
         from machine import Pin, PWM
-        dimmer_pin = Pin(resolve_pin('dim_1'))
+        dimmer_pin = Pin(bind_pin('dim_1'))
         if platform == 'esp8266':
             Data.DIMMER_OBJ = PWM(dimmer_pin, freq=1024)
         else:

micrOS/source/LM_distance.py

@@ -1,6 +1,6 @@
 from machine import Pin, time_pulse_us
 from utime import sleep_us
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Common import micro_task
 from Types import resolve
 
@@ -14,8 +14,8 @@ def __init_HCSR04():
     """
     global __TRIGGER_OBJ, __ECHO_OBJ
     if __TRIGGER_OBJ is None or __ECHO_OBJ is None:
-        trigger_pin = resolve_pin('hcsrtrig')
-        echo_pin = resolve_pin('hcsrecho')
+        trigger_pin = bind_pin('hcsrtrig')
+        echo_pin = bind_pin('hcsrecho')
         # Init trigger pin (out)
         __TRIGGER_OBJ = Pin(trigger_pin, mode=Pin.OUT, pull=None)
         __TRIGGER_OBJ.value(0)

micrOS/source/LM_ds18.py

@@ -1,5 +1,5 @@
 import machine, onewire, ds18x20, time
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Types import resolve
 
 DS_OBJ = None
@@ -8,7 +8,7 @@ DS_OBJ = None
 def __init_DS18():
     global DS_OBJ
     if DS_OBJ is None:
-        ds_pin = machine.Pin(resolve_pin('ds18'))
+        ds_pin = machine.Pin(bind_pin('ds18'))
         DS_OBJ = ds18x20.DS18X20(onewire.OneWire(ds_pin))
     return DS_OBJ