micrOSDevToolKit 2.17.2__py3-none-any.whl → 2.20.0__py3-none-any.whl

micrOS/source/modules/LM_tcs3472.py

@@ -6,26 +6,54 @@ Copyright (c) 2021 tti0
 Licensed under the MIT License
 """
 
-from machine import I2C, Pin
+from struct import unpack
+from time import sleep
+from machine import I2C, Pin, PWM
 from microIO import bind_pin, pinmap_search
-import struct
+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, bus, address=0x29):
-        self._bus = bus
+    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):
-        crgb = self.raw()
-        if crgb[0] > 0:
-            return tuple(float(x) / crgb[0] for x in crgb[1:])
-        return 0, 0, 0
+    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())
@@ -42,32 +70,118 @@ class TCS3472:
 
     def raw(self):
         self._bus.writeto(self._i2c_address, b'\xb4')
-        return struct.unpack("<HHHH", self._bus.readfrom(self._i2c_address, 8))
+        return unpack("<HHHH", self._bus.readfrom(self._i2c_address, 8))
 
 
 ############################ Exposed functions ############################
 
-def load():
+def load(led_pin=20):
     """
     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)
+        TCS3472(led_pin=led_pin)
+        neo_load(ledcnt=1)
+        led(False)
     return TCS3472.INSTANCE
 
 
 def pinmap():
-    return pinmap_search(['i2c_scl', 'i2c_sda'])
+    """
+    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()
-    return {"rgb": sensor.rgb(), "light": sensor.light(), "brightness": sensor.brightness()}
+    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(widgest=False):
+def help(widgets=False):
     """
     TCS3472 Color sensor
     """
-    return 'load', 'measure'
+    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)

micrOS/source/modules/LM_telegram.py

@@ -12,6 +12,7 @@ def _timestamp():
 
 
 class Telegram(Notify):
+    INSTANCE = None
     # Telegram bot token and chat ID
     # https://core.telegram.org/bots/api
     _TOKEN = None  # Telegram token
@@ -23,6 +24,7 @@ class Telegram(Notify):
     def __init__(self):
         # Subscribe to the notification system - provide send_msg method (over self)
         super().add_subscriber(self)
+        Telegram.INSTANCE = self
 
     @staticmethod
     def __id_cache(mode):
@@ -236,7 +238,7 @@ class Telegram(Notify):
         return verdict
 
     @staticmethod
-    async def bot_repl(tag, period=3):
+    async def server_bot(tag, period=3):
         """
         BOT - ReceiveEvalPrintLoop
         :param tag: task tag (access)
@@ -290,17 +292,16 @@ class Telegram(Notify):
 #########################################
 #          micrOS Notifications         #
 #########################################
-TELEGRAM_OBJ = None
 
 def __init():
-    global TELEGRAM_OBJ
-    if TELEGRAM_OBJ is None:
+    if Telegram.INSTANCE is None:
         # ENABLE TELEGRAM IF NW IS STA - CONNECTED TO THE WEB
         _sta_available = True if ifconfig()[0] == "STA" else False
         if _sta_available:
-            TELEGRAM_OBJ = Telegram()
+            Telegram()
         else:
             syslog("No STA: cannot init telegram")
+    return Telegram.INSTANCE
 
 # Auto INIT Telegram at load time (legacy)
 __init()
@@ -311,10 +312,9 @@ def load():
     - /ping
     - /cmd module function (params)
     """
-    __init()
-    if TELEGRAM_OBJ is None:
+    if __init() is None:
         return "Network unavailable."
-    verdict = TELEGRAM_OBJ.set_commands()
+    verdict = Telegram.set_commands()
     return "Missing telegram bot token" if verdict is None else verdict
 
 
@@ -324,9 +324,9 @@ def send(text):
     :param text: text to send
     return verdict
     """
-    if TELEGRAM_OBJ is None:
+    if Telegram.INSTANCE is None:
         return "Network unavailable."
-    verdict = TELEGRAM_OBJ.send_msg(text)
+    verdict = Telegram.send_msg(text)
     return "Missing telegram bot token" if verdict is None else verdict
 
 def notify(text):
@@ -336,9 +336,9 @@ def notify(text):
         telegram notification enable=True
         telegram notification enable=False
     """
-    if TELEGRAM_OBJ is None:
+    if Telegram.INSTANCE is None:
         return "Network unavailable."
-    return TELEGRAM_OBJ.notify(text)
+    return Telegram.INSTANCE.notify(text)
 
 
 def receive():
@@ -347,9 +347,9 @@ def receive():
     - if all value None, then no incoming messages
     One successful msg receive is necessary to get chat_id for msg send as well!
     """
-    if TELEGRAM_OBJ is None:
+    if Telegram.INSTANCE is None:
         return "Network unavailable."
-    verdict = TELEGRAM_OBJ.get_msg()
+    verdict = Telegram.get_msg()
     return "Missing telegram bot token" if verdict is None else verdict
 
 
@@ -359,11 +359,10 @@ def receiver_loop(period=3):
     - Only executes module (function) if the module is already loaded
     :param period: polling period in sec, default: 3
     """
-    if TELEGRAM_OBJ is None:
+    if Telegram.INSTANCE is None:
         return "Network unavailable."
-    tag = 'telegram.bot_repl'
-    state = micro_task(tag=tag, task=TELEGRAM_OBJ.bot_repl(tag=tag, period=period))
-    return "Starting" if state else "Already running"
+    tag = 'telegram.server_bot'
+    return micro_task(tag=tag, task=Telegram.server_bot(tag=tag, period=period))
 
 
 def help(widgets=False):