micrOSDevToolKit 2.10.6__py3-none-any.whl → 2.11.0__py3-none-any.whl

micrOS/source/LM_neomatrix.py

@@ -0,0 +1,305 @@
+from neopixel import NeoPixel
+from machine import Pin
+from utime import sleep_ms
+
+from microIO import bind_pin
+from Types import resolve
+from Common import manage_task, AnimationPlayer
+
+
+class NeoPixelMatrix(AnimationPlayer):
+    INSTANCE = None
+    DEFAULT_COLOR = (100, 23, 0)  # Default color for the matrix
+
+    def __init__(self, width: int = 8, height: int = 8, pin: int = 0):
+        super().__init__(tag="neomatrix")
+        self.width = width
+        self.height = height
+        self.num_pixels = width * height
+        self.pixels = NeoPixel(Pin(pin, Pin.OUT), self.num_pixels)
+        self._color_buffer = [(0, 0, 0)] * self.num_pixels      # Store original RGB values
+        self._brightness = 0.25                                 # Brightness level, default 25%
+        NeoPixelMatrix.INSTANCE = self
+
+    def update(self, x:int, y:int, color:tuple[int, int, int]):
+        # Animation player will call this method to update pixels.
+        self.set_pixel(x, y, color)
+
+    def draw(self):
+        # Animation player will call this method to update the display.
+        self.pixels.write()
+
+    def clear(self):
+        # Animation player will call this method to clear the display.
+        for i in range(self.num_pixels):
+            # Write pixel buffer before write to ws2812
+            self.pixels[i] = (0, 0, 0)
+        # Send buffer to device
+        self.draw()
+
+    def _coord_to_index(self, x: int, y: int, zigzag:bool=True):
+        """
+        Zigzag layout: even rows left-to-right, odd rows right-to-left
+        """
+        if (zigzag is None or zigzag) and y % 2 == 0:
+            return y * self.width + x
+        return y * self.width + (self.width - 1 - x)
+
+    def _rgb_to_grb_with_br(self, color: tuple[int, int, int]):
+        """
+        Converts RGB to GRB with brightness adjustment.
+        """
+        def scale(val):
+            return max(0, min(255, int(val * self._brightness)))
+
+        return scale(color[1]), scale(color[0]), scale(color[2])
+
+    def set_pixel(self, x: int, y: int, color: tuple[int, int, int], zigzag:bool=True):
+        """
+        Set pixel at (x, y) with RGB
+        """
+        if 0 <= x < self.width and 0 <= y < self.height:
+            index = self._coord_to_index(x, y, zigzag=zigzag)
+            self._color_buffer[index] = color  # store original RGB for brightness control
+            self.pixels[index] = self._rgb_to_grb_with_br(color)
+
+    def color(self, color: tuple[int, int, int]):
+        """
+        Fill color OR Animation color change.
+        :param color: tuple[int, int, int] range: 0-255
+        :return: str
+        """
+        r, g, b = max(0, min(color[0], 255)), max(0, min(color[1], 255)), max(0, min(color[2], 255))
+        color = (r, g, b)
+        NeoPixelMatrix.DEFAULT_COLOR = color
+        if manage_task(self._task_tag, "isbusy"):
+            return f"Set animation color to {color}"
+        for i in range(self.num_pixels):
+            self._color_buffer[i] = color
+            # Write pixel buffer before write to ws2812
+            self.pixels[i] = self._rgb_to_grb_with_br(color)
+        # Send buffer to device
+        self.draw()
+        return f"Set all pixels to {color}"
+
+    def brightness(self, br: int):
+        """
+        Change the brightness of all pixels.
+        """
+        br = max(0, min(br, 100))  # clamp brightness to 0–100%
+        self._brightness = br / 100.0
+        # Set color matrix brightness
+        for i, color in enumerate(self._color_buffer):
+            # Write pixel buffer before write to ws2812
+            self.pixels[i] = self._rgb_to_grb_with_br(color)
+        self.draw()
+        return f"Set brightness to {br}%"
+
+
+    def draw_colormap(self, bitmap:list):
+        """
+        Draw a bitmap on the Neopixel
+        bitmap: [(x, y, (r, g, b)),
+                 (x, y, (r, g, b)), ...]
+        """
+        if len(bitmap) == 0:
+            self.clear()
+            return
+        for bm in bitmap:
+            x, y, color = bm
+            self.set_pixel(x, y, color, zigzag=False)
+        self.draw()
+
+
+##########################################################################################################
+##########################################################################################################
+# --- Example usage with micrOS framework ---
+
+def load(width=8, height=8):
+    """
+    Load NeoPixelMatrix instance. If not already loaded
+    """
+    if NeoPixelMatrix.INSTANCE is None:
+        NeoPixelMatrix(width=width, height=height, pin=bind_pin('neop'))
+    return NeoPixelMatrix.INSTANCE
+
+
+def pixel(x, y, color=None, show=True):
+    """
+    Set pixel at (x,y) to RGB color.
+    """
+    color = NeoPixelMatrix.DEFAULT_COLOR if color is None else color
+    matrix = load()
+    matrix.set_pixel(x, y, color)
+    if show:
+        matrix.draw()
+        return "Set and draw color"
+    return "Set color"
+
+
+def draw():
+    """
+    Draw the current frame manually on the screen.
+    """
+    load().draw()
+    return "Draw screen"
+
+
+def clear():
+    """
+    Clear the screen.
+    """
+    load().clear()
+    return "Clear screen"
+
+
+def color_fill(r: int, g: int, b: int):
+    """
+    Fill the screen with a solid color.
+    OR
+    Change animation color (when possible)
+    """
+    return load().color((r, g, b))
+
+
+def brightness(br: int):
+    """
+    Change the brightness of the display. (0-100)
+    """
+    return load().brightness(br)
+
+
+def control(speed_ms=None, bt_draw:bool=None):
+    """
+    Change the speed of frame generation for animations.
+    """
+    data = load().control(play_speed_ms=speed_ms, bt_draw=bt_draw)
+    _speed_ms = data.get("player_speed", None)
+    return f"Control state: {data} (speed: {_speed_ms}ms)"
+
+
+def stop():
+    """
+    Stop the current animation
+    """
+    return load().stop()
+
+
+def draw_colormap(bitmap):
+    try:
+        load().draw_colormap(bitmap)
+    except Exception as e:
+        return str(e)
+    return "Done."
+# -----------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+
+
+def rainbow(speed_ms=0):
+    def effect_rainbow():
+        def hsv_to_rgb(h, s, v):
+            max_color = 150   #255
+            h = float(h)
+            s = float(s)
+            v = float(v)
+            i = int(h * 6.0)
+            f = (h * 6.0) - i
+            p = v * (1.0 - s)
+            q = v * (1.0 - s * f)
+            t = v * (1.0 - s * (1.0 - f))
+            i = i % 6
+            if i == 0:
+                r, g, b = v, t, p
+            elif i == 1:
+                r, g, b = q, v, p
+            elif i == 2:
+                r, g, b = p, v, t
+            elif i == 3:
+                r, g, b = p, q, v
+            elif i == 4:
+                r, g, b = t, p, v
+            elif i == 5:
+                r, g, b = v, p, q
+            return int(r * max_color), int(g * max_color), int(b * max_color)
+
+        width = 8
+        height = 8
+        total_frames = 64
+
+        for frame in range(total_frames):
+            for y in range(height):
+                for x in range(width):
+                    index = y * width + x
+                    hue = ((index + frame) % 64) / 64.0
+                    r, g, b = hsv_to_rgb(hue, 1.0, 0.7)
+                    yield x, y, (r, g, b)
+
+    return load().play(effect_rainbow, speed_ms=speed_ms, bt_draw=True, bt_size=8)
+
+
+def snake(speed_ms:int=50, length:int=5):
+    def effect_snake():
+        clear_color = (0, 0, 0)
+        total_steps = 8 * 8 + length  # run just past the end to clear tail
+
+        for step in range(total_steps):
+            # 1) clear the tail pixel once the snake is longer than `length`
+            if step >= length:
+                tail_idx = step - length
+                tx, ty = tail_idx % 8, tail_idx // 8
+                yield tx, ty, clear_color
+
+            # 2) move the head (only while head index < 64)
+            if step < 8 * 8:
+                hx, hy = step % 8, step // 8
+                yield hx, hy, NeoPixelMatrix.DEFAULT_COLOR
+
+    return load().play(effect_snake, speed_ms=speed_ms)
+
+
+def cube(speed_ms=10):
+    def effect_cube(max_radius:int = 3):
+        """
+        Generator yielding (x, y, color) for a centered 2×2 square ("cube")
+        that expands outward to `max_radius` then collapses back.
+        """
+        width, height = 8, 8
+        # Center the 2×2 core in an 8×8 grid
+        cx, cy = width // 2 - 1, height // 2 - 1
+
+        # Expansion phase: radius 0 (2×2) up to max_radius
+        for r in range(0, max_radius + 1):
+            for dx in range(-r, r + 2):
+                for dy in range(-r, r + 2):
+                    x, y = cx + dx, cy + dy
+                    if 0 <= x < width and 0 <= y < height:
+                        yield x, y, NeoPixelMatrix.DEFAULT_COLOR
+        # Clear matrix
+        try:
+            NeoPixelMatrix.INSTANCE.clear()
+        except:
+            pass
+        # Collapse phase: back down, skipping the largest to avoid duplicate
+        for r in range(max_radius - 1, -1, -1):
+            for dx in range(-r, r + 2):
+                for dy in range(-r, r + 2):
+                    x, y = cx + dx, cy + dy
+                    if 0 <= x < width and 0 <= y < height:
+                        yield x, y, NeoPixelMatrix.DEFAULT_COLOR
+
+    return load().play(effect_cube, speed_ms=speed_ms)
+
+
+def help(widgets=False):
+    return resolve(('load width=8 height=8',
+                             'pixel x y color=(10, 3, 0) show=True',
+                             'BUTTON clear',
+                             'COLOR color_fill r=<0-255-5> g=<0-255-5> b=<0-255-5>',
+                             'SLIDER brightness br=<0-60-2>',
+                             'BUTTON stop',
+                             'BUTTON snake speed_ms=50 length=5',
+                             'BUTTON rainbow',
+                             'BUTTON cube speed_ms=10',
+                             'SLIDER control speed_ms=<2-200-2> bt_draw=None',
+                             'draw_colormap bitmap=[(0,0,(10,2,0)),(x,y,color),...]'
+                    ), widgets=widgets)

micrOS/source/LM_neopixel.py

@@ -1,8 +1,7 @@
 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 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')
 
 
 #########################################
@@ -40,7 +40,7 @@ def __init_NEOPIXEL(pin=None, 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
@@ -77,7 +77,7 @@ def load(ledcnt=24, pin=None, cache=True):
     Initiate NeoPixel RGB module
     :param ledcnt: number of led segments
     :param pin: optional number to overwrite default pin
-    :param cache: default True, store stages on disk +  Load (.pds)
+    :param cache: default True, store stages on disk +  Load (.cache)
     :return str: Cache state
     """
     Data.PERSISTENT_CACHE = cache
@@ -182,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)

micrOS/source/LM_pacman.py

@@ -1,6 +1,7 @@
 from sys import modules
 from Common import socket_stream
 from Files import _is_module, list_fs, ilist_fs, remove_fs
+from Files import OSPath, path_join
 
 
 #############################################
@@ -42,7 +43,7 @@ def rm(path, allow_dir=False):
 def dirtree(path="/", raw=False):
     """Return only directories from a given path."""
     path = path if path.endswith('/') else f"{path}/"
-    folders = [f"{path}/{item}" for item in ilist_fs(path, type_filter='d')]
+    folders = [path_join(path, item) for item in ilist_fs(path, type_filter='d')]
     folder_contents = {folder:list_fs(folder) for folder in folders}
     if raw:
         return folder_contents
@@ -124,39 +125,42 @@ def moduls(unload=None):
 
 
 @socket_stream
-def cachedump(delpds=None, msgobj=None):
+def cachedump(delete=None, msgobj=None):
     """
-    Cache system persistent data storage files (.pds)
-    :param delpds: cache name to delete
+    Cache system persistent data storage files (.cache)
+    :param delete: cache name to delete
     """
-    if delpds is None:
-        # List pds files aka application cache
+    data_dir = OSPath.DATA
+    if delete is None:
+        # List cache files aka application cache
         msg_buf = []
-        for pds in (_pds for _pds in ilist_fs(type_filter='f') if _pds.endswith('.pds')):
-            with open(pds, 'r') as f:
+        for cache in (c for c in ilist_fs(data_dir, type_filter='f') if c.endswith('.cache')):
+            _path = path_join(data_dir, cache)
+            with open(_path, 'r') as f:
                 if msgobj is None:
-                    msg_buf.append(f'{pds}: {f.read()}')
+                    msg_buf.append(f'{_path}: {f.read()}')
                 else:
-                    msgobj(f'{pds}: {f.read()}')
+                    msgobj(f'{_path}: {f.read()}')
         return msg_buf if len(msg_buf) > 0 else ''
-    # Remove given pds file
+    # Remove given cache file
     try:
-        verdict = remove_fs(f'{delpds}.pds')
-        return f'{delpds}.pds delete done.: {verdict}'
+        delete_cache = path_join(data_dir, f"{delete}.cache")
+        verdict = remove_fs(delete_cache)
+        return f'{delete_cache} delete done.: {verdict}'
     except:
-        return f'{delpds}.pds not exists'
+        return f'{delete}.cache not exists'
 
 
-def dat_dump():
+def datdump():
     """
     Generic .dat file dump
-    - logged data from LMs, sensor datat, etc...
+    - logged data from LMs, sensor data, etc...
     """
-    logs_dir = "/logs/"
-    dats = (f for f in ilist_fs(type_filter='f') if f.endswith('.dat'))
+    data_dir = OSPath.DATA
+    dats = (f for f in ilist_fs(data_dir, type_filter='f') if f.endswith('.dat'))
     out = {}
     for dat in dats:
-        with open(f"{logs_dir}{dat}", 'r') as f:
+        with open(path_join(data_dir, dat), 'r') as f:
             out[dat] = f.read()
     return out
 
@@ -220,8 +224,8 @@ def help(widgets=False):
     """
     return ('listmods', 'delmod mod=<module>.py/.mpy or .js/.html/.css', 'del_duplicates',
             'moduls unload="LM_rgb/None"',
-            'cachedump delpds="rgb/None"',
-            'dat_dump',
+            'cachedump delete=None',
+            'datdump',
             'download url="BxNxM/micrOS/master/toolkit/workspace/precompiled/LM_robustness.py"',
             'micros_checksum',
             'ls path="/" content="*/f/d" select="*/LM/IO"',

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