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

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

micrOS/source/modules/LM_neoeffects.py

@@ -0,0 +1,284 @@
+from LM_neopixel import load as neoload, segment, Data, status, pinmap as pm
+from random import randint
+from Types import resolve
+from Common import manage_task, AnimationPlayer
+
+
+#################################
+#  NEOPIXEL EFFECT DRAWER CLASS #
+#################################
+
+class DrawEffectV2(AnimationPlayer):
+    INSTANCE = None
+
+    def __init__(self, pix_cnt=24):
+        super().__init__(tag="neoeffects")
+        neoload(ledcnt=pix_cnt)
+        DrawEffectV2.INSTANCE = self
+
+    @staticmethod
+    def normalize_index(value) -> int:
+        return value % Data.NEOPIXEL_OBJ.n
+
+    @staticmethod
+    def color_code(r:int=None, g:int=None, b:int=None) -> tuple[float, float, float]:
+        _r, _g, _b, _ = Data.DCACHE
+        r = _r if r is None else r
+        g = _g if g is None else g
+        b = _b if b is None else b
+        return r, g, b
+
+    def update(self, index:int, r:int|float, g:int|float, b:int|float):
+        # Animation player will call this method to update pixels.
+        segment(r=int(r), g=int(g), b=int(b), s=index, cache=False, write=False)
+
+    def draw(self):
+        # Animation player will call this method to update pixels.
+        Data.NEOPIXEL_OBJ.write()
+
+    def clear(self):
+        # Animation player will call this method to update pixels.
+        for i in range(0, Data.NEOPIXEL_OBJ.n):
+            self.update(i, 0, 0, 0)
+        self.draw()
+
+##################################################################################
+#                                  EFFECTS                                       #
+##################################################################################
+
+def meteor(speed_ms:int=60, shift:bool=True, batch:bool=True):
+    """
+    Meteor effect
+    :param speed_ms: animation speed in milliseconds
+    :param shift: automatic effect rotation
+    :param batch: batch mode
+    :return str: verdict
+    """
+    def effect_meteor():
+        """
+        Describe one full length color map
+        :return: yield tuple with r,g,b
+        """
+        nonlocal shift, pix_cnt
+        max_offset = pix_cnt if shift else 1
+        for offset in range(0, max_offset):
+            r, g, b = DrawEffectV2.color_code()
+            for pixel in range(0, pix_cnt):
+                br, norm = 0.6, pixel/pix_cnt
+                fade = br * norm ** 0.9         # exponent < 1 simulates log-like curve
+                yield DrawEffectV2.normalize_index(pixel+offset), r*fade, g*fade, b*fade
+
+    neoeffect = load()
+    pix_cnt = Data.NEOPIXEL_OBJ.n
+    return neoeffect.play(effect_meteor, speed_ms=speed_ms, bt_draw=batch, bt_size=pix_cnt)
+
+
+def cycle(speed_ms:int=60, shift:bool=True, batch:bool=True):
+    """
+    Cycle effect
+    :param speed_ms: animation speed in milliseconds
+    :param shift: automatic effect rotation
+    :param batch: enable/disable batch update mode
+    """
+    def effect_cycle():
+        """
+        Describe one full length color map
+        :return: yield tuple with index, r,g,b
+        """
+        nonlocal shift
+        max_offset = Data.NEOPIXEL_OBJ.n if shift else 1
+        for offset in range(0, max_offset):
+            r, g, b = DrawEffectV2.color_code()
+            lr, lg, lb = int(r * 0.1), int(g * 0.1), int(b * 0.1)
+            # Clean last pixel
+            yield DrawEffectV2.normalize_index(offset-1), 0, 0, 0
+            # Draw pattern
+            yield DrawEffectV2.normalize_index(offset), lr, lg, lb
+            yield DrawEffectV2.normalize_index(offset + 1), r, g, b
+            yield DrawEffectV2.normalize_index(offset + 2), lr, lg, lb
+
+    return load().play(effect_cycle, speed_ms=speed_ms, bt_draw=batch, bt_size=4)
+
+
+def rainbow(speed_ms=50, br=15, batch=True):
+    """
+    Rainbow effect animation
+    :param speed_ms: animation speed in milliseconds
+    :param br: Brightness of the pixels (0-100)
+    :param batch: Batch drawing of pixels (True/False)
+    """
+    def _wheel(pos):
+        # Input a value 0 to 255 to get a color value.
+        # The colours are a transition r - g - b - back to r.
+        if pos < 0 or pos > 255:
+            return 0, 0, 0
+        if pos < 85:
+            return 255 - pos * 3, pos * 3, 0
+        if pos < 170:
+            pos -= 85
+            return 0, 255 - pos * 3, pos * 3
+        pos -= 170
+        return pos * 3, 0, 255 - pos * 3
+
+    def effect_rainbow():
+        """
+        :param cnt: led segment count
+        :param br: max brightness 0-100%
+        :param step: step size
+        """
+        nonlocal pix_cnt, br
+        for color_wheel in range(0, 255):
+            for index in range(0, pix_cnt):
+                rc_index = (index * 256 // pix_cnt) + color_wheel
+                r, g, b = _wheel(rc_index & 255)
+                yield DrawEffectV2.normalize_index(index+color_wheel), round(r*br*0.01), round(g*br*0.01), round(b*br*0.01)
+
+    neoeffect = load()
+    pix_cnt = Data.NEOPIXEL_OBJ.n
+    return neoeffect.play(effect_rainbow, speed_ms=speed_ms, bt_draw=batch, bt_size=pix_cnt)
+
+
+def fire(speed_ms:int=150, br:int=30, batch:bool=True):
+    """
+    Fire effect
+    :param speed_ms: animation speed in milliseconds
+    :param br: max brightness 0-100%
+    :param batch: batch update
+    """
+    def effect_fire():
+        nonlocal pix_cnt, br
+        max_value = int(255 * (br/100))
+        for index in range(pix_cnt):
+            r, g, b = DrawEffectV2.color_code()
+            rand_percent = float(round(randint(1, max_value)/max_value, 2))
+            new_r = min(max(int(r * rand_percent), 0), max_value)
+            new_g = min(max(int(g * rand_percent), 0), max_value)
+            new_b = min(max(int(b * rand_percent), 0), max_value)
+            yield index, new_r, new_g, new_b
+
+    neoeffect = load()
+    pix_cnt = Data.NEOPIXEL_OBJ.n
+    return neoeffect.play(effect_fire, speed_ms=speed_ms, bt_draw=batch, bt_size=pix_cnt)
+
+
+def shader(offset=0, size=6):
+    """
+    Shader effect on neopixel ring.
+    :param offset: start pixel index
+    :param size: shader size (number of pixels)
+    """
+    def effect_shader():
+        nonlocal size, offset, neoeffect
+        pix_cnt = Data.NEOPIXEL_OBJ.n
+        # Conditional value load - with neopixel cache
+        r, g, b = DrawEffectV2.color_code()
+        # calculate 0->24 range
+        _slice1 = pix_cnt if size + offset > pix_cnt else size + offset
+        # calculate 24->0-> range (overflow)
+        _slice2 = size + offset - pix_cnt if size + offset > pix_cnt else 0
+        for i in range(0, pix_cnt):
+            if offset <= i < _slice1 or 0 <= i < _slice2:
+                neoeffect.update(i, 0, 0, 0)
+            else:
+                neoeffect.update(i, r, g, b)
+        neoeffect.draw()
+
+    neoeffect = load()
+    effect_shader()
+    return "Shader was set."
+
+
+def color(r:int=None, g:int=None, b:int=None):
+    """
+    Set color buffer - for runtime effect color change
+    :param r: red channel 0-255 (default: None - cached value)
+    :param g: green channel 0-255 (default: None - cached value)
+    :param b: blue channel 0-255 (default: None - cached value)
+    :return dict: rgb status - states: R, G, B, S
+    """
+    # Conditional value load - with neopixel cache
+    r, g, b = DrawEffectV2.color_code(r, g, b)
+    Data.DCACHE[0] = r
+    Data.DCACHE[1] = g
+    Data.DCACHE[2] = b
+    return status()
+
+
+def random(max_val=255):
+    """
+    Demo function: implements random color change
+    :param max_val: set channel maximum generated value: 0-255
+    :return str: rgb status - states: R, G, B
+    """
+    r = randint(0, max_val)
+    g = randint(0, max_val)
+    b = randint(0, max_val)
+    Data.DCACHE[0] = r
+    Data.DCACHE[1] = g
+    Data.DCACHE[2] = b
+    return "Set random: R:{} G: B:{}".format(r, g, b)
+
+
+def stop():
+    """
+    Stop all running (neo)effects tasks
+    """
+    player_info = load().stop()
+    random_task = manage_task("neoeffects.random", "kill")
+    return f"{player_info}\n{random_task}"
+
+def control(speed_ms=None, batch:bool=None):
+    """
+    Change the speed of frame generation for animations.
+    """
+    data = load().control(play_speed_ms=speed_ms, bt_draw=batch)
+    _speed_ms = data.get("player_speed", None)
+    return f"Control state: {data} (speed: {_speed_ms}ms)"
+
+
+def load(pixel_cnt=24):
+    """
+    Load LM_neopixel and DrawEffectV2
+    """
+    if DrawEffectV2.INSTANCE is None:
+        DrawEffectV2(pix_cnt=pixel_cnt)
+    return DrawEffectV2.INSTANCE
+
+#######################
+# 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 pm()
+
+
+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 pixel_cnt=24',
+                             'meteor speed_ms=60 shift=True batch=True',
+                             'BUTTON meteor speed_ms=60',
+                             'cycle speed_ms=60 shift=True batch=True',
+                             'BUTTON cycle speed_ms=60',
+                             'rainbow speed_ms=50 br=15 batch=True',
+                             'BUTTON rainbow',
+                             'fire speed_ms=150 br=30 batch=True',
+                             'BUTTON fire speed_ms=150',
+                             'BUTTON stop',
+                             'shader offset=0 size=6',
+                             'SLIDER control speed_ms=<1-200> batch=None',
+                             'random max_val=255',
+                             'pinmap',
+                             'COLOR color r=<0-255-10> g b'
+                    ), widgets=widgets)

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

@@ -1,9 +1,8 @@
 from neopixel import NeoPixel
 from machine import Pin
-from sys import platform
 from utime import sleep_ms
-from Common import transition_gen, micro_task
-from microIO import resolve_pin, pinmap_search
+from Common import transition_gen, micro_task, data_dir
+from microIO import bind_pin, pinmap_search
 from random import randint
 from Types import resolve
 
@@ -19,6 +18,7 @@ class Data:
     PERSISTENT_CACHE = False
     RGB_TASK_TAG = "neopixel._tran"
     TASK_STATE = False
+    FILE_CACHE = data_dir('neopixel.cache')
 
 
 #########################################
@@ -26,13 +26,13 @@ class Data:
 #########################################
 
 
-def __init_NEOPIXEL(n=24):
+def __init_NEOPIXEL(pin=None, n=24):
     """
     Init NeoPixel module
     n - number of led fragments
     """
     if Data.NEOPIXEL_OBJ is None:
-        neopixel_pin = Pin(resolve_pin('neop'))     # Get Neopixel pin from LED PIN pool
+        neopixel_pin = Pin(bind_pin('neop', number=pin))         # Get Neopixel pin from LED PIN pool
         Data.NEOPIXEL_OBJ = NeoPixel(neopixel_pin, n)                 # initialize for max 8 segments
         del neopixel_pin
     return Data.NEOPIXEL_OBJ
@@ -40,7 +40,7 @@ def __init_NEOPIXEL(n=24):
 
 def __persistent_cache_manager(mode):
     """
-    pds - persistent data structure
+    File cache
     modes:
         r - recover, s - save
     """
@@ -48,12 +48,12 @@ def __persistent_cache_manager(mode):
         return
     if mode == 's':
         # SAVE CACHE
-        with open('neopixel.pds', 'w') as f:
+        with open(Data.FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in Data.DCACHE]))
         return
     try:
         # RESTORE CACHE
-        with open('neopixel.pds', 'r') as f:
+        with open(Data.FILE_CACHE, 'r') as f:
             Data.DCACHE = [float(data) for data in f.read().strip().split(',')]
     except:
         pass
@@ -72,20 +72,17 @@ def __state_machine(r, g, b):
 #             USER FUNCTIONS            #
 #########################################
 
-def load(cache=None, ledcnt=24):
+def load(ledcnt=24, pin=None, cache=True):
     """
     Initiate NeoPixel RGB 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 ledcnt: number of led segments
+    :param pin: optional number to overwrite default pin
+    :param cache: default True, store stages on disk +  Load (.cache)
     :return str: Cache state
     """
-    if cache is None:
-        Data.PERSISTENT_CACHE = False if platform == 'esp8266' else True
-    else:
-        Data.PERSISTENT_CACHE = cache
+    Data.PERSISTENT_CACHE = cache
     __persistent_cache_manager('r')         # recover data cache
-    _ledcnt = __init_NEOPIXEL(n=ledcnt).n
+    _ledcnt = __init_NEOPIXEL(pin=pin, n=ledcnt).n
     if Data.PERSISTENT_CACHE and Data.DCACHE[3] == 1:
         Data.DCACHE[3] = 0                  # Force ON at boot
         toggle(True)
@@ -185,13 +182,13 @@ def segment(r=None, g=None, b=None, s=0, cache=False, write=True):
     :param g: green value 0-255
     :param b: blue value 0-255
     :param s: segment - index 0-ledcnt
-    :param cache: cache color (update .pds file)
+    :param cache: cache color (update .cache file)
     :param write: send color buffer to neopixel (update LEDs)
     :return dict: rgb status - states: R, G, B, S
     """
-    r = Data.DCACHE[0] if r is None else r
-    g = Data.DCACHE[1] if g is None else g
-    b = Data.DCACHE[2] if b is None else b
+    r = int(Data.DCACHE[0]) if r is None else r
+    g = int(Data.DCACHE[1]) if g is None else g
+    b = int(Data.DCACHE[2]) if b is None else b
     neo_n = __init_NEOPIXEL().n
     if s <= neo_n:
         Data.NEOPIXEL_OBJ[s] = (r, g, b)
@@ -281,8 +278,7 @@ def transition(r=None, g=None, b=None, sec=1.0, wake=False):
     # Create transition generator and calculate step_ms
     rgb_gen, step_ms = transition_gen(r_from, r_to, g_from, g_to, b_from, b_to, interval_sec=sec)
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.RGB_TASK_TAG, task=_task(ms_period=step_ms, iterable=rgb_gen))
-    return "Starting transition" if state else "Transition already running"
+    return micro_task(tag=Data.RGB_TASK_TAG, task=_task(ms_period=step_ms, iterable=rgb_gen))
 
 
 def random(smooth=True, max_val=255):

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

@@ -3,7 +3,7 @@
 from micropython import const
 import framebuf
 from machine import Pin, SoftI2C
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Types import resolve
 
 __INVERT = False
@@ -165,7 +165,7 @@ def load(width=128, height=64, brightness=50):
     :param brightness: percentage
     """
     if SSD1306_I2C.OLED_OBJ is None:
-        i2c = SoftI2C(Pin(resolve_pin('i2c_scl')), Pin(resolve_pin('i2c_sda')))
+        i2c = SoftI2C(Pin(bind_pin('i2c_scl')), Pin(bind_pin('i2c_sda')))
         # TODO: scan device - abort if no device is available
         SSD1306_I2C.OLED_OBJ = SSD1306_I2C(width, height, i2c)
         SSD1306_I2C.OLED_OBJ.contrast(percent=brightness)

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

@@ -16,7 +16,7 @@ from micropython import const
 import utime as time
 import framebuf
 from machine import Pin, I2C
-from microIO import resolve_pin, pinmap_search
+from microIO import bind_pin, pinmap_search
 from Types import resolve
 
 __INVERT = False
@@ -224,8 +224,8 @@ class SH1106_I2C(SH1106):
 
 def load(width=128, height=64, brightness=50, rotate=180):
     if SH1106_I2C.OLED_OBJ is None:
-        #i2c = SoftI2C(Pin(resolve_pin('i2c_scl')), Pin(resolve_pin('i2c_sda')))
-        i2c = I2C(scl=Pin(resolve_pin('i2c_scl')), sda=Pin(resolve_pin('i2c_sda')), freq=400000)
+        #i2c = SoftI2C(Pin(bind_pin('i2c_scl')), Pin(bind_pin('i2c_sda')))
+        i2c = I2C(scl=Pin(bind_pin('i2c_scl')), sda=Pin(bind_pin('i2c_sda')), freq=400000)
         # TODO: scan device - abort if no device is available
         SH1106_I2C.OLED_OBJ = SH1106_I2C(width, height, i2c, rotate=rotate)
         SH1106_I2C.OLED_OBJ.contrast(percent=brightness)