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

micrOS/release_info/micrOS_ReleaseInfo/system_analysis_sum.json

@@ -25,7 +25,7 @@
             1
         ],
         "Tasks.py": [
-            9.46,
+            9.48,
             12
         ],
         "Config.py": [
@@ -54,7 +54,7 @@
         ],
         "Common.py": [
             9.85,
-            35
+            34
         ],
         "InterConnect.py": [
             9.62,
@@ -69,7 +69,7 @@
             8
         ],
         "Espnow.py": [
-            9.48,
+            9.47,
             4
         ],
         "Scheduler.py": [
@@ -97,7 +97,7 @@
             5
         ],
         "modules/LM_roboarm.py": [
-            7.78,
+            7.83,
             0
         ],
         "modules/LM_stepper.py": [
@@ -125,7 +125,7 @@
             0
         ],
         "modules/LM_robustness.py": [
-            8.36,
+            8.33,
             0
         ],
         "modules/LM_qmi8658.py": [
@@ -137,7 +137,7 @@
             0
         ],
         "modules/LM_rest.py": [
-            8.18,
+            8.6,
             0
         ],
         "modules/LM_tcs3472.py": [
@@ -161,7 +161,7 @@
             0
         ],
         "modules/LM_buzzer.py": [
-            9.11,
+            9.09,
             0
         ],
         "modules/LM_switch.py": [
@@ -189,11 +189,11 @@
             0
         ],
         "modules/LM_neopixel.py": [
-            7.78,
+            7.77,
             0
         ],
         "modules/LM_cct.py": [
-            9.04,
+            9.03,
             0
         ],
         "modules/LM_L9110_DCmotor.py": [
@@ -220,10 +220,6 @@
             7.62,
             0
         ],
-        "modules/LM_pet_feeder.py": [
-            7.94,
-            0
-        ],
         "modules/LM_rencoder.py": [
             8.65,
             0
@@ -253,7 +249,7 @@
             0
         ],
         "modules/LM_telegram.py": [
-            9.63,
+            9.62,
             0
         ],
         "modules/LM_OV2640.py": [
@@ -265,7 +261,7 @@
             0
         ],
         "modules/LM_distance.py": [
-            8.87,
+            8.86,
             0
         ],
         "modules/LM_VL53L0X.py": [
@@ -273,7 +269,7 @@
             0
         ],
         "modules/LM_light_sensor.py": [
-            9.17,
+            9.12,
             0
         ],
         "modules/LM_rp2w.py": [
@@ -281,7 +277,7 @@
             0
         ],
         "modules/LM_presence.py": [
-            8.9,
+            8.89,
             0
         ],
         "modules/LM_trackball.py": [
@@ -289,7 +285,7 @@
             0
         ],
         "modules/LM_mqtt_client.py": [
-            8.45,
+            8.68,
             0
         ],
         "modules/LM_dashboard_be.py": [
@@ -297,7 +293,7 @@
             0
         ],
         "modules/LM_dimmer.py": [
-            8.33,
+            8.32,
             0
         ],
         "modules/LM_gameOfLife.py": [
@@ -309,7 +305,7 @@
             0
         ],
         "modules/LM_i2s_mic.py": [
-            8.43,
+            8.42,
             0
         ],
         "modules/LM_sdcard.py": [
@@ -323,12 +319,12 @@
     },
     "summary": {
         "core": [
-            4004,
+            3994,
             24
         ],
         "load": [
-            9988,
-            56
+            9912,
+            55
         ],
         "core_dep": [
             true,
@@ -339,7 +335,7 @@
             4
         ],
         "core_score": 9.25,
-        "load_score": 8.4,
-        "version": "2.19.0-0"
+        "load_score": 8.42,
+        "version": "2.20.0-0"
     }
 }

micrOS/source/Common.py

@@ -15,7 +15,7 @@ from Notify import Notify
 #####################################################################################
 #                                     SYSTEM                                        #
 #####################################################################################
-def micro_task(tag: str, task=None, _wrap=False):
+def micro_task(tag:str, task=None, _wrap=False):
     """
     [LM] Async task manager.
     Modes:
@@ -37,21 +37,14 @@ def micro_task(tag: str, task=None, _wrap=False):
     """
     # --- CREATE (original) ---
     if task is not None:
-        if TaskBase.is_busy(tag):
-            return None     # task already running
         return Manager().create_task(callback=task, tag=tag)
 
     # --- CREATE WITH DECORATOR FACTORY (simplified) ---
     if _wrap:
         def _decorator(async_fn):
             task_tag = f"{tag}._{async_fn.__name__}"
-            _launcher = (
-                lambda *args, **kwargs:
-                None if TaskBase.is_busy(task_tag)
-                else Manager().create_task(
-                    callback=async_fn(task_tag, *args, **kwargs),
-                    tag=task_tag)
-            )
+            _launcher = (lambda *args, **kwargs: Manager().create_task(callback=async_fn(task_tag, *args, **kwargs),
+                                                              tag=task_tag))
             return _launcher
         return _decorator
 
@@ -404,9 +397,8 @@ class AnimationPlayer:
         # Ensure async loop set up correctly. (After stop operation, it is needed)
         self.__running = True
         # [!] ASYNC TASK CREATION
-        raw_state:bool = micro_task(tag=self._task_tag, task=self._player())
-        state = "starting" if raw_state else "running"
-        settings["state"] = state
+        state:dict = micro_task(tag=self._task_tag, task=self._player())
+        settings["state"] = list(state.values())[0]
         return settings
 
     def stop(self):

micrOS/source/Espnow.py

@@ -201,8 +201,7 @@ class ESPNowSS:
         """
         # Create an asynchronous task with tag 'espnow.server'
         tag = 'espnow.server'
-        state = NativeTask().create(callback=self._server(tag), tag=tag)
-        return {tag: "Starting"} if state else {tag: "Already running"}
+        return NativeTask().create(callback=self._server(tag), tag=tag)
 
     #----------- SEND METHODS --------------
     async def __asend_raw(self, mac:bytes, msg:str):
@@ -249,8 +248,7 @@ class ESPNowSS:
         peer_name = hexlify(peer, ':').decode() if peer_name is None else peer_name
         task_id = f"con.espnow.{peer_name}"
         # Create an asynchronous sending task.
-        state = NativeTask().create(callback=self._asend_task(peer, task_id, msg), tag=task_id)
-        return {task_id: "Starting"} if state else {task_id: "Already running"}
+        return NativeTask().create(callback=self._asend_task(peer, task_id, msg), tag=task_id)
 
     def cluster_send(self, msg):
         """
@@ -304,8 +302,7 @@ class ESPNowSS:
             # Convert 50:02:91:86:34:28 format to b'P\x02\x91\x864(' bytes
             peer = bytes(int(x, 16) for x in peer.split(":"))
         if isinstance(peer, bytes):
-            state = NativeTask().create(callback=self._handshake(peer, task_id), tag=task_id)
-            return {task_id: "Starting"} if state else {task_id: "Already running"}
+            return NativeTask().create(callback=self._handshake(peer, task_id), tag=task_id)
         else:
             return {None: "Invalid MAC address format. Use 50:02:91:86:34:28 or b'P\\x02\\x91\\x864('"}
 

micrOS/source/InterConnect.py

@@ -258,8 +258,7 @@ def send_cmd(host:str, cmd:list|str) -> dict:
 
     com_obj = InterCon()
     task_id = f"con.{_tagify()}"            # CHECK TASK ID CONFLICT
-    state = com_obj.task.create(callback=_send_cmd(host, cmd, com_obj), tag=task_id)
-    return {task_id: "Starting"} if state else {task_id: "Already running"}
+    return com_obj.task.create(callback=_send_cmd(host, cmd, com_obj), tag=task_id)
 
 
 def host_cache() -> dict:

micrOS/source/Shell.py

@@ -25,7 +25,7 @@ from Debug import syslog
 
 class Shell:
     __slots__ = ['__devfid', '__auth_mode', '__hwuid', '__auth_ok', '__conf_mode']
-    MICROS_VERSION = '2.19.0-0'
+    MICROS_VERSION = '2.20.0-0'
 
     def __init__(self):
         """

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,32 +43,20 @@ class TaskBase:
         self.done = asyncio.Event()  # Store task done state
         self.out = ""                # Store task output
 
-    def _create(self, callback:callable) -> bool:
+    ######  BASE METHODS FOR CHILD CLASSES  ####
+    def _create(self, callback:callable) -> dict:
         """
         Create async task and register it to TASKS dict by tag
         :param callback: coroutine function
         """
-        if TaskBase.is_busy(self.tag):
-            # Skip task if already running
-            return False
         # 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 True
-
-    @staticmethod
-    def is_busy(tag:str) -> bool:
-        """
-        Check task is busy by tag
-        :param tag: for task selection
-        """
-        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())
+        return {self.tag: "Starting"}
 
     @staticmethod
-    def task_gc():
+    def _task_gc():
         """
         Automatic passive task deletion over QUEUE_SIZE
         """
@@ -77,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:
         """
@@ -109,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):
         """
@@ -130,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)
@@ -143,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
@@ -152,6 +152,9 @@ class NativeTask(TaskBase):
         """
         # Create task tag
         self.tag = f"aio.{ticks_ms()}" if tag is None else tag
+        if self.is_busy(self.tag):
+            # Skip task if already running
+            return {self.tag: "Already running"}
         # Create task with coroutine callback
         return super()._create(callback)
 
@@ -170,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()
 
 
@@ -186,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)
@@ -196,13 +199,14 @@ class MagicTask(TaskBase):
         """
         # Create task tag
         self.tag = '.'.join(callback[0:2])
-
+        if self.is_busy(self.tag):
+            # Skip task if already running
+            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
-
         # Create task with coroutine callback
         return super()._create(self.__task_wrapper())
 
@@ -219,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):
@@ -310,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
@@ -513,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)
@@ -590,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/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_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_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_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: