Remove unused pattern tests

Extract base Patterns class with async run/stop support

src/patterns.py

@@ -2,6 +2,9 @@ from machine import Pin
 from neopixel import NeoPixel
 import utime
 import random
+import _thread
+import asyncio
+from patterns_base import Patterns as PatternsBase
 
 # Short-key parameter mapping for convenience setters
 param_mapping = {
@@ -19,424 +22,252 @@ param_mapping = {
     "n4": "n4",
     "n5": "n5",
     "n6": "n6",
+    "auto": "auto",
 }
 
-class Patterns:
+class Patterns(PatternsBase):
     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)
+        super().__init__(pin, num_leds, color1, color2, brightness, selected, delay)
-        self.num_leds = num_leds
+        self.auto = True
-        self.pattern_step = 0
+        self.step = 0
-        self.last_update = utime.ticks_ms()
-        self.delay = delay
-        self.brightness = brightness
         self.patterns = {
             "off": self.off,
             "on" : self.on,
-            "color_wipe": self.color_wipe_step,
+            "blink": self.blink,
-            "rainbow_cycle": self.rainbow_cycle_step,
+            "rainbow": self.rainbow,
-            "theater_chase": self.theater_chase_step,
+            "pulse": self.pulse,
-            "blink": self.blink_step,
+            "transition": self.transition,
-            "color_transition": self.color_transition_step, # Added new pattern
-            "flicker": self.flicker_step,
-            "scanner": self.scanner_step, # New: Single direction scanner
-            "bidirectional_scanner": self.bidirectional_scanner_step, # New: Bidirectional scanner
-            "external": None,
-            "pulse": self.pulse
         }
-        self.selected = selected
-        # Ensure colors list always starts with at least two for robust transition handling
-        self.colors = [color1, color2] if color1 != color2 else [color1, (255, 255, 255)] # Fallback if initial colors are same
-        if not self.colors: # Ensure at least one color exists
-            self.colors = [(0, 0, 0)]
-
-        self.transition_duration = delay * 50 # Default transition duration
-        self.hold_duration = delay * 10 # Default hold duration at each color
-        self.transition_step = 0 # Current step in the transition
-        self.current_color_idx = 0 # Index of the color currently being held/transitioned from
-        self.current_color = self.colors[self.current_color_idx] # The actual blended color
-
-        self.hold_start_time = utime.ticks_ms() # Time when the current color hold started
-
-        # New attributes for scanner patterns
-        self.scanner_direction = 1 # 1 for forward, -1 for backward
-        self.scanner_tail_length = 3 # Number of trailing pixels
-
-    def sync(self):
-        self.pattern_step=0
-        self.last_update = utime.ticks_ms() - self.delay
-        if self.selected == "color_transition":
-            self.transition_step = 0
-            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):
-        self.pattern_step = step
-
-    def tick(self):
-        if self.patterns[self.selected]:
-            self.patterns[self.selected]()
-
-    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):
+    def blink(self):
-        self.brightness = brightness
+        self.stopped = False
+        self.running = True
+        state = True  # True = on, False = off
+        last_update = utime.ticks_ms()
         
-    def set_color1(self, color):
+        while self.running:
-        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
-
-    def apply_brightness(self, color, brightness_override=None):
-        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):
-            self.n[i] = fill_color
-        self.n.write()
-
-    def off(self):
-        self.fill((0, 0, 0))
-
-    def on(self):
-        self.fill(self.apply_brightness(self.colors[0]))
-
-    def color_wipe_step(self):
-        color = self.apply_brightness(self.colors[0])
             current_time = utime.ticks_ms()
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
+            if utime.ticks_diff(current_time, last_update) >= self.delay:
-            if self.pattern_step < self.num_leds:
+                if state:
-                for i in range(self.num_leds):
-                    self.n[i] = (0, 0, 0)
-                self.n[self.pattern_step] = self.apply_brightness(color)
-                self.n.write()
-                self.pattern_step += 1
-            else:
-                self.pattern_step = 0
-            self.last_update = current_time
-
-    def rainbow_cycle_step(self):
-        current_time = utime.ticks_ms()
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay/5:
-            def wheel(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)
-
-            for i in range(self.num_leds):
-                rc_index = (i * 256 // self.num_leds) + self.pattern_step
-                self.n[i] = self.apply_brightness(wheel(rc_index & 255))
-            self.n.write()
-            self.pattern_step = (self.pattern_step + 1) % 256
-            self.last_update = current_time
-
-    def theater_chase_step(self):
-        current_time = utime.ticks_ms()
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
-            for i in range(self.num_leds):
-                if (i + self.pattern_step) % 3 == 0:
-                    self.n[i] = self.apply_brightness(self.colors[0])
-                else:
-                    self.n[i] = (0, 0, 0)
-            self.n.write()
-            self.pattern_step = (self.pattern_step + 1) % 3
-            self.last_update = current_time
-
-    def blink_step(self):
-        current_time = utime.ticks_ms()
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
-            if self.pattern_step % 2 == 0:
                     self.fill(self.apply_brightness(self.colors[0]))
                 else:
                     self.fill((0, 0, 0))
-            self.pattern_step = (self.pattern_step + 1) % 2
+                state = not state
-            self.last_update = current_time
+                last_update = current_time
+        self.running = False
+        self.stopped = True
 
-    def color_transition_step(self):
-        current_time = utime.ticks_ms()
 
-        # Check for hold duration first
+    def rainbow(self):
-        if utime.ticks_diff(current_time, self.hold_start_time) < self.hold_duration:
+        self.stopped = False
-            # Still in hold phase, just display the current solid color
+        self.running = True
-            self.fill(self.apply_brightness(self.current_color))
+        step = self.step % 256
-            self.last_update = current_time # Keep updating last_update to avoid skipping frames
+        step_amount = max(1, int(self.n1))  # n1 controls step increment
+        
+        # If auto is False, run once and update step
+        if not self.auto:
+            for i in range(self.num_leds):
+                rc_index = (i * 256 // self.num_leds) + step
+                self.n[i] = self.apply_brightness(self.wheel(rc_index & 255))
+            self.n.write()
+            # Increment step by n1 for next call
+            self.step = (step + step_amount) % 256
+            self.running = False
+            self.stopped = True
             return
         
-        # If hold duration is over, proceed with transition
+        # Auto is True: run continuously
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
+        sleep_ms = max(1, int(self.delay / 5))
-            num_colors = len(self.colors)
+        last_update = utime.ticks_ms()
-            if num_colors < 2:
-                # Should not happen if select handles it, but as a safeguard
-                self.select("on")
-                return
         
-            from_color = self.colors[self.current_color_idx]
+        while self.running:
-            to_color_idx = (self.current_color_idx + 1) % num_colors
-            to_color = self.colors[to_color_idx]
-
-            # Calculate interpolation factor (0.0 to 1.0)
-            # transition_step goes from 0 to transition_duration - 1
-            if self.transition_duration > 0:
-                interp_factor = self.transition_step / self.transition_duration
-            else:
-                interp_factor = 1.0 # Immediately transition if duration is zero
-
-            # Interpolate each color component
-            r = int(from_color[0] + (to_color[0] - from_color[0]) * interp_factor)
-            g = int(from_color[1] + (to_color[1] - from_color[1]) * interp_factor)
-            b = int(from_color[2] + (to_color[2] - from_color[2]) * interp_factor)
-
-            self.current_color = (r, g, b)
-            self.fill(self.apply_brightness(self.current_color))
-
-            self.transition_step += self.delay # Advance the transition step by the delay
-
-            if self.transition_step >= self.transition_duration:
-                # Transition complete, move to the next color and reset for hold phase
-                self.current_color_idx = to_color_idx
-                self.current_color = self.colors[self.current_color_idx] # Ensure current_color is the exact target color
-                self.transition_step = 0 # Reset transition progress
-                self.hold_start_time = current_time # Start hold phase for the new color
-
-            self.last_update = current_time
-
-    def flicker_step(self):
             current_time = utime.ticks_ms()
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay/5:
+            if utime.ticks_diff(current_time, last_update) >= sleep_ms:
-            base_color = self.colors[0]
+                for i in range(self.num_leds):
-            # Increase the range for flicker_brightness_offset
+                    rc_index = (i * 256 // self.num_leds) + step
-            # Changed from self.brightness // 4 to self.brightness // 2 (or even self.brightness for max intensity)
+                    self.n[i] = self.apply_brightness(self.wheel(rc_index & 255))
-            flicker_brightness_offset = random.randint(-int(self.brightness // 1.5), int(self.brightness // 1.5))
-            flicker_brightness = max(0, min(255, self.brightness + flicker_brightness_offset))
-
-            flicker_color = self.apply_brightness(base_color, brightness_override=flicker_brightness)
-            self.fill(flicker_color)
-            self.last_update = current_time
-
-    def scanner_step(self):
-        """
-        Mimics a 'Knight Rider' style scanner, moving in one direction.
-        """
-        current_time = utime.ticks_ms()
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
-            self.fill((0, 0, 0)) # Clear all LEDs
-
-            # Calculate the head and tail position
-            head_pos = self.pattern_step
-            color = self.apply_brightness(self.colors[0])
-
-            # Draw the head
-            if 0 <= head_pos < self.num_leds:
-                self.n[head_pos] = color
-
-            # Draw the trailing pixels with decreasing brightness
-            for i in range(1, self.scanner_tail_length + 1):
-                tail_pos = head_pos - i
-                if 0 <= tail_pos < self.num_leds:
-                    # Calculate fading color for tail
-                    # Example: linear fade from full brightness to off
-                    fade_factor = 1.0 - (i / (self.scanner_tail_length + 1))
-                    faded_color = tuple(int(c * fade_factor) for c in color)
-                    self.n[tail_pos] = faded_color
-
                 self.n.write()
+                step = (step + step_amount) % 256
+                self.step = step
+                last_update = current_time
+        self.running = False
+        self.stopped = True
 
-            self.pattern_step += 1
-            if self.pattern_step >= self.num_leds + self.scanner_tail_length:
-                self.pattern_step = 0 # Reset to start
-
-            self.last_update = current_time
-
-    def bidirectional_scanner_step(self):
-        """
-        Mimics a 'Knight Rider' style scanner, moving back and forth.
-        """
-        current_time = utime.ticks_ms()
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay/100:
-            self.fill((0, 0, 0)) # Clear all LEDs
-
-            color = self.apply_brightness(self.colors[0])
-
-            # Calculate the head position based on direction
-            head_pos = self.pattern_step
-
-            # Draw the head
-            if 0 <= head_pos < self.num_leds:
-                self.n[head_pos] = color
-
-            # Draw the trailing pixels with decreasing brightness
-            for i in range(1, self.scanner_tail_length + 1):
-                tail_pos = head_pos - (i * self.scanner_direction)
-                if 0 <= tail_pos < self.num_leds:
-                    fade_factor = 1.0 - (i / (self.scanner_tail_length + 1))
-                    faded_color = tuple(int(c * fade_factor) for c in color)
-                    self.n[tail_pos] = faded_color
-
-            self.n.write()
-
-            self.pattern_step += self.scanner_direction
-
-            # Change direction if boundaries are reached
-            if self.scanner_direction == 1 and self.pattern_step >= self.num_leds:
-                self.scanner_direction = -1
-                self.pattern_step = self.num_leds - 1 # Start moving back from the last LED
-            elif self.scanner_direction == -1 and self.pattern_step < 0:
-                self.scanner_direction = 1
-                self.pattern_step = 0 # Start moving forward from the first LED
-
-            self.last_update = current_time
    
     def pulse(self):
-        if self.pattern_step == 0:
+        self.stopped = False
+        self.running = True
+        self.off()
+        
+        # Get timing parameters with defaults if not set
+        attack_ms = getattr(self, 'n1', 200)  # Attack time in ms
+        hold_ms = getattr(self, 'n2', 200)    # Hold time in ms
+        decay_ms = getattr(self, 'n3', 200)   # Decay time in ms
+        
+        # Ensure we have at least one color
+        if not self.colors:
+            self.colors = [(255, 255, 255)]
+        
+        color_index = 0
+        # Calculate minimum update interval based on LED count
+        # NeoPixel timing: ~30µs per LED + reset time = ~6ms for 200 LEDs
+        # Use 10ms minimum to ensure writes complete + overhead
+        min_write_time_ms = (self.num_leds * 30) // 1000 + 1  # Convert µs to ms, add 1ms overhead
+        update_interval = max(10, min_write_time_ms + 4)  # At least 10ms, add margin for safety
+        
+        while self.running:
+            cycle_start = utime.ticks_ms()
+            
+            # Get the current color from the cycle
+            base_color = self.colors[color_index % len(self.colors)]
+            
+            # Attack phase: fade from 0 to full brightness
+            if attack_ms > 0:
+                attack_start = utime.ticks_ms()
+                last_update = attack_start
+                while self.running and utime.ticks_diff(utime.ticks_ms(), attack_start) < attack_ms:
+                    now = utime.ticks_ms()
+                    if utime.ticks_diff(now, last_update) >= update_interval:
+                        elapsed = utime.ticks_diff(now, attack_start)
+                        brightness_factor = min(1.0, elapsed / attack_ms)
+                        color = tuple(int(c * brightness_factor) for c in base_color)
+                        self.fill(self.apply_brightness(color))
+                        last_update = now
+            
+            # Hold phase: maintain full brightness
+            if hold_ms > 0 and self.running:
+                self.fill(self.apply_brightness(base_color))
+                hold_start = utime.ticks_ms()
+                while self.running and utime.ticks_diff(utime.ticks_ms(), hold_start) < hold_ms:
+                    pass
+            
+            # Decay phase: fade from full brightness to 0
+            if decay_ms > 0:
+                decay_start = utime.ticks_ms()
+                last_update = decay_start
+                while self.running and utime.ticks_diff(utime.ticks_ms(), decay_start) < decay_ms:
+                    now = utime.ticks_ms()
+                    if utime.ticks_diff(now, last_update) >= update_interval:
+                        elapsed = utime.ticks_diff(now, decay_start)
+                        brightness_factor = max(0.0, 1.0 - (elapsed / decay_ms))
+                        color = tuple(int(c * brightness_factor) for c in base_color)
+                        self.fill(self.apply_brightness(color))
+                        last_update = now
+            
+            # Move to next color in the cycle
+            color_index += 1
+            
+            # If auto flag is False, run only once and exit
+            if not self.auto:
+                break
+            
+            # Ensure the cycle takes exactly delay milliseconds before restarting
+            if self.running:
+                self.off()
+                wait_until = utime.ticks_add(cycle_start, self.delay)
+                while self.running and utime.ticks_diff(wait_until, utime.ticks_ms()) > 0:
+                    pass
+        
+        self.running = False
+        self.stopped = True
+
+    def transition(self):
+        """Transition between colors, taking delay ms between each color"""
+        self.stopped = False
+        self.running = True
+        
+        if not self.colors:
+            # No colors, turn off
+            self.off()
+            self.running = False
+            self.stopped = True
+            return
+        
+        if len(self.colors) == 1:
+            # Only one color, just stay that color
+            last_update = utime.ticks_ms()
+            while self.running:
+                current_time = utime.ticks_ms()
+                if utime.ticks_diff(current_time, last_update) >= 100:
                     self.fill(self.apply_brightness(self.colors[0]))
-            self.pattern_step = 1
+                    last_update = current_time
-            self.last_update = utime.ticks_ms()
+            self.running = False
-        if utime.ticks_diff(utime.ticks_ms(), self.last_update) > self.delay:
+            self.stopped = True
-            self.fill((0, 0, 0))
+            return
         
+        # If auto is False, only transition between color1 and color2
+        if not self.auto:
+            if len(self.colors) < 2:
+                # Need at least 2 colors for transition
+                self.running = False
+                self.stopped = True
+                return
             
-if __name__ == "__main__":
+            transition_duration = max(10, self.delay)  # At least 10ms
-    import time
+            update_interval = max(10, transition_duration // 50)  # Update every ~2% of transition
-    from machine import WDT
+            
-    wdt = WDT(timeout=2000)  # Enable watchdog with a 2 second timeout
+            # Transition from color1 to color2
-    p = Patterns(pin=10, num_leds=200, color1=(255,0,0), color2=(0,0,255), brightness=127, selected="bidirectional_scanner", delay=50)
+            color1 = self.colors[0]
-    p.select("pulse")
+            color2 = self.colors[1]
-    for i in range(1000):
+            
-        p.tick()
+            transition_start = utime.ticks_ms()
-        wdt.feed()
+            last_update = transition_start
-        time.sleep_ms(1)
+            
+            while self.running and utime.ticks_diff(utime.ticks_ms(), transition_start) < transition_duration:
+                now = utime.ticks_ms()
+                if utime.ticks_diff(now, last_update) >= update_interval:
+                    # Calculate interpolation factor (0.0 to 1.0)
+                    elapsed = utime.ticks_diff(now, transition_start)
+                    factor = min(1.0, elapsed / transition_duration)
+                    
+                    # Interpolate between color1 and color2
+                    interpolated = tuple(
+                        int(color1[i] + (color2[i] - color1[i]) * factor)
+                        for i in range(3)
+                    )
+                    
+                    # Apply brightness and fill
+                    self.fill(self.apply_brightness(interpolated))
+                    last_update = now
+            
+            self.running = False
+            self.stopped = True
+            return
+        
+        # Auto is True: cycle through all colors continuously
+        color_index = 0
+        transition_duration = max(10, self.delay)  # At least 10ms
+        update_interval = max(10, transition_duration // 50)  # Update every ~2% of transition
+        
+        while self.running:
+            # Get current and next color
+            current_color = self.colors[color_index % len(self.colors)]
+            next_color = self.colors[(color_index + 1) % len(self.colors)]
+            
+            # Transition from current to next color
+            transition_start = utime.ticks_ms()
+            last_update = transition_start
+            
+            while self.running and utime.ticks_diff(utime.ticks_ms(), transition_start) < transition_duration:
+                now = utime.ticks_ms()
+                if utime.ticks_diff(now, last_update) >= update_interval:
+                    # Calculate interpolation factor (0.0 to 1.0)
+                    elapsed = utime.ticks_diff(now, transition_start)
+                    factor = min(1.0, elapsed / transition_duration)
+                    
+                    # Interpolate between colors
+                    interpolated = tuple(
+                        int(current_color[i] + (next_color[i] - current_color[i]) * factor)
+                        for i in range(3)
+                    )
+                    
+                    # Apply brightness and fill
+                    self.fill(self.apply_brightness(interpolated))
+                    last_update = now
+            
+            # Move to next color
+            color_index = (color_index + 1) % len(self.colors)
+        
+        self.running = False
+        self.stopped = True

src/patterns_base.py

@@ -1,9 +1,30 @@
 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",
+    "auto": "auto",
+}
 
-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
@@ -11,6 +32,7 @@ class PatternBase:
         self.last_update = utime.ticks_ms()
         self.delay = delay
         self.brightness = brightness
+        self.auto = False
         self.patterns = {}
         self.selected = selected
         # Ensure colors list always starts with at least two for robust transition handling
@@ -29,80 +51,44 @@ 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
@@ -110,45 +96,17 @@ class PatternBase:
            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 +114,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):
@@ -192,3 +125,18 @@ class PatternBase:
 
     def on(self):
         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)
+
+    

src/web.py

@@ -12,7 +12,7 @@ def web(settings, patterns):
     @app.route('/')
     async def index_hnadler(request):
         mac = wifi.get_mac().hex()
-        return Template('/index.html').render(settings=settings, patterns=patterns.patterns.keys(), mac=mac)
+        return Template('index.html').render(settings=settings, patterns=patterns.patterns.keys())
 
     @app.route("/static/<path:path>")
     def static_handler(request, path):
@@ -35,7 +35,7 @@ def web(settings, patterns):
             if data:
 
                 # Process the received data
-                _, status_code = settings.set_settings(json.loads(data), patterns, True)
+                _, status_code = await settings.set_settings(json.loads(data), patterns, True)
                 #await ws.send(status_code)
             else:
                 break

test/patterns/bidirectional_scanner.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-import utime
-from machine import WDT
-from settings import Settings
-from patterns import Patterns
-
-
-def run():
-    s = Settings()
-    pin = s.get("led_pin", 10)
-    num = s.get("num_leds", 30)
-
-    p = Patterns(pin=pin, num_leds=num)
-    wdt = WDT(timeout=10000)
-    p.set_param("br", 127)
-    p.set_param("dl", 50)
-    p.set_param("cl", [(0, 255, 0), (0, 255, 0)])
-    p.set_param("pt", "bidirectional_scanner")
-
-    start = utime.ticks_ms()
-    while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
-        p.tick()
-        wdt.feed()
-        utime.sleep_ms(10)
-
-    p.set_param("pt", "off")
-    p.tick()
-    utime.sleep_ms(100)
-
-
-if __name__ == "__main__":
-    run()
-
-

test/patterns/blink.py

@@ -1,11 +1,12 @@
 #!/usr/bin/env python3
+import uasyncio as asyncio
 import utime
 from machine import WDT
 from settings import Settings
 from patterns import Patterns
 
 
-def run():
+async def main():
     s = Settings()
     pin = s.get("led_pin", 10)
     num = s.get("num_leds", 30)
@@ -15,20 +16,17 @@ def run():
     p.set_param("br", 64)
     p.set_param("dl", 200)
     p.set_param("cl", [(255, 0, 0), (0, 0, 255)])
-    p.set_param("pt", "blink")
+    p.select("blink")
-
+    task = asyncio.create_task(p.run())
     start = utime.ticks_ms()
     while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
-        p.tick()
         wdt.feed()
-        utime.sleep_ms(10)
+        await asyncio.sleep_ms(10)
-
+    await p.stop()
-    p.set_param("pt", "off")
+    await task
-    p.tick()
-    utime.sleep_ms(100)
     
 
 if __name__ == "__main__":
-    run()
+    asyncio.run(main())
 
 

test/patterns/color_transition.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-import utime
-from machine import WDT
-from settings import Settings
-from patterns import Patterns
-
-
-def run():
-    s = Settings()
-    pin = s.get("led_pin", 10)
-    num = s.get("num_leds", 30)
-
-    p = Patterns(pin=pin, num_leds=num)
-    wdt = WDT(timeout=10000)
-    p.set_param("br", 64)
-    p.set_param("dl", 100)
-    p.set_param("cl", [(255, 0, 0), (0, 255, 0)])
-    p.set_param("pt", "color_transition")
-
-    start = utime.ticks_ms()
-    while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
-        p.tick()
-        wdt.feed()
-        utime.sleep_ms(10)
-
-    p.set_param("pt", "off")
-    p.tick()
-    utime.sleep_ms(100)
-
-
-if __name__ == "__main__":
-    run()
-
-

test/patterns/color_wipe.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-import utime
-from machine import WDT
-from settings import Settings
-from patterns import Patterns
-
-
-def run():
-    s = Settings()
-    pin = s.get("led_pin", 10)
-    num = s.get("num_leds", 30)
-
-    p = Patterns(pin=pin, num_leds=num)
-    wdt = WDT(timeout=10000)
-    p.set_param("br", 64)
-    p.set_param("dl", 60)
-    p.set_param("cl", [(0, 0, 255), (255, 0, 0)])
-    p.set_param("pt", "color_wipe")
-
-    start = utime.ticks_ms()
-    while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
-        p.tick()
-        wdt.feed()
-        utime.sleep_ms(10)
-
-    p.set_param("pt", "off")
-    p.tick()
-    utime.sleep_ms(100)
-
-
-if __name__ == "__main__":
-    run()
-
-

test/patterns/flicker.py

@@ -1,35 +0,0 @@
-#!/usr/bin/env python3
-import utime
-from machine import WDT
-from settings import Settings
-from patterns import Patterns
-
-
-def run():
-    s = Settings()
-    pin = s.get("led_pin", 10)
-    num = s.get("num_leds", 30)
-
-    p = Patterns(pin=pin, num_leds=num)
-    wdt = WDT(timeout=10000)
-    p.set_param("br", 127)
-    p.set_param("dl", 100)
-    p.set_param("cl", [(255, 136, 0), (255, 136, 0)])
-    p.set_param("n1", 10)
-    p.set_param("pt", "flicker")
-
-    start = utime.ticks_ms()
-    while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
-        p.tick()
-        wdt.feed()
-        utime.sleep_ms(10)
-
-    p.set_param("pt", "off")
-    p.tick()
-    utime.sleep_ms(100)
-
-
-if __name__ == "__main__":
-    run()
-
-

test/patterns/off.py

@@ -1,24 +1,26 @@
 #!/usr/bin/env python3
-import utime
+import uasyncio as asyncio
 from machine import WDT
 from settings import Settings
 from patterns import Patterns
 
 
-def run():
+async def main():
     s = Settings()
     pin = s.get("led_pin", 10)
     num = s.get("num_leds", 30)
 
     p = Patterns(pin=pin, num_leds=num)
     wdt = WDT(timeout=10000)
-    p.set_param("pt", "off")
+    p.select("off")
-    p.tick()
+    task = asyncio.create_task(p.run())
     wdt.feed()
-    utime.sleep_ms(200)
+    await asyncio.sleep_ms(200)
+    p.stopped = True
+    await task
 
 
 if __name__ == "__main__":
-    run()
+    asyncio.run(main())
 
 

test/patterns/on.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
-import utime
+import uasyncio as asyncio
 from machine import WDT
 from settings import Settings
 from patterns import Patterns
 
 
-def run():
+async def main():
     s = Settings()
     pin = s.get("led_pin", 10)
     num = s.get("num_leds", 30)
@@ -15,20 +15,20 @@ def run():
     p.set_param("br", 64)
     p.set_param("dl", 120)
     p.set_param("cl", [(255, 0, 0), (0, 0, 255)])
-    p.set_param("pt", "on")
+    p.select("on")
-
+    task = asyncio.create_task(p.run())
-    start = utime.ticks_ms()
+    await asyncio.sleep_ms(800)
-    while utime.ticks_diff(utime.ticks_ms(), start) < 800:
+    p.stopped = True
-        p.tick()
+    await task
-        wdt.feed()
+    p.stopped = False
-        utime.sleep_ms(10)
+    p.select("off")
-
+    task = asyncio.create_task(p.run())
-    p.set_param("pt", "off")
+    await asyncio.sleep_ms(100)
-    p.tick()
+    p.stopped = True
-    utime.sleep_ms(100)
+    await task
 
 
 if __name__ == "__main__":
-    run()
+    asyncio.run(main())
 
 

test/patterns/pulse.py

@@ -1,36 +1,160 @@
 #!/usr/bin/env python3
+import uasyncio as asyncio
 import utime
 from machine import WDT
 from settings import Settings
 from patterns import Patterns
 
 
-def run():
+async def main():
     s = Settings()
     pin = s.get("led_pin", 10)
     num = s.get("num_leds", 30)
 
     p = Patterns(pin=pin, num_leds=num)
     wdt = WDT(timeout=10000)
+    
+    # Test 1: Basic pulse with attack, hold, and decay
+    print("Test 1: Basic pulse pattern")
     p.set_param("br", 255)
-    p.set_param("dl", 100)
+    p.set_param("dl", 1000)  # 1 second delay between pulses
+    p.set_param("auto", True)  # Run continuously
     p.set_param("cl", [(255, 255, 255), (255, 255, 255)])
-    p.set_param("n1", 200)
+    p.set_param("n1", 200)  # Attack: 200ms
-    p.set_param("n2", 200)
+    p.set_param("n2", 200)  # Hold: 200ms
-    p.set_param("pt", "pulse")
+    p.set_param("n3", 200)  # Decay: 200ms
-
+    p.select("pulse")
+    task = asyncio.create_task(p.run())
     start = utime.ticks_ms()
-    while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
+    # Run for 3 seconds to see multiple pulse cycles
-        p.tick()
+    while utime.ticks_diff(utime.ticks_ms(), start) < 3000:
         wdt.feed()
-        utime.sleep_ms(10)
+        await asyncio.sleep_ms(10)
+    p.stopped = True
+    await task
     
-    p.set_param("pt", "off")
+    # Test 2: Fast pulse with shorter delay
-    p.tick()
+    print("Test 2: Fast pulse pattern")
-    utime.sleep_ms(100)
+    p.stopped = False
+    p.set_param("dl", 500)  # 500ms delay between pulses
+    p.set_param("auto", True)  # Run continuously
+    p.set_param("n1", 100)  # Attack: 100ms
+    p.set_param("n2", 100)  # Hold: 100ms
+    p.set_param("n3", 100)  # Decay: 100ms
+    p.select("pulse")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    # Run for 2 seconds
+    while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    p.stopped = True
+    await task
+    
+    # Test 3: Colored pulse
+    print("Test 3: Colored pulse pattern")
+    p.stopped = False
+    p.set_param("dl", 800)
+    p.set_param("auto", True)  # Run continuously
+    p.set_param("cl", [(255, 0, 0), (0, 0, 255)])  # Red pulse
+    p.set_param("n1", 150)
+    p.set_param("n2", 150)
+    p.set_param("n3", 150)
+    p.select("pulse")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    # Run for 2 seconds
+    while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    p.stopped = True
+    await task
+    
+    # Test 4: Verify delay restart timing
+    print("Test 4: Testing delay restart timing")
+    p.stopped = False
+    p.set_param("dl", 500)  # 500ms delay
+    p.set_param("auto", True)  # Run continuously
+    p.set_param("n1", 100)  # Total attack+hold+decay = 300ms, should wait 200ms more
+    p.set_param("n2", 100)
+    p.set_param("n3", 100)
+    p.select("pulse")
+    task = asyncio.create_task(p.run())
+    
+    # Monitor pulse cycles
+    cycle_count = 0
+    last_cycle_time = utime.ticks_ms()
+    start = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start) < 3000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+        # Check if we're near the start of a new cycle (LEDs off)
+        # This is a simplified check - in practice you'd monitor LED state
+    p.stopped = True
+    await task
+    
+    # Test 5: Single-shot pulse (auto=False)
+    print("Test 5: Single-shot pulse (auto=False)")
+    p.stopped = False
+    p.set_param("dl", 500)  # Delay between pulses
+    p.set_param("auto", False)  # Run only once
+    p.set_param("cl", [(0, 255, 0), (0, 255, 0)])  # Green pulse
+    p.set_param("n1", 150)  # Attack: 150ms
+    p.set_param("n2", 150)  # Hold: 150ms
+    p.set_param("n3", 150)  # Decay: 150ms
+    p.select("pulse")
+    task = asyncio.create_task(p.run())
+    
+    # The pulse should complete once and then stop
+    # Total time should be ~450ms (attack + hold + decay)
+    # Wait a bit longer to verify it doesn't repeat
+    start = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start) < 1000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    
+    # Task should have completed on its own (not stopped manually)
+    # Verify it's stopped
+    if not p.stopped:
+        print("Warning: Pulse should have stopped automatically with auto=False")
+        p.stopped = True
+    await task
+    
+    # Test 6: Pulse cycles through colors
+    print("Test 6: Pulse cycles through colors")
+    p.stopped = False
+    p.set_param("dl", 300)  # cycle interval
+    p.set_param("auto", True)  # Run continuously
+    p.set_param("cl", [
+        (255, 0, 0),   # red
+        (0, 255, 0),   # green
+        (0, 0, 255),   # blue
+        (255, 255, 0), # yellow
+    ])
+    p.set_param("n1", 50)
+    p.set_param("n2", 0)
+    p.set_param("n3", 50)
+    p.select("pulse")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    # Run long enough to observe multiple color cycles
+    while utime.ticks_diff(utime.ticks_ms(), start) < 10000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    p.stopped = True
+    await task
+    
+    # Cleanup
+    print("Test complete, turning off")
+    p.stopped = False
+    p.select("off")
+    task = asyncio.create_task(p.run())
+    await asyncio.sleep_ms(100)
+    p.stopped = True
+    await task
 
 
 if __name__ == "__main__":
-    run()
+    asyncio.run(main())
 
 

test/patterns/rainbow.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+import uasyncio as asyncio
+import utime
+from machine import WDT
+from settings import Settings
+from patterns import Patterns
+
+
+async def main():
+    s = Settings()
+    pin = s.get("led_pin", 10)
+    num = s.get("num_leds", 30)
+
+    p = Patterns(pin=pin, num_leds=num)
+    wdt = WDT(timeout=10000)
+    
+    # Test 1: Basic rainbow with auto=True (continuous)
+    print("Test 1: Basic rainbow (auto=True, n1=1)")
+    p.set_param("br", 255)
+    p.set_param("dl", 100)  # Delay affects animation speed
+    p.set_param("n1", 1)  # Step increment of 1
+    p.set_param("auto", True)  # Run continuously
+    p.select("rainbow")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    # Run for 3 seconds to see rainbow animation
+    while utime.ticks_diff(utime.ticks_ms(), start) < 3000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    await p.stop()
+    await task
+    
+    # Test 2: Fast rainbow
+    print("Test 2: Fast rainbow (low delay, n1=1)")
+    p.stopped = False
+    p.set_param("dl", 50)  # Faster animation
+    p.set_param("n1", 1)
+    p.set_param("auto", True)
+    p.select("rainbow")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    await p.stop()
+    await task
+    
+    # Test 3: Slow rainbow
+    print("Test 3: Slow rainbow (high delay, n1=1)")
+    p.stopped = False
+    p.set_param("dl", 500)  # Slower animation
+    p.set_param("n1", 1)
+    p.set_param("auto", True)
+    p.select("rainbow")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start) < 3000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    await p.stop()
+    await task
+    
+    # Test 4: Low brightness rainbow
+    print("Test 4: Low brightness rainbow (n1=1)")
+    p.stopped = False
+    p.set_param("br", 64)  # Low brightness
+    p.set_param("dl", 100)
+    p.set_param("n1", 1)
+    p.set_param("auto", True)
+    p.select("rainbow")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    await p.stop()
+    await task
+    
+    # Test 5: Single-step rainbow (auto=False)
+    print("Test 5: Single-step rainbow (auto=False, n1=1)")
+    p.stopped = False
+    p.set_param("br", 255)
+    p.set_param("dl", 100)
+    p.set_param("n1", 1)
+    p.set_param("auto", False)  # Run once per call
+    p.set_param("step", 0)  # Reset step
+    p.select("rainbow")
+    
+    # Call rainbow multiple times to see step progression
+    for i in range(10):
+        task = asyncio.create_task(p.run())
+        await task
+        await asyncio.sleep_ms(100)  # Small delay between steps
+        wdt.feed()
+    
+    # Test 6: Verify step updates correctly
+    print("Test 6: Verify step updates (auto=False, n1=1)")
+    p.stopped = False
+    p.set_param("n1", 1)
+    initial_step = p.step
+    p.select("rainbow")
+    task = asyncio.create_task(p.run())
+    await task
+    final_step = p.step
+    print(f"Step updated from {initial_step} to {final_step} (expected increment: 1)")
+    
+    # Test 7: Fast step increment (n1=5)
+    print("Test 7: Fast rainbow (n1=5, auto=True)")
+    p.stopped = False
+    p.set_param("br", 255)
+    p.set_param("dl", 100)
+    p.set_param("n1", 5)  # Step increment of 5 (5x faster)
+    p.set_param("auto", True)
+    p.select("rainbow")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    await p.stop()
+    await task
+    
+    # Test 8: Very fast step increment (n1=10)
+    print("Test 8: Very fast rainbow (n1=10, auto=True)")
+    p.stopped = False
+    p.set_param("n1", 10)  # Step increment of 10 (10x faster)
+    p.set_param("auto", True)
+    p.select("rainbow")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    await p.stop()
+    await task
+    
+    # Test 9: Verify n1 controls step increment (auto=False)
+    print("Test 9: Verify n1 step increment (auto=False, n1=5)")
+    p.stopped = False
+    p.set_param("n1", 5)  # Step increment of 5
+    p.set_param("auto", False)
+    p.set_param("step", 0)  # Reset step
+    initial_step = p.step
+    p.select("rainbow")
+    task = asyncio.create_task(p.run())
+    await task
+    final_step = p.step
+    expected_step = (initial_step + 5) % 256
+    print(f"Step updated from {initial_step} to {final_step} (expected: {expected_step})")
+    if final_step == expected_step:
+        print("✓ n1 step increment working correctly")
+    else:
+        print(f"✗ Step increment mismatch! Expected {expected_step}, got {final_step}")
+    
+    # Cleanup
+    print("Test complete, turning off")
+    p.stopped = False
+    p.select("off")
+    task = asyncio.create_task(p.run())
+    await asyncio.sleep_ms(100)
+    await p.stop()
+    await task
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

test/patterns/rainbow_cycle.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python3
-import utime
-from machine import WDT
-from settings import Settings
-from patterns import Patterns
-
-
-def run():
-    s = Settings()
-    pin = s.get("led_pin", 10)
-    num = s.get("num_leds", 30)
-
-    p = Patterns(pin=pin, num_leds=num)
-    wdt = WDT(timeout=10000)
-    p.set_param("br", 64)
-    p.set_param("dl", 100)
-    p.set_param("pt", "rainbow_cycle")
-
-    start = utime.ticks_ms()
-    while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
-        p.tick()
-        wdt.feed()
-        utime.sleep_ms(10)
-
-    p.set_param("pt", "off")
-    p.tick()
-    utime.sleep_ms(100)
-
-
-if __name__ == "__main__":
-    run()
-
-

test/patterns/scanner.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-import utime
-from machine import WDT
-from settings import Settings
-from patterns import Patterns
-
-
-def run():
-    s = Settings()
-    pin = s.get("led_pin", 10)
-    num = s.get("num_leds", 30)
-
-    p = Patterns(pin=pin, num_leds=num)
-    wdt = WDT(timeout=10000)
-    p.set_param("br", 127)
-    p.set_param("dl", 50)
-    p.set_param("cl", [(0, 255, 0), (0, 255, 0)])
-    p.set_param("pt", "scanner")
-
-    start = utime.ticks_ms()
-    while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
-        p.tick()
-        wdt.feed()
-        utime.sleep_ms(10)
-
-    p.set_param("pt", "off")
-    p.tick()
-    utime.sleep_ms(100)
-
-
-if __name__ == "__main__":
-    run()
-
-

test/patterns/theater_chase.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-import utime
-from machine import WDT
-from settings import Settings
-from patterns import Patterns
-
-
-def run():
-    s = Settings()
-    pin = s.get("led_pin", 10)
-    num = s.get("num_leds", 30)
-
-    p = Patterns(pin=pin, num_leds=num)
-    wdt = WDT(timeout=10000)
-    p.set_param("br", 64)
-    p.set_param("dl", 100)
-    p.set_param("cl", [(255, 255, 255), (0, 0, 0)])
-    p.set_param("pt", "theater_chase")
-
-    start = utime.ticks_ms()
-    while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
-        p.tick()
-        wdt.feed()
-        utime.sleep_ms(10)
-
-    p.set_param("pt", "off")
-    p.tick()
-    utime.sleep_ms(100)
-
-
-if __name__ == "__main__":
-    run()
-
-

test/patterns/transition.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+import uasyncio as asyncio
+import utime
+from machine import WDT
+from settings import Settings
+from patterns import Patterns
+
+
+async def main():
+    s = Settings()
+    pin = s.get("led_pin", 10)
+    num = s.get("num_leds", 30)
+
+    p = Patterns(pin=pin, num_leds=num)
+    wdt = WDT(timeout=10000)
+    
+    # Test 1: Basic transition with 2 colors (auto=True, cycles continuously)
+    print("Test 1: Basic transition (2 colors, 1000ms delay, auto=True)")
+    p.set_param("br", 255)
+    p.set_param("dl", 1000)  # 1 second transition time
+    p.set_param("auto", True)  # Cycle continuously
+    p.set_param("cl", [(255, 0, 0), (0, 255, 0)])  # Red to Green
+    p.select("transition")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    # Run for 5 seconds to see multiple transitions
+    while utime.ticks_diff(utime.ticks_ms(), start) < 5000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    p.stopped = True
+    await task
+    
+    # Test 2: Fast transition (auto=True, cycles continuously)
+    print("Test 2: Fast transition (500ms delay, auto=True)")
+    p.stopped = False
+    p.set_param("dl", 500)  # 500ms transition time
+    p.set_param("auto", True)  # Cycle continuously
+    p.set_param("cl", [(0, 0, 255), (255, 255, 0)])  # Blue to Yellow
+    p.select("transition")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    # Run for 3 seconds
+    while utime.ticks_diff(utime.ticks_ms(), start) < 3000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    p.stopped = True
+    await task
+    
+    # Test 3: Multiple colors transition (auto=True, cycles continuously)
+    print("Test 3: Multiple colors transition (3 colors, auto=True)")
+    p.stopped = False
+    p.set_param("dl", 800)
+    p.set_param("auto", True)  # Cycle continuously
+    p.set_param("cl", [
+        (255, 0, 0),   # Red
+        (0, 255, 0),   # Green
+        (0, 0, 255),   # Blue
+    ])
+    p.select("transition")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    # Run for 8 seconds to see full cycles
+    while utime.ticks_diff(utime.ticks_ms(), start) < 8000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    p.stopped = True
+    await task
+    
+    # Test 4: Single color (should just stay that color)
+    print("Test 4: Single color (should stay that color)")
+    p.stopped = False
+    p.set_param("dl", 1000)
+    p.set_param("cl", [(255, 128, 0)])  # Orange
+    p.select("transition")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    # Run for 3 seconds
+    while utime.ticks_diff(utime.ticks_ms(), start) < 3000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    p.stopped = True
+    await task
+    
+    # Test 5: Many colors transition (auto=True, cycles continuously)
+    print("Test 5: Many colors transition (5 colors, auto=True)")
+    p.stopped = False
+    p.set_param("dl", 600)
+    p.set_param("auto", True)  # Cycle continuously
+    p.set_param("cl", [
+        (255, 0, 0),     # Red
+        (255, 128, 0),   # Orange
+        (255, 255, 0),   # Yellow
+        (0, 255, 0),     # Green
+        (0, 0, 255),     # Blue
+    ])
+    p.select("transition")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    # Run for 10 seconds to see multiple cycles
+    while utime.ticks_diff(utime.ticks_ms(), start) < 10000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    p.stopped = True
+    await task
+    
+    # Test 6: Low brightness transition (auto=True, cycles continuously)
+    print("Test 6: Low brightness transition (auto=True)")
+    p.stopped = False
+    p.set_param("br", 64)  # Low brightness
+    p.set_param("dl", 1000)
+    p.set_param("auto", True)  # Cycle continuously
+    p.set_param("cl", [(255, 0, 0), (0, 255, 0)])
+    p.select("transition")
+    task = asyncio.create_task(p.run())
+    start = utime.ticks_ms()
+    # Run for 3 seconds
+    while utime.ticks_diff(utime.ticks_ms(), start) < 3000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    p.stopped = True
+    await task
+    
+    # Test 7: Single-shot transition (auto=False, only color1 to color2)
+    print("Test 7: Single-shot transition (auto=False, color1 to color2 only)")
+    p.stopped = False
+    p.set_param("br", 255)
+    p.set_param("dl", 1000)  # 1 second transition
+    p.set_param("auto", False)  # Run only once
+    p.set_param("cl", [
+        (255, 0, 0),     # Red (color1)
+        (0, 255, 0),     # Green (color2)
+        (0, 0, 255),     # Blue (should be ignored)
+        (255, 255, 0),   # Yellow (should be ignored)
+    ])
+    p.select("transition")
+    task = asyncio.create_task(p.run())
+    
+    # The transition should complete once (color1 to color2) and then stop
+    # Total time should be ~1000ms
+    # Wait a bit longer to verify it doesn't continue
+    start = utime.ticks_ms()
+    while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
+        wdt.feed()
+        await asyncio.sleep_ms(10)
+    
+    # Task should have completed on its own (not stopped manually)
+    # Verify it's stopped
+    if not p.stopped:
+        print("Warning: Transition should have stopped automatically with auto=False")
+        p.stopped = True
+    await task
+    
+    # Cleanup
+    print("Test complete, turning off")
+    p.stopped = False
+    p.select("off")
+    task = asyncio.create_task(p.run())
+    await asyncio.sleep_ms(100)
+    p.stopped = True
+    await task
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+