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

toolkit/dashboard_apps/_gyro_visualizer.py

@@ -0,0 +1,78 @@
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+import multiprocessing as mp
+from collections import deque
+from datetime import datetime
+import matplotlib.dates as mdates
+
+def visualizer_main(queue):
+    # Make figure wider and a bit taller
+    fig, (ax_accel, ax_gyro) = plt.subplots(2, 1, figsize=(14, 8))
+    plt.subplots_adjust(top=0.88, bottom=0.12, hspace=0.3)
+
+    history = 100
+    accel_data = {'x': deque([0] * history, maxlen=history),
+                  'y': deque([0] * history, maxlen=history),
+                  'z': deque([0] * history, maxlen=history)}
+    gyro_data = {'x': deque([0] * history, maxlen=history),
+                 'y': deque([0] * history, maxlen=history),
+                 'z': deque([0] * history, maxlen=history)}
+    time_axis = deque([datetime.now()] * history, maxlen=history)
+
+    # Increase line width here
+    line_width = 2.5
+
+    accel_lines = {
+        axis: ax_accel.plot([], [], label=f'accel_{axis}', linewidth=line_width)[0]
+        for axis in 'xyz'
+    }
+    gyro_lines = {
+        axis: ax_gyro.plot([], [], label=f'gyro_{axis}', linewidth=line_width)[0]
+        for axis in 'xyz'
+    }
+
+    ax_accel.set_ylim(-2, 2)
+    ax_gyro.set_ylim(-300, 300)
+
+    for ax in [ax_accel, ax_gyro]:
+        ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))
+        ax.legend()
+        ax.grid(True)
+        ax.set_xlabel("Time (H:M:S)")
+
+    ax_accel.set_title("Acceleration")
+    ax_gyro.set_title("Gyroscope")
+
+    def update(_):
+        try:
+            while not queue.empty():
+                data = queue.get_nowait()
+                current_time = datetime.now()
+                time_axis.append(current_time)
+
+                for axis, val in zip('xyz', data['accel']):
+                    accel_data[axis].append(val)
+                for axis, val in zip('xyz', data['gyro']):
+                    gyro_data[axis].append(val)
+        except Exception as e:
+            print(f"Visualizer error: {e}")
+            return
+
+        for axis in 'xyz':
+            accel_lines[axis].set_data(time_axis, accel_data[axis])
+            gyro_lines[axis].set_data(time_axis, gyro_data[axis])
+
+        for ax in [ax_accel, ax_gyro]:
+            ax.set_xlim(time_axis[0], time_axis[-1])
+            ax.figure.autofmt_xdate()
+
+        return list(accel_lines.values()) + list(gyro_lines.values())
+
+    ani = animation.FuncAnimation(fig, update, interval=50)
+    plt.show()
+
+
+if __name__ == "__main__":
+    mp.set_start_method('spawn')
+    queue = mp.Queue()
+    visualizer_main(queue)

toolkit/simulator_lib/machine.py

@@ -2,7 +2,6 @@ from threading import Thread
 import time
 import micropython
 from sim_console import console
-import sys
 
 
 def machine(*args, **kwargs):

toolkit/simulator_lib/neopixel.py

@@ -1,4 +1,4 @@
-
+from sim_console import console
 
 class NeoPixel:
     __instance = None
@@ -17,9 +17,10 @@ class NeoPixel:
         return cls.__pix_list[key]
 
     def __setitem__(cls, key, value):
+        console(f"Update NeoPixel at index {key} to {value}")
         cls.__pix_list[key] = value
 
     def write(cls):
-        pass
+        console(f"Neopixel write: {cls.__pix_list}")
 
 

toolkit/socketClient.py

@@ -424,7 +424,7 @@ def socket_commandline_args(arg_list):
     return ' <a> '.join(command_buffer), return_action_dict
 
 
-def run(arg_list=[], timeout=10):
+def run(arg_list=[], timeout=10, verbose=False):
     """ Run from code
         - Handles extra command line arguments
     """
@@ -434,7 +434,8 @@ def run(arg_list=[], timeout=10):
     output = False, ''
     try:
         #print("Socket run (args): {}".format(args))
-        output = main(args, host=host, port=port, timeout=timeout, pwd=action['password'], verbose=action['verbose'])
+        verbose = verbose or action['verbose']
+        output = main(args, host=host, port=port, timeout=timeout, pwd=action['password'], verbose=verbose)
     except Exception as e:
         if "TimeOut" in str(e):
             print("Resolve device by host ... {}.local {}:{}:{}".format(fid, host, port, uid))

toolkit/user_data/webhooks/generic.py

@@ -2,7 +2,7 @@
 
 """
 Generic webhook for socketClient that can invoke LoadModule calls remotely from any device.
-Example: http://10.0.1.61:5000/webhooks/generic/TinyDevBoard+system+clock
+Example: http://10.0.1.61:5005/webhooks/generic/TinyDevBoard+system+clock
 """
 
 import sys, os

toolkit/user_data/webhooks/macro.py

@@ -3,7 +3,7 @@
 """
 Template for webhook creation
 - replies with basic response message
-Example: http://10.0.1.61:5000/webhooks/template
+Example: http://10.0.1.61:5005/webhooks/template
 """
 
 import sys, os

toolkit/user_data/webhooks/template.py

@@ -3,7 +3,7 @@
 """
 Template for webhook creation
 - replies with basic response message
-Example: http://10.0.1.61:5000/webhooks/template
+Example: http://10.0.1.61:5005/webhooks/template
 """
 
 import sys, os

toolkit/workspace/precompiled/LM_VL53L0X.py

@@ -343,7 +343,7 @@ class VL53L0X:
 
 def measure():
     """
-    Experimental
+    Experimental - Time of Flight Distance Sensor
     """
     global __TOF_OBJ
     if __TOF_OBJ is None:

toolkit/workspace/precompiled/LM_espnow.py

@@ -2,10 +2,24 @@ import Espnow
 
 def load():
     """
-    Initialize ESPNOW protocal
+    OBSOLETE - remove
+    [DEBUG ONLY] ENABLE ESPNOW IN NODE CONFIG INSTEAD OF HERE!
+        Initialize ESPNOW protocal
     """
     return Espnow.initialize()
 
+def start_server():
+    """
+    OBSOLETE - remove
+    [DEBUG ONLY] ENABLE ESPNOW IN NODE CONFIG INSTEAD OF HERE!
+        Start ESPNOW server/listener
+        - this can receive espnow messages
+        - it includes Load Module execution logic (beta)
+    """
+    now = Espnow.initialize()
+    return now.start_server()
+
+
 def send(peer:bytes|str, msg:str='modules'):
     """
     Send message to peer (by mac address)
@@ -15,15 +29,6 @@ def send(peer:bytes|str, msg:str='modules'):
     now = Espnow.initialize()
     return now.send(peer, msg)
 
-def start_server():
-    """
-    Start ESPNOW server/listener
-    - this can receive espnow messages
-    - it includes Load Module execution logic (beta)
-    """
-    now = Espnow.initialize()
-    return now.start_server()
-
 def stats():
     """
     Get ESPNOW stats

toolkit/workspace/precompiled/LM_i2c.py

@@ -24,8 +24,9 @@ def discover():
     """
     Discover devices
     """
-    known_addresses = {hex(0x0A): "trackball", hex(0x3c): "oled",
-                       hex(0x76): "bme280", hex(0x10): 'veml7700'}
+    known_addresses = {hex(0x0A): "TRACKBALL", hex(0x3c): "OLED",
+                       hex(0x76): "BME280", hex(0x10): 'VEML7700',
+                       hex(0x6b): "QMI8658"}
     devices = scan()
     output = {"unknown": []}
     for k in devices:

toolkit/workspace/precompiled/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_tcs3472.py

@@ -0,0 +1,75 @@
+"""
+A MicroPython library for the TCS3472 light sensing chip
+https://github.com/tti0/tcs3472-micropython
+
+Copyright (c) 2021 tti0
+Licensed under the MIT License
+"""
+
+from machine import I2C, Pin
+from microIO import bind_pin, pinmap_search
+import struct
+
+
+class TCS3472:
+    INSTANCE = None
+
+    def __init__(self, bus, address=0x29):
+        self._bus = bus
+        self._i2c_address = address
+
+        self._bus.start()
+
+        self._bus.writeto(self._i2c_address, b'\x80\x03')
+        self._bus.writeto(self._i2c_address, b'\x81\x2b')
+
+        TCS3472.INSTANCE = self
+
+    def scaled(self):
+        crgb = self.raw()
+        if crgb[0] > 0:
+            return tuple(float(x) / crgb[0] for x in crgb[1:])
+
+        return (0, 0, 0)
+
+    def rgb(self):
+        return tuple(int(x * 255) for x in self.scaled())
+
+    def light(self):
+        return self.raw()[0]
+
+    def brightness(self, level=65.535):
+        return int((self.light() / level))
+
+    def valid(self):
+        self._bus.writeto(self._i2c_address, b'\x93')
+        return self._bus.readfrom(self._i2c_address, 1)[0] & 1
+
+    def raw(self):
+        self._bus.writeto(self._i2c_address, b'\xb4')
+        return struct.unpack("<HHHH", self._bus.readfrom(self._i2c_address, 8))
+
+
+############################ Exposed functions ############################
+
+def load():
+    """
+    Load the TCS3472 Color sensor instance.
+    """
+    if TCS3472.INSTANCE is None:
+        bus = I2C(sda=Pin(bind_pin('i2c_sda')), scl=Pin(bind_pin('i2c_scl')))
+        TCS3472.INSTANCE = TCS3472(bus)
+    return TCS3472.INSTANCE
+
+
+def pinmap():
+    return pinmap_search(['i2c_scl', 'i2c_sda'])
+
+
+def measure():
+    sensor = load()
+    return {"rgb": sensor.rgb(), "light": sensor.light(), "brightness": sensor.brightness()}
+
+
+def help(widgest=False):
+    return 'load', 'measure'

micrOS/source/LM_catgame.py

@@ -1,75 +0,0 @@
-from random import randint
-from LM_servo import sduty, deinit, pinmap as pm
-from utime import sleep_ms
-from Types import resolve
-
-
-def load():
-    """
-    Initialize catgame-servo module
-    """
-    return "catgame-servo module - loaded"
-
-
-def game(repeat=10, delta=20):
-    """
-    Servo cat toy "mover" - left-right
-    :param repeat int: repeat servo pos change
-    :param delta int: center(75) +/-delta(35)
-    :return str: verdict
-    """
-    sduty(75)
-    for _ in range(0, repeat):
-        sduty(randint(75-delta, 75+delta))
-        sleep_ms(randint(20, 1500))
-    sduty(75)
-    return 'Game action'
-
-
-def live_game(chance=10):
-    """
-    Generate game
-    :param chance int: percent value 0-100
-    :return str: verdict (action / no action)
-    """
-    action = randint(1, 10)
-    if action <= int(chance/10):
-        return game(repeat=5)
-    return 'No action'
-
-
-def stop():
-    """
-    Stop game - home position (75) + deinit
-    :return str: servo verdict
-    """
-    out = sduty(75)
-    deinit()
-    return out
-
-
-#######################
-# 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(('BUTTON game repeat=10',
-                             'SLIDER live_game chance=<10-90>',
-                             'BUTTON stop', 'pinmap',
-                             'load'), widgets=widgets)