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

micrOS/source/modules/LM_cluster.py

@@ -0,0 +1,255 @@
+"""
+micrOS ESPNow cluster module.
+  -- STA/AP Channel sync            [OK]
+  -- wifi settings sync             [OK]
+  -- health (cluster availability)  [OK]
+  -- cluster run <cmd>              [OK]
+ShellCli (socket) extension (todo)
+  -- health (cluster availability)
+"""
+
+from binascii import hexlify
+from machine import soft_reset
+from Config import cfgget, cfgput
+from Network import _select_available_wifi_nw, ifconfig, WLAN, STA_IF, AP_IF
+from Common import micro_task, exec_cmd, syslog
+if cfgget("espnow"):
+    from Espnow import ESPNowSS
+    ESPNOW = ESPNowSS()
+else:
+    ESPNOW = None
+
+class Cluster:
+    CHANNEL = 6                     # Leader channel to align with
+    ANCHOR_SSID_POSTFIX = "-mCSA"   # micrOS (Wifi) Channel Sync Anchor
+    ANCHOR_ENABLED = False          # Anchor indicator
+    REFRESH_MS = 20 * 60_000        # 20min - refresh channel sync period (AP mode)
+
+#########################################################
+#           CLUSTER - LOCAL EXECUTION "ON TARGET"       #
+#########################################################
+
+@micro_task("cluster", _wrap=True)
+async def _reboot(tag:str):
+    """
+    Restart in the background
+    (Enable function return before restart...)
+    """
+    with micro_task(tag) as my_task:
+        await my_task.feed(5000)
+        soft_reset()
+
+
+def _update_wifi(ssid:str, pwd:str):
+    """
+    Local Config Setter - Add WiFi settings
+    :param ssid: str - SSID
+    :param pwd: str - Password
+    """
+    def _update_sta_config():
+        nonlocal _ssid, _pwd
+        essids = cfgget("staessid")
+        passwords = cfgget("stapwd")
+        if _ssid in essids:
+            # [INFO] No password refresh is supported
+            return f"Wifi already known: {ssid}"
+        # Deserialize wifi settings from config file
+        essids_list = essids.split(";")
+        passwords_list = passwords.split(";")
+        # Extend with new wifi settings
+        essids_list.append(_ssid)
+        passwords_list.append(_pwd)
+        # Serialize back wifi settings to config file
+        cfgput("staessid",";".join(essids_list))
+        cfgput("stapwd", ";".join(passwords_list))
+        # REBOOT
+        _reboot()
+        return "Soft reboot, apply wifi settings"
+
+    if ';' in ssid or ';' in pwd:
+        return "Unsupported character in ssid or pwd ;"
+    # Check Wifi settings
+    if cfgget("nwmd").upper() == "STA":
+        # Check current wifi state
+        if ifconfig()[0] == "STA":
+            return "Device already connected to WiFi"
+        # Validate wifi essid is available
+        _ssid, _pwd = _select_available_wifi_nw(ssid, pwd)
+        if _ssid is None:
+            return f"Wifi SSID not available: {ssid}"
+        return _update_sta_config()
+    return "Wifi is in Access Point mode, skip sync"
+
+
+def _run(cmd:str):
+    state, out = exec_cmd(cmd.split(), secure=True)
+    return f"[{'OK' if state else 'NOK'}] {out}"
+
+
+@micro_task("cluster", _wrap=True)
+async def _align_channel(tag:str, sta:STA_IF, ap:AP_IF):
+    _initialized = False
+
+    with micro_task(tag) as my_task:
+        while True:
+            my_task.out = "Sync in progress..."
+            ch = Cluster.CHANNEL
+            _refresh_ms = Cluster.REFRESH_MS
+            for s, b, c, *_ in sta.scan():
+                sta_name = (s.decode() if isinstance(s, bytes) else s)
+                if sta_name.endswith(Cluster.ANCHOR_SSID_POSTFIX):
+                    my_task.out = f"Anchor {sta_name} channel: {c} (refresh: {int(_refresh_ms/60_000)}min)"
+                    ch = c
+                    break
+
+            if not _initialized or ch != Cluster.CHANNEL:
+                Cluster.CHANNEL = ch
+                if not sta.isconnected():
+                    # ENABLE ESPNOW STA MAC ACCESS - AFTER THIS ALL DEVICES CAN REACH EACH OTHER ON STA MAC ADDRESS
+                    try: sta.config(channel=ch)
+                    except Exception as e:
+                        my_task.out = f"STA Failed to set {ch} channel: {e}"
+                # ensure AP advertises/operates on the same channel (important when STA not connected yet)
+                try: ap.config(channel=ch)
+                except Exception as e:
+                    my_task.out = f"AP Failed to set {ch} channel: {e}"
+                _initialized = True
+            await my_task.feed(_refresh_ms)
+
+
+@micro_task("cluster", _wrap=True)
+async def _network(tag:str, anchor=False):
+    """
+    Support hybrid AP/STA ESPNow communication
+    For ESPNow communication all device should use the same Wifi channel!
+    - LEADER: STA*/AP mode - *channel is set by the router and can change
+    - AP deices should use the same channel as ANCHOR (discovery by leader/anchor(STA) over AP anchor)
+    - ESPNOW: STA mac addresses are stored on ANCHOR
+    :param anchor: enable anchor mode (AP) for ESPNow channel synchronization
+    """
+    def _conf_ap_anchor():
+        _ap = WLAN(AP_IF)
+        if not _ap.active(): _ap.active(True)
+        anchor_ssid = f"{cfgget('devfid')}{Cluster.ANCHOR_SSID_POSTFIX}"
+        try:
+            _ap.config(essid=anchor_ssid, password=cfgget("appwd"), authmode=3, max_clients=5)
+            return True
+        except Exception as e:
+            syslog(f"[ERR] Anchor configuration failed: {e}")
+        return False
+    def _enable_sta():
+        sta = WLAN(STA_IF)
+        if not sta.active(): sta.active(True)
+        return sta
+
+    with micro_task(tag) as my_task:
+        # CONFIGURE WIFI CHANNEL SYNC ROLES
+        my_task.out = "Configure cluster network"
+        micros_nw = ifconfig()[0]
+        # MICROS in STA MODE
+        if micros_nw == "STA":
+            if anchor:
+                # CREATE CHANNEL ANCHOR - AP channel is inherited from STA
+                Cluster.ANCHOR_ENABLED = _conf_ap_anchor()
+        else:
+            # MICROS in AP MODE: CLUSTER FOLLOWER - WIFI CHANNEL SYNC WITH ANCHOR
+            ap, sta = WLAN(AP_IF), _enable_sta()
+            # Sync Channel with Cluster Anchor
+            _align_channel(sta, ap)
+            if anchor:
+                # MICROS in AP MODE - RECONFIGURE AP NAME to match Anchor
+                # EXPERIMENTAL FEATURE: Scans and Advertise the channel as well.
+                Cluster.ANCHOR_ENABLED = _conf_ap_anchor()
+        my_task.out = status()
+
+#########################################################
+#                 CLUSTER WIDE FEATURES                 #
+#########################################################
+
+def sync_wifi():
+    """
+    ESPNow Cluster Wifi Settings Sync for Station (STA) Connection Mode
+    - Join devices to the same wifi network...
+    """
+    if ESPNOW is None:
+        return "ESPNow is disabled"
+    # Check current wifi state
+    if ifconfig()[0] != "STA":
+        return "No WiFi STA Connection: no verified settings to share"
+    # [1] Get current wifi ssid and password
+    _ssid, _pwd = _select_available_wifi_nw(cfgget("staessid"), cfgget("stapwd"))
+    # [2] Send command: 'cluster _update_wifi "<ssid>" "<pwd>"'
+    command = f"cluster _update_wifi '{_ssid}' '{_pwd}'"
+    sync_tasks = ESPNOW.cluster_send(command)
+    return sync_tasks
+
+
+def run(cmd:str):
+    """
+    Run a command on the cluster
+    :param cmd: str - command to run on the cluster
+        Example: cmd='system heartbeat'
+    """
+    command = f"cluster _run '{cmd}'"
+    sync_tasks = ESPNOW.cluster_send(command)
+    return sync_tasks
+
+
+def health():
+    """
+    Simple connection check
+    - with default espnow-micros hello message
+    """
+    if ESPNOW is None:
+        return "ESPNow is disabled"
+    return ESPNOW.cluster_send("hello")
+
+
+def members():
+    """
+    List all members in the cluster
+    """
+    if ESPNOW is None:
+        return "ESPNow is disabled"
+    return {hexlify(mac, ':').decode(): name for mac, name in ESPNOW.devices.items()}
+
+
+def status():
+    """
+    Cluster setup status
+    """
+    nw_if = ifconfig()[0]
+    cluster_settings = {"channel": Cluster.CHANNEL, "primary_nw": nw_if,
+                        "anchor": Cluster.ANCHOR_ENABLED}
+    if nw_if == "AP":
+        cluster_settings["refresh"] = Cluster.REFRESH_MS
+    return cluster_settings
+
+
+def load(anchor:bool=False, refresh:int=None):
+    """
+    Enable ESPNow protocol 'cluster' module access
+    :param anchor: create AP as Channel Anchor (Channel Leader Role)
+    :param refresh: refresh channel sync period in minute (AP)
+    """
+    if ESPNOW is None:
+        return "ESPNow is disabled"
+    if refresh is not None:
+        Cluster.REFRESH_MS = 60_000 if refresh < 1 else refresh * 60_000
+    # Configure cluster network - after micrOS network setup
+    _network(anchor)
+    return f"Enable cluster module access"
+
+
+def help(widgets=True):
+    """
+    [BETA]
+    Show help for cluster commands
+    """
+    return ("load anchor=False refresh=20",
+            "run 'command'",
+            "sync_wifi",
+            "health",
+            "members",
+            "status",
+            "[Info] Get command results:\n\ttask show con.espnow.*")

micrOS/source/{LM_co2.py → modules/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 → modules/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 → modules/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 → modules/LM_dimmer.py}

@@ -1,6 +1,6 @@
 from sys import platform
-from microIO import resolve_pin, pinmap_search
-from Common import transition_gen, micro_task
+from microIO import bind_pin, pinmap_search
+from Common import transition_gen, micro_task, data_dir
 from utime import sleep_ms
 from Types import resolve
 
@@ -15,6 +15,7 @@ class Data:
     PERSISTENT_CACHE = False
     DIMM_TASK_TAG = "dimmer._tran"
     TASK_STATE = False
+    FILE_CACHE = data_dir('dimmer.cache')
 
 
 #########################################
@@ -24,7 +25,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:
@@ -34,7 +35,7 @@ def __dimmer_init():
 
 def __persistent_cache_manager(mode='r'):
     """
-    pds - persistent data structure
+    File cache
     modes:
         r - recover, s - save
     """
@@ -42,12 +43,12 @@ def __persistent_cache_manager(mode='r'):
         return
     if mode == 's':
         # SAVE CACHE
-        with open('dimmer.pds', 'w') as f:
+        with open(Data.FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in Data.DIMMER_CACHE]))
         return
     try:
         # RESTORE CACHE
-        with open('dimmer.pds', 'r') as f:
+        with open(Data.FILE_CACHE, 'r') as f:
             Data.DIMMER_CACHE = [int(data) for data in f.read().strip().split(',')]
     except:
         pass
@@ -71,7 +72,7 @@ def load(cache=None):
     """
     Initialize dimmer module
     :param cache bool: file state machine cache: True/False/None(default: automatic True)
-    - Load .pds (state machine cache) for this load module
+    - Load .cache (state machine cache) for this load module
     - Apply loaded states to gpio pins (boot function)
     :return str: Cache state
     """
@@ -183,8 +184,7 @@ def transition(value, sec=1.0, wake=False):
     # Create transition generator and calculate step_ms
     fade_gen, fade_step_ms = transition_gen(from_dim, value, interval_sec=sec)
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.DIMM_TASK_TAG, task=_task(ms_period=fade_step_ms, iterable=fade_gen))
-    return "Starting transition" if state else "Transition already running"
+    return micro_task(tag=Data.DIMM_TASK_TAG, task=_task(ms_period=fade_step_ms, iterable=fade_gen))
 
 
 def subscribe_presence():

micrOS/source/{LM_distance.py → modules/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)
@@ -70,9 +70,7 @@ def start_dimmer_indicator(idle_distance=180):
     """Distance visualization on LED brightness (LM_dimmer)"""
     from LM_dimmer import set_value
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag="distance.visual", task=__task(period_ms=200, dimmer=set_value, idle_cm=idle_distance))
-    return "Starting" if state else "Already running"
-
+    return micro_task(tag="distance.visual", task=__task(period_ms=200, dimmer=set_value, idle_cm=idle_distance))
 
 
 #########################

micrOS/source/{LM_ds18.py → modules/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
 

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

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