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

micrOS/source/Tasks.py

@@ -18,10 +18,10 @@ from Config import cfgget
 from Network import sta_high_avail
 
 try:
-    from gc import collect
+    from gc import collect as gcollect
 except ImportError:
     console_write("[SIMULATOR MODE GC IMPORT]")
-    from simgc import collect
+    from simgc import collect as gcollect
 
 #################################################################
 #                Implement custom task class                    #
@@ -43,18 +43,20 @@ class TaskBase:
         self.done = asyncio.Event()  # Store task done state
         self.out = ""                # Store task output
 
-    @staticmethod
-    def is_busy(tag:str) -> bool:
+    ######  BASE METHODS FOR CHILD CLASSES  ####
+    def _create(self, callback:callable) -> dict:
         """
-        Check task is busy by tag
-        :param tag: for task selection
+        Create async task and register it to TASKS dict by tag
+        :param callback: coroutine function
         """
-        task = TaskBase.TASKS.get(tag, None)
-        # return True: busy OR False: not busy (inactive)
-        return bool(task is not None and not task.done.is_set())
+        # Create async task from coroutine function
+        self.task = asyncio.get_event_loop().create_task(callback)
+        # Store Task object by key - for task control
+        TaskBase.TASKS[self.tag] = self
+        return {self.tag: "Starting"}
 
     @staticmethod
-    def task_gc():
+    def _task_gc():
         """
         Automatic passive task deletion over QUEUE_SIZE
         """
@@ -63,18 +65,18 @@ class TaskBase:
         if len(passive) >= keep:
             for i in range(0, len(passive)-keep+1):
                 del TaskBase.TASKS[passive[i]]
-            collect()  # GC collect
+            gcollect()
 
+    ######  PUBLIC TASK METHODS  #####
     @staticmethod
-    async def feed(sleep_ms=1):
+    def is_busy(tag:str) -> bool:
         """
-        Feed event loop
-        :param sleep_ms: in millisecond
+        Check task is busy by tag
+        :param tag: for task selection
         """
-        # TODO: feed WDT - preemptive cooperative multitasking aka reboot if no feed until X time period
-        if sleep_ms <= 0:
-            return await asyncio.sleep(0.000_000_1)     # 0 means: 100ns (Absolute minimum)
-        return await asyncio.sleep_ms(sleep_ms)
+        task = TaskBase.TASKS.get(tag, None)
+        # return True: busy OR False: not busy (inactive) OR None: not exists
+        return bool(task is not None and not task.done.is_set())
 
     def cancel(self) -> bool:
         """
@@ -95,15 +97,16 @@ class TaskBase:
             return False
         return True
 
-    def __task_del(self, keep_cache=False):
+    @staticmethod
+    async def feed(sleep_ms=1):
         """
-        Delete task from TASKS
+        Feed event loop
+        :param sleep_ms: in millisecond
         """
-        self.done.set()
-        if self.tag in TaskBase.TASKS:
-            if not keep_cache:              # True - In case of destructor
-                del TaskBase.TASKS[self.tag]
-        collect()                           # GC collect
+        # TODO?: feed WDT - auto restart when system is frozen
+        if sleep_ms <= 0:
+            return await asyncio.sleep(0.000_000_1)     # 0 means: 100ns (Absolute minimum)
+        return await asyncio.sleep_ms(sleep_ms)
 
     async def await_result(self, timeout:int=5):
         """
@@ -116,6 +119,17 @@ class TaskBase:
             return "Timeout has beed exceeded"
         return self.out
 
+    ######  PRIVATE LCM METHODS  #####
+    def __task_del(self, keep_cache=False):
+        """
+        Delete task from TASKS
+        """
+        self.done.set()
+        if self.tag in TaskBase.TASKS:
+            if not keep_cache:              # True - In case of destructor
+                del TaskBase.TASKS[self.tag]
+        gcollect()
+
     def __del__(self):
         try:
             self.__task_del(keep_cache=True)
@@ -129,7 +143,7 @@ class NativeTask(TaskBase):
     - could be built in function or custom code from load modules
     """
 
-    def create(self, callback:callable=None, tag:str=None) -> bool:
+    def create(self, callback:callable=None, tag:str=None) -> dict:
         """
         Create async task with coroutine callback (no queue limit check!)
         + async socket server task
@@ -138,15 +152,11 @@ class NativeTask(TaskBase):
         """
         # Create task tag
         self.tag = f"aio.{ticks_ms()}" if tag is None else tag
-        if TaskBase.is_busy(self.tag):
+        if self.is_busy(self.tag):
             # Skip task if already running
-            return False
-
-        # Start task with coroutine callback
-        self.task = asyncio.get_event_loop().create_task(callback)
-        # Store Task object by key - for task control
-        TaskBase.TASKS[self.tag] = self
-        return True
+            return {self.tag: "Already running"}
+        # Create task with coroutine callback
+        return super()._create(callback)
 
     def __enter__(self):
         """
@@ -163,7 +173,7 @@ class NativeTask(TaskBase):
         Helper function for Task creation in Load Modules
         [HINT] Use python with feature to utilize this feature
         """
-        self.task_gc()    # Task pool cleanup
+        self._task_gc()    # Task pool cleanup
         self.done.set()
 
 
@@ -179,7 +189,7 @@ class MagicTask(TaskBase):
         self.__inloop = False        # [LM] Task while loop for LM callback
         self.__sleep = 20            # [LM] Task while loop - async wait (proc feed) [ms]
 
-    def create(self, callback:list=None, loop:bool=None, sleep:int=None) -> bool:
+    def create(self, callback:list=None, loop:bool=None, sleep:int=None) -> dict:
         """
         Create async task with function callback (with queue limit check)
         - wrap (sync) function into async task (task_wrapper)
@@ -189,20 +199,16 @@ class MagicTask(TaskBase):
         """
         # Create task tag
         self.tag = '.'.join(callback[0:2])
-        if TaskBase.is_busy(self.tag):
+        if self.is_busy(self.tag):
             # Skip task if already running
-            return False
-
+            return {self.tag: "Already running"}
         # Set parameters for async wrapper
         self.__callback = callback
         self.__inloop = self.__inloop if loop is None else loop
         # Set sleep value for async loop - optional parameter with min sleep limit check (20ms)
         self.__sleep = self.__sleep if sleep is None else sleep if sleep > 19 else self.__sleep
-
-        self.task = asyncio.get_event_loop().create_task(self.__task_wrapper())
-        # Store Task object by key - for task control
-        TaskBase.TASKS[self.tag] = self
-        return True
+        # Create task with coroutine callback
+        return super()._create(self.__task_wrapper())
 
     async def __task_wrapper(self):
         """
@@ -217,7 +223,7 @@ class MagicTask(TaskBase):
             state, self.out = _exec_lm_core(self.__callback)
             if not state or not self.__inloop:
                 break
-        self.task_gc()    # Task pool cleanup
+        self._task_gc()    # Task pool cleanup
         self.done.set()
 
     def cancel(self):
@@ -308,12 +314,16 @@ class Manager:
         my_task.done.set()
 
     @staticmethod
-    def create_task(callback, tag:str=None, loop:bool=False, delay:int=None):
+    def create_task(callback, tag:str=None, loop:bool=False, delay:int=None) -> dict:
         """
-        Primary interface
-        Generic task creator method
-            Create async Task with coroutine/list(lm call) callback
-        :param callback: list|callable
+        Primary interface of micrOS Generic task creator method
+        :param tag: task unique identifier
+        NativeTask:
+            :param callback: callable, coroutine to start a task
+        MagicTask with queue limiter:
+            :param callback: list of staring (command)
+            :param loop: MagicTask looping parameter
+            :param delay: MagicTask delay parameter
         """
         if isinstance(callback, list):
             # Check queue if task is Load Module
@@ -373,7 +383,7 @@ class Manager:
         return '\n'.join(output)
 
     @staticmethod
-    def kill(tag):
+    def kill(tag:str) -> (bool, str):
         """
         Primary interface
         Kill/terminate async task
@@ -474,11 +484,11 @@ def exec_builtins(func):
                 if arg_len > 1 and 'list' == arg_list[1]:
                     on, off = Manager.list_tasks(json=json_flag)
                     # RETURN:    JSON mode                                                   Human readable mode with cpu & queue info
-                    return (True, {'active': on[3:], 'inactive': off}) if json_flag else (True, '\n'.join(on) + '\n' + '\n'.join(off) + '\n')
+                    return (True, dumps({'active': on[3:], 'inactive': off})) if json_flag else (True, '\n'.join(on) + '\n' + '\n'.join(off) + '\n')
                 # task kill <taskID> / task show <taskID>
                 if arg_len > 2:
                     if 'kill' == arg_list[1]:
-                        state, msg = Manager.kill(tag=arg_list[2])
+                        _, msg = Manager.kill(tag=arg_list[2])
                         return True, msg
                     if 'show' == arg_list[1]:
                         return True, Manager.show(tag=arg_list[2])
@@ -511,15 +521,9 @@ def lm_exec(arg_list:list, jsonify:bool=None):
         delay = int(delay) if delay.isdigit() else None
         # Create and start async lm task
         try:
-            state = Manager.create_task(arg_list, loop=loop, delay=delay)
+            return True, Manager.create_task(arg_list, loop=loop, delay=delay)
         except Exception as e:
-            # Valid & handled task command
-            return True, str(e)
-        tag = '.'.join(arg_list[0:2])
-        # Valid & handled task command
-        if state:
-            return True, f"Start {tag}"
-        return True, f"{tag} is Busy"
+            return False, {".".join(arg_list[0:2]): str(e)}
 
     # [2] Sync "realtime" task execution
     state, out = _exec_lm_core(arg_list, jsonify)
@@ -588,7 +592,7 @@ def _exec_lm_core(cmd_list, jsonify):
                 # UNLOAD MODULE IF MEMORY ERROR HAPPENED + gc.collect
                 if lm_mod in modules:
                     del modules[lm_mod]
-                collect()
+                gcollect()
             # LM EXECUTION ERROR
             return False, f"Core error: {lm_mod}->{lm_func}: {e}"
     return False, "Shell: for hints type help.\nShell: for LM exec: [1](LM)module [2]function [3...]optional params"

micrOS/source/micrOSloader.py

@@ -102,7 +102,7 @@ def __auto_restart_event():
         if trigger_is_active and _is_micrOS():
             print("[loader][ota-rebooter][micros][trigger: True] OTA was finished - reboot")
             # Create cleanup indicator file for ConfigHandler
-            with open('cleanup.pds', 'w') as f:
+            with open('.cleanup', 'w') as f:
                 f.write('')
             # Reboot machine
             reset()

micrOS/source/modules/LM_buzzer.py

@@ -270,10 +270,7 @@ def play(rtttlstr='Indiana'):
     global CHECK_NOTIFY
     if CHECK_NOTIFY and not notify():
         return "NoBipp - notify off"
-    state = micro_task(tag=__TASK_TAG, task=_play(rtttlstr))
-    if state:
-        return 'Play song'
-    return 'Song already playing'
+    return micro_task(tag=__TASK_TAG, task=_play(rtttlstr))
 
 
 def list_tones():

micrOS/source/modules/LM_cct.py

@@ -238,8 +238,7 @@ def transition(cw=None, ww=None, sec=1.0, wake=False):
     # Create transition generator and calculate step_ms
     cct_gen, step_ms = transition_gen(cw_from, cw_to, ww_from, ww_to, interval_sec=sec)
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.CCT_TASK_TAG, task=_task(ms_period=step_ms, iterable=cct_gen))
-    return "Starting transition" if state else "Transition already running"
+    return micro_task(tag=Data.CCT_TASK_TAG, task=_task(ms_period=step_ms, iterable=cct_gen))
 
 
 def hue_transition(percent, sec=1.0, wake=False):
@@ -288,8 +287,7 @@ def hue_transition(percent, sec=1.0, wake=False):
         #print("Actual percent: {}, target percent: {}".format(actual_percent, warm_percent))
         hue_gen, step_ms = transition_gen(hue_curr_percent, percent*10, interval_sec=sec)
         # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-        state = micro_task(tag=Data.HUE_TASK_TAG, task=_task(ms_period=step_ms, iterable=hue_gen))
-        return "Starting transition" if state else "Transition already running"
+        return micro_task(tag=Data.HUE_TASK_TAG, task=_task(ms_period=step_ms, iterable=hue_gen))
     else:
         return "Invalid range, percent=<0-100>"
 

micrOS/source/modules/LM_dimmer.py

@@ -184,8 +184,7 @@ def transition(value, sec=1.0, wake=False):
     # Create transition generator and calculate step_ms
     fade_gen, fade_step_ms = transition_gen(from_dim, value, interval_sec=sec)
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.DIMM_TASK_TAG, task=_task(ms_period=fade_step_ms, iterable=fade_gen))
-    return "Starting transition" if state else "Transition already running"
+    return micro_task(tag=Data.DIMM_TASK_TAG, task=_task(ms_period=fade_step_ms, iterable=fade_gen))
 
 
 def subscribe_presence():

micrOS/source/modules/LM_distance.py

@@ -70,9 +70,7 @@ def start_dimmer_indicator(idle_distance=180):
     """Distance visualization on LED brightness (LM_dimmer)"""
     from LM_dimmer import set_value
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag="distance.visual", task=__task(period_ms=200, dimmer=set_value, idle_cm=idle_distance))
-    return "Starting" if state else "Already running"
-
+    return micro_task(tag="distance.visual", task=__task(period_ms=200, dimmer=set_value, idle_cm=idle_distance))
 
 
 #########################

micrOS/source/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')

micrOS/source/modules/LM_i2s_mic.py

@@ -94,8 +94,7 @@ def background_capture():
     if not Data.MIC_ENABLED:
         return "Microphone is disabled"
 
-    state = micro_task(tag=Data.TASK_TAG, task=__task(ms_period=1))
-    return "Starting" if state else "Already running"
+    return micro_task(tag=Data.TASK_TAG, task=__task(ms_period=1))
 
 
 def get_from_buffer(capture_duration=Data.CAPTURE_DURATION,

micrOS/source/modules/LM_keychain.py

@@ -216,8 +216,7 @@ def display(period=1000, tts=30):
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
     period_ms = 500 if period < 500 else period
     tts_ms = 5000 if tts < 5 else tts*1000
-    state = micro_task(tag="keychain.display", task=_ui_task(period_ms, tts_ms))
-    return "Starting" if state else "Already running"
+    return micro_task(tag="keychain.display", task=_ui_task(period_ms, tts_ms))
 
 
 def temperature():

micrOS/source/modules/LM_light_sensor.py

@@ -96,11 +96,8 @@ def subscribe_intercon(on, off, threshold=4, tolerance=2, sample_sec=60):
     """
     # Start play - servo XY in async task
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag="light_sensor.intercon", task=_task(on, off, threshold, tolerance=tolerance,
+    return micro_task(tag="light_sensor.intercon", task=_task(on, off, threshold, tolerance=tolerance,
                                                                check_ms=sample_sec*1000))
-    if state:
-        return 'Light sensor remote trigger starts'
-    return 'Light sensor remote trigger - already running'
 
 
 #######################

micrOS/source/modules/LM_mqtt_client.py

@@ -123,8 +123,8 @@ def publish(topic: str, message: str, retain: bool = False):
     :return: Status message string.
     """
     unique_tag = f'mqtt.publish.{topic}.{time.ticks_ms()}'
-    state = micro_task(tag=unique_tag, task=_publish(unique_tag, message, topic, retain))
-    return f"Message was sent {state}"
+    state:dict = micro_task(tag=unique_tag, task=_publish(unique_tag, message, topic, retain))
+    return f"Message was sent ({list(state.values())[0]})"
 
 
 ####################
@@ -142,8 +142,8 @@ async def _up():
             my_task.out = "Wait"
             await MQTT.CLIENT.up.wait()
             MQTT.CLIENT.up.clear()
-            state = micro_task(tag=MQTT.SUB_TASK, task=_subscribe(MQTT.DEFAULT_TOPIC))
-            my_task.out = f"Re-Subscription {state}"
+            state:dict = micro_task(tag=MQTT.SUB_TASK, task=_subscribe(MQTT.DEFAULT_TOPIC))
+            my_task.out = f"Re-Subscription ({list(state.values())[0]})"
             my_task.feed()
 
 
@@ -165,10 +165,14 @@ async def _init_client():
         MQTT.CLIENT.up.clear()
         
         # Initialize mqtt topics
-        if not micro_task(tag=MQTT.SUB_TASK, task=_subscribe(MQTT.DEFAULT_TOPIC)):
-            syslog(f"Failed start mqtt subscribe")
-        if not micro_task(tag=MQTT.UP_TASK, task=_up()):
-            syslog(f"Failed start mqtt up")
+        try:
+            micro_task(tag=MQTT.SUB_TASK, task=_subscribe(MQTT.DEFAULT_TOPIC))
+        except Exception as err:
+            syslog(f"Failed start mqtt subscribe: {err}")
+        try:
+            micro_task(tag=MQTT.UP_TASK, task=_up())
+        except Exception as err:
+            syslog(f"Failed start mqtt up: {err}")
         # Async listener loop
         await _receiver()
         my_task.out = "Receiver closed"
@@ -230,8 +234,7 @@ def load(username: str, password: str, server_ip: str, server_port: str='1883',
     MQTT.CLIENT = MQTTClient(_configure(username, password, server_ip, server_port))
     MQTT.QOS = qos
 
-    state = micro_task(tag=MQTT.CLIENT_TASK, task=_init_client())
-    return {MQTT.CLIENT_TASK: "Starting"} if state else {MQTT.CLIENT_TASK: "Already running"}
+    return micro_task(tag=MQTT.CLIENT_TASK, task=_init_client())
 
 
 def help(widgets=False):

micrOS/source/modules/LM_neoeffects.py

@@ -277,7 +277,7 @@ def help(widgets=False):
                              'BUTTON fire speed_ms=150',
                              'BUTTON stop',
                              'shader offset=0 size=6',
-                             'control speed_ms=None batch=None',
+                             'SLIDER control speed_ms=<1-200> batch=None',
                              'random max_val=255',
                              'pinmap',
                              'COLOR color r=<0-255-10> g b'

micrOS/source/modules/LM_neomatrix.py

@@ -430,7 +430,7 @@ def help(widgets=False):
                              'BUTTON rainbow',
                              'BUTTON spiral speed_ms=40',
                              'BUTTON noise speed_ms=85',
-                             'SLIDER control speed_ms=<1-200-2> bt_draw=None',
+                             'SLIDER control speed_ms=<1-200> bt_draw=None',
                              'draw_colormap bitmap=[(0,0,(10,2,0)),(x,y,color),...]',
                              'get_colormap',
                              'status'

micrOS/source/modules/LM_neopixel.py

@@ -278,8 +278,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_to, g_from, g_to, b_from, b_to, 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=255):

micrOS/source/modules/LM_oled_ui.py

@@ -343,9 +343,10 @@ class PageUI:
                 # Send CMD to other device & show result
                 state, data_meta = exec_cmd(cmd + [f">>{host}"], jsonify=True)
                 if state:
-                    self.cmd_task_tag = data_meta['tag']
-                    if "Task is Busy" in data_meta['verdict'] and not run:
-                        self.cmd_out = data_meta['verdict']     # Otherwise the task start output not relevant on UI
+                    self.cmd_task_tag = list(data_meta.keys())[0]
+                    verdict = list(data_meta.values())[0]
+                    if "Already running" in verdict and not run:
+                        self.cmd_out = verdict     # Otherwise the task start output not relevant on UI
                 else:
                     self.cmd_out = f"Error: {data_meta}"
             except Exception as e:

micrOS/source/modules/LM_oledui.py

@@ -121,8 +121,7 @@ class Frame(BaseFrame):
         """
         # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
         self._taskid = f"oledui.{tid}"
-        state = micro_task(tag=self._taskid, task=self._task(period_ms=period_ms))
-        return "Starting" if state else "Already running"
+        return micro_task(tag=self._taskid, task=self._task(period_ms=period_ms))
 
     def hover(self):
         """
@@ -486,8 +485,7 @@ class ScreenSaver(BaseFrame):
     def run(self, fps=10):
         # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
         period_ms = int(1000/fps)
-        state = micro_task(tag="oledui.anim", task=self._task(period_ms))
-        return "Starting" if state else "Already running"
+        return micro_task(tag="oledui.anim", task=self._task(period_ms))
 
     def cancel(self):
         if self.running:
@@ -782,9 +780,10 @@ class PageUI:
                 # Send CMD to other device & show result
                 state, data_meta = exec_cmd(cmd + [f">>{host}"], jsonify=True)
                 if state:
-                    self._cmd_task_tag = data_meta['tag']
-                    if "Task is Busy" in data_meta['verdict'] and not run:
-                        self.app_frame.press_output = data_meta['verdict']     # Otherwise the task start output not relevant on UI
+                    self._cmd_task_tag = list(data_meta.keys())[0]
+                    verdict = list(data_meta.values())[0]
+                    if "Already running" in verdict and not run:
+                        self.app_frame.press_output = verdict     # Otherwise the task start output not relevant on UI
                 else:
                     self.app_frame.press_output = f"Error: {data_meta}"
             except Exception as e:

micrOS/source/modules/LM_presence.py

@@ -213,8 +213,7 @@ def motion_trig(sample_ms=15, buff_size=10):
 
     # [3] Start mic sampling in async task
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
-    state = micro_task(tag=Data.TASK_TAG, task=__task(ms_period=sample_ms, buff_size=buff_size))
-    return "Starting" if state else "Already running"
+    return micro_task(tag=Data.TASK_TAG, task=__task(ms_period=sample_ms, buff_size=buff_size))
 
 
 def subscribe_intercon(on, off):

micrOS/source/modules/LM_rest.py

@@ -66,8 +66,7 @@ def aurl(subdomain):
     tag = "rest." + subdomain.replace("http://", '').replace("https://", '')
     if len(tag) > 50:
         tag = tag[0:50]
-    state = micro_task(tag=tag, task=__task(subdomain, tag))
-    return f"Starting" if state else f"Already running"
+    return micro_task(tag=tag, task=__task(subdomain, tag))
 
 
 def help(widgets=False):

micrOS/source/modules/LM_rgb.py

@@ -246,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):

micrOS/source/modules/LM_roboarm.py

@@ -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):
     """

micrOS/source/modules/LM_robustness.py

@@ -83,8 +83,7 @@ def create_task():
     """
     # [!] ASYNC TASK CREATION [1*] with async task callback + taskID (TAG) handling
     task_tag = "microtask.run"
-    state = micro_task(tag=task_tag, task=__task(tag=task_tag, period_ms=5))
-    return "Starting" if state else "Already running"
+    return micro_task(tag=task_tag, task=__task(tag=task_tag, period_ms=5))
 
 
 @micro_task("microtask", _wrap=True)