Split into pattern and low level methods

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,46 +10,45 @@ import time
 import wifi
 import json
 from p2p import p2p
-import espnow
-import network
 
-settings = Settings()
+async def main():
+    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"]))
 
-sta = network.WLAN(network.STA_IF)
-sta.active(True)
-sta.disconnect()   # Because ESP8266 auto-connects to last Access Point
+    async def tick():
+        while True:
+            patterns.tick()
+            await asyncio.sleep_ms(0)
 
-e = espnow.ESPNow()
-e.active(True)
-
-print(settings)
-# start the server in a bacakground task
-print("Starting")
-
-wdt = machine.WDT(timeout=10000)
-
-while True:
+    async def system():
+        while True:
+            gc.collect()
+            for i in range(60):
+                wdt.feed()
+                await asyncio.sleep(1)
 
+    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()
-    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))
+
+    asyncio.create_task(tick())
+    asyncio.create_task(p2p(settings, patterns))
+    asyncio.create_task(system())
+
+
+
+    # cleanup before ending the application
+    await server
+
+asyncio.run(main())

src/patterns.py

@@ -22,7 +22,8 @@ class Patterns:
             "flicker": self.flicker_step,
             "scanner": self.scanner_step, # New: Single direction scanner
             "bidirectional_scanner": self.bidirectional_scanner_step, # New: Bidirectional scanner
-            "external": None
+            "external": None,
+            "pulse": self.pulse
         }
         self.selected = selected
         # Ensure colors list always starts with at least two for robust transition handling
@@ -394,3 +395,23 @@ class Patterns:
                 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.fill(self.apply_brightness(self.colors[0]))
+            self.pattern_step = 1
+            self.last_update = utime.ticks_ms()
+        if utime.ticks_diff(utime.ticks_ms(), self.last_update) > self.delay:
+            self.fill((0, 0, 0))
+
+
+if __name__ == "__main__":
+    import time
+    from machine import WDT
+    wdt = WDT(timeout=2000)  # Enable watchdog with a 2 second timeout
+    p = Patterns(pin=10, num_leds=200, color1=(255,0,0), color2=(0,0,255), brightness=127, selected="bidirectional_scanner", delay=50)
+    p.select("pulse")
+    for i in range(1000):
+        p.tick()
+        wdt.feed()
+        time.sleep_ms(1)

src/patterns_base.py

@@ -0,0 +1,194 @@
+from machine import Pin
+from neopixel import NeoPixel
+import utime
+
+
+class PatternBase:
+    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.patterns = {}
+        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]))