micrOSDevToolKit 2.10.6__py3-none-any.whl → 2.13.0__py3-none-any.whl

micrOS/source/Common.py

@@ -3,94 +3,25 @@ micrOS Load Module programming Official API-s
     Designed by Marcell Ban aka BxNxM
 """
 from Server import Server, WebCli
-from Debug import errlog_add, console_write
+from Debug import syslog as debug_syslog, console_write
 from Logger import logger, log_get
+from Files import OSPath, path_join
 from microIO import resolve_pin
 from Tasks import TaskBase, Manager, lm_exec
 from machine import Pin, ADC
 from Notify import Notify
 
-################## Common LM features ##################
 
-def transition(from_val, to_val, step_ms, interval_sec):
-    """
-    [LM] Single Generator for color/value transition:
-    :param from_val: from value - start from
-    :param to_val: to value - target value
-    :param step_ms: step to reach to_val - timirq_seq
-    :param interval_sec: time of full interval
-    """
-    if interval_sec > 0:
-        step_cnt = round((interval_sec*1000)/step_ms)
-        delta = abs((from_val-to_val)/step_cnt)
-        direc = -1 if from_val > to_val else 1
-        for cnt in range(0, step_cnt+1):
-            yield round(from_val + (cnt * delta) * direc)
-    else:
-        yield round(to_val)
+#####################################################################################
+#                                     SYSTEM                                        #
+#####################################################################################
 
-
-def transition_gen(*args, interval_sec=1.0):
-    """
-    [LM] Multiple Generator for color/value transitions:
-    - calculate minimum step count -> step_ms
-    - autofill and use transition(from_val, to_val, step_ms, interval_sec)
-    :param args: ch1_from, ch1_to, ch2_from, ch2_to, etc...
-    :param interval_sec: interval in sec to calculate optimal fade/transition effect
-    return: gen, step_ms OR gen list, step_ms
+def micro_task(tag:str, task=None):
     """
-    step_ms_min = 5            # min calculated step is 5 ms - good enough
-    delta = max((abs(args[ch_from_i] - args[ch_from_i+1]) for ch_from_i in range(0, len(args)-1, 2)))
-    step_ms = 0 if delta == 0 else int(interval_sec*1000 / delta)
-    step_ms = step_ms_min if step_ms < step_ms_min else step_ms
-    transitions = list((transition(args[ch_from_i], args[ch_from_i+1], step_ms, interval_sec) for ch_from_i in range(0, len(args)-1, 2)))
-    if len(transitions) == 1:
-        return transitions[0], step_ms
-    return list(transitions), step_ms
-
-
-class SmartADC:
-    """
-    [LM] General ADC implementation for auto scaled output: raw, percent, volt
-    https://docs.micropython.org/en/latest/esp32/quickref.html#adc-analog-to-digital-conversion
-        ADC.ATTN_0DB: 0 dB attenuation, resulting in a full-scale voltage range of 0-1.1V
-        ADC.ATTN_2_5DB: 2.5 dB ... of 0-1.5V
-        ADC.ATTN_6DB: 6 dB ... of 0-2.2V
-        ADC.ATTN_11DB: 11 dB ... of 0-2450mV/
-    Note that the absolute maximum voltage rating for input pins is 3.6V. Going near to this boundary risks damage to the IC!
-    """
-    OBJS = {}
-
-    def __init__(self, pin):
-        self.adp_prop = (65535, 2450)                               # raw value, 2450mV (so 2,45V)
-        self.adc = None
-        if not isinstance(pin, int):
-            pin = resolve_pin(pin)
-        self.adc = ADC(Pin(pin))
-        self.adc.atten(ADC.ATTN_11DB)                               # 2450mV measure range
-
-    def get(self):
-        raw = int((self.adc.read_u16() + self.adc.read_u16())/2)    # 16-bit ADC value (0-65535)
-        percent = raw / self.adp_prop[0]
-        volt = round(percent * self.adp_prop[1] / 1000, 2)          # devide with 1000 to get V from mV
-        return {'raw': raw, 'percent': round(percent*100, 1), 'volt': volt}
-
-    @staticmethod
-    def get_instance(pin):
-        if pin in SmartADC.OBJS.keys():
-            return SmartADC.OBJS[pin]
-        SmartADC.OBJS[pin] = SmartADC(pin)
-        return SmartADC.OBJS[pin]
-
-################# micrOS feature interfaces #################
-
-def micro_task(tag, task=None):
-    """
-    [LM] Async task creation
-    :param tag:
-        [1] tag=None: return task generator object
-        [2] tag=taskID: return existing task object by tag
-    :param task: coroutine to execute (with built-in overload protection and lcm)
+    [LM] Async task manager.
+    :param tag: task tag string
+    :param task: coroutine (or list of command arguments) to contract a task with the given async task callback
+    return bool|callable
     """
     if task is None:
         # [1] Task is None -> Get task mode by tag
@@ -103,11 +34,11 @@ def micro_task(tag, task=None):
         return None
     # [3] Create task (not running) + task coroutine was provided
     # RETURN task creation state - success (True) / fail (False)
-    state = Manager().create_task(callback=task, tag=tag)
+    state:bool = Manager().create_task(callback=task, tag=tag)
     return state
 
 
-def manage_task(tag, operation):
+def manage_task(tag:str, operation:str):
     """
     [LM] Async task management
     :param tag: task tag
@@ -125,19 +56,15 @@ def manage_task(tag, operation):
     raise Exception(f"Invalid operation: {operation}")
 
 
-def exec_cmd(cmd:list, jsonify:bool=None, skip_check=False):
+def exec_cmd(cmd:list, jsonify:bool=None, skip_check=None):
     """
     [LM] Single (sync) LM execution
     :param cmd: command string list, ex.: ['system', 'clock']
     :param jsonify: request json output
-    :param skip_check: skip cmd type check, micropython bug
+    :param skip_check: legacy (check was removed) - remove parameter
     return state, output
     """
-    # [BUG] Solution with isinstance/type is not reliable... micropython 1.22
-    #          Invalid type, must be list: <class list>" ...
-    if skip_check:
-        return lm_exec(cmd, jsonify=jsonify)
-    return lm_exec(cmd, jsonify=jsonify) if isinstance(cmd, list) else False, f"CMD {type(cmd)}, must be list!"
+    return lm_exec(cmd, jsonify=jsonify)
 
 
 def notify(text=None) -> bool:
@@ -153,7 +80,7 @@ def notify(text=None) -> bool:
     try:
         out = Notify.notify(text)
     except Exception as e:
-        errlog_add(f"[ERR] Notify: {e}")
+        debug_syslog(f"[ERR] Notify: {e}")
         out = str(e)
     if out is not None and (out.startswith('Sent') or out.endswith('disabled')):
         return True
@@ -209,10 +136,278 @@ def data_logger(f_name, data=None, limit=12, msgobj=None):
 
 
 def syslog(msg):
-    """ Wrapper of errlog_add """
-    return errlog_add(f"{msg}")
+    """ Wrapper of debug_syslog """
+    return debug_syslog(f"{msg}")
 
 
 def console(msg):
     """ Wrapper of console_write """
     return console_write(msg)
+
+
+def data_dir(f_name=None):
+    """
+    Access for data dir path
+    :param f_name: if given, returns full path, otherwise returns data dir root path
+    """
+    root_path = OSPath.DATA
+    if f_name is None:
+        return root_path
+    return path_join(root_path, f_name)
+
+def web_dir(f_name=None):
+    """
+    Access for web dir path
+    :param f_name: if given, returns full path, otherwise returns web dir root path
+    """
+    root_path = OSPath.WEB
+    if f_name is None:
+        return root_path
+    return path_join(root_path, f_name)
+
+#####################################################################################
+#                             CHANNEL: SIGNAL GENERATORS                            #
+#####################################################################################
+
+def transition(from_val, to_val, step_ms, interval_sec):
+    """
+    [LM] Single Generator for color/value transition:
+    :param from_val: from value - start from
+    :param to_val: to value - target value
+    :param step_ms: step to reach to_val - timirq_seq
+    :param interval_sec: time of full interval
+    """
+    if interval_sec > 0:
+        step_cnt = round((interval_sec*1000)/step_ms)
+        delta = abs((from_val-to_val)/step_cnt)
+        direc = -1 if from_val > to_val else 1
+        for cnt in range(0, step_cnt+1):
+            yield round(from_val + (cnt * delta) * direc)
+    else:
+        yield round(to_val)
+
+
+def transition_gen(*args, interval_sec=1.0):
+    """
+    [LM] Multiple Generator for color/value transitions:
+    - calculate minimum step count -> step_ms
+    - autofill and use transition(from_val, to_val, step_ms, interval_sec)
+    :param args: ch1_from, ch1_to, ch2_from, ch2_to, etc...
+    :param interval_sec: interval in sec to calculate optimal fade/transition effect
+    return: gen, step_ms OR gen list, step_ms
+    """
+    step_ms_min = 5            # min calculated step is 5 ms - good enough
+    delta = max((abs(args[ch_from_i] - args[ch_from_i+1]) for ch_from_i in range(0, len(args)-1, 2)))
+    step_ms = 0 if delta == 0 else int(interval_sec*1000 / delta)
+    step_ms = step_ms_min if step_ms < step_ms_min else step_ms
+    transitions = list((transition(args[ch_from_i], args[ch_from_i+1], step_ms, interval_sec) for ch_from_i in range(0, len(args)-1, 2)))
+    if len(transitions) == 1:
+        return transitions[0], step_ms
+    return list(transitions), step_ms
+
+#####################################################################################
+#                                     EXTRAS                                        #
+#####################################################################################
+
+class SmartADC:
+    """
+    [LM] General ADC implementation for auto scaled output: raw, percent, volt
+    https://docs.micropython.org/en/latest/esp32/quickref.html#adc-analog-to-digital-conversion
+        ADC.ATTN_0DB: 0 dB attenuation, resulting in a full-scale voltage range of 0-1.1V
+        ADC.ATTN_2_5DB: 2.5 dB ... of 0-1.5V
+        ADC.ATTN_6DB: 6 dB ... of 0-2.2V
+        ADC.ATTN_11DB: 11 dB ... of 0-2450mV/
+    Note that the absolute maximum voltage rating for input pins is 3.6V. Going near to this boundary risks damage to the IC!
+    """
+    OBJS = {}
+
+    def __init__(self, pin):
+        self.adp_prop = (65535, 2450)                               # raw value, 2450mV (so 2,45V)
+        self.adc = None
+        if not isinstance(pin, int):
+            pin = resolve_pin(pin)
+        self.adc = ADC(Pin(pin))
+        self.adc.atten(ADC.ATTN_11DB)                               # 2450mV measure range
+
+    def get(self):
+        raw = int((self.adc.read_u16() + self.adc.read_u16())/2)    # 16-bit ADC value (0-65535)
+        percent = raw / self.adp_prop[0]
+        volt = round(percent * self.adp_prop[1] / 1000, 2)          # devide with 1000 to get V from mV
+        return {'raw': raw, 'percent': round(percent*100, 1), 'volt': volt}
+
+    @staticmethod
+    def get_instance(pin):
+        if pin in SmartADC.OBJS.keys():
+            return SmartADC.OBJS[pin]
+        SmartADC.OBJS[pin] = SmartADC(pin)
+        return SmartADC.OBJS[pin]
+
+
+class AnimationPlayer:
+    """
+    Generic async animation (generator) player.
+    """
+
+    def __init__(self, animation:callable=None, tag:str=None, batch_draw:bool=False, batch_size:int=None, loop:bool=True):
+        """
+        Initialize the AnimationPlayer with an optional animation.
+        :param animation: Function to GENERATE animation data
+        :param tag: Optional task tag for micro_task management.
+        :param batch_draw: If True - draw in batches
+        :param batch_size: Number of pixels per batch when drawing
+        :param loop: If True - loop the animation (default)
+        """
+        self.animation:callable = None
+        self.batch_draw:bool = batch_draw
+        self.__max_batch_size:int = 256                     # MAX BATCH SIZE - ASYNC PROTECTION
+        self.__batch_size:int = 8                           # Default batch size: 8
+        self.__loop:bool = loop                             # Loop the animation (generator)
+        self._set_batch_size(batch_size)                    # Set batch size from parameter
+        self._player_speed_ms:int = 10                      # Default speed in ms between frames
+        main_tag:str = tag if tag else "animation"
+        self._task_tag:str = f"{main_tag}.player"
+        if animation is not None and not self._set_animation(animation):
+            raise Exception("Invalid animation function provided.")
+        self.__running:bool = True
+
+    def _set_animation(self, animation:callable) -> bool:
+        """
+        Setter to change/set current animation.
+        """
+        if callable(animation):
+            self.animation = animation
+            return True
+        return False
+
+    def _set_batch_size(self, batch_size:int) -> None:
+        """
+        Setter to change/set batch size.
+        - with max batch size check (due to async event loop feeding)
+        """
+        if batch_size is None:
+            return
+        self.__batch_size = max(0, min(batch_size, self.__max_batch_size))
+
+    async def _render(self, my_task):
+        # Cache methods for speed
+        clear = self.clear
+        update = self.update
+        draw = self.draw
+        # Cache the current animation for comparison
+        current_animation = self.animation
+        frame_counter = 0
+        # Clear the display before each frame
+        if not self.batch_draw:
+            clear()
+        for data in self.animation():
+            # Check if animation has changed under the loop
+            if not self.__running or self.animation != current_animation:
+                # Animation changed — break — clean and restart animation loop.
+                clear()
+                break
+            # Update data cache
+            update(*data)
+            if self.batch_draw:
+                # Batched draw mode
+                frame_counter += 1
+                if frame_counter >= self.__batch_size:
+                    draw()
+                    frame_counter = 0
+                    await my_task.feed(sleep_ms=self._player_speed_ms)
+            else:
+                # Real-time draw mode
+                draw()
+                await my_task.feed(sleep_ms=self._player_speed_ms)
+
+    async def _player(self):
+        """
+        Async task to play the current animation.
+        """
+        with micro_task(tag=self._task_tag) as my_task:
+            while self.__running:
+                my_task.out = f"Play {self.animation.__name__} ({self._player_speed_ms}ms/frame)"
+                try:
+                    await self._render(my_task)
+                except IndexError:
+                    # Draw after generator exhausted and Restart animation if IndexError occurs
+                    self.draw()
+                    if not self.__loop:
+                        break
+                    await my_task.feed(sleep_ms=self._player_speed_ms)
+                    my_task.out = "Restart animation"
+                except Exception as e:
+                    my_task.out = f"Error: {e}"
+                    break
+            my_task.out = f"Animation stopped...{my_task.out}"
+
+    def control(self, play_speed_ms:int, bt_draw:bool=None, bt_size:int=None, loop:bool=None):
+        """
+        Set/Get current play speed of the animation.
+        :param play_speed_ms: player loop speed in milliseconds.
+        :param bt_draw: batch drawing flag.
+        :param bt_size: batch drawing size.
+        :param loop: loop flag.
+        """
+        if isinstance(play_speed_ms, int):
+            self._player_speed_ms = max(0, min(10000, int(play_speed_ms)))
+        if isinstance(bt_draw, bool):
+            self.batch_draw = bt_draw
+        if isinstance(bt_size, int):
+            self._set_batch_size(bt_size)
+        if isinstance(loop, bool):
+            self.__loop = loop
+        return {"realtime": not self.batch_draw, "batched": self.batch_draw,
+                "size": self.__batch_size, "speed_ms": self._player_speed_ms,
+                "loop": self.__loop}
+
+
+    def play(self, animation=None, speed_ms=None, bt_draw=False, bt_size=None, loop=True):
+        """
+        Play animation via generator function.
+        :param animation: Animation generator function.
+        :param speed_ms: Speed of the animation in milliseconds. (min.: 3ms)
+        :param bt_draw: batch drawing flag.
+        :param bt_size: batch drawing size.
+        :param loop: Loop the animation.
+        :return: Player settings.
+        """
+
+        if animation is not None:
+            if not self._set_animation(animation):
+                return "Invalid animation"
+        if self.animation is None:
+            return "No animation to play"
+        # Handle player settings
+        settings = self.control(play_speed_ms=speed_ms, bt_draw=bt_draw, bt_size=bt_size,  loop=loop)
+        # 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
+        return settings
+
+    def stop(self):
+        """
+        Stop the animation.
+        """
+        self.__running = False
+        return "Stop animation player"
+
+    def update(self, *arg, **kwargs):
+        """
+        Child class must implement this method to handle drawing logic.
+        """
+        raise NotImplementedError("Child class must implement update method.")
+
+    def draw(self):
+        """
+        Draw the current frame.
+        """
+        raise NotImplementedError("Child class must implement draw method.")
+
+    def clear(self):
+        """
+        Clear the display.
+        """
+        raise NotImplementedError("Child class must implement clear method.")

micrOS/source/Config.py

@@ -16,11 +16,11 @@ from re import search
 from json import load, dump
 from uos import remove
 from utime import sleep
-from Debug import DebugCfg, console_write, errlog_add
+from Debug import DebugCfg, console_write, syslog
 try:
     from microIO import set_pinmap
 except:
-    errlog_add("[ERR] LogicalPins import: set_pinmap")
+    syslog("[ERR] LogicalPins import: set_pinmap")
     set_pinmap = None
 
 
@@ -109,7 +109,7 @@ class Data:
             Data.write_cfg_file()
             console_write("[CONF] Save conf successful")
         except Exception as e:
-            errlog_add(f"[ERR] Save (__inject) conf failed: {e}")
+            syslog(f"[ERR] Save (__inject) conf failed: {e}")
         finally:
             del liveconf
 
@@ -127,7 +127,7 @@ class Data:
                 if nosafe:
                     break
                 sleep(0.2)
-                errlog_add(f'[ERR] read_cfg_file error: {e}')
+                syslog(f'[ERR] read_cfg_file error: {e}')
         # Return config cache
         return conf
 
@@ -140,7 +140,7 @@ class Data:
                     dump(Data.CONFIG_CACHE, f)
                 break
             except Exception as e:
-                errlog_add(f'[ERR] write_cfg_file {Data.CONFIG_PATH} (json): {e}')
+                syslog(f'[ERR] write_cfg_file {Data.CONFIG_PATH} (json): {e}')
             sleep(0.2)
         return True
 
@@ -217,7 +217,7 @@ def cfgget(key=None):
             return Data.disk_keys(key)
         return val
     except Exception as e:
-        errlog_add(f'[ERR] cfgget {key} error: {e}')
+        syslog(f'[ERR] cfgget {key} error: {e}')
     return None
 
 def cfgput(key, value, type_check=False):
@@ -242,7 +242,7 @@ def cfgput(key, value, type_check=False):
         del value
         return True
     except Exception as e:
-        errlog_add(f'[ERR] cfgput {key} error: {e}')
+        syslog(f'[ERR] cfgput {key} error: {e}')
         return False
 
 #################################################################

micrOS/source/Debug.py

@@ -1,12 +1,18 @@
+"""
+micrOS Console and Log write interface implementations.
+- with progress led feature, simple and custom
+    Designed by Marcell Ban aka BxNxM
+"""
+
 from machine import Pin
 try:
-    from Logger import syslog
+    from Logger import syslog as logger_syslog
 except:
-    syslog = None
+    logger_syslog = None
 try:
-    from microIO import resolve_pin, pinmap_search, detect_platform
+    from microIO import resolve_pin, pinmap_search, register_pin
 except:
-    detect_platform = None
+    pinmap_search = None
 
 
 #############################################
@@ -17,110 +23,60 @@ except:
 class DebugCfg:
     DEBUG = True        # DEBUG PRINT ON/OFF - SET FROM ConfigHandler
     PLED_STEP = None    # PROGRESS LED OBJECT - init in init_pled
-    NEO_WHEEL = None    # NEOPIXEL (ws2812/esp32s3) color wheel object
-    COLOR_INDEX = 0     # APA102 TinyPico color wheel counter
 
     @staticmethod
     def init_pled():
         # CALL FROM ConfigHandler
-        if detect_platform is None:
+        if pinmap_search is None:
             # Check LogicalPins module loadable (robustness...)
             return
-        micro_platform = detect_platform()
-        if micro_platform == "tinypico":
-            # Progress led for TinyPico
-            DebugCfg._init_apa102()
-            return
         pled = pinmap_search('builtin')['builtin']
-        if pled is not None:
-            if isinstance(pled, int):
-                # SET PROGRESS LED WITH BUILT-IN step FUNCTION
-                if micro_platform == "esp32s3":
-                    # Progress led for esp32s3
-                    DebugCfg._init_ws2812()
-                else:
-                    # Progress led for esp32/etc
-                    DebugCfg._init_simple()
-            else:
-                # OVERRIDE PROGRESS LED WITH CUSTOM step FUNCTION
-                DebugCfg.PLED_STEP = pled
+        if pled is None:
+            # No available builtin pin, skip pled init...
+            return
+        # CONFIGURE PROGRESS LED
+        if isinstance(pled, int):
+            # [MODE] Simple flashing progress LED
+            try:
+                # Progress led for esp32/etc
+                led_obj = Pin(abs(resolve_pin('builtin')), Pin.OUT)
+                if resolve_pin('builtin') < 0:
+                    # Pin number start with (-), like -8 (means inverted output)
+                    led_obj.value(1)            # Turn OFF built-in LED state invert (1:OFF)
+                # Set function callback for step function (simple led - blink)
+                DebugCfg.PLED_STEP = lambda: led_obj.value(not led_obj.value())  # # double-blink: return None
+            except Exception as e:
+                syslog(f"[PLED] led error: {e}")
+        elif callable(pled):
+            # [MODE] OVERRIDE PROGRESS LED WITH CUSTOM step FUNCTION
+            DebugCfg.PLED_STEP = pled
+            DebugCfg._auto_register_pin()
+        else:
+            syslog(f"[WARN] pled type not supported: {pled}")
 
-    @staticmethod
-    def step():
-        """
-        DEBUG LED FEEDBACK
-        - handle 3 types of builtin LEDs: analog, neopixel(ws2812), apa102
-        - automatic selection based on board type + builtin logical pin number
-        """
-        try:
-            if callable(DebugCfg.PLED_STEP):
-                return DebugCfg.PLED_STEP()         # Run step function (return None: double-blink OR True: no d-b)
-        except Exception as e:
-            errlog_add(f"[PLED] step error: {e}")
-        return True
 
     @staticmethod
-    def _init_simple():
+    def _auto_register_pin():
         try:
-            # Progress led for esp32/etc
-            led_obj = Pin(abs(resolve_pin('builtin')), Pin.OUT)
-            if resolve_pin('builtin') < 0:     # Pin number start with (-), like -8 (means inverted output)
-                led_obj.value(1)                # Turn OFF built-in LED state invert (1:OFF)
-            # Set function callback for step function (simple led - blink)
-            DebugCfg.PLED_STEP = lambda: led_obj.value(not led_obj.value())     # # double-blink: return None
+            pin = DebugCfg.PLED_STEP(pin=True)
+            if isinstance(pin, int):
+                register_pin('builtin', pin)
         except Exception as e:
-            errlog_add(f"[PLED] led error: {e}")
+            syslog(f"[ERR] pled pin registration: {e}", console=False)
 
-    @staticmethod
-    def _init_apa102():
-        try:
-            from machine import SoftSPI
-            from dotstar import DotStar
-            from tinypico import DOTSTAR_CLK, DOTSTAR_DATA, SPI_MISO, set_dotstar_power, dotstar_color_wheel
-            spi = SoftSPI(sck=Pin(DOTSTAR_CLK), mosi=Pin(DOTSTAR_DATA), miso=Pin(SPI_MISO))
-            # Create a DotStar instance
-            dotstar = DotStar(spi, 1, brightness=0.4)  # Just one DotStar, half brightness
-            # Turn on the power to the DotStar
-            set_dotstar_power(True)
-            DebugCfg.PLED_STEP = lambda: DebugCfg._step_apa102(led_obj=dotstar, color_wheel=dotstar_color_wheel)
-        except Exception as e:
-            errlog_add(f"[PLED] apa102 error: {e}")
-
-    @staticmethod
-    def _step_apa102(led_obj, color_wheel):
-        # Get the R,G,B values of the next colour
-        r, g, b = color_wheel(DebugCfg.COLOR_INDEX*2)
-        # Set the colour on the DOTSTAR
-        led_obj[0] = (int(r * 0.6), g, b, 0.4)
-        # Increase the wheel index
-        DebugCfg.COLOR_INDEX = 0 if DebugCfg.COLOR_INDEX > 1000 else DebugCfg.COLOR_INDEX + 2
-        return True                  # No double-blink
 
     @staticmethod
-    def _init_ws2812():
+    def step():
+        """
+        DEBUG LED FLASHING FEEDBACK
+        - handle step callback function execution
+        """
         try:
-            from neopixel import NeoPixel
-            neo_pin = Pin(resolve_pin('builtin'))
-            led_obj = NeoPixel(neo_pin, 1)
-            DebugCfg.PLED_STEP = lambda: DebugCfg._step_ws2812(led_obj)
+            if callable(DebugCfg.PLED_STEP):
+                return DebugCfg.PLED_STEP()         # Run step function (return None: double-blink OR True: no d-b)
         except Exception as e:
-            errlog_add(f"[PLED] ws2812 error: {e}")
-
-    @staticmethod
-    def _step_ws2812(led_obj):
-        def _color_wheel():
-            while True:
-                yield 10, 0, 0
-                yield 5, 5, 0
-                yield 0, 10, 0
-                yield 0, 5, 5
-                yield 0, 0, 10
-                yield 5, 0, 5
-        if DebugCfg.NEO_WHEEL is None:
-            DebugCfg.NEO_WHEEL = _color_wheel()
-        led_obj[0] = next(DebugCfg.NEO_WHEEL)
-        led_obj.write()
-        return True                     # No double-blink
+            syslog(f"[PLED] step error: {e}")
+        return True
 
 
 def console_write(msg):
@@ -131,10 +87,10 @@ def console_write(msg):
             if analog is None:
                 DebugCfg.step()             # Double-blink
         except Exception as e:
-            errlog_add(f"[ERR] console_write: {e}", console=False)
+            syslog(f"[ERR] console_write: {e}", console=False)
 
 
-def errlog_add(data, console=True):
+def syslog(data, console=True):
     """
     :param data: msg string / data
     :param console: activate console_write (default: True)
@@ -142,4 +98,4 @@ def errlog_add(data, console=True):
     """
     if console:
         console_write(data)
-    return False if syslog is None else syslog(data)
+    return False if logger_syslog is None else logger_syslog(data)