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

toolkit/workspace/precompiled/modules/LM_robustness.py

@@ -0,0 +1,137 @@
+from LM_system import memory_usage
+from Common import socket_stream, syslog, micro_task
+from Auth import sudo
+
+
+@socket_stream
+def raise_error(msgobj=None):
+    """
+    Test function - raise  LM exception
+    """
+    if msgobj is not None:
+        msgobj("Raise test exception")
+    state = syslog('Robustness TeSt ErRoR')
+    raise Exception(f"Test exception: {'OK' if state else 'NOK'}")
+
+
+@socket_stream
+def memory_leak(cnt=160, msgobj=None):
+    """
+    Test function - allocate lot of memory
+    :param cnt: data counter, default 160 iteration
+    :return: verdict
+    """
+    dict_test = {}
+    mem_start = memory_usage()['mem_used']
+    for k in range(cnt):
+        mem = memory_usage()['percent']
+        data = "micrOS memory usage: {} %".format(mem)
+        if msgobj is not None:
+            msgobj("[{}] gen: {}".format(k, data))
+        dict_test[k] = data
+    mem_end = memory_usage()['mem_used']
+    delta = mem_start - mem_end
+    return '[{}] RAM Alloc.: {} kB {} byte'.format(len(dict_test), int(delta / 1024), int(delta % 1024))
+
+@socket_stream
+def recursion_limit(limit=14, msgobj=None):
+    cnt = 0
+    for cnt in range(1, limit+1):
+        try:
+            _recursion(cnt, msgobj=msgobj)
+        except Exception as e:
+            msgobj(f"ok error: {e}")
+            break
+    return f"Recursion limit: {cnt}"
+
+
+def _recursion(cnt, msgobj=None):
+    """
+    Test function - recursion test
+    :param cnt: recursion depth
+    :return: verdict
+    Error example:
+        node01 $  robustness recursion_limit 15
+        lm_exec LM_robustness->recursion_limit: maximum recursion depth exceeded
+    """
+    if cnt > 0:
+        remain = _recursion(cnt-1)
+        if msgobj is not None:
+            msgobj("recalled {}".format(cnt))
+    else:
+        remain = 0
+    return remain
+
+################## TEST micro_task UCs ##########################
+
+async def __task(tag, period_ms):
+    counter = 0
+    with micro_task(tag=tag) as my_task:
+        while True:
+            # DO something here in the async loop...
+            counter += 1
+
+            # Store data in task cache (task show mytask)
+            my_task.out = f'MyTask Counter: {counter}'
+
+            # Async sleep - feed event loop
+            await my_task.feed(sleep_ms=period_ms)
+            # [i] feed same as "await asyncio.sleep_ms(period_ms)" with micrOS features (WDT)
+
+def create_task():
+    """
+    Legacy way of task creation (with exact task tagging)
+    """
+    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
+    task_tag = "microtask.run"
+    return micro_task(tag=task_tag, task=__task(tag=task_tag, period_ms=5))
+
+
+@micro_task("microtask", _wrap=True)
+async def mytask(tag, period_ms=30):
+    """
+    New shorter way of task creation
+     with decorator function
+    """
+    counter = 0
+    with micro_task(tag=tag) as my_task:
+        while True:
+            # DO something here in the async loop...
+            counter += 1
+
+            # Store data in task cache (task show mytask)
+            my_task.out = f'MyTask Counter: {counter}'
+
+            # Async sleep - feed event loop
+            await my_task.feed(sleep_ms=period_ms)
+            # [i] feed same as "await asyncio.sleep_ms(period_ms)" with micrOS features (WDT)
+
+
+@sudo
+def func_sudo():
+    """
+    Function execution requires pwd=<...>
+    """
+    return "Access granted"
+
+
+@sudo(_force_only=(True, 0))
+def func_sudo_force(force=False):
+    """
+    Function requires pwd=<...> when force=True
+    """
+    return f"Access granted, force flag: {force}"
+
+##############################################################################
+
+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 'NOTE: This is a test module to validate system robustness', \
+           'raise_error', 'memory_leak cnt=160', 'recursion_limit cnt=14', \
+           'create_task', 'mytask', "func_sudo", "func_sudo_force"
+

toolkit/workspace/precompiled/{LM_rp2w.py → modules/LM_rp2w.py}

@@ -12,4 +12,7 @@ def temp():
 
 
 def help(widgets=False):
+    """
+    [BETA]
+    """
     return 'temp'

toolkit/workspace/precompiled/{LM_sdcard.py → modules/LM_sdcard.py}

@@ -42,5 +42,8 @@ def read_file(name):
 
 
 def help(widgets=False):
+    """
+    [BETA]
+    """
     return "mount_storage", "unmount_storage", "list_storage",\
            "write_file name content", "read_file name"

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

{micrOS/source → toolkit/workspace/precompiled/web}/dashboard.html

@@ -31,14 +31,18 @@
             transition: border-color 0.3s ease; /* Smooth transition for border color */
         }
     </style>
-    <script src="uapi.js" defer></script>
-    <script src="uwidgets.js" defer></script>
-    <script src="udashboard.js" defer></script>
+    <script src="uapi.js" ></script>
+    <script src="uwidgets.js" ></script>
+    <script src="uwidgets_pro.js" ></script>
+    <script src="udashboard.js" ></script>
 </head>
 <body>
     <h1> micrOS dashboard </h1>
+    <div id="restInfo">
+      <div id="restInfoHeader"></div>
+    </div>
     <!-- Container for the dynamically generated list -->
-    <ul id="dynamicContent"></ul>
+    <section id="widgets-section"></section>
     <br><br><br>
     <button id="toggleDebugSection">console</button>
     <div id="debugSection" style="display: none;">
@@ -53,6 +57,7 @@
     <script>
         document.addEventListener("DOMContentLoaded", function() {
             // Init basic info from board after DOM is fully loaded
+            restInfo(showPages=false);
 
             // INIT DASHBOARD (load active modules -> build page)
             DynamicWidgetLoad();