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

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

@@ -1,7 +1,8 @@
 from machine import Pin
 import micropython
 from Common import socket_stream, syslog
-from microIO import physical_pin, pinmap_dump
+from microIO import bind_pin, pinmap_search
+from Types import resolve
 
 # https://www.coderdojotc.org/micropython/sensors/10-rotary-encoder/
 
@@ -42,27 +43,43 @@ class Rotary:
 
 class Data:
     ROTARY_OBJ = None
-    VAL = 0
     EVENT = True
+    VAL = 0
+    MIN_VAL = 0
+    MAX_VAL = 20
+    COLOR = (None, ())
 
 
 def _rotary_changed(change):
     if change == Rotary.ROT_CW:
         Data.EVENT = True
         Data.VAL = Data.VAL + 1
+        if Data.VAL > Data.MAX_VAL:
+            Data.VAL = Data.MIN_VAL
     elif change == Rotary.ROT_CCW:
         Data.EVENT = True
         Data.VAL = Data.VAL - 1
+        if Data.VAL < Data.MIN_VAL:
+            Data.VAL = Data.MAX_VAL
+    # Color on neopixel
+    if callable(Data.COLOR[0]):
+        try:
+            r, g, b = Data.COLOR[1][Data.VAL]
+            Data.COLOR[0](r, g, b)
+        except Exception as e:
+            syslog(f"[ERR] rencoder color: {e}")
 
 
-def load_n_init():
+def load(min_val=0, max_val=20):
     """
     Create rotary encoder
     """
     if Data.ROTARY_OBJ is None:
         # GPIO Pins 33 and 35 are for the encoder pins.
-        Data.ROTARY_OBJ = Rotary(physical_pin('rot_dt'), physical_pin('rot_clk'))
-        Data.VAL = 0
+        Data.ROTARY_OBJ = Rotary(bind_pin('rot_dt'), bind_pin('rot_clk'))
+        Data.MIN_VAL = min_val
+        Data.MAX_VAL = max_val
+        Data.VAL = min_val
         Data.ROTARY_OBJ.add_handler(_rotary_changed)
     return 'Init RotaryEncoder with IRQs.'
 
@@ -72,7 +89,7 @@ def read_state(msgobj=None):
     """
     Read rotary encoder status / relative position
     """
-    load_n_init()
+    load()
     if msgobj is not None:
         if Data.EVENT:
             msgobj(f"[stream] RotaryState: {Data.VAL}")
@@ -87,19 +104,31 @@ def reset_state():
     Reset rotary encoder state to 0
     """
     msg = f"Reset state {Data.VAL} -> 0"
-    Data.VAL = 0
+    Data.VAL = Data.MIN_VAL
     return msg
 
 
-def pinmap(widgets=False):
+def pinmap():
     """
     [i] micrOS LM naming convention
     Load Module built-in help message
     :return tuple: list of functions implemented by this application (widgets=False)
     :return tuple: list of widget json for UI generation (widgets=True)
     """
-    return pinmap_dump(['rot_clk', 'rot_dt'])
+    return pinmap_search(['rot_clk', 'rot_dt'])
+
+
+def color_indicator():
+    """Encoder visualization on LED colors (LM_neopixel)"""
+    from LM_neopixel import color
+    palette_template = ((20, 0, 0), (10, 10, 0), (0, 20, 0), (0, 10, 10), (0, 0, 20))
+    repeat = int(Data.MAX_VAL / len(palette_template))+1
+    palette = palette_template * repeat
+    Data.COLOR = (color, palette)
+    color(0, 0, 0)          # initial color OFF
+    return palette
 
 
-def help():
-    return 'load_n_init', 'read_state', 'reset_state', 'pinmap'
+def help(widgets=False):
+    return resolve(('load min_val=0 max_val=20', 'TEXTBOX read_state',
+                             'reset_state', 'color_indicator', 'pinmap'), widgets=widgets)

micrOS/source/modules/LM_rest.py

@@ -0,0 +1,81 @@
+from urequests import get as http_get
+from urequests import aget as http_aget
+from Common import micro_task
+
+
+class Rest:
+    GATEWAY_HOST = None
+
+
+def load(gateway_url=None):
+    """
+    Set gateway url aka main domain
+    :param gateway_url: base url of gateway, like: http://gateway.local:5005
+    """
+    if gateway_url is None:
+        if Rest.GATEWAY_HOST is None:
+            return 'Missing Gateway url'
+        return Rest.GATEWAY_HOST
+    if gateway_url.startswith("http"):
+        Rest.GATEWAY_HOST = gateway_url
+    else:
+        return f"URL have to starts with http/https"
+    return f'Gateway url: {gateway_url}'
+
+
+def _subdomain(subdomain):
+    if Rest.GATEWAY_HOST is None:
+        raise Exception('Missing Gateway url')
+    if not subdomain.startswith('/'):
+        subdomain = '/' + subdomain
+    domain = f'{Rest.GATEWAY_HOST}{subdomain}'
+    return domain
+
+
+def url(subdomain):
+    """
+    Execute rest call with given subdomain / url
+    :param subdomain: url parameter,  http(s) full url or gateway subdomain like: /webhooks/template
+    """
+    if subdomain.startswith('http'):
+        domain = subdomain
+    else:
+        domain = _subdomain(subdomain)
+    status_code, response = http_get(domain, jsonify=True)
+    return {'status': status_code, 'response': response}
+
+
+async def __task(subdomain, tag):
+    with micro_task(tag=tag) as my_task:
+        my_task.out = f"GET {subdomain}"
+        if subdomain.startswith('http'):
+            domain = subdomain
+        else:
+            domain = _subdomain(subdomain)
+        status_code, response = await http_aget(domain, jsonify=True)
+        my_task.out = f'status: {status_code}, response: {response}'
+    return {'status': status_code, 'response': response}
+
+
+def aurl(subdomain):
+    """
+    Execute async rest call with given subdomain / url
+    :param subdomain: url parameter,  http(s) full url or gateway subdomain like: /webhooks/template
+    """
+    # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
+    tag = "rest." + subdomain.replace("http://", '').replace("https://", '')
+    if len(tag) > 50:
+        tag = tag[0:50]
+    return micro_task(tag=tag, task=__task(subdomain, tag))
+
+
+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 gateway_url=<http://gateway.local:5005>',
+            'url subdomain=</webhooks/template>',
+            'aurl subdomain=</webhooks/template>')

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

@@ -2,11 +2,9 @@
 #       ANALOG rgb CONTROLLER PARAMS    #
 #########################################
 from machine import Pin, PWM
-from sys import platform
-from Common import transition_gen, micro_task
-import uasyncio as asyncio
+from Common import transition_gen, micro_task, data_dir
 from utime import sleep_ms
-from microIO import physical_pin, pinmap_dump
+from microIO import bind_pin, pinmap_search
 from random import randint
 from Types import resolve
 
@@ -21,31 +19,27 @@ class Data:
     CH_MAX = 1000                          # maximum value per channel
     TASK_STATE = False
     RGB_TASK_TAG = "rgb._tran"
+    FILE_CACHE = data_dir('rgb.cache')
 
 
 #########################################
 #      ANALOG rgb WITH 3 channel PWM    #
 #########################################
 
-def __RGB_init():
+def __RGB_init(red_pin=None, green_pin=None, blue_pin=None):
     if Data.RGB_OBJS[0] is None or Data.RGB_OBJS[1] is None or Data.RGB_OBJS[2] is None:
-        red = Pin(physical_pin('redgb'))
-        green = Pin(physical_pin('rgreenb'))
-        blue = Pin(physical_pin('rgbue'))
-        if platform == 'esp8266':
-            Data.RGB_OBJS = (PWM(red, freq=1024),
-                          PWM(green, freq=1024),
-                          PWM(blue, freq=1024))
-        else:
-            Data.RGB_OBJS = (PWM(red, freq=20480),
-                          PWM(green, freq=20480),
-                          PWM(blue, freq=20480))
+        red = Pin(bind_pin('redgb', red_pin))
+        green = Pin(bind_pin('rgreenb', green_pin))
+        blue = Pin(bind_pin('rgbue', blue_pin))
+        Data.RGB_OBJS = (PWM(red, freq=20480),
+                         PWM(green, freq=20480),
+                         PWM(blue, freq=20480))
     return Data.RGB_OBJS
 
 
 def __persistent_cache_manager(mode):
     """
-    pds - persistent data structure
+    File state cache
     modes:
         r - recover, s - save
     """
@@ -53,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,20 +68,18 @@ def __state_machine(r, g, b):
     __persistent_cache_manager('s')
 
 
-def load_n_init(cache=None):
+def load(red_pin=None, green_pin=None, blue_pin=None, cache=True):
     """
     Initiate RGB module
-    :param cache bool: file state machine cache: True/False/None(default: automatic True)
-    - Load .pds (state machine cache) for this load module
-    - Apply loaded states to gpio pins (boot function)
+    :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 (.cache), default=True
     :return str: Cache state
     """
-    from sys import platform
-    if cache is None:
-        Data.PERSISTENT_CACHE = False if platform == 'esp8266' else True
-    else:
-        Data.PERSISTENT_CACHE = cache
+    Data.PERSISTENT_CACHE = cache
     __persistent_cache_manager('r')     # recover data cache if enabled
+    __RGB_init(red_pin, green_pin, blue_pin)
     if Data.RGB_CACHE[3] == 1:
         Data.RGB_CACHE[3] = 0           # Force ON at boot
         toggle(True)
@@ -240,7 +232,7 @@ def transition(r=None, g=None, b=None, sec=1.0, wake=False):
                 Data.RGB_CACHE[1] = _g if _g > 5 else 5   # SAVE VALUE TO CACHE > 5 ! because toggle
                 Data.RGB_CACHE[2] = _b if _b > 5 else 5   # SAVE VALUE TO CACHE > 5 ! because toggle
                 my_task.out = f"Dimming: R:{_r} G:{_g} B:{_b}"
-                await asyncio.sleep_ms(ms_period)
+                await my_task.feed(sleep_ms=ms_period)
             if Data.RGB_CACHE[3] == 1 or wake:
                 __state_machine(_r, _g, _b)
             my_task.out = f"Dimming DONE: R:{_r} G:{_g} B:{_b}"
@@ -254,8 +246,7 @@ def transition(r=None, g=None, b=None, sec=1.0, wake=False):
     # Create transition generator and calculate step_ms
     rgb_gen, step_ms = transition_gen(r_from, r, g_from, g, b_from, b, interval_sec=sec)
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.RGB_TASK_TAG, task=_task(ms_period=step_ms, iterable=rgb_gen))
-    return "Starting transition" if state else "Transition already running"
+    return micro_task(tag=Data.RGB_TASK_TAG, task=_task(ms_period=step_ms, iterable=rgb_gen))
 
 
 def random(smooth=True, max_val=1000):
@@ -303,7 +294,7 @@ def pinmap():
     - info which pins to use for this application
     :return dict: pin name (str) - pin value (int) pairs
     """
-    return pinmap_dump(['redgb', 'rgreenb', 'rgbue'])
+    return pinmap_search(['redgb', 'rgreenb', 'rgbue'])
 
 
 def help(widgets=False):
@@ -313,8 +304,8 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return resolve(( 'COLOR color r=<0-1000> g b smooth=True force=True',
-                              'TOGGLE toggle state smooth=True', 'load_n_init',
+    return resolve(( 'COLOR color r=<0-1000-10> g b smooth=True force=True',
+                              'BUTTON toggle state=<True,False> smooth=True', 'load',
                               'SLIDER brightness percent=<0-100> smooth=True wake=True',
                               'transition r=None g=None b=None sec=1.0 wake=False',
                               'BUTTON random smooth=True max_val=1000',

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

@@ -3,12 +3,12 @@ import LM_cct
 from Types import resolve
 
 
-def load_n_init(cache=None):
+def load(cache=None):
     """
     Unified rgb and cct module usage as one module
     """
-    s1 = LM_rgb.load_n_init(cache)
-    s2 = LM_cct.load_n_init(cache)
+    s1 = LM_rgb.load(cache)
+    s2 = LM_cct.load(cache)
     return f'RGB: {s1}, CCT: {s2}'
 
 
@@ -59,7 +59,7 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return resolve(('load_n_init',
-                             'BUTTON toggle state smooth=True',
+    return resolve(('load',
+                             'BUTTON toggle state=<True,False> smooth=True',
                              'SLIDER brightness percent smooth=True wake=True',
                              'status', 'pinmap'), widgets=widgets)

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

@@ -1,10 +1,9 @@
 from utime import sleep_ms
 from random import randint
 import LM_servo as servo
-from LM_switch import set_state
-from LM_switch import pinmap as pm
-from Common import transition, micro_task
-import uasyncio as asyncio
+from LM_switch import set_state, pinmap as switch_pinmap
+from Common import transition, micro_task, data_dir
+from Types import resolve
 
 
 class RoboArm:
@@ -14,29 +13,30 @@ 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
 
 
-def load_n_init():
+def load():
     """
     Initiate roboarm module
     - move servo motors to middle position
@@ -52,11 +52,11 @@ def load_n_init():
     return f'Init and Move to home X{x}, Y{y}'
 
 
-def control(x_new, y_new, speed_ms=None, smooth=True):
+def control(x, y, speed_ms=None, smooth=True):
     """
     Control robot arm function
-    :param x_new: new x position (40-115)
-    :param y_new: new y position (40-115)
+    :param x: new x position (40-115)
+    :param y: new y position (40-115)
     :param speed_ms: speed - step wait in ms
     :param smooth: smooth transition, default True
     :return str: move verdict
@@ -76,11 +76,11 @@ def control(x_new, y_new, speed_ms=None, smooth=True):
             sleep_ms(step_ms)
 
     # Skip if new XY is the same as current
-    if RoboArm.ACTUAL_XY[0] == x_new and RoboArm.ACTUAL_XY[1] == y_new:
-        return f"Already on X:{x_new} Y:{y_new}"
+    if RoboArm.ACTUAL_XY[0] == x and RoboArm.ACTUAL_XY[1] == y:
+        return f"Already on X:{x} Y:{y}"
     # Check input parameter range
-    if RoboArm.RANGE[0] > x_new > RoboArm.RANGE[1] or RoboArm.RANGE[0] > y_new > RoboArm.RANGE[1]:
-        return f"X{x_new}/Y{y_new} out of range... range: {RoboArm.RANGE[0]}-{RoboArm.RANGE[1]}"
+    if RoboArm.RANGE[0] > x > RoboArm.RANGE[1] or RoboArm.RANGE[0] > y > RoboArm.RANGE[1]:
+        return f"X{x}/Y{y} out of range... range: {RoboArm.RANGE[0]}-{RoboArm.RANGE[1]}"
 
     # Set arm speed
     RoboArm.SPEED_MS = speed_ms if isinstance(speed_ms, int) else RoboArm.SPEED_MS
@@ -90,14 +90,14 @@ def control(x_new, y_new, speed_ms=None, smooth=True):
 
     if smooth:
         # Move roboarm to position
-        __buttery(x_prev, y_prev, x_new, y_new)
-        RoboArm.ACTUAL_XY = [x_new, y_new]
+        __buttery(x_prev, y_prev, x, y)
+        RoboArm.ACTUAL_XY = [x, y]
     else:
         # Fast move robaorm to position
-        servo.sduty(x_new)
-        servo.s2duty(y_new)
-        RoboArm.ACTUAL_XY[0] = x_new
-        RoboArm.ACTUAL_XY[1] = y_new
+        servo.sduty(x)
+        servo.s2duty(y)
+        RoboArm.ACTUAL_XY[0] = x
+        RoboArm.ACTUAL_XY[1] = y
     return 'Move X{}->{} Y{}->{}'.format(x_prev, RoboArm.ACTUAL_XY[0], y_prev, RoboArm.ACTUAL_XY[1])
 
 
@@ -109,7 +109,7 @@ def boot_move(speed_ms=None):
     """
     RoboArm.SPEED_MS = speed_ms if isinstance(speed_ms, int) else RoboArm.SPEED_MS
     # Set arm to center
-    load_n_init()
+    load()
     sleep_ms(RoboArm.SPEED_MS*2)
     # Test X
     control(RoboArm.RANGE[0], RoboArm.CENTER_XY)
@@ -179,7 +179,7 @@ async def _play(args, deinit, delay):
             if task is not None:
                 task.out = "Roboarm X:{} Y:{}".format(x, y)
             # Async wait between steps
-            await asyncio.sleep_ms(delay)
+            await task.feed(sleep_ms=delay)
         if deinit:
             servo.deinit()
         # OFF LASER
@@ -204,11 +204,10 @@ def play(*args, s=None, delay=None, deinit=True):
 
     # Start play - servo XY in async task
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=RoboArm.PLAY_TAG, task=_play(args, deinit, delay))
-    if state:
-        return 'Play: {} steps'.format(int(len(args)/2))
-    return 'Play - already running'
 
+    state:dict = micro_task(tag=RoboArm.PLAY_TAG, task=_play(args, deinit, delay))
+    state.update({"Play steps": int(len(args)/2)})
+    return state
 
 def record(clean=False, rec_limit=8):
     """
@@ -262,15 +261,6 @@ def status(lmf=None):
     return {'X': RoboArm.ACTUAL_XY[0], 'Y': RoboArm.ACTUAL_XY[1]}
 
 
-def lmdep():
-    """
-    Show Load Module dependency
-    - List of load modules used by this application
-    :return: tuple
-    """
-    return 'servo', 'switch'
-
-
 def pinmap():
     """
     [i] micrOS LM naming convention
@@ -279,7 +269,7 @@ def pinmap():
     :return dict: pin name (str) - pin value (int) pairs
     """
     s_pm = servo.pinmap()
-    s_pm.update({'switch_1': pm()['switch_1']})
+    s_pm.update(switch_pinmap())
     return s_pm
 
 
@@ -290,11 +280,13 @@ def help(widgets=False):
         (widgets=False) list of functions implemented by this application
         (widgets=True) list of widget json for UI generation
     """
-    return 'control x=<40-115> y=<40-115> s=<ms delay> smooth=True',\
-           'boot_move speed_ms',\
-           'standby y_pos=45',\
-           'jiggle delta=2',\
-           'play 40 40 115 115 s=<speed ms> delay=<ms> deinit=True',\
-           'record clean=False rec_limit=8',\
-           'random x_range=20 y_range=20 speed_ms=5',\
-           'load_n_init', 'pinmap', 'status', 'lmdep'
+    return resolve(('JOYSTICK control x=<40-115> y=<40-115> speed_ms=5 smooth=True',
+                             'BUTTON boot_move speed_ms=10',
+                             'BUTTON standby y_pos=45',
+                             'BUTTON jiggle delta=3',
+                             'play 40 40 115 115 s=<speed ms> delay=<ms> deinit=True',
+                             'BUTTON play deinit=True',
+                             'record clean=False rec_limit=8',
+                             'random x_range=20 y_range=20 speed_ms=5',
+                             'load', 'pinmap',
+                             'status'), widgets=widgets)

micrOS/source/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"
+

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

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

micrOS/source/{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"