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, "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 } 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 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 color_transition_step(self): 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 # 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 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 # 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.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 self.last_update = current_time 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)) flicker_color = self.apply_brightness(base_color, brightness_override=flicker_brightness) self.fill(flicker_color) self.last_update = current_time 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 # 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 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.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 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 color = self.apply_brightness(self.colors[0]) # 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 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.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 self.last_update = current_time