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

env/driver_cp210x/macOS_VCP_Driver/macOS_VCP_Driver_Release_Notes.txt

@@ -1,5 +1,5 @@
 CP210x Macintosh OS VCP Driver v6 Release Notes
-Copyright (C) 2017-2021 Silicon Laboratories Inc.
+Copyright (C) 2017-2025 Silicon Laboratories Inc.
 
 This release contains the following components:
 
@@ -32,6 +32,7 @@ Uninstalling the Driver
 
 Release Dates
 -------------
+	CP210x Macintosh OS VCP Driver 6.0.3     - May 23, 2025
 	CP210x Macintosh OS VCP Driver 6.0.2     - October 26, 2021
 	CP210x Macintosh OS VCP Driver 6.0.1     - March 26, 2021
 	CP210x Macintosh OS VCP Driver 6.0       - December 18, 2020
@@ -73,6 +74,21 @@ Release Dates
 
 CP210x Macintosh OS Driver Revision History
 --------------------------------------------
+Version 6.0.3
+	Added a feature where the CP210x device sends an XOFF signal to the connected device when macOS goes to sleep.
+	Resolved an issue with driver uninstallation on macOS 13.
+	Fixed an issue where the Mac OSX CP210x v6.0.2 VCP Driver could crash during stress testing.
+	Added VID/PID for UAB DIELEKTRIK.
+	Added VID/PID for Quell Tech Ltd.
+	Added VID/PID for Profoto.
+	Added VID/PID for Cambo Fotografische Industrie BV.
+	Added VID/PID for ZTC WND-7300.
+	Added VID/PID for Integrel Solutions Ltd.
+	Added VID/PID for BRAIN MAGIC.
+	Added VID/PID for ELV Elektronik AG.
+	Added VID/PID for TDK Corporation.
+	Added VID/PID for Regula Forensics.
+	Added VID/PID for ALC Embedded Systems Ltd.
 Version 6.0.2
 	On macOS Big Sur:
 		Fix issue that Xoff state is not remembered when macOS goes to sleep.

micrOS/release_info/micrOS_ReleaseInfo/system_analysis_sum.json

@@ -1,19 +1,19 @@
 {
     "files": {
         "Time.py": [
-            9.16,
-            7
+            9.17,
+            6
         ],
         "Files.py": [
-            9.6,
-            4
+            9.35,
+            8
         ],
         "micrOSloader.py": [
             7.33,
             1
         ],
         "Hooks.py": [
-            9.85,
+            9.67,
             1
         ],
         "Server.py": [
@@ -46,22 +46,22 @@
         ],
         "Types.py": [
             8.91,
-            29
+            28
         ],
         "Logger.py": [
-            8.9,
+            9.05,
             4
         ],
         "Common.py": [
-            9.78,
-            35
+            9.84,
+            34
         ],
         "InterConnect.py": [
             9.41,
-            3
+            2
         ],
         "Debug.py": [
-            8.4,
+            7.37,
             18
         ],
         "Network.py": [
@@ -69,19 +69,19 @@
             8
         ],
         "Espnow.py": [
-            9.5,
-            1
+            9.57,
+            2
         ],
         "Scheduler.py": [
             9.62,
             1
         ],
         "microIO.py": [
-            9.43,
-            42
+            9.44,
+            43
         ],
         "micrOS.py": [
-            9.25,
+            9.27,
             1
         ],
         "Interrupts.py": [
@@ -97,7 +97,7 @@
             5
         ],
         "LM_roboarm.py": [
-            7.76,
+            7.78,
             0
         ],
         "LM_stepper.py": [
@@ -105,7 +105,7 @@
             1
         ],
         "LM_pacman.py": [
-            8.92,
+            8.95,
             0
         ],
         "LM_genIO.py": [
@@ -124,6 +124,10 @@
             7.57,
             0
         ],
+        "LM_qmi8658.py": [
+            9.1,
+            0
+        ],
         "LM_co2.py": [
             8.5,
             0
@@ -132,6 +136,10 @@
             8.18,
             0
         ],
+        "LM_tcs3472.py": [
+            9.02,
+            0
+        ],
         "LM_oled.py": [
             9.09,
             4
@@ -148,21 +156,17 @@
             8.04,
             0
         ],
-        "LM_ph_sensor.py": [
-            5.79,
-            0
-        ],
         "LM_buzzer.py": [
-            8.8,
+            9.11,
             0
         ],
         "LM_switch.py": [
-            8.66,
+            8.68,
             1
         ],
         "LM_servo.py": [
             7.73,
-            3
+            2
         ],
         "LM_rgbcct.py": [
             8.62,
@@ -181,11 +185,11 @@
             0
         ],
         "LM_neopixel.py": [
-            7.43,
+            7.54,
             2
         ],
         "LM_cct.py": [
-            9.03,
+            9.04,
             1
         ],
         "LM_L9110_DCmotor.py": [
@@ -193,7 +197,7 @@
             0
         ],
         "LM_neoeffects.py": [
-            6.86,
+            9.09,
             0
         ],
         "LM_i2c.py": [
@@ -253,7 +257,7 @@
             0
         ],
         "LM_rgb.py": [
-            8.75,
+            8.88,
             1
         ],
         "LM_distance.py": [
@@ -289,25 +293,13 @@
             0
         ],
         "LM_dimmer.py": [
-            8.32,
+            8.33,
             1
         ],
-        "LM_demo.py": [
-            8.57,
-            0
-        ],
         "LM_gameOfLife.py": [
             9.29,
             3
         ],
-        "LM_catgame.py": [
-            8.85,
-            0
-        ],
-        "LM_intercon.py": [
-            8.18,
-            0
-        ],
         "LM_ds18.py": [
             6.0,
             2
@@ -319,16 +311,20 @@
         "LM_sdcard.py": [
             7.88,
             0
+        ],
+        "LM_neomatrix.py": [
+            8.72,
+            0
         ]
     },
     "summary": {
         "core": [
-            3554,
+            3723,
             24
         ],
         "load": [
-            9227,
-            56
+            9410,
+            55
         ],
         "core_dep": [
             true,
@@ -336,10 +332,10 @@
         ],
         "load_dep": [
             true,
-            6
+            5
         ],
-        "core_score": 9.24,
-        "load_score": 8.23,
-        "version": "2.10.5-1"
+        "core_score": 9.19,
+        "load_score": 8.35,
+        "version": "2.11.0-0"
     }
 }

micrOS/source/Common.py

@@ -5,92 +5,23 @@ micrOS Load Module programming Official API-s
 from Server import Server, WebCli
 from Debug import errlog_add, 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):
+def micro_task(tag:str, task=None):
     """
-    [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
-
-
-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:
@@ -216,3 +143,251 @@ def syslog(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)
+
+#####################################################################################
+#                             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):
+        """
+        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
+        """
+        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._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()
+                    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):
+        """
+        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.
+        """
+        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)
+        return {"realtime": not self.batch_draw, "batched": self.batch_draw,
+                "size": self.__batch_size, "speed_ms": self._player_speed_ms}
+
+
+    def play(self, animation=None, speed_ms=None, bt_draw=False, bt_size=None):
+        """
+        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.
+        """
+
+        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)
+        # 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.")