Switch to async patterns

src/boot.py

@@ -5,4 +5,5 @@ from settings import Settings
 s = Settings()
 
 name = s.get('name', 'led')
-wifi.ap(name, '')
+password = s.get("ap_password", "")
+wifi.ap(name, password)

src/main.py

@@ -1,6 +1,6 @@
 import asyncio
 import aioespnow
-from settings import Settings, set_settings
+from settings import Settings
 from web import web
 from patterns import Patterns
 import gc
@@ -8,17 +8,17 @@ import utime
 import machine
 import time
 import wifi
-
+import json
+from p2p import p2p
 
 async def main():
-
-
-
     settings = Settings()
 
-    patterns = Patterns(4, settings["num_leds"], selected=settings["pattern"])
+    patterns = Patterns(settings["led_pin"], settings["num_leds"], selected=settings["pattern"])
-    patterns.set_color1(tuple(int(settings["color1"][i:i+2], 16) for i in (1, 5, 3)))
+    if settings["color_order"] == "rbg": color_order = (1, 5, 3)
-    patterns.set_color2(tuple(int(settings["color2"][i:i+2], 16) for i in (1, 5, 3)))
+    else: color_order = (1, 3, 5)
+    patterns.set_color(0,(tuple(int(settings["color1"][i:i+2], 16) for i in color_order)))
+    patterns.set_color(1,(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"]))
 
@@ -27,33 +27,18 @@ async def main():
     # 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 = machine.WDT(timeout=10000)
-    #wdt.feed()
+    wdt.feed()
 
-    async def tick():
+    asyncio.create_task(p2p(settings, patterns))
-        while True:
-            patterns.tick()
-            await asyncio.sleep_ms(1)
-
-    async def espnow():
-        e = aioespnow.AIOESPNow()  # Returns AIOESPNow enhanced with async support
-        e.active(True)
-        async for mac, msg in e:
-            print(msg)
-            set_settings(msg, settings, patterns)
-        print("should not print")
-
-    asyncio.create_task(tick())
-    asyncio.create_task(espnow())
 
     while True:
 
         #print(time.localtime())
-
+        gc.collect()
-        # gc.collect()
+        for i in range(20):
-        for i in range(60):
+            wdt.feed()
-            #wdt.feed()
+            await asyncio.sleep_ms(1000)
-            await asyncio.sleep_ms(500)
 
     # cleanup before ending the application
     await server

src/p2p.py

@@ -0,0 +1,20 @@
+import asyncio
+import aioespnow
+import json
+
+async def p2p(settings, patterns):
+    e = aioespnow.AIOESPNow()  # Returns AIOESPNow enhanced with async support
+    e.active(True)
+    async for mac, msg in e:
+        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:
+                await settings.set_settings(data.get("settings", {}), patterns, data.get("save", False))
+    print("should not print")

src/patterns.py

@@ -1,4 +1,5 @@
-from machine import Pin
+import asyncio
+from machine import Pin, WDT
 from neopixel import NeoPixel
 import utime
 import random
@@ -7,38 +8,25 @@ 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
-        self.pattern_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,
+            "theater chase": self.theater_chase,
-            "blink": self.blink_step,
+            "flicker": self.flicker # Added flicker pattern
-            "random_color_wipe": self.random_color_wipe_step,
+
-            "random_rainbow_cycle": self.random_rainbow_cycle_step,
-            "random_theater_chase": self.random_theater_chase_step,
-            "random_blink": self.random_blink_step,
-            "color_transition": self.color_transition_step,
-            "external": None
         }
         self.selected = selected
-        self.color1 = color1
+        # Ensure colors list always starts with at least two for robust transition handling
-        self.color2 = color2
+        self.colors = [color1, color2] if color1 != color2 else [color1, (255, 255, 255)] # Fallback if initial colors are same
-        self.transition_duration = 50  # Duration of color transition in milliseconds
+        if not self.colors: # Ensure at least one color exists
-        self.transition_step = 0
+            self.colors = [(0, 0, 0)]
-    
+        self.task = None
-    def sync(self):
+        self.pattern_step = 0
-        self.pattern_step=0
-        self.last_update = utime.ticks_ms()
 
-    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
@@ -49,243 +37,186 @@ class Patterns:
 
     def set_brightness(self, brightness):
         self.brightness = brightness
-        
+
-    def set_color1(self, color):
+    def set_colors(self, colors):
-        print(color)
+        self.colors = colors
-        self.color1 = self.apply_brightness(color)
+
-        
+    def set_color(self, num, color):
-    def set_color2(self, color):
+        # Changed: More robust index check
-        self.color2 = self.apply_brightness(color)
+        if 0 <= num < len(self.colors):
-    
+           self.colors[num] = color
-    def apply_brightness(self, color):
+           return True
-        return tuple(int(c * self.brightness / 255) for c in color)
+        elif num == len(self.colors): # Allow setting a new color at the end
-    
+            self.colors.append(color)
-    def select(self, pattern):
-        if pattern in self.patterns:
-            self.selected = pattern
             return True
         return False
-    
+
+    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]
+           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)
+
+    async def select(self, pattern, reset = True):
+        if pattern not in self.patterns:
+            return False
+        self.selected = pattern
+        if self.task is not None:
+            self.task.cancel()
+        if reset: self.pattern_step = 0
+        print(pattern)
+        self.task = asyncio.create_task(self.patterns[pattern]())
+        return True
+
     def set(self, i, color):
         self.n[i] = color
 
     def write(self):
         self.n.write()
-        
+
-    def fill(self):
+    def fill(self, color):
-        for i in range(self.num_leds):
+        self.n.fill(color)
-            self.n[i] = self.color1
         self.n.write()
 
-    def off(self):
+    async def off(self):
-        color = self.color1
+        self.fill((0, 0, 0))
-        self.color1 = (0,0,0)
+
-        self.fill()
+    async def on(self):
-        self.color1 = color
+        self.fill(self.apply_brightness(self.colors[0]))
-    
+
-    def on(self):
+    def sync(self):
-        color = self.color1
+        self.pattern_step = 0
-        self.color1 = self.apply_brightness(self.color1)
+
-        self.fill()
+    async def rainbow(self):
-        self.color1 = color
+        def wheel(pos):
-    
+            if pos < 85:
-    
+                return (pos * 3, 255 - pos * 3, 0)
-    def color_wipe_step(self):
+            elif pos < 170:
-        color = self.apply_brightness(self.color1)
+                pos -= 85
-        current_time = utime.ticks_ms()
+                return (255 - pos * 3, 0, pos * 3)
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
+            else:
-            if self.pattern_step < self.num_leds:
+                pos -= 170
+                return (0, pos * 3, 255 - pos * 3)
+        last_update = utime.ticks_ms()
+        while True:
+            if utime.ticks_diff(utime.ticks_ms(), last_update) >= self.delay:
                 for i in range(self.num_leds):
-                    self.n[i] = (0, 0, 0)
+                    rc_index = (i * 256 // self.num_leds) + self.pattern_step
-                self.n[self.pattern_step] = self.apply_brightness(color)
+                    self.n[i] = self.apply_brightness(wheel(rc_index & 255))
                 self.n.write()
-                self.pattern_step += 1
+                self.pattern_step = (self.pattern_step + 1) % 256
-            else:
+                last_update += self.delay
-                self.pattern_step = 0
+                await asyncio.sleep(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):
+    async def theater_chase(self):
-                rc_index = (i * 256 // self.num_leds) + self.pattern_step
+        last_update = utime.ticks_ms()
-                self.n[i] = self.apply_brightness(wheel(rc_index & 255))
+        while True:
-            self.n.write()
+            if utime.ticks_diff(utime.ticks_ms(), last_update) >= self.delay:
-            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.color1)
-                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:
                 for i in range(self.num_leds):
-                    self.n[i] = self.apply_brightness(self.color1)
+                    if (i + self.pattern_step) % 3 == 0:
-            else:
+                        self.n[i] = self.apply_brightness(self.colors[0])
-                for i in range(self.num_leds):
+                    else:
-                    self.n[i] = (0, 0, 0)
+                        self.n[i] = (0, 0, 0)
-            self.n.write()
-            self.pattern_step = (self.pattern_step + 1) % 2
-            self.last_update = current_time
-
-    def random_color_wipe_step(self):
-        current_time = utime.ticks_ms()
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
-            color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
-            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
+                self.pattern_step = (self.pattern_step + 1) % 3
-            else:
+                last_update += self.delay
-                self.pattern_step = 0
+            await asyncio.sleep(0)
-            self.last_update = current_time
 
-    def random_rainbow_cycle_step(self):
+    async def blink(self):
-        current_time = utime.ticks_ms()
+        last_update = utime.ticks_ms()
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
+        self.pattern_step = 0
-            def wheel(pos):
+        while True:
-                if pos < 85:
+            if utime.ticks_diff(utime.ticks_ms(), last_update) >= self.delay:
-                    return (pos * 3, 255 - pos * 3, 0)
+                if self.pattern_step:
-                elif pos < 170:
+                    self.off()
-                    pos -= 85
+                    self.pattern_step = 0
-                    return (255 - pos * 3, 0, pos * 3)
                 else:
-                    pos -= 170
+                    self.on()
-                    return (0, pos * 3, 255 - pos * 3)
+                    self.pattern_step = 1
+                last_update += self.delay
+                await asyncio.sleep(0)
 
-            random_offset = random.randint(0, 255)
+    async def flicker(self):
-            for i in range(self.num_leds):
+            last_update = utime.ticks_ms()
-                rc_index = (i * 256 // self.num_leds) + self.pattern_step + random_offset
+            while True:
-                self.n[i] = self.apply_brightness(wheel(rc_index & 255))
+                if utime.ticks_diff(utime.ticks_ms(), last_update) >= self.delay:
-            self.n.write()
+                    # Calculate a single flicker amount for all LEDs
-            self.pattern_step = (self.pattern_step + 1) % 256
+                    flicker_amount = random.randint(int(-self.brightness // 1.5), int(self.brightness // 1.5))
-            self.last_update = current_time
+                    flicker_brightness = max(0, min(255, self.brightness + flicker_amount))
+                    self.fill(self.apply_brightness(self.colors[0], brightness_override=flicker_brightness))
+                    last_update += self.delay
+                await asyncio.sleep(0)
 
-    def random_theater_chase_step(self):
+    async def color_transition(self):
-        current_time = utime.ticks_ms()
+            if len(self.colors) < 2:
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
+                # If there's only one color or no colors, just display that color (or off)
-            color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+                self.fill(self.apply_brightness(self.colors[0]))
-            for i in range(self.num_leds):
+                return
-                if (i + self.pattern_step) % 3 == 0:
-                    self.n[i] = self.apply_brightness(color)
-                else:
-                    self.n[i] = (0, 0, 0)
-            self.n.write()
-            self.pattern_step = (self.pattern_step + 1) % 3
-            self.last_update = current_time
 
-    def random_blink_step(self):
+            last_transition_start_time = utime.ticks_ms()
-        current_time = utime.ticks_ms()
+            current_color_index = 0
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
+            transition_duration_ms = self.delay # Use self.delay as the transition time
-            color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
-            if self.pattern_step % 2 == 0:
-                for i in range(self.num_leds):
-                    self.n[i] = self.apply_brightness(color)
-            else:
-                for i in range(self.num_leds):
-                    self.n[i] = (0, 0, 0)
-            self.n.write()
-            self.pattern_step = (self.pattern_step + 1) % 2
-            self.last_update = current_time
 
-    def color_transition_step(self):
+            while True:
-        current_time = utime.ticks_ms()
+                color_from = self.colors[current_color_index]
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
+                color_to = self.colors[(current_color_index + 1) % len(self.colors)]
-            # Calculate transition factor based on elapsed time
-            transition_factor = (self.pattern_step * 100) / self.transition_duration
-            if transition_factor > 100:
-                transition_factor = 100
-            color = self.interpolate_color(self.color1, self.color2, transition_factor / 100)
-            
-            # Apply the interpolated color to all LEDs
-            for i in range(self.num_leds):
-                self.n[i] = self.apply_brightness(color)
-            self.n.write()
 
-            self.pattern_step += self.delay
+                start_time = utime.ticks_ms()
-            if self.pattern_step > self.transition_duration:
+                elapsed_time = 0
-                self.pattern_step = 0
 
-            self.last_update = current_time
+                while elapsed_time < transition_duration_ms:
+                    # Calculate the interpolation factor (0.0 to 1.0)
+                    # Maximize to avoid division by zero if delay is 0, though a meaningful delay is expected
+                    t = min(1.0, elapsed_time / max(1, transition_duration_ms))
 
-    def interpolate_color(self, color1, color2, factor):
+                    # Interpolate each color component
-        return (
+                    interpolated_color = (
-            int(color1[0] + (color2[0] - color1[0]) * factor),
+                        int(color_from[0] + (color_to[0] - color_from[0]) * t),
-            int(color1[1] + (color2[1] - color1[1]) * factor),
+                        int(color_from[1] + (color_to[1] - color_from[1]) * t),
-            int(color1[2] + (color2[2] - color1[2]) * factor)
+                        int(color_from[2] + (color_to[2] - color_from[2]) * t)
-        )
+                    )
-    
-    def two_steps_forward_one_step_back_step(self):
-        current_time = utime.ticks_ms()
-        if utime.ticks_diff(current_time, self.last_update) >= self.delay:
-            # Move forward 2 steps and backward 1 step
-            if self.direction == 1:  # Moving forward
-                if self.scanner_position < self.num_leds - 2:
-                    self.scanner_position += 2  # Move forward 2 steps
-                else:
-                    self.direction = -1  # Change direction to backward
-            else:  # Moving backward
-                if self.scanner_position > 0:
-                    self.scanner_position -= 1  # Move backward 1 step
-                else:
-                    self.direction = 1  # Change direction to forward
-            
-            # Set all LEDs to off
-            for i in range(self.num_leds):
-                self.n[i] = (0, 0, 0)
-            
-            # Set the current position to the color
-            self.n[self.scanner_position] = self.apply_brightness(self.color1)
-            
-            # Apply the color transition
-            transition_factor = (self.pattern_step * 100) / self.transition_duration
-            if transition_factor > 100:
-                transition_factor = 100
-            color = self.interpolate_color(self.color1, self.color2, transition_factor / 100)
-            self.n[self.scanner_position] = self.apply_brightness(color)
-            
-            self.n.write()
-            self.pattern_step += self.delay
-            if self.pattern_step > self.transition_duration:
-                self.pattern_step = 0
 
-            self.last_update = current_time
+                    self.fill(self.apply_brightness(interpolated_color))
+                    await asyncio.sleep(0) # Update smoothly
+                    elapsed_time = utime.ticks_diff(utime.ticks_ms(), start_time)
+
+                # Ensure the final color is set precisely after interpolation loop
+                self.fill(self.apply_brightness(color_to))
+
+                current_color_index = (current_color_index + 1) % len(self.colors)
+                await asyncio.sleep(0) # Yield control
+
+async def main():
+    w = WDT(timeout = 10000)
+    p = Patterns(num_leds=10, pin=10, color1=(16,16,0))
+    # p.set_delay(100)
+    # await p.select("blink")
+    # await asyncio.sleep(2)
+    # p.set_delay(10)
+    # await p.select("rainbow")
+    # await asyncio.sleep(2)
+    # p.set_delay(100)
+    # await p.select("theater chase")
+    # await asyncio.sleep(2)
+    # p.set_colors([(255, 100, 0)]) # Set a base color for flicker (e.g., orange for a candle effect)
+    # p.set_brightness(200) # Set a brighter base for flicker to allow for dimming
+    # p.set_delay(100) # Faster updates for a more convincing flicker
+    # await p.select("flicker")
+    # await asyncio.sleep(2)
+    w.feed()
+# Test the new color transition pattern
+    print("Starting color transition...")
+    p.set_colors([(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 0)]) # Red, Green, Blue, Yellow
+    p.set_delay(1000) # 1 second transition between colors
+    p.set_brightness(150)
+    await p.select("color transition")
+    await asyncio.sleep(10) # Let it run for 10 seconds
 
 if __name__ == "__main__":
-    p = Patterns(4, 180)
+    asyncio.run(main())
-    p.set_color1((255,0,0))
-    p.set_color2((0,255,0))
-    #p.set_delay(10)
-    try:
-        while True:
-            for key in p.patterns:
-                print(key)
-                p.select(key)
-                for _ in range(2000):
-                    p.tick()
-                    utime.sleep_ms(1)
-    except KeyboardInterrupt:
-        p.fill((0, 0, 0))

src/settings.py

@@ -9,16 +9,21 @@ class Settings(dict):
     def __init__(self):
         super().__init__()
         self.load()  # Load settings from file during initialization
+        if self["color_order"] == "rbg": self.color_order = (1, 5, 3)
+        else: self.color_order = (1, 3, 5)
 
     def set_defaults(self):
+        self["led_pin"] = 10
         self["num_leds"] = 50
         self["pattern"] = "on"
         self["color1"] = "#00ff00"
         self["color2"] = "#ff0000"
         self["delay"] = 100
         self["brightness"] = 10
+        self["color_order"] = "rgb"
         self["name"] = f"led-{ubinascii.hexlify(wifi.get_mac()).decode()}"
         self["ap_password"] = ""
+        self["id"] = 0
 
     def save(self):
         try:
@@ -40,6 +45,54 @@ class Settings(dict):
             self.set_defaults()
             self.save()
 
+    async def set_settings(self, data, patterns, save):
+        try:
+            print(data)
+            for key, value in data.items():
+                print(key, value)
+                if key == "colors":
+                    buff = []
+                    for color in value:
+                        buff.append(tuple(int(color[i:i+2], 16) for i in self.color_order))
+                    patterns.set_colors(buff)
+                elif key == "color1":
+                    patterns.set_color(0,(tuple(int(value[i:i+2], 16) for i in self.color_order))) # Convert hex to RGB
+                elif key == "color2":
+                    patterns.set_color(1,(tuple(int(value[i:i+2], 16) for i in self.color_order)))  # Convert hex to RGB
+                elif key == "num_leds":
+                    patterns.update_num_leds(self["led_pin"], value)
+                elif key ==  "pattern":
+                    if not await patterns.select(value):
+                        return "Pattern doesn't exist", 400
+                elif key == "delay":
+                    delay = int(data["delay"])
+                    patterns.set_delay(delay)
+                elif key == "brightness":
+                    brightness = int(data["brightness"])
+                    patterns.set_brightness(brightness)
+                elif key == "name":
+                    self[key] = value
+                    self.save()
+                    machine.reset()
+                elif key == "color_order":
+                    if value == "rbg": self.color_order = (1, 5, 3)
+                    else: self.color_order = (1, 3, 5)
+                    pass
+                elif key == "id":
+                    pass
+                elif key == "led_pin":
+                    patterns.update_num_leds(value, self["num_leds"])
+                else:
+                    return "Invalid key", 400
+                self[key] = value
+            #print(self)
+            patterns.sync()
+            if save:
+                self.save()
+            return "OK", 200
+        except (KeyError, ValueError):
+            return "Bad request", 400
+
 # Example usage
 def main():
     settings = Settings()
@@ -53,39 +106,7 @@ def main():
     print(f"Loaded number of LEDs: {new_settings['num_leds']}")
     print(settings)
 
-def set_settings(raw_json, settings, patterns):
+
-    patterns.sync()
-    try:
-        data = json.loads(raw_json)
-        print(data)
-        for key, value in data.items():
-            print(key, value)
-            if key == "color1":
-                patterns.set_color1(tuple(int(value[i:i+2], 16) for i in (1, 3, 5)))  # Convert hex to RGB
-            elif key == "color2":
-                patterns.set_color2(tuple(int(value[i:i+2], 16) for i in (1, 3, 5)))  # Convert hex to RGB
-            elif key == "num_leds":
-                patterns.update_num_leds(4, value)
-            elif key ==  "pattern":
-                if not patterns.select(value):
-                    return "Pattern doesn't exist", 400
-            elif key == "delay":
-                delay = int(data["delay"])
-                patterns.set_delay(delay)
-            elif key == "brightness":
-                brightness = int(data["brightness"])
-                patterns.set_brightness(brightness)
-            elif key == "name":
-                settings[key] = value
-                settings.save()
-                machine.reset()
-            else:
-                return "Invalid key", 400
-            settings[key] = value
-            settings.save()
-            return "OK", 200
-    except (KeyError, ValueError):
-        return "Bad request", 400
 
 # Run the example
 if __name__ == "__main__":

src/static/main.css

@@ -98,3 +98,12 @@ input[type="range"]::-moz-range-thumb {
 #connection-status.closed {
     background-color: red;
 }
+
+#color_order_form label,
+#color_order_form input[type="radio"] {
+    /* Ensures they behave as inline elements */
+    display: inline-block;
+    /* Adds some space between them for readability */
+    margin-right: 10px;
+    vertical-align: middle; /* Aligns them nicely if heights vary */
+}

src/static/main.js

@@ -150,6 +150,30 @@ async function updateName(event) {
   sendWebSocketData({ name: name });
 }
 
+async function updateID(event) {
+  event.preventDefault();
+  const id = document.getElementById("id").value;
+  sendWebSocketData({ id: parseInt(id) });
+}
+
+async function updateLedPin(event) {
+  event.preventDefault();
+  const ledpin = document.getElementById("led_pin").value;
+  sendWebSocketData({ led_pin: parseInt(ledpin) });
+}
+
+function handleRadioChange(event) {
+  event.preventDefault();
+  console.log("Selected color order:", event.target.value);
+  // Add your specific logic here
+  if (event.target.value === "rgb") {
+    console.log("RGB order selected!");
+  } else if (event.target.value === "rbg") {
+    console.log("RBG order selected!");
+  }
+  sendWebSocketData({ color_order: event.target.value });
+}
+
 function createPatternButtons(patterns) {
   const container = document.getElementById("pattern_buttons");
   container.innerHTML = ""; // Clear previous buttons
@@ -184,11 +208,17 @@ document.addEventListener("DOMContentLoaded", async function () {
     .getElementById("num_leds_form")
     .addEventListener("submit", updateNumLeds);
   document.getElementById("name_form").addEventListener("submit", updateName);
+  document.getElementById("id_form").addEventListener("submit", updateID);
+  document
+    .getElementById("led_pin_form")
+    .addEventListener("submit", updateLedPin);
   document.getElementById("delay").addEventListener("touchend", updateDelay);
   document
     .getElementById("brightness")
     .addEventListener("touchend", updateBrightness);
 
+  document.getElementById("rgb").addEventListener("change", handleRadioChange);
+  document.getElementById("rbg").addEventListener("change", handleRadioChange);
   document.querySelectorAll(".pattern_button").forEach((button) => {
     console.log(button.value);
     button.addEventListener("click", async (event) => {

src/templates/index.html

@@ -4,12 +4,12 @@
     <head>
         <meta charset="UTF-8" />
         <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-        <title>LED Control</title>
+        <title>{{settings['name']}}</title>
         <script src="static/main.js"></script>
         <link rel="stylesheet" href="static/main.css" />
     </head>
     <body>
-        <h1>Control LEDs</h1>
+        <h1>{{settings['name']}}</h1>
         <button onclick="selectControls()">Controls</button>
         <button onclick="selectSettings()">Settings</button>
 
@@ -79,6 +79,16 @@
                 />
                 <input type="submit" value="Update Name" />
             </form>
+            <form id="id_form" method="post" action="/id">
+                <label for="id">ID:</label>
+                <input
+                    type="text"
+                    id="id"
+                    name="id"
+                    value="{{settings['id']}}"
+                />
+                <input type="submit" value="Update ID" />
+            </form>
             <!-- Separate form for submitting num_leds -->
             <form id="num_leds_form" method="post" action="/num_leds">
                 <label for="num_leds">Number of LEDs:</label>
@@ -90,6 +100,23 @@
                 />
                 <input type="submit" value="Update Number of LEDs" />
             </form>
+            <form id="led_pin_form" method="post" action="/led_pin">
+                <label for="num_leds">Led pin:</label>
+                <input
+                    type="text"
+                    id="led_pin"
+                    name="led_pin"
+                    value="{{settings['led_pin']}}"
+                />
+                <input type="submit" value="Update Led Pin" />
+            </form>
+            <form id="color_order_form">
+                <label for="rgb">RGB:</label>
+                <input type="radio" id="rgb" name="color_order" value="rgb" {{'checked' if settings["color_order"]=="rgb" else ''}} />
+                <label for="rbg">RBG</label>
+                <input type="radio" id="rbg" name="color_order" value="rbg" {{'checked' if settings["color_order"]=="rbg" else ''}}/>
+            </form>
+
             <p>Mac address: {{mac}}</p>
         </div>
         <div id="connection-status"></div>

src/web.py

@@ -2,7 +2,6 @@ from microdot import Microdot, send_file, Response
 from microdot.utemplate import Template
 from microdot.websocket import with_websocket
 import machine
-from settings import set_settings
 import wifi
 import json
 
@@ -26,7 +25,7 @@ def web(settings, patterns):
     def settings_handler(request):
         # Keep the POST handler for compatibility or alternative usage if needed
         # For WebSocket updates, the /ws handler is now primary
-        return set_settings(request.body.decode('utf-8'), settings, patterns)
+        return settings.set_settings(request.body.decode('utf-8'), patterns)
 
     @app.route("/ws")
     @with_websocket
@@ -34,8 +33,9 @@ def web(settings, patterns):
         while True:
             data = await ws.receive()
             if data:
+
                 # Process the received data
-                _, status_code = set_settings(data, settings, patterns)
+                _, status_code = await settings.set_settings(json.loads(data), patterns, True)
                 #await ws.send(status_code)
             else:
                 break

src/wifi.py

@@ -2,14 +2,15 @@ import network
 from time import sleep
 
 def connect(ssid, password, ip, gateway):
-    if ssid is None or password is None:
+
-        print("Missing ssid or password")
-        return None
     try:
         sta_if = network.WLAN(network.STA_IF)
-        if ip is not None and gateway is not None:
-            sta_if.ifconfig((ip, '255.255.255.0', gateway, '1.1.1.1'))
         if not sta_if.isconnected():
+            if ssid == "" or password == "":
+                print("Missing ssid or password")
+                return None
+            if ip != "" and gateway != "":
+                sta_if.ifconfig((ip, '255.255.255.0', gateway, '1.1.1.1'))
             print('connecting to network...')
             sta_if.active(True)
             sta_if.connect(ssid, password)