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

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'

micrOS/source/LM_rest.py

@@ -10,7 +10,7 @@ class Rest:
 def load(gateway_url=None):
     """
     Set gateway url aka main domain
-    :param gateway_url: base url of gateway, like: http://gateway.local:5000
+    :param gateway_url: base url of gateway, like: http://gateway.local:5005
     """
     if gateway_url is None:
         if Rest.GATEWAY_HOST is None:
@@ -77,6 +77,6 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return ('load gateway_url=<http://gateway.local:5000>',
+    return ('load gateway_url=<http://gateway.local:5005>',
             'url subdomain=</webhooks/template>',
-            'aurl subdomain=</webhooks/template>')
+            'aurl subdomain=</webhooks/template>')

micrOS/source/LM_rgb.py

@@ -2,8 +2,7 @@
 #       ANALOG rgb CONTROLLER PARAMS    #
 #########################################
 from machine import Pin, PWM
-from sys import platform
-from Common import transition_gen, micro_task
+from Common import transition_gen, micro_task, data_dir
 from utime import sleep_ms
 from microIO import bind_pin, pinmap_search
 from random import randint
@@ -20,6 +19,7 @@ class Data:
     CH_MAX = 1000                          # maximum value per channel
     TASK_STATE = False
     RGB_TASK_TAG = "rgb._tran"
+    FILE_CACHE = data_dir('rgb.cache')
 
 
 #########################################
@@ -39,7 +39,7 @@ def __RGB_init(red_pin=None, green_pin=None, blue_pin=None):
 
 def __persistent_cache_manager(mode):
     """
-    pds - persistent data structure
+    File state cache
     modes:
         r - recover, s - save
     """
@@ -47,12 +47,12 @@ def __persistent_cache_manager(mode):
         return
     if mode == 's':
         # SAVE CACHE
-        with open('rgb.pds', 'w') as f:
+        with open(Data.FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in Data.RGB_CACHE]))
         return
     try:
         # RESTORE CACHE
-        with open('rgb.pds', 'r') as f:
+        with open(Data.FILE_CACHE, 'r') as f:
             Data.RGB_CACHE = [float(data) for data in f.read().strip().split(',')]
     except:
         pass
@@ -74,7 +74,7 @@ def load(red_pin=None, green_pin=None, blue_pin=None, cache=True):
     :param red_pin: optional red color pin to overwrite built-in
     :param green_pin: optional green color pin to overwrite built-in
     :param blue_pin: optional blue color pin to overwrite built-in
-    :param cache: file state machine cache: True/False (.pds), default=True
+    :param cache: file state machine cache: True/False (.cache), default=True
     :return str: Cache state
     """
     Data.PERSISTENT_CACHE = cache

micrOS/source/LM_roboarm.py

@@ -2,7 +2,7 @@ from utime import sleep_ms
 from random import randint
 import LM_servo as servo
 from LM_switch import set_state, pinmap as switch_pinmap
-from Common import transition, micro_task
+from Common import transition, micro_task, data_dir
 from Types import resolve
 
 
@@ -13,23 +13,24 @@ class RoboArm:
     SPEED_MS = 10                           # Set default speed between steps (ms)
     MOVE_RECORD = []                        # Buffer for XY move record/replay
     PLAY_TAG = 'roboarm._play'
+    FILE_CACHE = data_dir('rarm.cache')
 
 
 def __persistent_cache_manager(mode):
     """
-    pds - persistent data structure
+    File state cache
     modes:
         r - recover, s - save
     """
 
     if mode == 's':
         # SAVE CACHE
-        with open('rarm.pds', 'w') as f:
+        with open(RoboArm.FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in RoboArm.MOVE_RECORD]))
         return
     try:
         # RESTORE CACHE
-        with open('rarm.pds', 'r') as f:
+        with open(RoboArm.FILE_CACHE, 'r') as f:
             RoboArm.MOVE_RECORD = [int(data) for data in f.read().strip().split(',')]
     except:
         pass

micrOS/source/LM_switch.py

@@ -1,5 +1,6 @@
 from machine import Pin
 from microIO import bind_pin, pinmap_search
+from Common import data_dir
 from Types import resolve
 
 #########################################
@@ -8,6 +9,7 @@ from Types import resolve
 __SWITCH_OBJ = [None, None, None, None]
 __PERSISTENT_CACHE = False
 __SWITCH_STATE = [0, 0, 0, 0]
+__FILE_CACHE = data_dir('switch.cache')
 
 
 #########################################
@@ -16,7 +18,7 @@ __SWITCH_STATE = [0, 0, 0, 0]
 
 def __persistent_cache_manager(mode):
     """
-    pds - persistent data structure
+    File cache
     modes:
         r - recover, s - save
     """
@@ -25,12 +27,12 @@ def __persistent_cache_manager(mode):
     global __SWITCH_STATE
     if mode == 's':
         # SAVE CACHE
-        with open('switch.pds', 'w') as f:
+        with open(__FILE_CACHE, 'w') as f:
             f.write(','.join([str(k) for k in __SWITCH_STATE]))
         return
     try:
         # RESTORE CACHE
-        with open('switch.pds', 'r') as f:
+        with open(__FILE_CACHE, 'r') as f:
             __SWITCH_STATE = [int(data) for data in f.read().strip().split(',')]
     except:
         pass
@@ -54,7 +56,7 @@ def load(cache=None, ch_init=None):
     """
     Initiate switch module (4 switch pack)
     :param cache bool: file state machine cache: True/False/None(default: automatic True)
-    - Load .pds (state machine cache) for this load module
+    - Load .cache (state machine cache) for this load module
     - Apply loaded states to gpio pins (boot function)
     :return str: Cache state
     """

micrOS/source/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_telegram.py

@@ -2,7 +2,7 @@ from sys import modules
 import urequests
 from Notify import Notify
 from Config import cfgget
-from Common import micro_task, syslog, console_write
+from Common import micro_task, syslog, console_write, data_dir
 from LM_system import ifconfig
 from utime import localtime
 
@@ -18,6 +18,7 @@ class Telegram(Notify):
     _CHAT_IDS = set()  # Telegram bot chat IDs - multi group support - persistent caching
     _API_PARAMS = "?offset=-1&limit=1&timeout=2"  # Generic API params - optimization
     _IN_MSG_ID = None
+    _FILE_CACHE = data_dir('telegram.cache')
 
     def __init__(self):
         # Subscribe to the notification system - provide send_msg method (over self)
@@ -26,20 +27,20 @@ class Telegram(Notify):
     @staticmethod
     def __id_cache(mode):
         """
-        pds - persistent data structure
+        File cache
         modes:
             r - recover, s - save
         """
         if mode == 's':
             # SAVE CACHE
             console_write("[NTFY] Save chatIDs cache...")
-            with open('telegram.pds', 'w') as f:
+            with open(Telegram._FILE_CACHE, 'w') as f:
                 f.write(','.join([str(k) for k in Telegram._CHAT_IDS]))
             return
         try:
             # RESTORE CACHE
             console_write("[NTFY] Restore chatIDs cache...")
-            with open('telegram.pds', 'r') as f:
+            with open(Telegram._FILE_CACHE, 'r') as f:
                 # set() comprehension
                 Telegram._CHAT_IDS = {int(k) for k in f.read().strip().split(',')}
         except:

micrOS/source/Logger.py

@@ -6,48 +6,52 @@ Designed by Marcell Ban aka BxNxM
 """
 from time import localtime
 from re import match
-from uos import remove, mkdir, getcwd
-from Files import ilist_fs, is_dir
+from uos import remove, mkdir
+from Files import OSPath, path_join, ilist_fs, is_dir
 
 #############################################
 #        LOGGING WITH DATA ROTATION         #
 #############################################
-LOG_FOLDER = None
 
 def _init_logger():
     """ Init /logs folder """
-    global LOG_FOLDER
-    if LOG_FOLDER is None:
-        LOG_FOLDER = f"{getcwd()}logs"
-        if not is_dir(LOG_FOLDER):
-            try:
-                mkdir(LOG_FOLDER)
-                syslog(f"[BOOT] log dir {LOG_FOLDER} init")
-            except Exception as e:
-                LOG_FOLDER = getcwd()
-                syslog(f"[BOOT] log dir {LOG_FOLDER} fallback: {e}")
-    return LOG_FOLDER
+    if not is_dir(OSPath.LOGS):
+        try:
+            mkdir(OSPath.LOGS)
+            syslog(f"[BOOT] log dir {OSPath.LOGS} init")
+        except Exception as e:
+            OSPath.LOGS = OSPath.ROOT
+            syslog(f"[BOOT] log dir {OSPath.LOGS} fallback: {e}")
+    return OSPath.LOGS
+
+
+def _dir_select(f_name:str) -> str:
+    """
+    Select log dir based on file extension
+    :param f_name: filename with extension to detect target dir
+    """
+    if f_name.endswith(".log"):
+        return OSPath.LOGS
+    return OSPath.DATA
 
 
-def logger(data, f_name, limit):
+def logger(data, f_name:str, limit:int):
     """
-    Create generic logger function
-    - implements log line rotation
-    - automatic time stump
-    :param data: input string data to log
+    Generic logger function with line rotation and time
+    :param data: data to log
     :param f_name: file name to use
     :param limit: line limit for log rotation
     return write verdict - true / false
     INFO: hardcoded max data number = 30
     """
     def _logger(f_mode='r+'):
-        nonlocal data, f_name, limit
+        nonlocal data, f_path, limit
         limit = min(limit, 30)  # Hardcoded max data line = 30
         # [1] GET TIME STUMP
         ts_buff = [str(k) for k in localtime()]
         ts = ".".join(ts_buff[0:3]) + "-" + ":".join(ts_buff[3:6])
         # [2] OPEN FILE - WRITE DATA WITH TS
-        with open(f_name, f_mode) as f:
+        with open(f_path, f_mode) as f:
             _data = f"{ts} {data}\n"
             # read file lines and filter by time stump chunks (hack for replace truncate)
             lines = [_l for _l in f.readlines() if '-' in _l and '.' in _l]
@@ -61,7 +65,7 @@ def logger(data, f_name, limit):
             # write file
             f.write(''.join(lines))
 
-    f_name = f"{LOG_FOLDER}/{f_name}"
+    f_path = path_join(_dir_select(f_name), f_name)
     # Run logger
     try:
         # There is file - append 'r+'
@@ -75,17 +79,17 @@ def logger(data, f_name, limit):
     return True
 
 
-def log_get(f_name, msgobj=None):
+def log_get(f_name:str, msgobj=None):
     """
-    Get and stream (ver osocket/stdout) .log file's content and count "critical" errors
-    - critical error tag in log line: [ERR]
+    Generic file getter for .log files
+    - log content critical [ERR] counter
     """
-    f_name = f"{LOG_FOLDER}/{f_name}"
+    f_path = path_join(_dir_select(f_name), f_name)
     err_cnt = 0
     try:
         if msgobj is not None:
-            msgobj(f_name)
-        with open(f_name, 'r') as f:
+            msgobj(f_path)
+        with open(f_path, 'r') as f:
             eline = f.readline().strip()
             while eline:
                 # GET error from log line (tag: [ERR])
@@ -100,10 +104,16 @@ def log_get(f_name, msgobj=None):
 
 
 def syslog(data=None, msgobj=None):
+    """
+    System log setter/getter
+    :param data: None - read logs, str - write logs
+    :param msgobj: function to stream .log files
+    """
     if data is None:
-        err_cnt = sum([log_get(f, msgobj) for f in ilist_fs(LOG_FOLDER, type_filter='f') if f.endswith(".sys.log")])
+        # READ LOGS
+        err_cnt = sum([log_get(f, msgobj) for f in ilist_fs(OSPath.LOGS, type_filter='f') if f.endswith(".sys.log")])
         return err_cnt
-
+    # WRITE LOGS - [target].sys.log automatic log level detection
     _match = match(r"^\[([^\[\]]+)\]", data)
     log_lvl = _match.group(1).lower() if _match else 'user'
     f_name = f"{log_lvl}.sys.log" if log_lvl in ("err", "warn", "boot") else 'user.sys.log'
@@ -111,9 +121,13 @@ def syslog(data=None, msgobj=None):
 
 
 def log_clean(msgobj=None):
-    to_del = [file for file in ilist_fs(LOG_FOLDER, type_filter='f') if file.endswith('.log')]
+    """
+    Clean logs folder
+    """
+    logs_dir = OSPath.LOGS
+    to_del = [file for file in ilist_fs(logs_dir, type_filter='f') if file.endswith('.log')]
     for _del in to_del:
-        _del = f"{LOG_FOLDER}/{_del}"
+        _del = path_join(logs_dir, _del)
         if msgobj is not None:
             msgobj(f" Delete: {_del}")
         remove(_del)