from machine import Pin from neopixel import NeoPixel import utime import random 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, "rainbow_cycle": self.rainbow_cycle_step, "theater_chase": self.theater_chase_step, "blink": self.blink_step, "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.colors = [color1, color2] self.transition_duration = delay * 10 # Default transition duration is 10 times the delay self.transition_step = 0 self.current_color = self.colors[0] # New: Track the current index for color transitions self.current_color_idx = 0 def sync(self): self.pattern_step=0 self.last_update = utime.ticks_ms() - self.delay 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 when delay changes for color_transition pattern if self.selected == "color_transition": self.transition_duration = self.delay * 10 # Or some other multiplier def set_brightness(self, brightness): self.brightness = brightness def set_color1(self, color): self.colors[0] = color if self.selected == "color_transition": # Restart transition if color 0 (start color) is changed self.transition_step = 0 self.current_color_idx = 0 # Ensure we start from the new color[0] self.current_color = self.colors[0] def set_color2(self, color): self.colors[1] = color if self.selected == "color_transition": # No direct effect on current_color here, but transition will eventually use it pass def set_colors(self, colors): self.colors = colors 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: self.transition_step = 0 # Optionally reset current_color_idx if num is the start color if num == current_from_idx: self.current_color_idx = num self.current_color = self.colors[num] 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) 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 self.select("off") # Or some other default else: self.current_color_idx %= len(self.colors) # Adjust index if it's out of bounds self.transition_step = 0 self.current_color = self.colors[self.current_color_idx] return True return False def apply_brightness(self, color): return tuple(int(c * self.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.transition_duration = self.delay * 10 # Initialize transition 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 def rainbow_cycle_step(self): current_time = utime.ticks_ms() if utime.ticks_diff(current_time, self.last_update) >= self.delay/5: def wheel(pos): if pos < 85: return (pos * 3, 255 - pos * 3, 0) elif pos < 170: pos -= 85 return (255 - pos * 3, 0, pos * 3) else: pos -= 170 return (0, pos * 3, 255 - pos * 3) for i in range(self.num_leds): rc_index = (i * 256 // self.num_leds) + self.pattern_step self.n[i] = self.apply_brightness(wheel(rc_index & 255)) self.n.write() self.pattern_step = (self.pattern_step + 1) % 256 self.last_update = current_time def theater_chase_step(self): current_time = utime.ticks_ms() if utime.ticks_diff(current_time, self.last_update) >= self.delay: for i in range(self.num_leds): if (i + self.pattern_step) % 3 == 0: self.n[i] = self.apply_brightness(self.colors[0]) else: self.n[i] = (0, 0, 0) self.n.write() self.pattern_step = (self.pattern_step + 1) % 3 self.last_update = current_time def blink_step(self): current_time = utime.ticks_ms() if utime.ticks_diff(current_time, self.last_update) >= self.delay: if self.pattern_step % 2 == 0: self.fill(self.apply_brightness(self.colors[0])) else: self.fill((0, 0, 0)) self.pattern_step = (self.pattern_step + 1) % 2 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 else: self.pattern_step = 0 self.last_update = current_time def random_rainbow_cycle_step(self): current_time = utime.ticks_ms() if utime.ticks_diff(current_time, self.last_update) >= self.delay: 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) random_offset = random.randint(0, 255) for i in range(self.num_leds): rc_index = (i * 256 // self.num_leds) + self.pattern_step + random_offset self.n[i] = self.apply_brightness(wheel(rc_index & 255)) self.n.write() self.pattern_step = (self.pattern_step + 1) % 256 self.last_update = current_time def random_theater_chase_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)) for i in range(self.num_leds): 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): current_time = utime.ticks_ms() if utime.ticks_diff(current_time, self.last_update) >= self.delay*10: color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)) if self.pattern_step % 2 == 0: self.fill(self.apply_brightness(color)) else: self.fill((0, 0, 0)) self.pattern_step = (self.pattern_step + 1) % 2 self.last_update = current_time def interpolate_color(self, color_a, color_b, factor): """Interpolates between two colors.""" return tuple(int(a + (b - a) * factor) for a, b in zip(color_a, color_b)) def color_transition_step(self): current_time = utime.ticks_ms() if len(self.colors) < 2: # Not enough colors to transition, possibly switch to 'on' or 'off' self.fill(self.apply_brightness(self.colors[0])) return # Exit if there aren't enough colors if utime.ticks_diff(current_time, self.last_update) >= 1: # Update frequently for smooth transition self.transition_step += utime.ticks_diff(current_time, self.last_update) self.last_update = current_time color_from = self.colors[self.current_color_idx] color_to_idx = (self.current_color_idx + 1) % len(self.colors) color_to = self.colors[color_to_idx] if self.transition_step >= self.transition_duration: # Transition complete to the next color self.current_color_idx = color_to_idx # Move to the next color in the sequence self.transition_step = 0 # Reset transition step # Calculate the interpolation factor (0 to 1) factor = self.transition_step / self.transition_duration # Get the interpolated color and apply brightness interpolated_color = self.interpolate_color(color_from, color_to, factor) self.current_color = self.apply_brightness(interpolated_color) # Fill the LEDs with the current interpolated color self.fill(self.current_color) if __name__ == "__main__": p = Patterns(4, 180) p.set_color1((255,0,0)) p.set_color2((0,0,255)) # Blue p.add_color((0,255,0)) # Green p.add_color((255,255,0)) # Yellow #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))