refactor: simplify patterns_base class

Extract base Patterns class with async run/stop support

src/patterns_base.py

@@ -1,9 +1,29 @@
 from machine import Pin
 from neopixel import NeoPixel
 import utime
+import random
+import _thread
+import asyncio
 
+# Short-key parameter mapping for convenience setters
+param_mapping = {
+    "pt": "selected",
+    "pa": "selected",
+    "cl": "colors",
+    "br": "brightness",
+    "dl": "delay",
+    "nl": "num_leds",
+    "co": "color_order",
+    "lp": "led_pin",
+    "n1": "n1",
+    "n2": "n2",
+    "n3": "n3",
+    "n4": "n4",
+    "n5": "n5",
+    "n6": "n6",
+}
 
-class PatternBase:
+class Patterns:
     def __init__(self, pin, num_leds, color1=(0,0,0), color2=(0,0,0), brightness=127, selected="rainbow_cycle", delay=100):
         self.n = NeoPixel(Pin(pin, Pin.OUT), num_leds)
         self.num_leds = num_leds
@@ -29,126 +49,62 @@ class PatternBase:
         # New attributes for scanner patterns
         self.scanner_direction = 1 # 1 for forward, -1 for backward
         self.scanner_tail_length = 3 # Number of trailing pixels
+        self.running = False
+        self.stopped = True
 
-    def sync(self):
+    def select(self, pattern):
-        self.pattern_step=0
+        if pattern in self.patterns:
-        self.last_update = utime.ticks_ms() - self.delay
+            self.selected = pattern
-        if self.selected == "color_transition":
+            return True
-            self.transition_step = 0
+        return False
-            self.current_color_idx = 0
-            self.current_color = self.colors[self.current_color_idx]
-            self.hold_start_time = utime.ticks_ms() # Reset hold time
-        # Reset scanner specific variables
-        self.scanner_direction = 1
-        self.tick()
 
-    def set_pattern_step(self, step):
+    async def run(self):
-        self.pattern_step = step
+        print(f"Stopping pattern")
+        await self.stop()
+        self.running = True
+        print(f"Starting pattern {self.selected}")
+        if self.selected in self.patterns:
+            _thread.start_new_thread(self.patterns[self.selected], ())
+        else:
+            print(f"Pattern {self.selected} not found")
 
-    def tick(self):
+    async def stop(self):
-        if self.patterns[self.selected]:
+        self.running = False
-            self.patterns[self.selected]()
+        start = utime.ticks_ms()
+        while not self.stopped and utime.ticks_diff(utime.ticks_ms(), start) < 1000:
+            await asyncio.sleep_ms(0)
+        self.stopped = True
+   
+    def set_param(self, key, value):
+        if key in param_mapping:
+            setattr(self, param_mapping[key], value)
+            return True
+        print(f"Invalid parameter: {key}")
+        return False
 
     def update_num_leds(self, pin, num_leds):
         self.n = NeoPixel(Pin(pin, Pin.OUT), num_leds)
         self.num_leds = num_leds
         self.pattern_step = 0
 
-    def set_delay(self, delay):
+ 
-        self.delay = delay
-        # Update transition duration and hold duration when delay changes
-        self.transition_duration = self.delay * 50
-        self.hold_duration = self.delay * 10
-
-
-    def set_brightness(self, brightness):
-        self.brightness = brightness
-
-    def set_color1(self, color):
-        if len(self.colors) > 0:
-            self.colors[0] = color
-            if self.selected == "color_transition":
-                # If the first color is changed, potentially reset transition
-                # to start from this new color if we were about to transition from it
-                if self.current_color_idx == 0:
-                    self.transition_step = 0
-                    self.current_color = self.colors[0]
-                    self.hold_start_time = utime.ticks_ms()
-        else:
-            self.colors.append(color)
-
-
-    def set_color2(self, color):
-        if len(self.colors) > 1:
-            self.colors[1] = color
-        elif len(self.colors) == 1:
-            self.colors.append(color)
-        else: # List is empty
-            self.colors.append((0,0,0)) # Dummy color
-            self.colors.append(color)
-
-
-    def set_colors(self, colors):
-        if colors and len(colors) >= 2:
-            self.colors = colors
-            if self.selected == "color_transition":
-                self.sync() # Reset transition if new color list is provided
-        elif colors and len(colors) == 1:
-            self.colors = [colors[0], (255,255,255)] # Add a default second color
-            if self.selected == "color_transition":
-                print("Warning: 'color_transition' requires at least two colors. Adding a default second color.")
-                self.sync()
-        else:
-            print("Error: set_colors requires a list of at least one color.")
-            self.colors = [(0,0,0), (255,255,255)] # Fallback
-            if self.selected == "color_transition":
-                self.sync()
-
     def set_color(self, num, color):
         # Changed: More robust index check
         if 0 <= num < len(self.colors):
            self.colors[num] = color
            # If the changed color is part of the current or next transition,
            # restart the transition for smoother updates
-           if self.selected == "color_transition":
-               current_from_idx = self.current_color_idx
-               current_to_idx = (self.current_color_idx + 1) % len(self.colors)
-               if num == current_from_idx or num == current_to_idx:
-                   # If we change a color involved in the current transition,
-                   # it's best to restart the transition state for smoothness.
-                   self.transition_step = 0
-                   self.current_color_idx = current_from_idx # Stay at the current starting color
-                   self.current_color = self.colors[self.current_color_idx]
-                   self.hold_start_time = utime.ticks_ms() # Reset hold
            return True
         elif num == len(self.colors): # Allow setting a new color at the end
             self.colors.append(color)
             return True
         return False
 
-    def add_color(self, color):
-        self.colors.append(color)
-        if self.selected == "color_transition" and len(self.colors) == 2:
-            # If we just added the second color needed for transition
-            self.sync()
-
 
     def del_color(self, num):
         # Changed: More robust index check and using del for lists
         if 0 <= num < len(self.colors):
            del self.colors[num]
-           # If the color being deleted was part of the current transition,
-           # re-evaluate the current_color_idx
-           if self.selected == "color_transition":
-               if len(self.colors) < 2: # Need at least two colors for transition
-                   print("Warning: Not enough colors for 'color_transition'. Switching to 'on'.")
-                   self.select("on") # Or some other default
-               else:
-                   # Adjust index if it's out of bounds after deletion or was the one transitioning from
-                   self.current_color_idx %= len(self.colors)
-                   self.transition_step = 0
-                   self.current_color = self.colors[self.current_color_idx]
-                   self.hold_start_time = utime.ticks_ms()
            return True
         return False
 
@@ -156,31 +112,6 @@ class PatternBase:
         effective_brightness = brightness_override if brightness_override is not None else self.brightness
         return tuple(int(c * effective_brightness / 255) for c in color)
 
-    def select(self, pattern):
-        if pattern in self.patterns:
-            self.selected = pattern
-            self.sync() # Reset pattern state when selecting a new pattern
-            if pattern == "color_transition":
-                if len(self.colors) < 2:
-                    print("Warning: 'color_transition' requires at least two colors. Switching to 'on'.")
-                    self.selected = "on" # Fallback if not enough colors
-                    self.sync() # Re-sync for the new pattern
-                else:
-                    self.transition_step = 0
-                    self.current_color_idx = 0 # Start from the first color in the list
-                    self.current_color = self.colors[self.current_color_idx]
-                    self.hold_start_time = utime.ticks_ms() # Reset hold timer
-                    self.transition_duration = self.delay * 50 # Initialize transition duration
-                    self.hold_duration = self.delay * 10 # Initialize hold duration
-            return True
-        return False
-
-    def set(self, i, color):
-        self.n[i] = color
-
-    def write(self):
-        self.n.write()
-
     def fill(self, color=None):
         fill_color = color if color is not None else self.colors[0]
         for i in range(self.num_leds):
@@ -191,4 +122,19 @@ class PatternBase:
         self.fill((0, 0, 0))
 
     def on(self):
-        self.fill(self.apply_brightness(self.colors[0]))
+        self.fill(self.apply_brightness(self.colors[0]))
+
+
+    
+
+    def wheel(self, pos):
+        if pos < 85:
+            return (pos * 3, 255 - pos * 3, 0)
+        elif pos < 170:
+            pos -= 85
+            return (255 - pos * 3, 0, pos * 3)
+        else:
+            pos -= 170
+            return (0, pos * 3, 255 - pos * 3)
+
+