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

micrOS/source/modules/LM_pacman.py

@@ -0,0 +1,320 @@
+from sys import modules
+from Common import socket_stream
+from Files import list_fs, ilist_fs, remove_file, remove_dir, OSPath, path_join, is_protected
+from Auth import sudo
+
+
+#############################################
+#     Safe file system handler functions    #
+#############################################
+
+def ls(path="/", content='*', raw=False, select='*', core=False):
+    """
+    Linux like ls command - list app resources and app folders
+    :param path: path to list, default: /
+    :param content: content type, default all, f-file, d-dir can be selected
+    :param raw: keep raw output [(is_app, type), ...]
+    :param select: select specific app resource: LM or IO, default: all
+    :param core: include core system files
+    """
+    items = list_fs(path, content, select=select, core=core)
+    if raw:
+        return items
+
+    # Build a formatted output (just like `ls -l` style index)
+    lines = ""
+    for i, f in enumerate(items):
+        spacer = " " * (4 - len(str(i+1)))
+        if content == "*":
+            lines += f"{i+1}{spacer}{f[0]}   {f[1]}\n"
+        else:
+            lines += f"{i + 1}{spacer}{f}\n"
+    return lines
+
+
+@sudo(_force_only=(True, 1))
+def rm(path, force=False):
+    """
+    Linux like rm command - delete app resources and folders
+    :param path: app resource name/path, ex.: LM_robustness.py
+    :param force: bypasses protection check - sudo mode
+    """
+    return remove_file(path, force)
+
+
+@sudo(_force_only=(True, 1))
+def rmdir(path, force=False):
+    """
+    Linux like rmdir command for directory deletion
+    :param path: app resource folder path, ex.: /lib/myapp
+    :param force: bypasses protection check - sudo mode
+    """
+    return remove_dir(path, force)
+
+
+def dirtree(path="/", raw=False, core=False):
+    """Return only directories from a given path."""
+    path = path if path.endswith('/') else f"{path}/"
+    folders = [path_join(path, item) for item in ilist_fs(path, type_filter='d', core=core)]
+    folder_contents = {folder:list_fs(folder) for folder in folders}
+    if raw:
+        return folder_contents
+    formatted_output = ""
+    for k, v in folder_contents.items():
+        formatted_output += f"{k}\n"
+        for val in v:
+            formatted_output += f"\t{val[0]}   {val[1]}\n"
+    return formatted_output
+
+
+def cat(path):
+    """
+    Dump any file content
+    """
+    if is_protected(path):
+        return f'Read not allowed'
+    with open(path, 'r') as f:
+        content = f.read()
+    return content
+
+
+def install(ref=None):
+    """
+    Unified mip-based installer for micrOS.
+    Automatically detects:
+      1. Official MicroPython packages (from https://micropython.org/pi/v2)
+            Example: pacman install "umqtt.simple"
+      2. Single-file load modules (LM_/IO_ names or URLs)
+            Example: pacman install "https://github.com/BxNxM/micrOS/blob/master/toolkit/workspace/precompiled/modules/LM_rgb.mpy"
+                     pacman install "github.com/BxNxM/micrOS/blob/master/toolkit/workspace/precompiled/modules/LM_rgb.mpy"
+      3. GitHub packages (folders via tree/blob URLs or github: form)
+            Example: pacman install "github:peterhinch/micropython-mqtt"
+                     pacman install "https://github.com/peterhinch/micropython-mqtt/tree/master"
+                     pacman install "https://github.com/peterhinch/micropython-mqtt/blob/master/package.json"
+                     pacman install "https://github.com/peterhinch/micropython-mqtt"
+                     [NOK] pacman install "https://github.com/basanovase/sim7600/tree/main/sim7600" -> Package not found: github:basanovase/sim7600/package.json
+      4. Install from local /config/requirements.txt file
+            Example: pacman install "requirements.txt"
+    """
+    from Pacman import install as pm_install
+    return pm_install(ref)
+
+
+@sudo
+def uninstall(name=None):
+    """
+    Delete package by name from /lib
+    :param name: None (default) show installed package name
+                 OR package name to delete (str)
+    """
+    if name is None:
+        return list_fs(path=OSPath.LIB, type_filter='d')
+    from Pacman import uninstall as pm_uninstall
+    return pm_uninstall(name)
+
+
+def upgrade(name=None, force=False):
+    """
+    Upgrade package by name from /lib
+    :param name: None (default) show installed package name
+                 OR package name to upgrade (str)
+    :param force: skip version check
+    """
+    if name is None:
+        return list_fs(path=OSPath.LIB, type_filter='d')
+    from Pacman import upgrade as pm_upgrade
+    return pm_upgrade(name, force)
+
+
+def del_duplicates(migrate=True):
+    """
+    Load module package manager (Not just load modules)
+    - delete duplicated .mpy and .py resources, keep .mpy resource!
+    """
+    modules_path = OSPath.MODULES
+    msg_buf = []
+    files =  list_fs(path=modules_path, type_filter='f', select='LM')
+    py = list((res.split('.')[0] for res in files if res.endswith('.py')))       # Normally smaller list
+    mpy = (res.split('.')[0] for res in files if res.endswith('.mpy'))
+    for m in mpy:
+        # Iterate over mpy resources
+        state = True
+        if m in py and m != 'main':
+            to_delete = f'{m}.py'
+            try:
+                verdict = remove_file(path_join(modules_path, to_delete))
+            except:
+                verdict = "n/a"
+                state = False
+            msg_buf.append(f'   Delete {to_delete} {state} - {verdict}')
+
+
+    # MIGRATE /ROOT/LMs & IOs -> /modules
+    def _migrate_from_root(_rf):
+        nonlocal _deleted, files
+        if _rf in files:
+            remove_file(path_join(OSPath._ROOT, _rf))
+            if _rf in ("LM_pacman.mpy", "LM_system.mpy"):
+                # Delete protected LMs from root
+                remove(path_join(OSPath._ROOT, _rf))
+            _deleted += 1
+        else:
+            rename(path_join(OSPath._ROOT, _rf), path_join(modules_path, _rf))
+            msg_buf.append(f'   Move /{_rf} -> modules/{_rf}')
+    if migrate:
+        from uos import rename, remove
+        _deleted = 0
+        files = files + list_fs(path=OSPath._ROOT, type_filter='f', select='IO')
+        for rf in ilist_fs(path=OSPath._ROOT, type_filter='f', select='LM'):
+            _migrate_from_root(rf)
+        for rf in ilist_fs(path=OSPath._ROOT, type_filter='f', select='IO'):
+            _migrate_from_root(rf)
+        if _deleted > 0:
+            msg_buf.append(f'   Purged (/): {_deleted}')
+
+    return '\n'.join(msg_buf) if len(msg_buf) > 0 else 'Nothing to delete.'
+
+
+def moduls(unload=None):
+    """
+    List / unload loaded upython Load Modules
+    :param unload: module name to unload
+    :param unload: None - list active modules
+    :return str: verdict
+    """
+    if unload is None:
+        return list(modules.keys())
+    if unload in modules.keys():
+        del modules[unload]
+        return f"Module unload {unload} done."
+    return f"Module unload {unload} failed."
+
+
+@socket_stream
+def cachedump(delete=None, ext="cache", msgobj=None):
+    """
+    Cache system persistent data storage files (.cache)
+    :param delete: cache name to delete
+    :param ext: cache file extension (default: cache)
+    """
+    data_dir = OSPath.DATA
+    if delete is None:
+        # List cache files aka application cache
+        msg_buf = []
+        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'{_path}: {f.read()}')
+                else:
+                    msgobj(f'{_path}: {f.read()}')
+        return msg_buf if len(msg_buf) > 0 else ''
+    # Remove given cache file
+    try:
+        delete_cache = path_join(data_dir, f"{delete}.cache")
+        verdict = remove_file(delete_cache)
+        return f'{delete_cache} delete done.: {verdict}'
+    except:
+        return f'{delete}.{ext} not exists'
+
+
+def datdump():
+    """
+    Generic .dat file dump
+    - logged data from LMs, sensor data, etc...
+    """
+    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(path_join(data_dir, dat), 'r') as f:
+            out[dat] = f.read()
+    return out
+
+
+def makedir(path):
+    """
+    Create directory command
+    """
+    from uos import mkdir
+    try:
+        mkdir(path)
+        return f"{path} dir created."
+    except Exception as e:
+        return f"{path} failed to create: {e}"
+
+#############################################
+#              Legacy features              #
+#############################################
+
+
+@socket_stream
+def listmods(msgobj=None):
+    """
+    Load module package manager
+    - list all load modules
+    """
+    # Dump available LMs
+    msg_buf = []
+    for k in (res.replace('LM_', '') for res in ilist_fs(path=OSPath.MODULES, type_filter='f', select='LM')):
+        if msgobj is None:
+            msg_buf.append(f'   {k}')
+        else:
+            msgobj(f'   {k}')
+    return msg_buf if len(msg_buf) > 0 else ''
+
+
+@sudo
+def delmod(mod):
+    """
+    Module package manager
+    :param mod:
+        Delete Load Module with full name: module.py or module.mpy
+        OR delete any web resource: *.js, *.css, *.html
+    """
+    if mod.endswith('py'):
+        to_remove = f'LM_{mod}'
+    else:
+        return f'Invalid {mod}, must ends with .py or .mpy'
+    try:
+        return remove_file(path_join(OSPath.MODULES, to_remove))
+    except Exception as e:
+        return f'Cannot delete: {mod}: {e}'
+
+
+@socket_stream
+def micros_checksum(msgobj=None):
+    from hashlib import sha1
+    from binascii import hexlify
+    from Config import cfgget
+
+    for f_name in ilist_fs(path=OSPath.MODULES, type_filter='f', select='LM'):
+        with open(f_name, 'rb') as f:
+            cs = hexlify(sha1(f.read()).digest()).decode('utf-8')
+        msgobj(f"{cs} {f_name}")
+    # GC collect?
+    return f"micrOS version: {cfgget('version')}"
+
+
+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 ('listmods', 'delmod mod=<module>.py/.mpy', 'del_duplicates',
+            'moduls unload="LM_rgb/None"',
+            'cachedump delete=None',
+            'datdump',
+            # Package commands
+            'install url="BxNxM/micrOS/master/toolkit/workspace/precompiled/LM_robustness.py"',
+            'uninstall name=None',
+            'upgrade name=None',
+            # File system commands
+            'micros_checksum',
+            'ls path="/" content="*/f/d" select="*/LM/IO"',
+            'rm <path>',
+            'rmdir <path>',
+            'dirtree path="/"',
+            'makedir <path>')

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

@@ -1,16 +1,12 @@
-from microIO import physical_pin, pinmap_dump
-from Common import SmartADC, micro_task, notify, syslog
-import uasyncio as asyncio
+from microIO import bind_pin, pinmap_search
+from Common import SmartADC, micro_task, notify, syslog, exec_cmd
 from utime import ticks_ms
-try:
-    import LM_intercon as InterCon
-except:
-    InterCon = None
+
 
 class Data:
     TASK_TAG = 'presence._capture'
 
-    MIC_TYPES={'NONE': 0, 'ADC':1, 'I2S': 2}
+    MIC_TYPES = {'NONE':0, 'ADC':1, 'I2S':2}
     MIC_TYPE = MIC_TYPES['NONE']      # Enable/Disable MIC periphery ('ADC', 'I2S', None)
     RAW_DATA = []               # format [[<time>, <amplitude>, <trigger>],...]
     MIC_ADC = None              # Initialized by micro task if sampled by ADC
@@ -26,7 +22,8 @@ class Data:
     OFF_INTERCON_CLBK = None    # Intercon OFF callback
 
     I2S_MIC = None              # Optional LM_i2s_mic import
-    NOTIFY = False
+
+    ENABLE_NOTIFY = False
 
 
 #######################################
@@ -68,9 +65,9 @@ def __run_intercon(state):
         try:
             cmd = Data.ON_INTERCON_CLBK.split()
             host = cmd[0]
-            cmd = ' '.join(cmd[1:])
-            # Send CMD to other device & show result
-            InterCon.send_cmd(host, cmd)
+            cmd = cmd[1:]
+            # Send CMD to other device
+            state, _ = exec_cmd(cmd + [f">>{host}"], jsonify=True)
         except Exception as e:
             syslog(f"__run_intercon error: {e}")
     if state.lower() == "off":
@@ -79,9 +76,9 @@ def __run_intercon(state):
         try:
             cmd = Data.OFF_INTERCON_CLBK.split()
             host = cmd[0]
-            cmd = ' '.join(cmd[1:])
-            # Send CMD to other device & show result
-            InterCon.send_cmd(host, cmd)
+            cmd = cmd[1:]
+            # Send CMD to other device
+            state, _ = exec_cmd(cmd + [f">>{host}"], jsonify=True)
         except Exception as e:
             syslog(f"__run_intercon error: {e}")
 
@@ -91,18 +88,17 @@ def __run_intercon(state):
 ####################################
 
 async def __task(ms_period, buff_size):
-    if Data.NOTIFY:
-        if not notify("Motion detected"):
-            syslog("Motion detect. notify, error...")
+    if Data.ENABLE_NOTIFY and not notify("Motion detected"):
+        syslog("Motion detect. notify, error...")
 
     if Data.MIC_TYPE == Data.MIC_TYPES['ADC']:
         # Create ADC object
-        Data.MIC_ADC = SmartADC.get_singleton(physical_pin('mic'))
+        Data.MIC_ADC = SmartADC.get_instance(bind_pin('mic'))
     elif Data.MIC_TYPE == Data.MIC_TYPES['I2S']:
         if Data.I2S_MIC is None:
             import LM_i2s_mic
             Data.I2S_MIC = LM_i2s_mic
-        Data.I2S_MIC.load_n_init(sampling_rate=2000) # High frequencies can result in slow performance
+        Data.I2S_MIC.load(sampling_rate=2000) # High frequencies can result in slow performance
         Data.I2S_MIC.background_capture()
 
     # ASYNC TASK ADAPTER [*2] with automatic state management
@@ -115,7 +111,7 @@ async def __task(ms_period, buff_size):
                 my_task.out = f"{int(Data.OFF_EV_TIMER)-1} sec until off event"
             Data.OFF_EV_TIMER -= round(ms_period / 1000, 3)
             # Async sleep - feed event loop
-            await asyncio.sleep_ms(ms_period)
+            await my_task.feed(sleep_ms=ms_period)
 
         # RUN OFF CALLBACK (local + remote)
         __exec_local_callbacks(Data.OFF_CALLBACKS)
@@ -186,18 +182,20 @@ def __mic_sample(buff_size, mytask):
 #  PRESENCE PUBLIC FUNCTIONS #
 ##############################
 
-def load_n_init(threshold=Data.TRIG_THRESHOLD, timer=Data.TIMER_VALUE, mic=Data.MIC_TYPE):
+def load(threshold=Data.TRIG_THRESHOLD, timer=Data.TIMER_VALUE, mic=Data.MIC_TYPE, enable_notify=False):
     """
     Initialize presence module
     :param threshold: trigger on relative noice change in percent
     :param timer: off timer in sec
     :param mic: enable / disable mic sampling (bool)
+    :param enable_notify: enable (True) / disable (False) telegram notifications
     """
     threshold = threshold if threshold > 1 else 1
     Data.TRIG_THRESHOLD = threshold
     Data.TIMER_VALUE = timer
     Data.MIC_TYPE = mic
-    return f"Init presence module: th: {threshold} timer: {timer} mic: {mic}"
+    Data.ENABLE_NOTIFY = enable_notify
+    return f"Init presence module: th: {threshold} timer: {timer} mic: {mic} notify: {enable_notify}"
 
 
 def motion_trig(sample_ms=15, buff_size=10):
@@ -215,8 +213,7 @@ def motion_trig(sample_ms=15, buff_size=10):
 
     # [3] Start mic sampling in async task
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.TASK_TAG, task=__task(ms_period=sample_ms, buff_size=buff_size))
-    return "Starting" if state else "Already running"
+    return micro_task(tag=Data.TASK_TAG, task=__task(ms_period=sample_ms, buff_size=buff_size))
 
 
 def subscribe_intercon(on, off):
@@ -231,14 +228,6 @@ def subscribe_intercon(on, off):
     return {'on': Data.ON_INTERCON_CLBK, 'off': Data.OFF_INTERCON_CLBK}
 
 
-def notification(state=None):
-    """Enable/Disable motion detection notifications"""
-    if state is None:
-        return f"Notifications: {'enabled' if Data.NOTIFY else 'disabled'}"
-    Data.NOTIFY = True if state else False
-    return f"Set notifications: {'ON' if Data.NOTIFY else 'OFF'}"
-
-
 def get_samples():
     """
     [DEBUG] Return measured data set
@@ -257,7 +246,7 @@ def pinmap():
     - info which pins to use for this application
     :return dict: pin name (str) - pin value (int) pairs
     """
-    return pinmap_dump(['mic', 'irq1'])
+    return pinmap_search(['mic', 'irq1'])
 
 
 def help(widgets=False):
@@ -267,8 +256,7 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return 'load_n_init threshold=<percent> timer=<sec> mic=0 (0: None, 1: ADC, 2: I2S)',\
+    return 'load threshold=<percent> timer=<sec> mic=0 (0: None, 1: ADC, 2: I2S) enable_notify=False',\
            'motion_trig sample_ms=15 buff_size=10', 'get_samples',\
            'subscribe_intercon on="host cmd" off="host cmd"',\
-           'notification state=None/True/False',\
            'pinmap'

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