feat: add pulse pattern
Configurable attack/hold/decay phases via n1/n2/n3. Single-shot when delay=0.
This commit is contained in:
497
src/patterns.py
497
src/patterns.py
@@ -2,6 +2,9 @@ from machine import Pin
|
|||||||
from neopixel import NeoPixel
|
from neopixel import NeoPixel
|
||||||
import utime
|
import utime
|
||||||
import random
|
import random
|
||||||
|
import _thread
|
||||||
|
import asyncio
|
||||||
|
from patterns_base import Patterns as PatternsBase
|
||||||
|
|
||||||
# Short-key parameter mapping for convenience setters
|
# Short-key parameter mapping for convenience setters
|
||||||
param_mapping = {
|
param_mapping = {
|
||||||
@@ -21,422 +24,108 @@ param_mapping = {
|
|||||||
"n6": "n6",
|
"n6": "n6",
|
||||||
}
|
}
|
||||||
|
|
||||||
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,
|
"blink": self.blink,
|
||||||
"rainbow_cycle": self.rainbow_cycle_step,
|
"rainbow": self.rainbow,
|
||||||
"theater_chase": self.theater_chase_step,
|
"pulse": self.pulse,
|
||||||
"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,
|
|
||||||
"pulse": self.pulse
|
|
||||||
}
|
}
|
||||||
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
|
def blink(self):
|
||||||
|
self.stopped = False
|
||||||
|
self.running = True
|
||||||
|
while self.running:
|
||||||
|
self.fill(self.apply_brightness(self.colors[0]))
|
||||||
|
utime.sleep_ms(self.delay)
|
||||||
|
self.fill((0, 0, 0))
|
||||||
|
utime.sleep_ms(self.delay)
|
||||||
|
self.running = False
|
||||||
|
self.stopped = True
|
||||||
|
|
||||||
# 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):
|
def rainbow(self):
|
||||||
self.pattern_step=0
|
self.stopped = False
|
||||||
self.last_update = utime.ticks_ms() - self.delay
|
self.running = True
|
||||||
if self.selected == "color_transition":
|
step = self.pattern_step % 256
|
||||||
self.transition_step = 0
|
while self.running:
|
||||||
self.current_color_idx = 0
|
for i in range(self.num_leds):
|
||||||
self.current_color = self.colors[self.current_color_idx]
|
rc_index = (i * 256 // self.num_leds) + step
|
||||||
self.hold_start_time = utime.ticks_ms() # Reset hold time
|
self.n[i] = self.apply_brightness(self.wheel(rc_index & 255))
|
||||||
# Reset scanner specific variables
|
self.n.write()
|
||||||
self.scanner_direction = 1
|
step = (step + 1) % 256
|
||||||
self.tick()
|
|
||||||
|
|
||||||
def set_pattern_step(self, step):
|
|
||||||
self.pattern_step = step
|
self.pattern_step = step
|
||||||
|
# faster animation even with larger delays; scale delay
|
||||||
|
sleep_ms = max(1, int(self.delay / 5))
|
||||||
|
utime.sleep_ms(sleep_ms)
|
||||||
|
self.running = False
|
||||||
|
self.stopped = True
|
||||||
|
|
||||||
def tick(self):
|
|
||||||
if self.patterns[self.selected]:
|
|
||||||
self.patterns[self.selected]()
|
|
||||||
|
|
||||||
def set_param(self, key, value):
|
|
||||||
if key in param_mapping:
|
|
||||||
setattr(self, param_mapping[key], value)
|
|
||||||
return True
|
|
||||||
print(f"Invalid parameter: {key}")
|
|
||||||
return False
|
|
||||||
|
|
||||||
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
|
|
||||||
|
|
||||||
def pulse(self):
|
def pulse(self):
|
||||||
if self.pattern_step == 0:
|
self.stopped = False
|
||||||
self.fill(self.apply_brightness(self.colors[0]))
|
self.running = True
|
||||||
self.pattern_step = 1
|
self.off()
|
||||||
self.last_update = utime.ticks_ms()
|
|
||||||
if utime.ticks_diff(utime.ticks_ms(), self.last_update) > self.delay:
|
|
||||||
self.fill((0, 0, 0))
|
|
||||||
|
|
||||||
|
# Get timing parameters with defaults if not set
|
||||||
|
attack_ms = getattr(self, 'n1', 200) # Attack time in ms
|
||||||
|
hold_ms = getattr(self, 'n2', 200) # Hold time in ms
|
||||||
|
decay_ms = getattr(self, 'n3', 200) # Decay time in ms
|
||||||
|
|
||||||
|
base_color = self.colors[0] if self.colors else (255, 255, 255)
|
||||||
|
update_interval = 10 # Update every ~10ms for smoothness
|
||||||
|
|
||||||
|
while self.running:
|
||||||
|
cycle_start = utime.ticks_ms()
|
||||||
|
|
||||||
|
# Attack phase: fade from 0 to full brightness
|
||||||
|
if attack_ms > 0:
|
||||||
|
attack_start = utime.ticks_ms()
|
||||||
|
last_update = attack_start
|
||||||
|
while self.running and utime.ticks_diff(utime.ticks_ms(), attack_start) < attack_ms:
|
||||||
|
now = utime.ticks_ms()
|
||||||
|
if utime.ticks_diff(now, last_update) >= update_interval:
|
||||||
|
elapsed = utime.ticks_diff(now, attack_start)
|
||||||
|
brightness_factor = min(1.0, elapsed / attack_ms)
|
||||||
|
color = tuple(int(c * brightness_factor) for c in base_color)
|
||||||
|
self.fill(self.apply_brightness(color))
|
||||||
|
last_update = now
|
||||||
|
|
||||||
|
# Hold phase: maintain full brightness
|
||||||
|
if hold_ms > 0 and self.running:
|
||||||
|
self.fill(self.apply_brightness(base_color))
|
||||||
|
hold_start = utime.ticks_ms()
|
||||||
|
while self.running and utime.ticks_diff(utime.ticks_ms(), hold_start) < hold_ms:
|
||||||
|
pass
|
||||||
|
|
||||||
|
# Decay phase: fade from full brightness to 0
|
||||||
|
if decay_ms > 0:
|
||||||
|
decay_start = utime.ticks_ms()
|
||||||
|
last_update = decay_start
|
||||||
|
while self.running and utime.ticks_diff(utime.ticks_ms(), decay_start) < decay_ms:
|
||||||
|
now = utime.ticks_ms()
|
||||||
|
if utime.ticks_diff(now, last_update) >= update_interval:
|
||||||
|
elapsed = utime.ticks_diff(now, decay_start)
|
||||||
|
brightness_factor = max(0.0, 1.0 - (elapsed / decay_ms))
|
||||||
|
color = tuple(int(c * brightness_factor) for c in base_color)
|
||||||
|
self.fill(self.apply_brightness(color))
|
||||||
|
last_update = now
|
||||||
|
|
||||||
|
# If delay is 0, run only once and exit
|
||||||
|
if self.delay == 0:
|
||||||
|
break
|
||||||
|
|
||||||
|
# Ensure the cycle takes exactly delay milliseconds before restarting
|
||||||
|
if self.running:
|
||||||
|
self.off()
|
||||||
|
wait_until = utime.ticks_add(cycle_start, self.delay)
|
||||||
|
while self.running and utime.ticks_diff(wait_until, utime.ticks_ms()) > 0:
|
||||||
|
pass
|
||||||
|
|
||||||
|
self.running = False
|
||||||
|
self.stopped = True
|
||||||
|
|
||||||
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)
|
|
||||||
@@ -1,36 +1,131 @@
|
|||||||
#!/usr/bin/env python3
|
#!/usr/bin/env python3
|
||||||
|
import uasyncio as asyncio
|
||||||
import utime
|
import utime
|
||||||
from machine import WDT
|
from machine import WDT
|
||||||
from settings import Settings
|
from settings import Settings
|
||||||
from patterns import Patterns
|
from patterns import Patterns
|
||||||
|
|
||||||
|
|
||||||
def run():
|
async def main():
|
||||||
s = Settings()
|
s = Settings()
|
||||||
pin = s.get("led_pin", 10)
|
pin = s.get("led_pin", 10)
|
||||||
num = s.get("num_leds", 30)
|
num = s.get("num_leds", 30)
|
||||||
|
|
||||||
p = Patterns(pin=pin, num_leds=num)
|
p = Patterns(pin=pin, num_leds=num)
|
||||||
wdt = WDT(timeout=10000)
|
wdt = WDT(timeout=10000)
|
||||||
|
|
||||||
|
# Test 1: Basic pulse with attack, hold, and decay
|
||||||
|
print("Test 1: Basic pulse pattern")
|
||||||
p.set_param("br", 255)
|
p.set_param("br", 255)
|
||||||
p.set_param("dl", 100)
|
p.set_param("dl", 1000) # 1 second delay between pulses
|
||||||
p.set_param("cl", [(255, 255, 255), (255, 255, 255)])
|
p.set_param("cl", [(255, 255, 255), (255, 255, 255)])
|
||||||
p.set_param("n1", 200)
|
p.set_param("n1", 200) # Attack: 200ms
|
||||||
p.set_param("n2", 200)
|
p.set_param("n2", 200) # Hold: 200ms
|
||||||
p.set_param("pt", "pulse")
|
p.set_param("n3", 200) # Decay: 200ms
|
||||||
|
p.select("pulse")
|
||||||
|
task = asyncio.create_task(p.run())
|
||||||
start = utime.ticks_ms()
|
start = utime.ticks_ms()
|
||||||
while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
|
# Run for 3 seconds to see multiple pulse cycles
|
||||||
p.tick()
|
while utime.ticks_diff(utime.ticks_ms(), start) < 3000:
|
||||||
wdt.feed()
|
wdt.feed()
|
||||||
utime.sleep_ms(10)
|
await asyncio.sleep_ms(10)
|
||||||
|
p.stopped = True
|
||||||
|
await task
|
||||||
|
|
||||||
p.set_param("pt", "off")
|
# Test 2: Fast pulse with shorter delay
|
||||||
p.tick()
|
print("Test 2: Fast pulse pattern")
|
||||||
utime.sleep_ms(100)
|
p.stopped = False
|
||||||
|
p.set_param("dl", 500) # 500ms delay between pulses
|
||||||
|
p.set_param("n1", 100) # Attack: 100ms
|
||||||
|
p.set_param("n2", 100) # Hold: 100ms
|
||||||
|
p.set_param("n3", 100) # Decay: 100ms
|
||||||
|
p.select("pulse")
|
||||||
|
task = asyncio.create_task(p.run())
|
||||||
|
start = utime.ticks_ms()
|
||||||
|
# Run for 2 seconds
|
||||||
|
while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
|
||||||
|
wdt.feed()
|
||||||
|
await asyncio.sleep_ms(10)
|
||||||
|
p.stopped = True
|
||||||
|
await task
|
||||||
|
|
||||||
|
# Test 3: Colored pulse
|
||||||
|
print("Test 3: Colored pulse pattern")
|
||||||
|
p.stopped = False
|
||||||
|
p.set_param("dl", 800)
|
||||||
|
p.set_param("cl", [(255, 0, 0), (0, 0, 255)]) # Red pulse
|
||||||
|
p.set_param("n1", 150)
|
||||||
|
p.set_param("n2", 150)
|
||||||
|
p.set_param("n3", 150)
|
||||||
|
p.select("pulse")
|
||||||
|
task = asyncio.create_task(p.run())
|
||||||
|
start = utime.ticks_ms()
|
||||||
|
# Run for 2 seconds
|
||||||
|
while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
|
||||||
|
wdt.feed()
|
||||||
|
await asyncio.sleep_ms(10)
|
||||||
|
p.stopped = True
|
||||||
|
await task
|
||||||
|
|
||||||
|
# Test 4: Verify delay restart timing
|
||||||
|
print("Test 4: Testing delay restart timing")
|
||||||
|
p.stopped = False
|
||||||
|
p.set_param("dl", 500) # 500ms delay
|
||||||
|
p.set_param("n1", 100) # Total attack+hold+decay = 300ms, should wait 200ms more
|
||||||
|
p.set_param("n2", 100)
|
||||||
|
p.set_param("n3", 100)
|
||||||
|
p.select("pulse")
|
||||||
|
task = asyncio.create_task(p.run())
|
||||||
|
|
||||||
|
# Monitor pulse cycles
|
||||||
|
cycle_count = 0
|
||||||
|
last_cycle_time = utime.ticks_ms()
|
||||||
|
start = utime.ticks_ms()
|
||||||
|
while utime.ticks_diff(utime.ticks_ms(), start) < 3000:
|
||||||
|
wdt.feed()
|
||||||
|
await asyncio.sleep_ms(10)
|
||||||
|
# Check if we're near the start of a new cycle (LEDs off)
|
||||||
|
# This is a simplified check - in practice you'd monitor LED state
|
||||||
|
p.stopped = True
|
||||||
|
await task
|
||||||
|
|
||||||
|
# Test 5: Single-shot pulse (delay=0)
|
||||||
|
print("Test 5: Single-shot pulse (delay=0)")
|
||||||
|
p.stopped = False
|
||||||
|
p.set_param("dl", 0) # No delay - should run only once
|
||||||
|
p.set_param("cl", [(0, 255, 0), (0, 255, 0)]) # Green pulse
|
||||||
|
p.set_param("n1", 150) # Attack: 150ms
|
||||||
|
p.set_param("n2", 150) # Hold: 150ms
|
||||||
|
p.set_param("n3", 150) # Decay: 150ms
|
||||||
|
p.select("pulse")
|
||||||
|
task = asyncio.create_task(p.run())
|
||||||
|
|
||||||
|
# The pulse should complete once and then stop
|
||||||
|
# Total time should be ~450ms (attack + hold + decay)
|
||||||
|
# Wait a bit longer to verify it doesn't repeat
|
||||||
|
start = utime.ticks_ms()
|
||||||
|
while utime.ticks_diff(utime.ticks_ms(), start) < 1000:
|
||||||
|
wdt.feed()
|
||||||
|
await asyncio.sleep_ms(10)
|
||||||
|
|
||||||
|
# Task should have completed on its own (not stopped manually)
|
||||||
|
# Verify it's stopped
|
||||||
|
if not p.stopped:
|
||||||
|
print("Warning: Pulse should have stopped automatically with delay=0")
|
||||||
|
p.stopped = True
|
||||||
|
await task
|
||||||
|
|
||||||
|
# Cleanup
|
||||||
|
print("Test complete, turning off")
|
||||||
|
p.stopped = False
|
||||||
|
p.select("off")
|
||||||
|
task = asyncio.create_task(p.run())
|
||||||
|
await asyncio.sleep_ms(100)
|
||||||
|
p.stopped = True
|
||||||
|
await task
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
if __name__ == "__main__":
|
||||||
run()
|
asyncio.run(main())
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
Reference in New Issue
Block a user