technicalkiwi/led-bar
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: technicalkiwi:main
Branches Tags
technicalkiwi:main technicalkiwi:espnow technicalkiwi:patterns technicalkiwi:dev technicalkiwi:patterns-async
...
compare: technicalkiwi:90e1511651317d975c0003269b9efc47e0bf5666
Branches Tags
technicalkiwi:espnow technicalkiwi:patterns technicalkiwi:dev technicalkiwi:patterns-async technicalkiwi:main

3 Commits
main ... 90e1511651

Author SHA1 Message Date
jimmy
90e1511651 Switch to using itterators 2025-08-30 21:31:24 +12:00
jimmy
9b96a6d4a9 Serperate out the pattertns and the lower level methods 2025-08-30 20:18:45 +12:00
jimmy
d3f04dcc6d Remove web server, espnow only 2025-08-30 18:29:30 +12:00
4 changed files with 415 additions and 378 deletions
Expand all files Collapse all files

2
src/boot.py
View File

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

73
src/main.py
View File

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

513
src/patterns.py
View File

@@ -2,395 +2,226 @@ from machine import Pin
from neopixel import NeoPixel from neopixel import NeoPixel
import utime import utime
import random 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): 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.pattern_step = 0
self.last_update = utime.ticks_ms()
self.delay = delay
self.brightness = brightness
self.patterns = { self.patterns = {
"off": self.off, "off": self.off(),
"on" : self.on, "on" : self.on(),
"color_wipe": self.color_wipe_step, "color_wipe": self.color_wipe_step(),
"rainbow_cycle": self.rainbow_cycle_step, "rainbow_cycle": self.rainbow_cycle_step(),
"theater_chase": self.theater_chase_step, "theater_chase": self.theater_chase_step(),
"blink": self.blink_step, "blink": self.blink_step(),
"color_transition": self.color_transition_step, # Added new pattern "color_transition": self.color_transition_step(), # Added new pattern
"flicker": self.flicker_step, "flicker": self.flicker_step(),
"scanner": self.scanner_step, # New: Single direction scanner "scanner": self.scanner_step(), # New: Single direction scanner
"bidirectional_scanner": self.bidirectional_scanner_step, # New: Bidirectional scanner "bidirectional_scanner": self.bidirectional_scanner_step(), # New: Bidirectional scanner
"external": None
} }
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): def color_wipe_step(self):
color = self.apply_brightness(self.colors[0]) while True:
current_time = utime.ticks_ms() color = self.apply_brightness(self.colors[0])
if utime.ticks_diff(current_time, self.last_update) >= self.delay: current_time = utime.ticks_ms()
if self.pattern_step < self.num_leds: if utime.ticks_diff(current_time, self.last_update) >= self.delay:
for i in range(self.num_leds): if self.pattern_step < self.num_leds:
self.n[i] = (0, 0, 0) for i in range(self.num_leds):
self.n[self.pattern_step] = self.apply_brightness(color) self.n[i] = (0, 0, 0)
self.n.write() self.n[self.pattern_step] = self.apply_brightness(color)
self.pattern_step += 1 self.n.write()
else: self.pattern_step += 1
self.pattern_step = 0 else:
self.last_update = current_time self.pattern_step = 0
self.last_update = current_time
yield
def rainbow_cycle_step(self): def rainbow_cycle_step(self):
current_time = utime.ticks_ms() while True:
if utime.ticks_diff(current_time, self.last_update) >= self.delay/5: current_time = utime.ticks_ms()
def wheel(pos): if utime.ticks_diff(current_time, self.last_update) >= self.delay/5:
if pos < 85: def wheel(pos):
return (pos * 3, 255 - pos * 3, 0) if pos < 85:
elif pos < 170: return (pos * 3, 255 - pos * 3, 0)
pos -= 85 elif pos < 170:
return (255 - pos * 3, 0, pos * 3) pos -= 85
else: return (255 - pos * 3, 0, pos * 3)
pos -= 170 else:
return (0, pos * 3, 255 - pos * 3) pos -= 170
return (0, pos * 3, 255 - pos * 3)
for i in range(self.num_leds): for i in range(self.num_leds):
rc_index = (i * 256 // self.num_leds) + self.pattern_step rc_index = (i * 256 // self.num_leds) + self.pattern_step
self.n[i] = self.apply_brightness(wheel(rc_index & 255)) self.n[i] = self.apply_brightness(wheel(rc_index & 255))
self.n.write() self.n.write()
self.pattern_step = (self.pattern_step + 1) % 256 self.pattern_step = (self.pattern_step + 1) % 256
self.last_update = current_time self.last_update = current_time
yield
def theater_chase_step(self): def theater_chase_step(self):
current_time = utime.ticks_ms() while True:
if utime.ticks_diff(current_time, self.last_update) >= self.delay: current_time = utime.ticks_ms()
for i in range(self.num_leds): if utime.ticks_diff(current_time, self.last_update) >= self.delay:
if (i + self.pattern_step) % 3 == 0: for i in range(self.num_leds):
self.n[i] = self.apply_brightness(self.colors[0]) if (i + self.pattern_step) % 3 == 0:
else: self.n[i] = self.apply_brightness(self.colors[0])
self.n[i] = (0, 0, 0) else:
self.n.write() self.n[i] = (0, 0, 0)
self.pattern_step = (self.pattern_step + 1) % 3 self.n.write()
self.last_update = current_time self.pattern_step = (self.pattern_step + 1) % 3
self.last_update = current_time
yield
def blink_step(self): def blink_step(self):
current_time = utime.ticks_ms() while True:
if utime.ticks_diff(current_time, self.last_update) >= self.delay: current_time = utime.ticks_ms()
if self.pattern_step % 2 == 0: if utime.ticks_diff(current_time, self.last_update) >= self.delay:
self.fill(self.apply_brightness(self.colors[0])) if self.pattern_step % 2 == 0:
else: self.fill(self.apply_brightness(self.colors[0]))
self.fill((0, 0, 0)) else:
self.pattern_step = (self.pattern_step + 1) % 2 self.fill((0, 0, 0))
self.last_update = current_time self.pattern_step = (self.pattern_step + 1) % 2
self.last_update = current_time
yield
def color_transition_step(self): def color_transition_step(self):
current_time = utime.ticks_ms() while True:
current_time = utime.ticks_ms()
# Check for hold duration first # Check for hold duration first
if utime.ticks_diff(current_time, self.hold_start_time) < self.hold_duration: if utime.ticks_diff(current_time, self.hold_start_time) < self.hold_duration:
# Still in hold phase, just display the current solid color # Still in hold phase, just display the current solid color
self.fill(self.apply_brightness(self.current_color)) self.fill(self.apply_brightness(self.current_color))
self.last_update = current_time # Keep updating last_update to avoid skipping frames self.last_update = current_time # Keep updating last_update to avoid skipping frames
return yield
# If hold duration is over, proceed with transition # If hold duration is over, proceed with transition
if utime.ticks_diff(current_time, self.last_update) >= self.delay: if utime.ticks_diff(current_time, self.last_update) >= self.delay:
num_colors = len(self.colors) num_colors = len(self.colors)
if num_colors < 2: if num_colors < 2:
# Should not happen if select handles it, but as a safeguard # Should not happen if select handles it, but as a safeguard
self.select("on") self.select("on")
return yield
from_color = self.colors[self.current_color_idx] from_color = self.colors[self.current_color_idx]
to_color_idx = (self.current_color_idx + 1) % num_colors to_color_idx = (self.current_color_idx + 1) % num_colors
to_color = self.colors[to_color_idx] to_color = self.colors[to_color_idx]
# Calculate interpolation factor (0.0 to 1.0) # Calculate interpolation factor (0.0 to 1.0)
# transition_step goes from 0 to transition_duration - 1 # transition_step goes from 0 to transition_duration - 1
if self.transition_duration > 0: if self.transition_duration > 0:
interp_factor = self.transition_step / self.transition_duration interp_factor = self.transition_step / self.transition_duration
else: else:
interp_factor = 1.0 # Immediately transition if duration is zero interp_factor = 1.0 # Immediately transition if duration is zero
# Interpolate each color component # Interpolate each color component
r = int(from_color[0] + (to_color[0] - from_color[0]) * interp_factor) 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) 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) b = int(from_color[2] + (to_color[2] - from_color[2]) * interp_factor)
self.current_color = (r, g, b) self.current_color = (r, g, b)
self.fill(self.apply_brightness(self.current_color)) 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: if self.transition_step >= self.transition_duration:
# Transition complete, move to the next color and reset for hold phase # Transition complete, move to the next color and reset for hold phase
self.current_color_idx = to_color_idx 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.current_color = self.colors[self.current_color_idx] # Ensure current_color is the exact target color
self.transition_step = 0 # Reset transition progress self.transition_step = 0 # Reset transition progress
self.hold_start_time = current_time # Start hold phase for the new color 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): def flicker_step(self):
current_time = utime.ticks_ms() while True:
if utime.ticks_diff(current_time, self.last_update) >= self.delay/5: current_time = utime.ticks_ms()
base_color = self.colors[0] if utime.ticks_diff(current_time, self.last_update) >= self.delay/5:
# Increase the range for flicker_brightness_offset base_color = self.colors[0]
# Changed from self.brightness // 4 to self.brightness // 2 (or even self.brightness for max intensity) # Increase the range for flicker_brightness_offset
flicker_brightness_offset = random.randint(-int(self.brightness // 1.5), int(self.brightness // 1.5)) # Changed from self.brightness // 4 to self.brightness // 2 (or even self.brightness for max intensity)
flicker_brightness = max(0, min(255, self.brightness + flicker_brightness_offset)) 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) flicker_color = self.apply_brightness(base_color, brightness_override=flicker_brightness)
self.fill(flicker_color) self.fill(flicker_color)
self.last_update = current_time self.last_update = current_time
yield
def scanner_step(self): def scanner_step(self):
""" """
Mimics a 'Knight Rider' style scanner, moving in one direction. Mimics a 'Knight Rider' style scanner, moving in one direction.
""" """
current_time = utime.ticks_ms() while True:
if utime.ticks_diff(current_time, self.last_update) >= self.delay: current_time = utime.ticks_ms()
self.fill((0, 0, 0)) # Clear all LEDs 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 # Calculate the head and tail position
head_pos = self.pattern_step head_pos = self.pattern_step
color = self.apply_brightness(self.colors[0]) color = self.apply_brightness(self.colors[0])
# Draw the head # Draw the head
if 0 <= head_pos < self.num_leds: if 0 <= head_pos < self.num_leds:
self.n[head_pos] = color self.n[head_pos] = color
# Draw the trailing pixels with decreasing brightness # Draw the trailing pixels with decreasing brightness
for i in range(1, self.scanner_tail_length + 1): for i in range(1, self.scanner_tail_length + 1):
tail_pos = head_pos - i tail_pos = head_pos - i
if 0 <= tail_pos < self.num_leds: if 0 <= tail_pos < self.num_leds:
# Calculate fading color for tail # Calculate fading color for tail
# Example: linear fade from full brightness to off # Example: linear fade from full brightness to off
fade_factor = 1.0 - (i / (self.scanner_tail_length + 1)) fade_factor = 1.0 - (i / (self.scanner_tail_length + 1))
faded_color = tuple(int(c * fade_factor) for c in color) faded_color = tuple(int(c * fade_factor) for c in color)
self.n[tail_pos] = faded_color self.n[tail_pos] = faded_color
self.n.write() self.n.write()
self.pattern_step += 1 self.pattern_step += 1
if self.pattern_step >= self.num_leds + self.scanner_tail_length: if self.pattern_step >= self.num_leds + self.scanner_tail_length:
self.pattern_step = 0 # Reset to start self.pattern_step = 0 # Reset to start
self.last_update = current_time self.last_update = current_time
yield
def bidirectional_scanner_step(self): def bidirectional_scanner_step(self):
""" """
Mimics a 'Knight Rider' style scanner, moving back and forth. Mimics a 'Knight Rider' style scanner, moving back and forth.
""" """
current_time = utime.ticks_ms() while True:
if utime.ticks_diff(current_time, self.last_update) >= self.delay/100: current_time = utime.ticks_ms()
self.fill((0, 0, 0)) # Clear all LEDs 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 # Calculate the head position based on direction
head_pos = self.pattern_step head_pos = self.pattern_step
# Draw the head # Draw the head
if 0 <= head_pos < self.num_leds: if 0 <= head_pos < self.num_leds:
self.n[head_pos] = color self.n[head_pos] = color
# Draw the trailing pixels with decreasing brightness # Draw the trailing pixels with decreasing brightness
for i in range(1, self.scanner_tail_length + 1): for i in range(1, self.scanner_tail_length + 1):
tail_pos = head_pos - (i * self.scanner_direction) tail_pos = head_pos - (i * self.scanner_direction)
if 0 <= tail_pos < self.num_leds: if 0 <= tail_pos < self.num_leds:
fade_factor = 1.0 - (i / (self.scanner_tail_length + 1)) fade_factor = 1.0 - (i / (self.scanner_tail_length + 1))
faded_color = tuple(int(c * fade_factor) for c in color) faded_color = tuple(int(c * fade_factor) for c in color)
self.n[tail_pos] = faded_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 # Change direction if boundaries are reached
if self.scanner_direction == 1 and self.pattern_step >= self.num_leds: if self.scanner_direction == 1 and self.pattern_step >= self.num_leds:
self.scanner_direction = -1 self.scanner_direction = -1
self.pattern_step = self.num_leds - 1 # Start moving back from the last LED self.pattern_step = self.num_leds - 1 # Start moving back from the last LED
elif self.scanner_direction == -1 and self.pattern_step < 0: elif self.scanner_direction == -1 and self.pattern_step < 0:
self.scanner_direction = 1 self.scanner_direction = 1
self.pattern_step = 0 # Start moving forward from the first LED self.pattern_step = 0 # Start moving forward from the first LED
self.last_update = current_time self.last_update = current_time
yield

205
src/patterns_base.py Normal file
View File

@@ -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