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

toolkit/micrOSdashboard.py

@@ -6,17 +6,12 @@ import os
 import threading
 import subprocess
 import time
-from PyQt5.QtWidgets import QPushButton
-import PyQt5.QtCore as QtCore
-from PyQt5.QtCore import pyqtSlot
-from PyQt5.QtWidgets import *
-from PyQt5.QtGui import QIcon
-from PyQt5.QtGui import QTextCursor
-from PyQt5.QtWidgets import QApplication, QPlainTextEdit
-from PyQt5.QtCore import QThread, pyqtSignal
-from PyQt5.QtGui import QFont
-from PyQt5 import QtGui
-from PyQt5.QtGui import QPixmap
+
+from PyQt5.QtWidgets import (QApplication, QPlainTextEdit, QPushButton, QProgressBar, QComboBox, QLabel, QCheckBox,
+                             QLineEdit, QMessageBox, QWidget, QToolTip)
+from PyQt5.QtCore import pyqtSlot, QThread, QSize, pyqtSignal
+from PyQt5.QtGui import QIcon, QTextCursor, QFont, QPixmap
+
 import concurrent.futures
 
 MYPATH = os.path.dirname(__file__)
@@ -454,7 +449,7 @@ class HeaderInfo:
         logo_path = os.path.join(MYPATH, '../media/logo_mini.png')
         button = QPushButton('', self.parent_obj)
         button.setIcon(QIcon(logo_path))
-        button.setIconSize(QtCore.QSize(50, 50))
+        button.setIconSize(QSize(50, 50))
         button.setGeometry(20, 5, 50, 50)
         button.setToolTip(f"Open micrOS repo documentation\n{self.url}")
         button.setStyleSheet('border: 0px solid black;')
@@ -1219,7 +1214,7 @@ class micrOSGUI(QWidget):
 
 def main():
     app = QApplication(sys.argv)
-    app.setWindowIcon(QtGui.QIcon(os.path.join(MYPATH, '../media/logo.png')))
+    app.setWindowIcon(QIcon(os.path.join(MYPATH, '../media/logo.png')))
     ex = micrOSGUI()
     ex.draw()
     sys.exit(app.exec_())

toolkit/socketClient.py

@@ -185,8 +185,8 @@ class ConnectionData:
             return None, None, None, None
 
     @staticmethod
-    def nodes_status():
-        spr_offset1 = 30
+    def nodes_status(feature_stat=True):
+        spr_offset1 = 25
         spr_offset2 = 57
 
         def _dev_status(ip, port, fuid, uid):
@@ -199,6 +199,10 @@ class ConnectionData:
                     Colors.WARN, Colors.NC)
                 version_data = '<n/a>'
                 elapsed_time = 'n/a'
+                webui_state = 'n/a'
+                espnow_state  = 'n/a'
+                cron_state = 'n/a'
+                timirq_state = 'n/a'
                 online_ip = None
 
                 # is online
@@ -206,9 +210,17 @@ class ConnectionData:
                     # get version data
                     online_ip = ip
                     try:
+                        connection = SocketDictClient(host=ip, port=port, silent_mode=True, tout=3)
+                        # Get version and elapsed time data
                         start_comm = time.time()
-                        version_data = SocketDictClient(host=ip, port=port, silent_mode=True, tout=3).non_interactive(['version'])
+                        version_data = connection.non_interactive(['version'])
                         elapsed_time = "{:.3f}".format(time.time() - start_comm)
+                        if feature_stat:
+                            # Get active features info
+                            webui_state = connection.non_interactive(['conf', 'webui'])
+                            espnow_state = connection.non_interactive(['conf', 'espnow'])
+                            cron_state = connection.non_interactive(['conf', 'cron'])
+                            timirq_state = connection.non_interactive(['conf', 'timirq'])
                     except Exception as e:
                         print(f"Getting device version {fuid}:{uid} error: {e}")
 
@@ -216,14 +228,22 @@ class ConnectionData:
                 base_info = "{uid}{spr1}{fuid}".format(uid=uid, spr1=spacer1, fuid=fuid)
                 spacer1 = " " * (spr_offset2 - len(base_info))
                 spacer2 = "\t" if len(version_data) > 7 else "\t\t"
-                data_line_str = f"{base_info}{spacer1}{ip}\t{is_online}\t\t{version_data}{spacer2}{elapsed_time}"
+                feature_info = ""
+                if feature_stat:
+                    _on_str = f"{Colors.OKGREEN}{Colors.BOLD}ON {Colors.NC}"
+                    _off_str = f"{Colors.BOLD}OFF{Colors.NC}"
+                    _fspacer = " "*6
+                    bool2str = lambda x: _on_str if x.strip() == "True" else _off_str if x != "n/a" else x
+                    feature_info = f"\t\t{bool2str(webui_state)}{_fspacer}{bool2str(espnow_state)}{_fspacer}{bool2str(cron_state)}{_fspacer}{bool2str(timirq_state)}"
+                data_line_str = f"{base_info}{spacer1}{ip}\t{is_online}\t\t{version_data}{spacer2}{elapsed_time}{feature_info}"
                 return data_line_str, online_ip
             return None
 
         nodes_dict = ConnectionData.read_micrOS_device_cache()
-        spacer1 = " " * (spr_offset1 - 14)
-        print("{cols}       [ UID ]{spr1}[ FUID ]\t\t[ IP ]\t\t[ STATUS ]\t[ VERSION ]\t[COMM SEC]{cole}"
-              .format(spr1=spacer1, cols=Colors.OKBLUE + Colors.BOLD, cole=Colors.NC))
+        spacer1 = " " * (spr_offset1 - 8)
+        feature_header_str = "\t[WEBUI | ESPNOW | CRON | TIMIRQ]" if feature_stat else ""
+        print("{cols}[ UID ]{spr1}[ FUID ]\t\t[ IP ]\t\t[ STATUS ]\t[ VERSION ]\t[COMM SEC]{features}{cole}"
+              .format(spr1=spacer1, cols=Colors.OKBLUE + Colors.BOLD, features=feature_header_str, cole=Colors.NC))
 
         # Start parallel status queries
         query_list = []

toolkit/workspace/precompiled/modules/LM_espnow.py

@@ -17,6 +17,13 @@ def stats():
     return ESPNOW.stats()
 
 
+def members():
+    """
+    Get ESPNow devices
+    """
+    return ESPNOW.members()
+
+
 def handshake(peer:bytes|str):
     """
     Handshake with ESPNow Peer
@@ -27,10 +34,20 @@ def handshake(peer:bytes|str):
     return ESPNOW.handshake(peer)
 
 
+def remove(peer:bytes):
+    """
+    Remove peer by binary mac address
+    :param peer: binary mac address of espnow device
+    """
+    return ESPNOW.remove_peer(peer)
+
+
 def help():
     """
     ESPNOW sender/receiver with LM execution
     """
     return ('handshake peer=<mac-address>',
             'send peer=<peer-name> cmd="hello"',
-            'stats')
+            'remove peer=<binary-mac-address>',
+            'stats',
+            'members')

toolkit/workspace/precompiled/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)