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

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

@@ -1,4 +1,4 @@
-from os import statvfs, getcwd, listdir, uname
+from uos import statvfs, getcwd, uname
 from utime import localtime
 from network import WLAN, STA_IF, AP_IF
 from binascii import hexlify
@@ -124,18 +124,18 @@ def sun(refresh=False):
     return Sun.TIME
 
 
-def setclock(year, month, mday, hour, min, sec):
+def setclock(year, month, mday, hour, minute, sec):
     """
     Set Localtime + RTC Clock manually
     :param year
     :param month
     :param mday
     :param hour
-    :param min
+    :param minute
     :param sec
     :return: localtime
     """
-    set_time(year, month, mday, hour, min, sec)
+    set_time(year, month, mday, hour, minute, sec)
     return localtime()
 
 
@@ -178,17 +178,20 @@ def list_stations():
     return [("NoAP", '')]
 
 
-def pinmap(keys='builtin irq1 irq2 irq3 irq4'):
+def pinmap(keys:str=None) -> dict:
     """
     Get Logical pin by key runtime
-    :param keys str: logical pin name or names to resolve
+    :param keys: logical pin name or names to resolve
+        example: 'builtin irq1 irq2 irq3 irq4'
     :return dict: key map
     """
     from microIO import pinmap_search, pinmap_info
-    map = pinmap_info()
-    keys = keys.split()
-    map["search"] = pinmap_search(keys)
-    return map
+    if keys is None:
+        map = pinmap_info(show_all=True)                 # map, booked, custom, known_maps
+        return map
+    keys = keys.replace(',', '').split()
+    return pinmap_search(keys)
+
 
 @socket_stream
 def alarms(clean=False, msgobj=None):
@@ -204,19 +207,6 @@ def alarms(clean=False, msgobj=None):
     return {'NOK alarm': errcnt} if errcnt > 0 else {'OK alarm': errcnt}
 
 
-def dat_dump():
-    """
-    Generic .dat file dump
-    - logged data from LMs
-    """
-    dats = (f for f in listdir() if f.endswith('.dat'))
-    out = {}
-    for dat in dats:
-        with open(dat, 'r') as f:
-            out[dat] = f.read()
-    return out
-
-
 def ifconfig():
     """
     Show network ifconfig
@@ -224,24 +214,39 @@ def ifconfig():
     return network_config()
 
 
-def urequests_host_cache():
+def hosts():
     """
-    Debug function for urequests address caching
-    - returns all known http(s) host addresses
-    - cache only in memory
+    Dump cached hosts
+    - urequests (only memory cache)
+    - intercon connection cache
     """
     from urequests import host_cache
-    return host_cache()
+    from InterConnect import host_cache as ihost_cache
+    return {"urequests": host_cache(), "intercon":  ihost_cache()}
 
 
 def notifications(enable=None):
     """
     Global notifications control for micrOS
     :param enable: True: Enable notifications / False: Disable notifications
-    return: state verdict
+    return: show state verdict and available notification handlers
     """
     return Notify.notifications(state=enable)
 
+def notify(msg, *args, **kwargs):
+    """
+    Send notification over registered notification handlers
+    :param msg: notification message
+    :param channels (optional): select communication interface(s) by class name
+       e.g. "Telegram", "MQTT" or an iterable of these.
+       If omitted or empty, sends over all available channels.
+    :param *: optional interface dependent options (topic, chat_id, etc...)
+    Control with:
+        system notifications enable=True
+        system notifications enable=False
+    """
+    return Notify.notify(msg, *args, **kwargs)
+
 #######################
 # LM helper functions #
 #######################
@@ -254,8 +259,9 @@ def help(widgets=False):
         (widgets=True) list of widget json for UI generation
     """
     return resolve(('info', 'TEXTBOX top', 'gclean', 'heartbeat', 'clock',
-                    'setclock year month mday hour min sec',
-                    'ntp', 'rssi', 'list_stations', 'pinmap key="dhtpin"/None', 'alarms clean=False',
+                    'setclock year month mday hour minute sec',
+                    'ntp', 'rssi', 'list_stations', 'pinmap key="builtin"', 'alarms clean=False',
                     'notifications enable=<None,True,False>',
+                    'notify "msg" *',
                     'sun refresh=False', 'ifconfig', 'memory_usage',
-                    'disk_usage', 'dat_dump', 'urequests_host_cache'), widgets=widgets)
+                    'disk_usage', 'hosts'), widgets=widgets)

micrOS/source/modules/LM_tcs3472.py

@@ -0,0 +1,187 @@
+"""
+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 struct import unpack
+from time import sleep
+from machine import I2C, Pin, PWM
+from microIO import bind_pin, pinmap_search
+from Types import resolve
+
+from LM_neopixel import load as neo_load, color as neo_color, toggle as neo_toggle    # local neopixel light indicator
+from LM_cluster import run as cluster_run                                             # DEMO: neomatrix cluster
+
+CURRENT_ANIMATION_INDEX = 0                                                           # DEMO: neomatrix cluster animation
+
+class TCS3472:
+    INSTANCE = None
+
+    def __init__(self, address=0x29, led_pin=None):
+        self._bus = I2C(sda=Pin(bind_pin('i2c_sda')), scl=Pin(bind_pin('i2c_scl')))
+        self._i2c_address = address
+        self._bus.writeto(self._i2c_address, b'\x80\x03')
+        self._bus.writeto(self._i2c_address, b'\x81\x2b')
+        self.led = PWM(Pin(bind_pin('led', led_pin), Pin.OUT), freq=20480)
+        self.led_brightness = 20
+        TCS3472.INSTANCE = self
+
+    def scaled(self, saturation=1.5):
+        """
+        Normalize by strongest color, then adjust saturation.
+        saturation = 1.0 -> normal
+        saturation > 1.0 -> more vibrant
+        saturation < 1.0 -> more pastel
+        """
+        _, r, g, b = self.raw()
+        m = max(r, g, b)
+        if m == 0:
+            return 0.0, 0.0, 0.0
+
+        # Normalize by strongest channel
+        r, g, b = r / m, g / m, b / m
+
+        # Grayscale = average of channels
+        gray = (r + g + b) / 3
+
+        # Interpolate between gray and color
+        r = gray + (r - gray) * saturation
+        g = gray + (g - gray) * saturation
+        b = gray + (b - gray) * saturation
+
+        # Clamp to 0..1
+        return max(0, min(1, r)), max(0, min(1, g)), max(0, min(1, b))
+
+    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 unpack("<HHHH", self._bus.readfrom(self._i2c_address, 8))
+
+
+############################ Exposed functions ############################
+
+def load(led_pin=20):
+    """
+    Load the TCS3472 Color sensor instance.
+    """
+    if TCS3472.INSTANCE is None:
+        TCS3472(led_pin=led_pin)
+        neo_load(ledcnt=1)
+        led(False)
+    return TCS3472.INSTANCE
+
+
+def pinmap():
+    """
+    Show used pin mapping for this module.
+    """
+    return pinmap_search(['i2c_scl', 'i2c_sda', 'led'])
+
+
+def measure():
+    """
+    MEASURE sensor
+    """
+    sensor = load()
+    measurement = {"rgb": sensor.rgb(), "light": sensor.light(), "brightness": sensor.brightness()}
+    return measurement
+
+
+def led(state:bool=None, br:int=None):
+    """
+    SENSOR LED toggle
+    :param state: None-automatic, True-ON, False-OFF
+    :param br: brightness 0-100
+    """
+    def _set_duty(_br):
+        _br = sensor.led_brightness if _br is None else _br
+        sensor.led.duty(int(_br * 10))
+        if _br != 0:
+            sensor.led_brightness = _br
+
+    sensor = load()
+    if state is None:
+        # INVERT STATE
+        led_current_state = sensor.led.duty() > 0
+        if led_current_state:
+            _set_duty(br)
+            _set_duty(0)
+            neo_toggle(False)
+        else:
+            _set_duty(br)
+            neo_toggle(True)
+    else:
+        # SET STATE: ON/OFF
+        if state:
+            _set_duty(br)
+            neo_toggle(True)
+        else:
+            _set_duty(br)
+            _set_duty(0)
+            neo_toggle(False)
+    return f"LED on, {sensor.led_brightness}%" if sensor.led.duty()>0 else f"LED off"
+
+
+def indicator(br=5):
+    """
+    Color indicator Neopixel LED update
+    :param br: brightness 0-100
+    """
+    r, g, b = measure()['rgb']
+    br = float(br / 100)
+    _r, _g, _b = int(r*br), int(g*br), int(b*br)
+    neo_color(_r, _g, _b, smooth=False)
+    return r, g, b
+
+
+def neomatrix_update():
+    """
+    DEMO - Send color codes for all neomatrix devices over espnow cluster
+    """
+    r, g, b = indicator()
+    command = f"neomatrix color_fill {r} {g} {b}"
+    cluster_run(command)
+    return {"cmd": command, "cluster": "task show con.espnow.*"}
+
+
+def neomatrix_animation():
+    """
+    DEMO - Set random animation on neomatrix espnow cluster
+    """
+    global CURRENT_ANIMATION_INDEX
+    animations = ('spiral', 'snake', 'noise')
+
+    next_animation = CURRENT_ANIMATION_INDEX + 1
+    CURRENT_ANIMATION_INDEX = 0 if next_animation >= len(animations) else next_animation
+    command = f"neomatrix {animations[CURRENT_ANIMATION_INDEX]}"
+    cluster_run(command)
+    return {"cmd": command, "cluster": "task show con.espnow.*"}
+
+
+def help(widgets=False):
+    """
+    TCS3472 Color sensor
+    """
+    return resolve(('load led_pin=20',
+                    'TEXTBOX measure',
+                    'BUTTON led state=<True,False>',
+                    'SLIDER led state=True br=<0-100-5>',
+                    'indicator br=<0-100>',
+                    'BUTTON neomatrix_update',
+                    'BUTTON neomatrix_animation',
+                    'pinmap'), widgets=widgets)