Switch to using itterators

src/boot.py

@@ -6,4 +6,4 @@ s = Settings()
 
 name = s.get('name', 'led')
 password = s.get("ap_password", "")
-wifi.ap(name, password)
+# wifi.ap(name, password)

src/main.py

@@ -10,45 +10,46 @@ import time
 import wifi
 import json
 from p2p import p2p
+import espnow
+import network
 
-async def main():
-    settings = Settings()
+settings = Settings()
 
-    patterns = Patterns(settings["led_pin"], settings["num_leds"], selected=settings["pattern"])
-    if settings["color_order"] == "rbg": color_order = (1, 5, 3)
-    else: color_order = (1, 3, 5)
-    patterns.set_color1(tuple(int(settings["color1"][i:i+2], 16) for i in color_order))
-    patterns.set_color2(tuple(int(settings["color2"][i:i+2], 16) for i in color_order))
-    patterns.set_brightness(int(settings["brightness"]))
-    patterns.set_delay(int(settings["delay"]))
+patterns = Patterns(settings["led_pin"], settings["num_leds"], selected=settings["pattern"])
+if settings["color_order"] == "rbg": color_order = (1, 5, 3)
+else: color_order = (1, 3, 5)
+patterns.set_color1(tuple(int(settings["color1"][i:i+2], 16) for i in color_order))
+patterns.set_color2(tuple(int(settings["color2"][i:i+2], 16) for i in color_order))
+patterns.set_brightness(int(settings["brightness"]))
+patterns.set_delay(int(settings["delay"]))
 
-    async def tick():
-        while True:
-            patterns.tick()
-            await asyncio.sleep_ms(0)
+sta = network.WLAN(network.STA_IF)
+sta.active(True)
+sta.disconnect()   # Because ESP8266 auto-connects to last Access Point
 
-    async def system():
-        while True:
-            gc.collect()
-            for i in range(60):
-                wdt.feed()
-                await asyncio.sleep(1)
+e = espnow.ESPNow()
+e.active(True)
+
+print(settings)
+# start the server in a bacakground task
+print("Starting")
+
+wdt = machine.WDT(timeout=10000)
+
+while True:
 
-    w = web(settings, patterns)
-    print(settings)
-    # start the server in a bacakground task
-    print("Starting")
-    server = asyncio.create_task(w.start_server(host="0.0.0.0", port=80))
-    wdt = machine.WDT(timeout=10000)
     wdt.feed()
-
-    asyncio.create_task(tick())
-    asyncio.create_task(p2p(settings, patterns))
-    asyncio.create_task(system())
-
-
-
-    # cleanup before ending the application
-    await server
-
-asyncio.run(main())
+    patterns.tick()
+    host, msg = e.recv(0)
+    if msg:
+        try:
+            data = json.loads(msg)
+        except:
+            print(f"Failed to load espnow data {msg}")
+            continue
+        print(data)
+        if "names" not in data or settings.get("name") in data.get("names", []):
+            if "step" in settings and isinstance(settings["step"], int):
+                patterns.set_pattern_step(settings["step"])
+            else:
+                settings.set_settings(data.get("settings", {}), patterns, data.get("save", False))

src/patterns.py

@@ -2,395 +2,226 @@ from machine import Pin
 from neopixel import NeoPixel
 import utime
 import random
+from patterns_base import PatternsBase
 
-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)
-        self.num_leds = num_leds
-        self.pattern_step = 0
-        self.last_update = utime.ticks_ms()
-        self.delay = delay
-        self.brightness = brightness
+        super().__init__(pin, num_leds, color1, color2, brightness, selected, delay)
         self.patterns = {
-            "off": self.off,
-            "on" : self.on,
-            "color_wipe": self.color_wipe_step,
-            "rainbow_cycle": self.rainbow_cycle_step,
-            "theater_chase": self.theater_chase_step,
-            "blink": self.blink_step,
-            "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
+            "off": self.off(),
+            "on" : self.on(),
+            "color_wipe": self.color_wipe_step(),
+            "rainbow_cycle": self.rainbow_cycle_step(),
+            "theater_chase": self.theater_chase_step(),
+            "blink": self.blink_step(),
+            "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
         }
-        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 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
-
-    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 self.pattern_step < self.num_leds:
-                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
+        while True:
+            color = self.apply_brightness(self.colors[0])
+            current_time = utime.ticks_ms()
+            if utime.ticks_diff(current_time, self.last_update) >= self.delay:
+                if self.pattern_step < self.num_leds:
+                    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
+            yield
 
     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)
+        while True:
+            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
+                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
+            yield
 
     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
+        while True:
+            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
+            yield
 
     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
-            self.last_update = current_time
+        while True:
+            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
+                self.last_update = current_time
+            yield
 
     def color_transition_step(self):
-        current_time = utime.ticks_ms()
+        while True:
+            current_time = utime.ticks_ms()
 
-        # Check for hold duration first
-        if utime.ticks_diff(current_time, self.hold_start_time) < self.hold_duration:
-            # Still in hold phase, just display the current solid color
-            self.fill(self.apply_brightness(self.current_color))
-            self.last_update = current_time # Keep updating last_update to avoid skipping frames
-            return
+            # Check for hold duration first
+            if utime.ticks_diff(current_time, self.hold_start_time) < self.hold_duration:
+                # Still in hold phase, just display the current solid color
+                self.fill(self.apply_brightness(self.current_color))
+                self.last_update = current_time # Keep updating last_update to avoid skipping frames
+                yield
 
-        # If hold duration is over, proceed with transition
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
-            num_colors = len(self.colors)
-            if num_colors < 2:
-                # Should not happen if select handles it, but as a safeguard
-                self.select("on")
-                return
+            # If hold duration is over, proceed with transition
+            if utime.ticks_diff(current_time, self.last_update) >= self.delay:
+                num_colors = len(self.colors)
+                if num_colors < 2:
+                    # Should not happen if select handles it, but as a safeguard
+                    self.select("on")
+                    yield
 
-            from_color = self.colors[self.current_color_idx]
-            to_color_idx = (self.current_color_idx + 1) % num_colors
-            to_color = self.colors[to_color_idx]
+                from_color = self.colors[self.current_color_idx]
+                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
+                # 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)
+                # 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.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
+                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
+                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
+                self.last_update = current_time
+            yield
 
     def flicker_step(self):
-        current_time = utime.ticks_ms()
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay/5:
-            base_color = self.colors[0]
-            # Increase the range for flicker_brightness_offset
-            # Changed from self.brightness // 4 to self.brightness // 2 (or even self.brightness for max intensity)
-            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))
+        while True:
+            current_time = utime.ticks_ms()
+            if utime.ticks_diff(current_time, self.last_update) >= self.delay/5:
+                base_color = self.colors[0]
+                # Increase the range for flicker_brightness_offset
+                # Changed from self.brightness // 4 to self.brightness // 2 (or even self.brightness for max intensity)
+                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
+                flicker_color = self.apply_brightness(base_color, brightness_override=flicker_brightness)
+                self.fill(flicker_color)
+                self.last_update = current_time
+            yield
 
     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
+        while True:
+            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])
+                # 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 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
+                # 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()
+                self.n.write()
 
-            self.pattern_step += 1
-            if self.pattern_step >= self.num_leds + self.scanner_tail_length:
-                self.pattern_step = 0 # Reset to start
+                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
+                self.last_update = current_time
+            yield
 
     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
+        while True:
+            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])
+                color = self.apply_brightness(self.colors[0])
 
-            # Calculate the head position based on direction
-            head_pos = self.pattern_step
+                # 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 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
+                # 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.n.write()
 
-            self.pattern_step += self.scanner_direction
+                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
+                # 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
+                self.last_update = current_time
+            yield

src/patterns_base.py

@@ -0,0 +1,205 @@
+from machine import Pin
+from neopixel import NeoPixel
+import utime
+
+class 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)
+        self.num_leds = num_leds
+        self.pattern_step = 0
+        self.last_update = utime.ticks_ms()
+        self.delay = delay
+        self.brightness = brightness
+        self. run = True
+        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
+        self.patterns = {}
+        self.run = True
+
+    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 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
+
+    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 and hasattr(self.patterns[pattern], "__next__"):
+            self.selected = pattern
+            self.run = True
+            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 tick(self):
+        if self.run:
+            try:
+                next(self.patterns[self.selected])
+            except StopIteration:
+                self.run = 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):
+        while True:
+            self.fill((0, 0, 0))
+            self.run = False
+            yield
+
+    def on(self):
+        while True:
+            self.fill(self.apply_brightness(self.colors[0]))
+            self.run = False
+            yield