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

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')

toolkit/workspace/precompiled/modules/LM_i2c.py

@@ -0,0 +1,61 @@
+from microIO import bind_pin, pinmap_search
+
+__I2C = None
+
+
+def __init():
+    global __I2C
+    if __I2C is None:
+        from machine import Pin, I2C
+        __I2C = I2C(-1, Pin(bind_pin('i2c_scl')), Pin(bind_pin('i2c_sda')))
+    return __I2C
+
+
+def scan():
+    """
+    I2C scan function - experimental
+    :return list: list of devices
+    """
+    devices = [ hex(device) for device in  __init().scan() ]
+    return devices
+
+
+def discover():
+    """
+    Discover devices
+    """
+    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:
+        if k in known_addresses:
+            device_name = known_addresses[k]
+            output[device_name] = k
+        else:
+            output["unknown"].append(k)
+    return output
+
+#######################
+# 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(['i2c_scl', 'i2c_sda'])
+
+
+def help(widgets=False):
+    """
+    [BETA][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 'scan', 'discover', 'pinmap'

toolkit/workspace/precompiled/modules/LM_mh_z19c.py

@@ -0,0 +1,198 @@
+"""
+MH-Z19 Co2 sensor driver for MicroPython (supports MH-Z19B and MH-Z19C)
+
+Provides a simple interface to read:
+    - Co2 concentration (PPM)
+    - Temperature
+    - Status
+
+Calibration (MH-Z19C)
+---------------------
+There are two ways to calibrate the zero point on MH-Z19C:
+
+1) Apply a low-level signal for more than 7 seconds.
+
+2) Send the calibration command:
+   FF 01 87 00 00 00 00 00 78
+   On success the sensor returns:
+   FF 87 01 00 00 00 00 00 78
+
+Auto-calibration (ABC) period
+-----------------------------
+Set 7-day automatic calibration period:
+    Command:      FF 01 AF 01 07 00 00 00 48
+    Confirmation: FF AF 01 07 00 00 00 00 49
+
+Set 1-day automatic calibration period:
+    Command:      FF 01 AF 01 01 00 00 00 4E
+    Confirmation: FF AF 01 01 00 00 00 00 4F
+
+Notes
+-----
+- Use a well-ventilated environment (around 400 ppm) for command-based zero calibration
+
+:author: Florian Mandl
+:version: 1.0
+:date: 2025-12-06
+"""
+
+import time
+import json
+from machine import Pin, UART
+from microIO import bind_pin, pinmap_search
+from Common import micro_task, manage_task, console, notify
+from Types import resolve
+
+
+class MHZ19:
+    INSTANCE = None
+
+    SENSOR_TASK = 'mh_z19c.sensor'
+    CALIBRATE_TASK = 'mh_z19c.calibrate'
+
+    def __init__(self):
+        self.uart_no = 1
+        self.ppm = 0
+        self.temp = 0
+        self.co2status = 0
+        self.tx_pin = Pin(bind_pin('mh_z19c_tx',16))
+        self.rx_pin = Pin(bind_pin('mh_z19c_rx',17))
+        self.hd_pin = Pin(bind_pin('mh_z19c_hd',19), Pin.OUT, Pin.PULL_UP)
+        self.start()
+
+    def start(self):
+        self.uart = UART(self.uart_no, baudrate=9600, tx=self.tx_pin, rx=self.rx_pin)
+        self.uart.init(9600, bits=8, parity=None, stop=1, timeout=10)
+
+    def stop(self):
+        while self.uart.any():
+            self.uart.read()
+        self.uart.deinit()
+
+    def get_data(self):
+        # Clear buffer
+        while self.uart.any():
+            self.uart.read()
+
+        self.uart.write(b"\xff\x01\x86\x00\x00\x00\x00\x00\x79")
+        time.sleep(0.1)
+        s = self.uart.read(9)
+        if not s or len(s) < 9:
+            return False
+        if self._crc8(s) != s[8]:
+            self.stop()
+            time.sleep(0.1)
+            self.start()
+            return False
+        self.ppm = s[2] * 256 + s[3]
+        self.temp = s[4] - 40
+        self.co2status = s[5]
+        return True
+
+    async def calibrate(self):
+        with micro_task(tag=self.CALIBRATE_TASK) as my_task:
+            try:
+                self.stop()
+                self.hd_pin.value(0)
+                await my_task.feed(sleep_ms=8000)
+                self.hd_pin.value(1)
+                self.start()
+                console("Calibration finished")
+            except Exception as e:
+                console(f"Calibration error: {e}")
+
+    @staticmethod
+    def _crc8(a):
+        crc = sum(bytearray(a)[1:8]) % 256
+        crc = (~crc & 0xFF) + 1
+        return crc
+
+#########################
+# Application functions #
+#########################
+
+def load():
+    """
+    Create MH-Z19 CO2 sensor (over UART)
+    """
+
+    if MHZ19.INSTANCE is None:
+        MHZ19.INSTANCE = MHZ19()
+    return MHZ19.INSTANCE
+
+
+def measure():
+    """
+    Measure with MH-Z19 CO2 sensor
+    """
+    mhz19 = load()
+    mhz19.get_data()
+    return {"ppm": mhz19.ppm,
+            "temp": mhz19.temp,
+            "status": mhz19.co2status}
+
+
+def calibrate():
+    """
+    Calibrate MH-Z19 sensor
+    """
+    mhz19 = load()
+    return micro_task(tag=MHZ19.CALIBRATE_TASK, task=mhz19.calibrate())
+
+
+async def _run_sensor_loop(interval, topic, channels):
+    channels = [] if channels is None else channels
+    with micro_task(tag=MHZ19.SENSOR_TASK) as my_task:
+        while True:
+            my_task.out = "Start measurement"
+            out = notify(json.dumps(measure()), topic=topic, channels=channels)
+            my_task.out = f"Measurement published: {out}, wait {interval}ms"
+            await my_task.feed(sleep_ms=interval)
+
+
+def start(interval:int=5000, topic:str="MH_Z19C", channels:list=None):
+    """
+    Start sensor measurement loop and publish results over micros notify feature
+    :param interval: update interval in milliseconds
+    :param topic: for MQTT channel, default: MH_Z19C
+    :param channels: selected notification channels, ex.: ["MQTT"], default: None (all)
+    """
+    load()
+    return micro_task(tag=MHZ19.SENSOR_TASK, task=_run_sensor_loop(interval, topic, channels))
+
+
+def stop():
+    """
+    Stop sensor measurement loop and publish, delete MHZ19.INSTANCE
+    """
+    mhz19 = load()
+    manage_task(MHZ19.SENSOR_TASK, "kill")
+    if mhz19:
+        mhz19.stop()
+        MHZ19.INSTANCE = None
+    return f"{MHZ19.SENSOR_TASK}: Stopped"
+
+#######################
+# 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(['mh_z19c_tx', 'mh_z19c_rx', 'mh_z19c_hd'])
+
+
+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 resolve(('load',
+                    'BUTTON start interval=5000',
+                    'BUTTON stop', 'TEXTBOX measure', 'calibrate', 'pinmap'), widgets=widgets)

toolkit/workspace/precompiled/modules/LM_qmi8658.py

@@ -0,0 +1,204 @@
+"""
+A simple driver for the QMI8658 IMU.
+https://github.com/echo-lalia/qmi8658-micropython/blob/main/qmi8685.py
+"""
+
+import struct
+import time
+from machine import Pin, I2C
+from micropython import const
+from microIO import bind_pin, pinmap_search
+
+
+# Sensor constants
+_QMI8685_PARTID = const(0x05)
+_REG_PARTID = const(0x00)
+_REG_REVISION = const(0x01)
+
+_REG_CTRL1 = const(0x02)  # Serial interface and sensor enable
+_REG_CTRL2 = const(0x03)  # Accelerometer settings
+_REG_CTRL3 = const(0x04)  # Gyroscope settings
+_REG_CTRL4 = const(0x05)  # Magnetomer settings (support not implemented in this driver yet)
+_REG_CTRL5 = const(0x06)  # Sensor data processing settings
+_REG_CTRL6 = const(0x07)  # Attitude Engine ODR and Motion on Demand
+_REG_CTRL7 = const(0x08)  # Enable Sensors and Configure Data Reads
+
+_REG_TEMP = const(0x33)  # Temperature sensor.
+
+_REG_AX_L = const(0x35)  # Read accelerometer
+_REG_AX_H = const(0x36)
+_REG_AY_L = const(0x37)
+_REG_AY_H = const(0x38)
+_REG_AZ_L = const(0x39)
+_REG_AZ_H = const(0x3A)
+
+_REG_GX_L = const(0x3B)  # read gyro
+_REG_GX_H = const(0x3C)
+_REG_GY_L = const(0x3D)
+_REG_GY_H = const(0x3E)
+_REG_GZ_L = const(0x3F)
+_REG_GZ_H = const(0x40)
+
+_QMI8658_I2CADDR_DEFAULT = const(0X6B)
+
+
+_ACCELSCALE_RANGE_2G = const(0b00)
+_ACCELSCALE_RANGE_4G = const(0b01)
+_ACCELSCALE_RANGE_8G = const(0b10)
+_ACCELSCALE_RANGE_16G = const(0b11)
+
+_GYROSCALE_RANGE_16DPS = const(0b000)
+_GYROSCALE_RANGE_32DPS = const(0b001)
+_GYROSCALE_RANGE_64DPS = const(0b010)
+_GYROSCALE_RANGE_128DPS = const(0b011)
+_GYROSCALE_RANGE_256DPS = const(0b100)
+_GYROSCALE_RANGE_512DPS = const(0b101)
+_GYROSCALE_RANGE_1024DPS = const(0b110)
+_GYROSCALE_RANGE_2048DPS = const(0b111)
+
+_ODR_8000HZ = const(0b0000)
+_ODR_4000HZ = const(0b0001)
+_ODR_2000HZ = const(0b0010)
+_ODR_1000HZ = const(0b0011)
+_ODR_500HZ = const(0b0100)
+_ODR_250HZ = const(0b0101)
+_ODR_125HZ = const(0b0110)
+_ODR_62_5HZ = const(0b0111)
+
+
+class QMI8658:
+    """QMI8658 inertial measurement unit."""
+    INSTANCE = None
+
+    def __init__(
+            self,
+            i2c_bus: I2C,
+            address: int = _QMI8658_I2CADDR_DEFAULT,
+            accel_scale: int = _ACCELSCALE_RANGE_8G,
+            gyro_scale: int = _GYROSCALE_RANGE_256DPS):
+        """Read from a sensor on the given I2C bus, at the given address."""
+        self.i2c = i2c_bus
+        self.address = address
+        # Cache the sensor instance globally for easy access
+        QMI8658.INSTANCE = self
+
+        # Verify sensor part ID
+        if self._read_u8(_REG_PARTID) != _QMI8685_PARTID:
+            raise AttributeError("Cannot find a QMI8658")
+
+        # Setup initial configuration
+        self._configure_sensor(accel_scale, gyro_scale)
+
+        # Configure scales/divisors for the driver
+        self.acc_scale_divisor = {
+            _ACCELSCALE_RANGE_2G: 1 << 14,
+            _ACCELSCALE_RANGE_4G: 1 << 13,
+            _ACCELSCALE_RANGE_8G: 1 << 12,
+            _ACCELSCALE_RANGE_16G: 1 << 11,
+        }[accel_scale]
+
+        self.gyro_scale_divisor = {
+            _GYROSCALE_RANGE_16DPS: 2048,
+            _GYROSCALE_RANGE_32DPS: 1024,
+            _GYROSCALE_RANGE_64DPS: 512,
+            _GYROSCALE_RANGE_128DPS: 256,
+            _GYROSCALE_RANGE_256DPS: 128,
+            _GYROSCALE_RANGE_512DPS: 64,
+            _GYROSCALE_RANGE_1024DPS: 32,
+            _GYROSCALE_RANGE_2048DPS: 16,
+        }[gyro_scale]
+
+
+    def _configure_sensor(self, accel_scale: int, gyro_scale: int):
+        # Initialize accelerometer and gyroscope settings
+        self._write_u8(_REG_CTRL1, 0x60)  # Set SPI auto increment and big endian (Ctrl 1)
+        self._write_u8(_REG_CTRL2, (accel_scale << 4) | _ODR_1000HZ)  # Accel Config
+        self._write_u8(_REG_CTRL3, (gyro_scale << 4) | _ODR_1000HZ)  # Gyro Config
+        self._write_u8(_REG_CTRL5, 0x01)  # Low-pass filter enable
+        self._write_u8(_REG_CTRL7, 0x03)  # Enable accel and gyro
+        time.sleep_ms(100)
+
+
+    # Helper functions for register operations
+    def _read_u8(self, reg:int) -> int:
+        return self.i2c.readfrom_mem(self.address, reg, 1)[0]
+
+    def _read_xyz(self, reg:int) -> tuple[int, int, int]:
+        data = self.i2c.readfrom_mem(self.address, reg, 6)
+        return struct.unpack('<hhh', data)
+
+    def _write_u8(self, reg: int, value: int):
+        self.i2c.writeto_mem(self.address, reg, bytes([value]))
+
+
+    @property
+    def temperature(self) -> float:
+        """Get the device temperature."""
+        temp_raw = self._read_u8(_REG_TEMP)
+        return temp_raw / 256
+
+    @property
+    def acceleration(self) -> tuple[float, float, float]:
+        """Get current acceleration reading."""
+        raw_accel = self._read_xyz(_REG_AX_L)
+        return tuple(val / self.acc_scale_divisor for val in raw_accel)
+
+    @property
+    def gyro(self) -> tuple[float, float, float]:
+        """Get current gyroscope reading."""
+        raw_gyro = self._read_xyz(_REG_GX_L)
+        return tuple(val / self.gyro_scale_divisor for val in raw_gyro)
+
+#######################
+#   Public functions  #
+#######################
+
+def load():
+    """
+    Load the QMI8658 sensor instance.
+    The QMI8658 is a motion sensor that measures acceleration, angular velocity (gyroscope), and temperature
+    """
+    if QMI8658.INSTANCE is None:
+        QMI8658(I2C(0, sda=Pin(bind_pin('i2c_sda')), scl=Pin(bind_pin('i2c_scl'))))
+    return QMI8658.INSTANCE
+
+
+def temperature():
+    return load().temperature
+
+
+def acceleration():
+    return load().acceleration
+
+
+def gyro():
+    return load().gyro
+
+
+def measure():
+    inst = load()
+    return {"temp": inst.temperature, "accel": inst.acceleration, "gyro": inst.gyro}
+
+
+#######################
+# 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(['i2c_scl', 'i2c_sda'])
+
+
+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 'load', 'temperature', 'acceleration', 'gyro', 'measure', 'pinmap'

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

@@ -1,7 +1,8 @@
 from machine import Pin
 import micropython
 from Common import socket_stream, syslog
-from microIO import physical_pin, pinmap_dump
+from microIO import bind_pin, pinmap_search
+from Types import resolve
 
 # https://www.coderdojotc.org/micropython/sensors/10-rotary-encoder/
 
@@ -42,27 +43,43 @@ class Rotary:
 
 class Data:
     ROTARY_OBJ = None
-    VAL = 0
     EVENT = True
+    VAL = 0
+    MIN_VAL = 0
+    MAX_VAL = 20
+    COLOR = (None, ())
 
 
 def _rotary_changed(change):
     if change == Rotary.ROT_CW:
         Data.EVENT = True
         Data.VAL = Data.VAL + 1
+        if Data.VAL > Data.MAX_VAL:
+            Data.VAL = Data.MIN_VAL
     elif change == Rotary.ROT_CCW:
         Data.EVENT = True
         Data.VAL = Data.VAL - 1
+        if Data.VAL < Data.MIN_VAL:
+            Data.VAL = Data.MAX_VAL
+    # Color on neopixel
+    if callable(Data.COLOR[0]):
+        try:
+            r, g, b = Data.COLOR[1][Data.VAL]
+            Data.COLOR[0](r, g, b)
+        except Exception as e:
+            syslog(f"[ERR] rencoder color: {e}")
 
 
-def load_n_init():
+def load(min_val=0, max_val=20):
     """
     Create rotary encoder
     """
     if Data.ROTARY_OBJ is None:
         # GPIO Pins 33 and 35 are for the encoder pins.
-        Data.ROTARY_OBJ = Rotary(physical_pin('rot_dt'), physical_pin('rot_clk'))
-        Data.VAL = 0
+        Data.ROTARY_OBJ = Rotary(bind_pin('rot_dt'), bind_pin('rot_clk'))
+        Data.MIN_VAL = min_val
+        Data.MAX_VAL = max_val
+        Data.VAL = min_val
         Data.ROTARY_OBJ.add_handler(_rotary_changed)
     return 'Init RotaryEncoder with IRQs.'
 
@@ -72,7 +89,7 @@ def read_state(msgobj=None):
     """
     Read rotary encoder status / relative position
     """
-    load_n_init()
+    load()
     if msgobj is not None:
         if Data.EVENT:
             msgobj(f"[stream] RotaryState: {Data.VAL}")
@@ -87,19 +104,31 @@ def reset_state():
     Reset rotary encoder state to 0
     """
     msg = f"Reset state {Data.VAL} -> 0"
-    Data.VAL = 0
+    Data.VAL = Data.MIN_VAL
     return msg
 
 
-def pinmap(widgets=False):
+def pinmap():
     """
     [i] micrOS LM naming convention
     Load Module built-in help message
     :return tuple: list of functions implemented by this application (widgets=False)
     :return tuple: list of widget json for UI generation (widgets=True)
     """
-    return pinmap_dump(['rot_clk', 'rot_dt'])
+    return pinmap_search(['rot_clk', 'rot_dt'])
+
+
+def color_indicator():
+    """Encoder visualization on LED colors (LM_neopixel)"""
+    from LM_neopixel import color
+    palette_template = ((20, 0, 0), (10, 10, 0), (0, 20, 0), (0, 10, 10), (0, 0, 20))
+    repeat = int(Data.MAX_VAL / len(palette_template))+1
+    palette = palette_template * repeat
+    Data.COLOR = (color, palette)
+    color(0, 0, 0)          # initial color OFF
+    return palette
 
 
-def help():
-    return 'load_n_init', 'read_state', 'reset_state', 'pinmap'
+def help(widgets=False):
+    return resolve(('load min_val=0 max_val=20', 'TEXTBOX read_state',
+                             'reset_state', 'color_indicator', 'pinmap'), widgets=widgets)