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

micrOS/source/modules/LM_L298N.py

@@ -0,0 +1,161 @@
+from machine import Pin, PWM
+from microIO import bind_pin, pinmap_search
+
+
+# Cache of last set motor speeds (motor1, motor2) to ensure state() reports the latest values
+# even if hardware PWM duty readout is delayed or unsupported on some boards
+__MOTOR_SPEEDS = [0, 0] # motor1, motor2
+__L298N_OBJS = []
+
+PWM_FREQ = 50
+# Deprecated LM_L298N_DCmotor: l298speed, l298dir_1, l298dir_2
+PIN_BINDINGS = [
+    ('l298n_ENA', 10), ('l298n_INA', 12), ('l298n_INB', 11),  # motor 1
+    ('l298n_ENB', 3),  ('l298n_INC', 9),  ('l298n_IND', 40),  # motor 2
+]
+STATE_MAP = {
+    (1, 0): 'forward',
+    (0, 1): 'backward',
+    (0, 0): 'coast',
+    (1, 1): 'brake'
+}
+
+
+def __l298n_init():
+    global __L298N_OBJS
+    if not __L298N_OBJS:
+        for index, (name, pin) in enumerate(PIN_BINDINGS):
+            if index % 3 == 0: # PWM pin
+                pwm = PWM(bind_pin(name, pin), freq=PWM_FREQ)
+                pwm.duty(0)
+                __L298N_OBJS.append(pwm)
+            else:
+                p = Pin(bind_pin(name, pin), Pin.OUT)
+                p.value(0)
+                __L298N_OBJS.append(p)
+    return __L298N_OBJS
+
+
+def __get_motor_state(motor_index):
+    objlist = __l298n_init()
+    pwm_index = motor_index * 3
+    in1, in2 = objlist[pwm_index + 1].value(), objlist[pwm_index + 2].value()
+    state = STATE_MAP.get((in1, in2), 'unknown')
+    return {'speed': __MOTOR_SPEEDS[motor_index], 'state': state}
+
+
+#########################
+# Application functions #
+#########################
+
+def load(pwm_freq:int=None):
+    """
+    [i] micrOS LM naming convention
+    Load the L298N motor driver module
+    """
+    global PWM_FREQ
+    if pwm_freq is not None:
+        PWM_FREQ = pwm_freq
+    __l298n_init()
+    return "Motor driver loaded successfully."
+
+
+def state(motor=0):
+    """
+    [i] micrOS LM naming convention
+    Get the current state of a motor or all motors
+    :param motor: Motor number (1 or 2) or None for all motors
+    """
+    if motor == 1:
+        return {'motor1': __get_motor_state(0)}
+    elif motor == 2:
+        return {'motor2': __get_motor_state(1)}
+    else:
+        return {
+            'motor1': __get_motor_state(0),
+            'motor2': __get_motor_state(1)
+        }
+
+
+def _control_motor(motor, in1, in2):
+    objlist = __l298n_init()
+    motor_index = 0 if motor == 1 else 3
+    objlist[motor_index + 1].value(in1)
+    objlist[motor_index + 2].value(in2)
+
+
+def speed(motor, speed:int=1023):
+    """
+    Set the speed of a motor
+    :param motor: Motor number (1 or 2)
+    :param speed: Speed value (0-1023)
+    :return: Current motor state
+    """
+    if not (0 <= speed <= 1023):
+        return {'speed': 'value range error'}
+    pwm_index = 0 if motor == 1 else 3
+    motor_index = 0 if motor == 1 else 1
+    __l298n_init()[pwm_index].duty(speed)
+    __MOTOR_SPEEDS[motor_index] = speed
+    return state(motor)
+
+
+def direction(motor, forward: bool=True):
+    """
+    Set the direction of a motor
+    :param motor: Motor number (1 or 2)
+    :param forward: True if motor should move forward, False if backward
+    :return: Current motor state
+    """
+    _control_motor(motor, 1 if forward else 0, 0 if forward else 1)
+    return state(motor)
+
+
+def coast(motor):
+    """
+    Coast the motor
+    :param motor: Motor number (1 or 2)
+    """
+    _control_motor(motor, 0, 0)
+    return state(motor)
+
+
+def brake(motor):
+    """
+    Brake the motor
+    :param motor: Motor number (1 or 2)
+    :return: Current motor state
+    """
+    _control_motor(motor, 1, 1)
+    return state(motor)
+
+
+#######################
+# LM helper functions #
+#######################
+
+def pinmap():
+    """
+    [i] micrOS LM naming convention
+    Shows logical pins - pin number(s) used by this Load module
+    - info which pins to use for this application
+    :return dict: pin name (str) - pin value (int) pairs
+    """
+    return pinmap_search([name for name, _ in PIN_BINDINGS])
+
+
+def help(widgets=False):
+    """
+    [i] micrOS LM naming convention - built-in help message
+    :return tuple:
+        (widgets=False) list of functions implemented by this application
+        (widgets=True) list of widget json for UI generation
+    """
+    return (
+        'speed motor=<1/2> speed=<0-1023>', 
+        'direction motor=<1/2> forward=<True/False>',
+        'coast motor=<1/2>',
+        'brake motor=<1/2>',
+        'state motor=<0/1/2>',
+        'pinmap'
+    )

micrOS/source/modules/LM_cluster.py

@@ -0,0 +1,250 @@
+"""
+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(3000)
+        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..."
+            _channel = 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)"
+                    _channel = c
+
+            if not _initialized or _channel != Cluster.CHANNEL:
+                Cluster.CHANNEL = _channel
+                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=_channel)
+                    except Exception as e:
+                        my_task.out = f"STA Failed to set {_channel} channel: {e}"
+                # ensure AP advertises/operates on the same channel (important when STA not connected yet)
+                try: ap.config(channel=_channel)
+                except Exception as e:
+                    my_task.out = f"AP Failed to set {_channel} channel: {e}"
+                _initialized = True
+            await my_task.feed(_refresh_ms)
+
+
+def __configure_cluster_network(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
+
+    # CONFIGURE WIFI CHANNEL SYNC ROLES
+    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()
+        _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()
+    return 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
+    out = __configure_cluster_network(anchor)
+    return f"Enable cluster module access\n{out}"
+
+
+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.*")

{toolkit/workspace/precompiled → micrOS/source/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,36 @@
+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 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 help():
+    """
+    ESPNOW sender/receiver with LM execution
+    """
+    return ('handshake peer=<mac-address>',
+            'send peer=<peer-name> cmd="hello"',
+            'stats')

micrOS/source/{LM_i2c.py → modules/LM_i2c.py}

@@ -26,7 +26,7 @@ def discover():
     """
     known_addresses = {hex(0x0A): "TRACKBALL", hex(0x3c): "OLED",
                        hex(0x76): "BME280", hex(0x10): 'VEML7700',
-                       hex(0x6b): "QMI8658"}
+                       hex(0x6b): "QMI8658", hex(0x29): 'TCS3472'}
     devices = scan()
     output = {"unknown": []}
     for k in devices:

micrOS/source/{LM_light_sensor.py → modules/LM_light_sensor.py}

@@ -73,13 +73,13 @@ async def _task(on, off, threshold, tolerance=2, check_ms=5000):
             if percent <= threshold:
                 if on != last_ev:
                     host = on[0]
-                    state, _ = exec_cmd(on[1:] + [f">>{host}"], jsonify=True, skip_check=True)
+                    state, _ = exec_cmd(on[1:] + [f">>{host}"], jsonify=True)
                     my_task.out = f"{percent}% <= threshold: {threshold}% - ON [{'OK' if state else 'NOK'}]"
                     last_ev = on
             elif percent > threshold+tolerance:     # +tolerance to avoid "on/off/on/off" on threshold limit
                 if off != last_ev:
                     host = off[0]
-                    state, _ = exec_cmd(off[1:] + [f">>{host}"], jsonify=True, skip_check=True)
+                    state, _ = exec_cmd(off[1:] + [f">>{host}"], jsonify=True)
                     my_task.out = f"{percent}% > threshold: {threshold+tolerance}% - OFF [{'OK' if state else 'NOK'}]"
                     last_ev = off
             await my_task.feed(sleep_ms=check_ms)   # Sample every <check_ms> sec