Import led-driver app: pico/ and esp32/ layout
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
@@ -24,7 +24,7 @@ for pin, num_leds in pins:
|
||||
ws = WS2812B(num_leds, pin, sm, brightness=1.0) # 1.0 so fill() is visible
|
||||
strips.append(ws)
|
||||
sm += 1
|
||||
ws.fill((255,0,0))
|
||||
ws.fill((8,0,0))
|
||||
ws.show()
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
190
pico/test/patterns/auto_manual.py
Normal file
190
pico/test/patterns/auto_manual.py
Normal file
@@ -0,0 +1,190 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, duration_ms):
|
||||
"""Run pattern for specified duration."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < duration_ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
print("=" * 50)
|
||||
print("Testing Auto and Manual Modes")
|
||||
print("=" * 50)
|
||||
|
||||
# Test 1: Rainbow in AUTO mode (continuous)
|
||||
print("\nTest 1: Rainbow pattern in AUTO mode (should run continuously)")
|
||||
p.edit("rainbow_auto", {
|
||||
"p": "rainbow",
|
||||
"b": 128,
|
||||
"d": 50,
|
||||
"n1": 2,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow_auto")
|
||||
print("Running rainbow_auto for 3 seconds...")
|
||||
run_for(p, wdt, 3000)
|
||||
print("✓ Auto mode: Pattern ran continuously")
|
||||
|
||||
# Test 2: Rainbow in MANUAL mode (one step per tick)
|
||||
print("\nTest 2: Rainbow pattern in MANUAL mode (one step per tick)")
|
||||
p.edit("rainbow_manual", {
|
||||
"p": "rainbow",
|
||||
"b": 128,
|
||||
"d": 50,
|
||||
"n1": 2,
|
||||
"a": False,
|
||||
})
|
||||
p.select("rainbow_manual")
|
||||
print("Calling tick() 5 times (should advance 5 steps)...")
|
||||
for i in range(5):
|
||||
p.tick()
|
||||
utime.sleep_ms(100) # Small delay to see changes
|
||||
print(f" Tick {i+1}: generator={'active' if p.generator is not None else 'stopped'}")
|
||||
|
||||
# Check if generator stopped after one cycle
|
||||
if p.generator is None:
|
||||
print("✓ Manual mode: Generator stopped after one step (as expected)")
|
||||
else:
|
||||
print("⚠ Manual mode: Generator still active (may need multiple ticks)")
|
||||
|
||||
# Test 3: Pulse in AUTO mode (continuous cycles)
|
||||
print("\nTest 3: Pulse pattern in AUTO mode (should pulse continuously)")
|
||||
p.edit("pulse_auto", {
|
||||
"p": "pulse",
|
||||
"b": 128,
|
||||
"d": 100,
|
||||
"n1": 500, # Attack
|
||||
"n2": 200, # Hold
|
||||
"n3": 500, # Decay
|
||||
"c": [(255, 0, 0)],
|
||||
"a": True,
|
||||
})
|
||||
p.select("pulse_auto")
|
||||
print("Running pulse_auto for 3 seconds...")
|
||||
run_for(p, wdt, 3000)
|
||||
print("✓ Auto mode: Pulse ran continuously")
|
||||
|
||||
# Test 4: Pulse in MANUAL mode (one cycle then stop)
|
||||
print("\nTest 4: Pulse pattern in MANUAL mode (one cycle then stop)")
|
||||
p.edit("pulse_manual", {
|
||||
"p": "pulse",
|
||||
"b": 128,
|
||||
"d": 100,
|
||||
"n1": 300, # Attack
|
||||
"n2": 200, # Hold
|
||||
"n3": 300, # Decay
|
||||
"c": [(0, 255, 0)],
|
||||
"a": False,
|
||||
})
|
||||
p.select("pulse_manual")
|
||||
print("Running pulse_manual until generator stops...")
|
||||
tick_count = 0
|
||||
max_ticks = 200 # Safety limit
|
||||
while p.generator is not None and tick_count < max_ticks:
|
||||
p.tick()
|
||||
tick_count += 1
|
||||
utime.sleep_ms(10)
|
||||
|
||||
if p.generator is None:
|
||||
print(f"✓ Manual mode: Pulse completed one cycle after {tick_count} ticks")
|
||||
else:
|
||||
print(f"⚠ Manual mode: Pulse still running after {tick_count} ticks")
|
||||
|
||||
# Test 5: Transition in AUTO mode (continuous transitions)
|
||||
print("\nTest 5: Transition pattern in AUTO mode (continuous transitions)")
|
||||
p.edit("transition_auto", {
|
||||
"p": "transition",
|
||||
"b": 128,
|
||||
"d": 500,
|
||||
"c": [(255, 0, 0), (0, 255, 0), (0, 0, 255)],
|
||||
"a": True,
|
||||
})
|
||||
p.select("transition_auto")
|
||||
print("Running transition_auto for 3 seconds...")
|
||||
run_for(p, wdt, 3000)
|
||||
print("✓ Auto mode: Transition ran continuously")
|
||||
|
||||
# Test 6: Transition in MANUAL mode (one transition then stop)
|
||||
print("\nTest 6: Transition pattern in MANUAL mode (one transition then stop)")
|
||||
p.edit("transition_manual", {
|
||||
"p": "transition",
|
||||
"b": 128,
|
||||
"d": 500,
|
||||
"c": [(255, 0, 0), (0, 255, 0)],
|
||||
"a": False,
|
||||
})
|
||||
p.select("transition_manual")
|
||||
print("Running transition_manual until generator stops...")
|
||||
tick_count = 0
|
||||
max_ticks = 200
|
||||
while p.generator is not None and tick_count < max_ticks:
|
||||
p.tick()
|
||||
tick_count += 1
|
||||
utime.sleep_ms(10)
|
||||
|
||||
if p.generator is None:
|
||||
print(f"✓ Manual mode: Transition completed after {tick_count} ticks")
|
||||
else:
|
||||
print(f"⚠ Manual mode: Transition still running after {tick_count} ticks")
|
||||
|
||||
# Test 7: Switching between auto and manual modes
|
||||
print("\nTest 7: Switching between auto and manual modes")
|
||||
p.edit("switch_test", {
|
||||
"p": "rainbow",
|
||||
"b": 128,
|
||||
"d": 50,
|
||||
"n1": 2,
|
||||
"a": True,
|
||||
})
|
||||
p.select("switch_test")
|
||||
print("Running in auto mode for 1 second...")
|
||||
run_for(p, wdt, 1000)
|
||||
|
||||
# Switch to manual mode by editing the preset
|
||||
print("Switching to manual mode...")
|
||||
p.edit("switch_test", {"a": False})
|
||||
p.select("switch_test") # Re-select to apply changes
|
||||
|
||||
print("Calling tick() 3 times in manual mode...")
|
||||
for i in range(3):
|
||||
p.tick()
|
||||
utime.sleep_ms(100)
|
||||
print(f" Tick {i+1}: generator={'active' if p.generator is not None else 'stopped'}")
|
||||
|
||||
# Switch back to auto mode
|
||||
print("Switching back to auto mode...")
|
||||
p.edit("switch_test", {"a": True})
|
||||
p.select("switch_test")
|
||||
print("Running in auto mode for 1 second...")
|
||||
run_for(p, wdt, 1000)
|
||||
print("✓ Successfully switched between auto and manual modes")
|
||||
|
||||
# Cleanup
|
||||
print("\nCleaning up...")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
p.tick()
|
||||
utime.sleep_ms(100)
|
||||
|
||||
print("\n" + "=" * 50)
|
||||
print("All tests completed!")
|
||||
print("=" * 50)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
35
pico/test/patterns/blink.py
Normal file
35
pico/test/patterns/blink.py
Normal file
@@ -0,0 +1,35 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Create blink preset (use short-key fields: p=pattern, b=brightness, d=delay, c=colors)
|
||||
p.edit("test_blink", {
|
||||
"p": "blink",
|
||||
"b": 64,
|
||||
"d": 200,
|
||||
"c": [(255, 0, 0), (0, 0, 255)],
|
||||
})
|
||||
p.select("test_blink")
|
||||
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 1500:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
161
pico/test/patterns/chase.py
Normal file
161
pico/test/patterns/chase.py
Normal file
@@ -0,0 +1,161 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, ms):
|
||||
"""Helper: run current pattern for given ms using tick()."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Test 1: Basic chase (n1=5, n2=5, n3=1, n4=1)
|
||||
print("Test 1: Basic chase (n1=5, n2=5, n3=1, n4=1)")
|
||||
p.edit("chase1", {
|
||||
"p": "chase",
|
||||
"b": 255,
|
||||
"d": 200,
|
||||
"n1": 5,
|
||||
"n2": 5,
|
||||
"n3": 1,
|
||||
"n4": 1,
|
||||
"c": [(255, 0, 0), (0, 255, 0)],
|
||||
})
|
||||
p.select("chase1")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 2: Forward and backward (n3=2, n4=-1)
|
||||
print("Test 2: Forward and backward (n3=2, n4=-1)")
|
||||
p.edit("chase2", {
|
||||
"p": "chase",
|
||||
"n1": 3,
|
||||
"n2": 3,
|
||||
"n3": 2,
|
||||
"n4": -1,
|
||||
"d": 150,
|
||||
"c": [(0, 0, 255), (255, 255, 0)],
|
||||
})
|
||||
p.select("chase2")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 3: Large segments (n1=10, n2=5)
|
||||
print("Test 3: Large segments (n1=10, n2=5, n3=3, n4=3)")
|
||||
p.edit("chase3", {
|
||||
"p": "chase",
|
||||
"n1": 10,
|
||||
"n2": 5,
|
||||
"n3": 3,
|
||||
"n4": 3,
|
||||
"d": 200,
|
||||
"c": [(255, 128, 0), (128, 0, 255)],
|
||||
})
|
||||
p.select("chase3")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 4: Fast movement (n3=5, n4=5)
|
||||
print("Test 4: Fast movement (n3=5, n4=5)")
|
||||
p.edit("chase4", {
|
||||
"p": "chase",
|
||||
"n1": 4,
|
||||
"n2": 4,
|
||||
"n3": 5,
|
||||
"n4": 5,
|
||||
"d": 100,
|
||||
"c": [(255, 0, 255), (0, 255, 255)],
|
||||
})
|
||||
p.select("chase4")
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 5: Backward movement (n3=-2, n4=-2)
|
||||
print("Test 5: Backward movement (n3=-2, n4=-2)")
|
||||
p.edit("chase5", {
|
||||
"p": "chase",
|
||||
"n1": 6,
|
||||
"n2": 4,
|
||||
"n3": -2,
|
||||
"n4": -2,
|
||||
"d": 200,
|
||||
"c": [(255, 255, 255), (0, 0, 0)],
|
||||
})
|
||||
p.select("chase5")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 6: Alternating forward/backward (n3=3, n4=-2)
|
||||
print("Test 6: Alternating forward/backward (n3=3, n4=-2)")
|
||||
p.edit("chase6", {
|
||||
"p": "chase",
|
||||
"n1": 5,
|
||||
"n2": 5,
|
||||
"n3": 3,
|
||||
"n4": -2,
|
||||
"d": 250,
|
||||
"c": [(255, 0, 0), (0, 255, 0)],
|
||||
})
|
||||
p.select("chase6")
|
||||
run_for(p, wdt, 4000)
|
||||
|
||||
# Test 7: Manual mode - advance one step per beat
|
||||
print("Test 7: Manual mode chase (auto=False, n3=2, n4=1)")
|
||||
p.edit("chase_manual", {
|
||||
"p": "chase",
|
||||
"n1": 4,
|
||||
"n2": 4,
|
||||
"n3": 2,
|
||||
"n4": 1,
|
||||
"d": 200,
|
||||
"c": [(255, 255, 0), (0, 255, 255)],
|
||||
"a": False,
|
||||
})
|
||||
p.step = 0 # Reset step counter
|
||||
print(" Advancing pattern with 10 beats (select + tick)...")
|
||||
for i in range(10):
|
||||
p.select("chase_manual") # Simulate beat - restarts generator
|
||||
p.tick() # Advance one step
|
||||
utime.sleep_ms(500) # Pause to see the pattern
|
||||
wdt.feed()
|
||||
print(f" Beat {i+1}: step={p.step}")
|
||||
|
||||
# Test 8: Verify step increments correctly in manual mode
|
||||
print("Test 8: Verify step increments (auto=False)")
|
||||
p.edit("chase_manual2", {
|
||||
"p": "chase",
|
||||
"n1": 3,
|
||||
"n2": 3,
|
||||
"n3": 1,
|
||||
"n4": 1,
|
||||
"a": False,
|
||||
})
|
||||
p.step = 0
|
||||
initial_step = p.step
|
||||
p.select("chase_manual2")
|
||||
p.tick()
|
||||
final_step = p.step
|
||||
print(f" Step updated from {initial_step} to {final_step} (expected: 1)")
|
||||
if final_step == 1:
|
||||
print(" ✓ Step increment working correctly")
|
||||
else:
|
||||
print(f" ✗ Step increment mismatch! Expected 1, got {final_step}")
|
||||
|
||||
# Cleanup
|
||||
print("Test complete, turning off")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
run_for(p, wdt, 100)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
113
pico/test/patterns/circle.py
Normal file
113
pico/test/patterns/circle.py
Normal file
@@ -0,0 +1,113 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, ms):
|
||||
"""Helper: run current pattern for given ms using tick()."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Test 1: Basic circle (n1=50, n2=100, n3=200, n4=0)
|
||||
print("Test 1: Basic circle (n1=50, n2=100, n3=200, n4=0)")
|
||||
p.edit("circle1", {
|
||||
"p": "circle",
|
||||
"b": 255,
|
||||
"n1": 50, # Head moves 50 LEDs/second
|
||||
"n2": 100, # Max length 100 LEDs
|
||||
"n3": 200, # Tail moves 200 LEDs/second
|
||||
"n4": 0, # Min length 0 LEDs
|
||||
"c": [(255, 0, 0)], # Red
|
||||
})
|
||||
p.select("circle1")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Test 2: Slow growth, fast shrink (n1=20, n2=50, n3=100, n4=0)
|
||||
print("Test 2: Slow growth, fast shrink (n1=20, n2=50, n3=100, n4=0)")
|
||||
p.edit("circle2", {
|
||||
"p": "circle",
|
||||
"n1": 20,
|
||||
"n2": 50,
|
||||
"n3": 100,
|
||||
"n4": 0,
|
||||
"c": [(0, 255, 0)], # Green
|
||||
})
|
||||
p.select("circle2")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Test 3: Fast growth, slow shrink (n1=100, n2=30, n3=20, n4=0)
|
||||
print("Test 3: Fast growth, slow shrink (n1=100, n2=30, n3=20, n4=0)")
|
||||
p.edit("circle3", {
|
||||
"p": "circle",
|
||||
"n1": 100,
|
||||
"n2": 30,
|
||||
"n3": 20,
|
||||
"n4": 0,
|
||||
"c": [(0, 0, 255)], # Blue
|
||||
})
|
||||
p.select("circle3")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Test 4: With minimum length (n1=50, n2=40, n3=100, n4=10)
|
||||
print("Test 4: With minimum length (n1=50, n2=40, n3=100, n4=10)")
|
||||
p.edit("circle4", {
|
||||
"p": "circle",
|
||||
"n1": 50,
|
||||
"n2": 40,
|
||||
"n3": 100,
|
||||
"n4": 10,
|
||||
"c": [(255, 255, 0)], # Yellow
|
||||
})
|
||||
p.select("circle4")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Test 5: Very fast (n1=200, n2=20, n3=200, n4=0)
|
||||
print("Test 5: Very fast (n1=200, n2=20, n3=200, n4=0)")
|
||||
p.edit("circle5", {
|
||||
"p": "circle",
|
||||
"n1": 200,
|
||||
"n2": 20,
|
||||
"n3": 200,
|
||||
"n4": 0,
|
||||
"c": [(255, 0, 255)], # Magenta
|
||||
})
|
||||
p.select("circle5")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 6: Very slow (n1=10, n2=25, n3=10, n4=0)
|
||||
print("Test 6: Very slow (n1=10, n2=25, n3=10, n4=0)")
|
||||
p.edit("circle6", {
|
||||
"p": "circle",
|
||||
"n1": 10,
|
||||
"n2": 25,
|
||||
"n3": 10,
|
||||
"n4": 0,
|
||||
"c": [(0, 255, 255)], # Cyan
|
||||
})
|
||||
p.select("circle6")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Cleanup
|
||||
print("Test complete, turning off")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
run_for(p, wdt, 100)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
30
pico/test/patterns/off.py
Normal file
30
pico/test/patterns/off.py
Normal file
@@ -0,0 +1,30 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Create an "off" preset (use short-key field `p` for pattern)
|
||||
p.edit("test_off", {"p": "off"})
|
||||
p.select("test_off")
|
||||
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 200:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
47
pico/test/patterns/on.py
Normal file
47
pico/test/patterns/on.py
Normal file
@@ -0,0 +1,47 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Create presets for on and off using the short-key fields that Presets expects
|
||||
# Preset fields:
|
||||
# p = pattern name, b = brightness, d = delay, c = list of (r,g,b) colors
|
||||
p.edit("test_on", {
|
||||
"p": "on",
|
||||
"b": 64,
|
||||
"d": 120,
|
||||
"c": [(255, 0, 0), (0, 0, 255)],
|
||||
})
|
||||
p.edit("test_off", {"p": "off"})
|
||||
|
||||
# ON phase
|
||||
p.select("test_on")
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 800:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
# OFF phase
|
||||
p.select("test_off")
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 100:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
92
pico/test/patterns/pulse.py
Normal file
92
pico/test/patterns/pulse.py
Normal file
@@ -0,0 +1,92 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, ms):
|
||||
"""Helper: run current pattern for given ms using tick()."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Test 1: Simple single-color pulse
|
||||
print("Test 1: Single-color pulse (attack=500, hold=500, decay=500, delay=500)")
|
||||
p.edit("pulse1", {
|
||||
"p": "pulse",
|
||||
"b": 255,
|
||||
"c": [(255, 0, 0)],
|
||||
"n1": 500, # attack ms
|
||||
"n2": 500, # hold ms
|
||||
"n3": 500, # decay ms
|
||||
"d": 500, # delay ms between pulses
|
||||
"a": True,
|
||||
})
|
||||
p.select("pulse1")
|
||||
run_for(p, wdt, 5000)
|
||||
|
||||
# Test 2: Faster pulse
|
||||
print("Test 2: Fast pulse (attack=100, hold=100, decay=100, delay=100)")
|
||||
p.edit("pulse2", {
|
||||
"p": "pulse",
|
||||
"n1": 100,
|
||||
"n2": 100,
|
||||
"n3": 100,
|
||||
"d": 100,
|
||||
"c": [(0, 255, 0)],
|
||||
})
|
||||
p.select("pulse2")
|
||||
run_for(p, wdt, 4000)
|
||||
|
||||
# Test 3: Multi-color pulse cycle
|
||||
print("Test 3: Multi-color pulse (red -> green -> blue)")
|
||||
p.edit("pulse3", {
|
||||
"p": "pulse",
|
||||
"n1": 300,
|
||||
"n2": 300,
|
||||
"n3": 300,
|
||||
"d": 200,
|
||||
"c": [(255, 0, 0), (0, 255, 0), (0, 0, 255)],
|
||||
"a": True,
|
||||
})
|
||||
p.select("pulse3")
|
||||
run_for(p, wdt, 6000)
|
||||
|
||||
# Test 4: One-shot pulse (auto=False)
|
||||
print("Test 4: Single pulse, auto=False")
|
||||
p.edit("pulse4", {
|
||||
"p": "pulse",
|
||||
"n1": 400,
|
||||
"n2": 0,
|
||||
"n3": 400,
|
||||
"d": 0,
|
||||
"c": [(255, 255, 255)],
|
||||
"a": False,
|
||||
})
|
||||
p.select("pulse4")
|
||||
# Run long enough to allow one full pulse cycle
|
||||
run_for(p, wdt, 1500)
|
||||
|
||||
# Cleanup
|
||||
print("Test complete, turning off")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
run_for(p, wdt, 200)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
151
pico/test/patterns/rainbow.py
Normal file
151
pico/test/patterns/rainbow.py
Normal file
@@ -0,0 +1,151 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, ms):
|
||||
"""Helper: run current pattern for given ms using tick()."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Test 1: Basic rainbow with auto=True (continuous)
|
||||
print("Test 1: Basic rainbow (auto=True, n1=1)")
|
||||
p.edit("rainbow1", {
|
||||
"p": "rainbow",
|
||||
"b": 255,
|
||||
"d": 100,
|
||||
"n1": 1,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow1")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 2: Fast rainbow
|
||||
print("Test 2: Fast rainbow (low delay, n1=1)")
|
||||
p.edit("rainbow2", {
|
||||
"p": "rainbow",
|
||||
"d": 50,
|
||||
"n1": 1,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow2")
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 3: Slow rainbow
|
||||
print("Test 3: Slow rainbow (high delay, n1=1)")
|
||||
p.edit("rainbow3", {
|
||||
"p": "rainbow",
|
||||
"d": 500,
|
||||
"n1": 1,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow3")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Test 4: Low brightness rainbow
|
||||
print("Test 4: Low brightness rainbow (n1=1)")
|
||||
p.edit("rainbow4", {
|
||||
"p": "rainbow",
|
||||
"b": 64,
|
||||
"d": 100,
|
||||
"n1": 1,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow4")
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 5: Single-step rainbow (auto=False)
|
||||
print("Test 5: Single-step rainbow (auto=False, n1=1)")
|
||||
p.edit("rainbow5", {
|
||||
"p": "rainbow",
|
||||
"b": 255,
|
||||
"d": 100,
|
||||
"n1": 1,
|
||||
"a": False,
|
||||
})
|
||||
p.step = 0
|
||||
for i in range(10):
|
||||
p.select("rainbow5")
|
||||
# One tick advances the generator one frame when auto=False
|
||||
p.tick()
|
||||
utime.sleep_ms(100)
|
||||
wdt.feed()
|
||||
|
||||
# Test 6: Verify step updates correctly
|
||||
print("Test 6: Verify step updates (auto=False, n1=1)")
|
||||
p.edit("rainbow6", {
|
||||
"p": "rainbow",
|
||||
"n1": 1,
|
||||
"a": False,
|
||||
})
|
||||
initial_step = p.step
|
||||
p.select("rainbow6")
|
||||
p.tick()
|
||||
final_step = p.step
|
||||
print(f"Step updated from {initial_step} to {final_step} (expected increment: 1)")
|
||||
|
||||
# Test 7: Fast step increment (n1=5)
|
||||
print("Test 7: Fast rainbow (n1=5, auto=True)")
|
||||
p.edit("rainbow7", {
|
||||
"p": "rainbow",
|
||||
"b": 255,
|
||||
"d": 100,
|
||||
"n1": 5,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow7")
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 8: Very fast step increment (n1=10)
|
||||
print("Test 8: Very fast rainbow (n1=10, auto=True)")
|
||||
p.edit("rainbow8", {
|
||||
"p": "rainbow",
|
||||
"n1": 10,
|
||||
"a": True,
|
||||
})
|
||||
p.select("rainbow8")
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 9: Verify n1 controls step increment (auto=False)
|
||||
print("Test 9: Verify n1 step increment (auto=False, n1=5)")
|
||||
p.edit("rainbow9", {
|
||||
"p": "rainbow",
|
||||
"n1": 5,
|
||||
"a": False,
|
||||
})
|
||||
p.step = 0
|
||||
initial_step = p.step
|
||||
p.select("rainbow9")
|
||||
p.tick()
|
||||
final_step = p.step
|
||||
expected_step = (initial_step + 5) % 256
|
||||
print(f"Step updated from {initial_step} to {final_step} (expected: {expected_step})")
|
||||
if final_step == expected_step:
|
||||
print("✓ n1 step increment working correctly")
|
||||
else:
|
||||
print(f"✗ Step increment mismatch! Expected {expected_step}, got {final_step}")
|
||||
|
||||
# Cleanup
|
||||
print("Test complete, turning off")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
run_for(p, wdt, 100)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
81
pico/test/patterns/transition.py
Normal file
81
pico/test/patterns/transition.py
Normal file
@@ -0,0 +1,81 @@
|
||||
#!/usr/bin/env python3
|
||||
import utime
|
||||
from machine import WDT
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
|
||||
|
||||
def run_for(p, wdt, ms):
|
||||
"""Helper: run current pattern for given ms using tick()."""
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < ms:
|
||||
wdt.feed()
|
||||
p.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
|
||||
def main():
|
||||
s = Settings()
|
||||
pin = s.get("led_pin", 10)
|
||||
num = s.get("num_leds", 30)
|
||||
|
||||
p = Presets(pin=pin, num_leds=num)
|
||||
wdt = WDT(timeout=10000)
|
||||
|
||||
# Test 1: Simple two-color transition
|
||||
print("Test 1: Two-color transition (red <-> blue, delay=1000)")
|
||||
p.edit("transition1", {
|
||||
"p": "transition",
|
||||
"b": 255,
|
||||
"d": 1000, # transition duration
|
||||
"c": [(255, 0, 0), (0, 0, 255)],
|
||||
"a": True,
|
||||
})
|
||||
p.select("transition1")
|
||||
run_for(p, wdt, 6000)
|
||||
|
||||
# Test 2: Multi-color transition
|
||||
print("Test 2: Multi-color transition (red -> green -> blue -> white)")
|
||||
p.edit("transition2", {
|
||||
"p": "transition",
|
||||
"d": 800,
|
||||
"c": [(255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 255)],
|
||||
"a": True,
|
||||
})
|
||||
p.select("transition2")
|
||||
run_for(p, wdt, 8000)
|
||||
|
||||
# Test 3: One-shot transition (auto=False)
|
||||
print("Test 3: One-shot transition (auto=False)")
|
||||
p.edit("transition3", {
|
||||
"p": "transition",
|
||||
"d": 1000,
|
||||
"c": [(255, 0, 0), (0, 255, 0)],
|
||||
"a": False,
|
||||
})
|
||||
p.select("transition3")
|
||||
# Run long enough for a single transition step
|
||||
run_for(p, wdt, 2000)
|
||||
|
||||
# Test 4: Single-color behavior (should just stay on)
|
||||
print("Test 4: Single-color transition (should hold color)")
|
||||
p.edit("transition4", {
|
||||
"p": "transition",
|
||||
"c": [(0, 0, 255)],
|
||||
"d": 500,
|
||||
"a": True,
|
||||
})
|
||||
p.select("transition4")
|
||||
run_for(p, wdt, 3000)
|
||||
|
||||
# Cleanup
|
||||
print("Test complete, turning off")
|
||||
p.edit("cleanup_off", {"p": "off"})
|
||||
p.select("cleanup_off")
|
||||
run_for(p, wdt, 200)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
|
||||
@@ -28,13 +28,13 @@ def hue_to_rgb(hue):
|
||||
return (int(r * 255), int(g * 255), int(b * 255))
|
||||
|
||||
|
||||
def make_rainbow_double(num_leds, brightness=1.0):
|
||||
"""Build 2 full rainbow cycles (2*num_leds pixels, GRB). Returns (double_buf, strip_len).
|
||||
head must be in 0..strip_len-1 so DMA reads double_buf[head:head+strip_len] with no copy."""
|
||||
n = 2 * num_leds
|
||||
def make_rainbow_ring(total_leds, brightness=1.0):
|
||||
"""Build one rainbow over the whole ring: 2 full hue cycles over total_leds (GRB).
|
||||
Returns (double_buf, ring_len_bytes). All strips sample from this so phase is continuous."""
|
||||
n = 2 * total_leds
|
||||
double_buf = bytearray(n * 3)
|
||||
for i in range(n):
|
||||
hue = (i / n) * 360 * 2
|
||||
hue = ((i % total_leds) / total_leds) * 360 * 2
|
||||
r, g, b = hue_to_rgb(hue)
|
||||
g = int(g * brightness) & 0xFF
|
||||
r = int(r * brightness) & 0xFF
|
||||
@@ -43,52 +43,83 @@ def make_rainbow_double(num_leds, brightness=1.0):
|
||||
double_buf[o] = g
|
||||
double_buf[o + 1] = r
|
||||
double_buf[o + 2] = b
|
||||
strip_len = num_leds * 3
|
||||
return (double_buf, strip_len)
|
||||
ring_len_bytes = total_leds * 3
|
||||
return (double_buf, ring_len_bytes)
|
||||
|
||||
|
||||
def show_rainbow(strip, double_buf, strip_len, head):
|
||||
"""DMA reads directly from double_buf at head; no copy. head in 0..strip_len-1."""
|
||||
strip.show(double_buf, head)
|
||||
def make_strip_rainbow(num_leds, cumulative_leds, total_ring_leds, brightness=1.0):
|
||||
"""Per-strip double buffer: pixel j has hue at global position (cumulative_leds + j) % total_ring_leds.
|
||||
Use same head for all strips: head = rainbow_head % (2*num_leds*3)."""
|
||||
n = 2 * num_leds
|
||||
buf = bytearray(n * 3)
|
||||
for j in range(n):
|
||||
global_pos = (cumulative_leds + j) % total_ring_leds
|
||||
hue = (global_pos / total_ring_leds) * 360 * 2
|
||||
r, g, b = hue_to_rgb(hue)
|
||||
g = int(g * brightness) & 0xFF
|
||||
r = int(r * brightness) & 0xFF
|
||||
b = int(b * brightness) & 0xFF
|
||||
o = j * 3
|
||||
buf[o] = g
|
||||
buf[o + 1] = r
|
||||
buf[o + 2] = b
|
||||
strip_len_bytes = num_leds * 3
|
||||
return (buf, strip_len_bytes)
|
||||
|
||||
|
||||
# --- Strips + rainbow buffers per strip ---
|
||||
def show_rainbow_segment(strip, buf, strip_len_bytes, head):
|
||||
"""DMA reads strip's segment from buf at head."""
|
||||
strip.show(buf, head)
|
||||
|
||||
|
||||
# --- Strips + one global ring rainbow (all strips in phase) ---
|
||||
# Each strip can have a different length; one rainbow spans total_ring_leds so hue is continuous.
|
||||
|
||||
# (pin, num_leds) per strip — lengths differ per segment
|
||||
STRIP_CONFIG = (
|
||||
(2, 291),
|
||||
(3, 290),
|
||||
(4, 283),
|
||||
(7, 278),
|
||||
(0, 275),
|
||||
(28, 278),
|
||||
(29, 283),
|
||||
(6, 290),
|
||||
)
|
||||
|
||||
strips = []
|
||||
pins = ((2, 291),
|
||||
(3, 290),
|
||||
(4, 283),
|
||||
(7, 278),
|
||||
(0, 275),
|
||||
(28, 278),
|
||||
(29, 283),
|
||||
(6, 290))
|
||||
sm = 0
|
||||
for pin, num_leds in pins:
|
||||
for pin, num_leds in STRIP_CONFIG:
|
||||
print(pin, num_leds)
|
||||
ws = WS2812B(num_leds, pin, sm, brightness=1.0) # 1.0 so fill() is visible
|
||||
strips.append(ws)
|
||||
sm += 1
|
||||
|
||||
# One rainbow double buffer per strip (num_leds can differ); no transfer buffer
|
||||
now = time.ticks_ms()
|
||||
rainbow_data = [make_rainbow_double(ws.num_leds, ws.brightness) for ws in strips]
|
||||
# Cumulative LEDs before each strip so rainbow lines up around the ring
|
||||
# Cumulative LED count before each strip; total ring size
|
||||
cumulative_leds = [0]
|
||||
for ws in strips[:-1]:
|
||||
cumulative_leds.append(cumulative_leds[-1] + ws.num_leds)
|
||||
# Global phase (bytes); each strip gets head = (phase + cumulative_leds * 3) % strip_len
|
||||
total_ring_leds = cumulative_leds[-1] + strips[-1].num_leds
|
||||
bytes_per_cycle = total_ring_leds * 3
|
||||
|
||||
# Per-strip rainbow buffers: each strip's segment of the ring (same phase, no shared-buffer DMA)
|
||||
now = time.ticks_ms()
|
||||
rainbow_data = [
|
||||
make_strip_rainbow(ws.num_leds, cumulative_leds[i], total_ring_leds, ws.brightness)
|
||||
for i, ws in enumerate(strips)
|
||||
]
|
||||
print(time.ticks_diff(time.ticks_ms(), now), "ms")
|
||||
|
||||
rainbow_head = 0
|
||||
step = 3
|
||||
|
||||
while True:
|
||||
now = time.ticks_ms()
|
||||
for i, (strip, (double_buf, strip_len)) in enumerate(zip(strips, rainbow_data)):
|
||||
head = (rainbow_head + cumulative_leds[i] * 3) % strip_len
|
||||
show_rainbow(strip, double_buf, strip_len, head)
|
||||
for i, (strip, (buf, strip_len_bytes)) in enumerate(zip(strips, rainbow_data)):
|
||||
# Same head for all: each strip's buffer is already offset by cumulative_leds[i]
|
||||
double_len_bytes = 2 * strip.num_leds * 3
|
||||
head = rainbow_head % double_len_bytes
|
||||
show_rainbow_segment(strip, buf, strip_len_bytes, head)
|
||||
rainbow_head = (rainbow_head + step) % bytes_per_cycle
|
||||
#print(time.ticks_diff(time.ticks_ms(), now), "ms")
|
||||
time.sleep_ms(10)
|
||||
|
||||
694
pico/test/test_espnow_receive.py
Normal file
694
pico/test/test_espnow_receive.py
Normal file
@@ -0,0 +1,694 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Test ESPNow receive functionality - runs on MicroPython device."""
|
||||
import json
|
||||
import os
|
||||
import utime
|
||||
from settings import Settings
|
||||
from presets import Presets
|
||||
from utils import convert_and_reorder_colors
|
||||
|
||||
|
||||
class MockESPNow:
|
||||
"""Mock ESPNow for testing that can send messages."""
|
||||
def __init__(self):
|
||||
self.messages = []
|
||||
self.active_state = False
|
||||
|
||||
def active(self, state):
|
||||
self.active_state = state
|
||||
|
||||
def any(self):
|
||||
"""Return True if there are messages."""
|
||||
return len(self.messages) > 0
|
||||
|
||||
def recv(self):
|
||||
"""Receive a message (removes it from queue)."""
|
||||
if self.messages:
|
||||
return self.messages.pop(0)
|
||||
return None, None
|
||||
|
||||
def send_message(self, host, msg_data):
|
||||
"""Send a message by adding it to the queue (testing helper)."""
|
||||
if isinstance(msg_data, dict):
|
||||
msg = json.dumps(msg_data)
|
||||
else:
|
||||
msg = msg_data
|
||||
self.messages.append((host, msg))
|
||||
|
||||
def clear(self):
|
||||
"""Clear all messages (testing helper)."""
|
||||
self.messages = []
|
||||
|
||||
|
||||
from machine import WDT
|
||||
|
||||
def get_wdt():
|
||||
"""Get a real WDT instance for tests."""
|
||||
return WDT(timeout=10000) # 10 second timeout for tests
|
||||
|
||||
|
||||
def run_main_loop_iterations(espnow, patterns, settings, wdt, max_iterations=10):
|
||||
"""Run main loop iterations until no messages or max reached."""
|
||||
iterations = 0
|
||||
results = []
|
||||
|
||||
while iterations < max_iterations:
|
||||
wdt.feed()
|
||||
patterns.tick()
|
||||
|
||||
if espnow.any():
|
||||
host, msg = espnow.recv()
|
||||
data = json.loads(msg)
|
||||
|
||||
if data.get("v") != "1":
|
||||
results.append(("version_rejected", data))
|
||||
continue
|
||||
|
||||
if "presets" in data:
|
||||
for name, preset_data in data["presets"].items():
|
||||
# Convert hex color strings to RGB tuples and reorder based on device color order
|
||||
if "colors" in preset_data:
|
||||
preset_data["colors"] = convert_and_reorder_colors(preset_data["colors"], settings)
|
||||
patterns.edit(name, preset_data)
|
||||
results.append(("presets_processed", list(data["presets"].keys())))
|
||||
|
||||
if settings.get("name") in data.get("select", {}):
|
||||
select_list = data["select"][settings.get("name")]
|
||||
# Select value is always a list: ["preset_name"] or ["preset_name", step]
|
||||
if select_list:
|
||||
preset_name = select_list[0]
|
||||
step = select_list[1] if len(select_list) > 1 else None
|
||||
if patterns.select(preset_name, step=step):
|
||||
results.append(("selected", preset_name))
|
||||
|
||||
iterations += 1
|
||||
|
||||
# Stop if no more messages
|
||||
if not espnow.any():
|
||||
break
|
||||
|
||||
return results
|
||||
|
||||
|
||||
def test_version_check():
|
||||
"""Test that messages with wrong version are rejected."""
|
||||
print("Test 1: Version check")
|
||||
settings = Settings()
|
||||
patterns = Presets(settings["led_pin"], settings["num_leds"])
|
||||
mock_espnow = MockESPNow()
|
||||
wdt = get_wdt()
|
||||
|
||||
# Send message with wrong version
|
||||
mock_espnow.send_message(b"\xaa\xaa\xaa\xaa\xaa\xaa", {"v": "2", "presets": {"test": {"pattern": "on"}}})
|
||||
results = run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
|
||||
assert len([r for r in results if r[0] == "version_rejected"]) > 0, "Should reject wrong version"
|
||||
assert "test" not in patterns.presets, "Preset should not be created"
|
||||
print(" ✓ Version check passed")
|
||||
|
||||
# Send message with correct version
|
||||
mock_espnow.clear()
|
||||
mock_espnow.send_message(b"\xaa\xaa\xaa\xaa\xaa\xaa", {"v": "1", "presets": {"test": {"pattern": "on"}}})
|
||||
results = run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
|
||||
assert len([r for r in results if r[0] == "presets_processed"]) > 0, "Should process correct version"
|
||||
assert "test" in patterns.presets, "Preset should be created"
|
||||
print(" ✓ Correct version accepted")
|
||||
|
||||
|
||||
def test_preset_creation():
|
||||
"""Test preset creation from ESPNow messages."""
|
||||
print("\nTest 2: Preset creation")
|
||||
settings = Settings()
|
||||
patterns = Presets(settings["led_pin"], settings["num_leds"])
|
||||
mock_espnow = MockESPNow()
|
||||
wdt = get_wdt()
|
||||
|
||||
msg = {
|
||||
"v": "1",
|
||||
"presets": {
|
||||
"test_blink": {
|
||||
"pattern": "blink",
|
||||
"colors": ["#FF0000", "#00FF00"],
|
||||
"delay": 200,
|
||||
"brightness": 128
|
||||
},
|
||||
"test_rainbow": {
|
||||
"pattern": "rainbow",
|
||||
"delay": 100,
|
||||
"n1": 2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mock_espnow.send_message(b"\xbb\xbb\xbb\xbb\xbb\xbb", msg)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
|
||||
assert "test_blink" in patterns.presets, "test_blink preset should exist"
|
||||
assert "test_rainbow" in patterns.presets, "test_rainbow preset should exist"
|
||||
|
||||
# Check preset values
|
||||
blink_preset = patterns.presets["test_blink"]
|
||||
assert blink_preset.pattern == "blink", "Pattern should be blink"
|
||||
assert blink_preset.delay == 200, "Delay should be 200"
|
||||
assert blink_preset.brightness == 128, "Brightness should be 128"
|
||||
|
||||
rainbow_preset = patterns.presets["test_rainbow"]
|
||||
assert rainbow_preset.pattern == "rainbow", "Pattern should be rainbow"
|
||||
assert rainbow_preset.n1 == 2, "n1 should be 2"
|
||||
|
||||
print(" ✓ Presets created correctly")
|
||||
|
||||
|
||||
def test_color_conversion():
|
||||
"""Test hex color string conversion and reordering."""
|
||||
print("\nTest 3: Color conversion")
|
||||
settings = Settings()
|
||||
settings["color_order"] = "rgb" # Default RGB order
|
||||
patterns = Presets(settings["led_pin"], settings["num_leds"])
|
||||
mock_espnow = MockESPNow()
|
||||
wdt = get_wdt()
|
||||
|
||||
msg = {
|
||||
"v": "1",
|
||||
"presets": {
|
||||
"test_colors": {
|
||||
"pattern": "on",
|
||||
"colors": ["#FF0000", "#00FF00", "#0000FF"] # Red, Green, Blue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mock_espnow.send_message(b"\xcc\xcc\xcc\xcc\xcc\xcc", msg)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
|
||||
preset = patterns.presets["test_colors"]
|
||||
assert len(preset.colors) == 3, "Should have 3 colors"
|
||||
assert preset.colors[0] == (255, 0, 0), "First color should be red (255,0,0)"
|
||||
assert preset.colors[1] == (0, 255, 0), "Second color should be green (0,255,0)"
|
||||
assert preset.colors[2] == (0, 0, 255), "Third color should be blue (0,0,255)"
|
||||
print(" ✓ Colors converted correctly (RGB order)")
|
||||
|
||||
# Test GRB order
|
||||
settings["color_order"] = "grb"
|
||||
patterns2 = Presets(settings["led_pin"], settings["num_leds"])
|
||||
mock_espnow2 = MockESPNow()
|
||||
msg2 = {
|
||||
"v": "1",
|
||||
"presets": {
|
||||
"test_grb": {
|
||||
"pattern": "on",
|
||||
"colors": ["#FF0000"] # Red in RGB, should become (0, 255, 0) in GRB
|
||||
}
|
||||
}
|
||||
}
|
||||
mock_espnow2.send_message(b"\xdd\xdd\xdd\xdd\xdd\xdd", msg2)
|
||||
wdt2 = get_wdt()
|
||||
run_main_loop_iterations(mock_espnow2, patterns2, settings, wdt2)
|
||||
preset2 = patterns2.presets["test_grb"]
|
||||
assert preset2.colors[0] == (0, 255, 0), "GRB: Red should become green (0,255,0)"
|
||||
print(" ✓ Colors reordered correctly (GRB order)")
|
||||
|
||||
|
||||
def test_preset_update():
|
||||
"""Test that editing an existing preset updates it."""
|
||||
print("\nTest 4: Preset update")
|
||||
settings = Settings()
|
||||
patterns = Presets(settings["led_pin"], settings["num_leds"])
|
||||
mock_espnow = MockESPNow()
|
||||
wdt = get_wdt()
|
||||
|
||||
# Create initial preset
|
||||
msg1 = {
|
||||
"v": "1",
|
||||
"presets": {
|
||||
"test_update": {
|
||||
"pattern": "blink",
|
||||
"delay": 100,
|
||||
"brightness": 64
|
||||
}
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\xee\xee\xee\xee\xee\xee", msg1)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
assert patterns.presets["test_update"].delay == 100, "Initial delay should be 100"
|
||||
|
||||
# Update preset
|
||||
mock_espnow.clear()
|
||||
msg2 = {
|
||||
"v": "1",
|
||||
"presets": {
|
||||
"test_update": {
|
||||
"pattern": "blink",
|
||||
"delay": 200,
|
||||
"brightness": 128
|
||||
}
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\xff\xff\xff\xff\xff\xff", msg2)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
assert patterns.presets["test_update"].delay == 200, "Updated delay should be 200"
|
||||
assert patterns.presets["test_update"].brightness == 128, "Updated brightness should be 128"
|
||||
print(" ✓ Preset updated correctly")
|
||||
|
||||
|
||||
def test_select():
|
||||
"""Test preset selection."""
|
||||
print("\nTest 5: Preset selection")
|
||||
settings = Settings()
|
||||
settings["name"] = "device1"
|
||||
patterns = Presets(settings["led_pin"], settings["num_leds"])
|
||||
mock_espnow = MockESPNow()
|
||||
wdt = get_wdt()
|
||||
|
||||
# Create presets
|
||||
msg1 = {
|
||||
"v": "1",
|
||||
"presets": {
|
||||
"preset1": {"pattern": "on", "colors": [(255, 0, 0)]},
|
||||
"preset2": {"pattern": "rainbow", "delay": 50}
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\x11\x11\x11\x11\x11\x11", msg1)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
|
||||
# Select preset
|
||||
mock_espnow.clear()
|
||||
msg2 = {
|
||||
"v": "1",
|
||||
"select": {
|
||||
"device1": ["preset1"],
|
||||
"device2": ["preset2"]
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\x22\x22\x22\x22\x22\x22", msg2)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
assert patterns.selected == "preset1", "Should select preset1"
|
||||
print(" ✓ Preset selected correctly")
|
||||
|
||||
|
||||
def test_full_message():
|
||||
"""Test a full message with presets and select."""
|
||||
print("\nTest 6: Full message (presets + select)")
|
||||
settings = Settings()
|
||||
settings["name"] = "test_device"
|
||||
patterns = Presets(settings["led_pin"], settings["num_leds"])
|
||||
mock_espnow = MockESPNow()
|
||||
wdt = get_wdt()
|
||||
|
||||
msg = {
|
||||
"v": "1",
|
||||
"presets": {
|
||||
"my_preset": {
|
||||
"pattern": "pulse",
|
||||
"colors": ["#FF0000", "#00FF00"],
|
||||
"delay": 150,
|
||||
"n1": 500,
|
||||
"n2": 200,
|
||||
"n3": 500
|
||||
}
|
||||
},
|
||||
"select": {
|
||||
"test_device": ["my_preset"],
|
||||
"other_device": ["other_preset"]
|
||||
}
|
||||
}
|
||||
|
||||
mock_espnow.send_message(b"\x44\x44\x44\x44\x44\x44", msg)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
|
||||
assert "my_preset" in patterns.presets, "Preset should be created"
|
||||
assert patterns.selected == "my_preset", "Preset should be selected"
|
||||
|
||||
preset = patterns.presets["my_preset"]
|
||||
assert preset.pattern == "pulse", "Pattern should be pulse"
|
||||
assert preset.delay == 150, "Delay should be 150"
|
||||
assert preset.n1 == 500, "n1 should be 500"
|
||||
print(" ✓ Full message processed correctly")
|
||||
|
||||
|
||||
def test_switch_presets():
|
||||
"""Test switching between different presets."""
|
||||
print("\nTest 7: Switch between presets")
|
||||
settings = Settings()
|
||||
settings["name"] = "switch_device"
|
||||
patterns = Presets(settings["led_pin"], settings["num_leds"])
|
||||
mock_espnow = MockESPNow()
|
||||
wdt = get_wdt()
|
||||
|
||||
# Create multiple presets
|
||||
msg1 = {
|
||||
"v": "1",
|
||||
"presets": {
|
||||
"preset_blink": {"pattern": "blink", "delay": 200, "colors": [(255, 0, 0)]},
|
||||
"preset_rainbow": {"pattern": "rainbow", "delay": 100, "n1": 2},
|
||||
"preset_pulse": {"pattern": "pulse", "delay": 150, "n1": 500, "n2": 200, "n3": 500}
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\x55\x55\x55\x55\x55\x55", msg1)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
|
||||
# Select and run first preset for 2 seconds
|
||||
mock_espnow.clear()
|
||||
msg2 = {
|
||||
"v": "1",
|
||||
"select": {
|
||||
"switch_device": ["preset_blink"]
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\x66\x66\x66\x66\x66\x66", msg2)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
assert patterns.selected == "preset_blink", "Should select preset_blink"
|
||||
print(" ✓ Selected preset_blink, running for 2 seconds...")
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
|
||||
wdt.feed()
|
||||
patterns.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
# Switch to second preset and run for 2 seconds
|
||||
mock_espnow.clear()
|
||||
msg3 = {
|
||||
"v": "1",
|
||||
"select": {
|
||||
"switch_device": ["preset_rainbow"]
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\x77\x77\x77\x77\x77\x77", msg3)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
assert patterns.selected == "preset_rainbow", "Should switch to preset_rainbow"
|
||||
print(" ✓ Switched to preset_rainbow, running for 2 seconds...")
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
|
||||
wdt.feed()
|
||||
patterns.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
# Switch to third preset and run for 2 seconds
|
||||
mock_espnow.clear()
|
||||
msg4 = {
|
||||
"v": "1",
|
||||
"select": {
|
||||
"switch_device": ["preset_pulse"]
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\x88\x88\x88\x88\x88\x88", msg4)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
assert patterns.selected == "preset_pulse", "Should switch to preset_pulse"
|
||||
print(" ✓ Switched to preset_pulse, running for 2 seconds...")
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
|
||||
wdt.feed()
|
||||
patterns.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
# Switch back to first preset and run for 2 seconds
|
||||
mock_espnow.clear()
|
||||
msg5 = {
|
||||
"v": "1",
|
||||
"select": {
|
||||
"switch_device": ["preset_blink"]
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\x99\x99\x99\x99\x99\x99", msg5)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
assert patterns.selected == "preset_blink", "Should switch back to preset_blink"
|
||||
print(" ✓ Switched back to preset_blink, running for 2 seconds...")
|
||||
start = utime.ticks_ms()
|
||||
while utime.ticks_diff(utime.ticks_ms(), start) < 2000:
|
||||
wdt.feed()
|
||||
patterns.tick()
|
||||
utime.sleep_ms(10)
|
||||
|
||||
print(" ✓ Preset switching works correctly")
|
||||
|
||||
|
||||
def test_beat_functionality():
|
||||
"""Test beat functionality - calling select() again with same preset restarts pattern."""
|
||||
print("\nTest 8: Beat functionality")
|
||||
settings = Settings()
|
||||
settings["name"] = "beat_device"
|
||||
patterns = Presets(settings["led_pin"], settings["num_leds"])
|
||||
mock_espnow = MockESPNow()
|
||||
wdt = get_wdt()
|
||||
|
||||
# Create presets with manual mode
|
||||
msg1 = {
|
||||
"v": "1",
|
||||
"presets": {
|
||||
"beat_rainbow": {"pattern": "rainbow", "delay": 100, "n1": 1, "auto": False},
|
||||
"beat_chase": {"pattern": "chase", "delay": 200, "n1": 4, "n2": 4, "n3": 2, "n4": 1, "auto": False},
|
||||
"beat_pulse": {"pattern": "pulse", "delay": 150, "n1": 300, "n2": 100, "n3": 300, "auto": False}
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\xaa\xaa\xaa\xaa\xaa\xaa", msg1)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
|
||||
# Test 1: Beat with rainbow (manual mode) - should advance one step per beat
|
||||
print(" Test 8.1: Beat with rainbow (manual mode)")
|
||||
patterns.step = 0
|
||||
mock_espnow.clear()
|
||||
msg2 = {
|
||||
"v": "1",
|
||||
"select": {
|
||||
"beat_device": ["beat_rainbow"]
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\xbb\xbb\xbb\xbb\xbb\xbb", msg2)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
assert patterns.selected == "beat_rainbow", "Should select beat_rainbow"
|
||||
initial_step = patterns.step
|
||||
|
||||
# First beat - advance one step
|
||||
mock_espnow.clear()
|
||||
mock_espnow.send_message(b"\xcc\xcc\xcc\xcc\xcc\xcc", msg2) # Same select message = beat
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=5)
|
||||
# tick() is already called in run_main_loop_iterations, so step should be incremented
|
||||
assert patterns.step == (initial_step + 1) % 256, f"Step should increment from {initial_step} to {(initial_step + 1) % 256}, got {patterns.step}"
|
||||
|
||||
# Second beat - advance another step
|
||||
mock_espnow.clear()
|
||||
mock_espnow.send_message(b"\xdd\xdd\xdd\xdd\xdd\xdd", msg2) # Beat again
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=5)
|
||||
assert patterns.step == (initial_step + 2) % 256, f"Step should increment to {(initial_step + 2) % 256}, got {patterns.step}"
|
||||
print(" ✓ Rainbow beat advances one step per beat")
|
||||
|
||||
# Test 2: Beat with chase (manual mode) - should advance one step per beat
|
||||
print(" Test 8.2: Beat with chase (manual mode)")
|
||||
patterns.step = 0
|
||||
mock_espnow.clear()
|
||||
msg3 = {
|
||||
"v": "1",
|
||||
"select": {
|
||||
"beat_device": ["beat_chase"]
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\xee\xee\xee\xee\xee\xee", msg3)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
assert patterns.selected == "beat_chase", "Should select beat_chase"
|
||||
initial_step = patterns.step
|
||||
|
||||
# First beat
|
||||
mock_espnow.clear()
|
||||
mock_espnow.send_message(b"\xff\xff\xff\xff\xff\xff", msg3) # Beat
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=5)
|
||||
# tick() is already called in run_main_loop_iterations
|
||||
assert patterns.step == initial_step + 1, f"Chase step should increment from {initial_step} to {initial_step + 1}, got {patterns.step}"
|
||||
|
||||
# Second beat
|
||||
mock_espnow.clear()
|
||||
mock_espnow.send_message(b"\x11\x11\x11\x11\x11\x11", msg3) # Beat again
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=5)
|
||||
assert patterns.step == initial_step + 2, f"Chase step should increment to {initial_step + 2}, got {patterns.step}"
|
||||
print(" ✓ Chase beat advances one step per beat")
|
||||
|
||||
# Test 3: Beat with pulse (manual mode) - should restart full cycle
|
||||
print(" Test 8.3: Beat with pulse (manual mode)")
|
||||
mock_espnow.clear()
|
||||
msg4 = {
|
||||
"v": "1",
|
||||
"select": {
|
||||
"beat_device": ["beat_pulse"]
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\x22\x22\x22\x22\x22\x22", msg4)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
assert patterns.selected == "beat_pulse", "Should select beat_pulse"
|
||||
assert patterns.generator is not None, "Generator should be active"
|
||||
|
||||
# First beat - should restart generator
|
||||
initial_generator = patterns.generator
|
||||
mock_espnow.clear()
|
||||
mock_espnow.send_message(b"\x33\x33\x33\x33\x33\x33", msg4) # Beat
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
assert patterns.generator is not None, "Generator should still be active after beat"
|
||||
assert patterns.generator != initial_generator, "Generator should be restarted (new instance)"
|
||||
print(" ✓ Pulse beat restarts generator for full cycle")
|
||||
|
||||
# Test 4: Multiple beats in sequence
|
||||
print(" Test 8.4: Multiple beats in sequence")
|
||||
patterns.step = 0
|
||||
mock_espnow.clear()
|
||||
mock_espnow.send_message(b"\x44\x44\x44\x44\x44\x44", msg2) # Select rainbow
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
|
||||
# Send 5 beats
|
||||
for i in range(5):
|
||||
mock_espnow.clear()
|
||||
mock_espnow.send_message(b"\x55\x55\x55\x55\x55\x55", msg2) # Beat
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=5)
|
||||
# tick() is already called in run_main_loop_iterations
|
||||
wdt.feed()
|
||||
utime.sleep_ms(50)
|
||||
|
||||
assert patterns.step == 5, f"After 5 beats, step should be 5, got {patterns.step}"
|
||||
print(" ✓ Multiple beats work correctly")
|
||||
|
||||
print(" ✓ Beat functionality works correctly")
|
||||
|
||||
|
||||
def test_select_with_step():
|
||||
"""Test selecting a preset with an explicit step value."""
|
||||
print("\nTest 9: Select with step value")
|
||||
settings = Settings()
|
||||
settings["name"] = "step_device"
|
||||
patterns = Presets(settings["led_pin"], settings["num_leds"])
|
||||
mock_espnow = MockESPNow()
|
||||
wdt = get_wdt()
|
||||
|
||||
# Create preset
|
||||
msg1 = {
|
||||
"v": "1",
|
||||
"presets": {
|
||||
"step_preset": {"pattern": "rainbow", "delay": 100, "n1": 1, "auto": False}
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\xaa\xaa\xaa\xaa\xaa\xaa", msg1)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt)
|
||||
|
||||
# Select with explicit step value
|
||||
mock_espnow.clear()
|
||||
msg2 = {
|
||||
"v": "1",
|
||||
"select": {
|
||||
"step_device": ["step_preset", 10]
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\xbb\xbb\xbb\xbb\xbb\xbb", msg2)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=2)
|
||||
# Ensure tick() is called after select() to advance the step
|
||||
patterns.tick()
|
||||
|
||||
assert patterns.selected == "step_preset", "Should select step_preset"
|
||||
# Step is set to 10, then tick() advances it, so it should be 11
|
||||
assert patterns.step == 11, f"Step should be set to 10 then advanced to 11 by tick(), got {patterns.step}"
|
||||
print(" ✓ Step value set correctly")
|
||||
|
||||
# Select without step (should use default behavior)
|
||||
mock_espnow.clear()
|
||||
msg3 = {
|
||||
"v": "1",
|
||||
"select": {
|
||||
"step_device": ["step_preset"]
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\xcc\xcc\xcc\xcc\xcc\xcc", msg3)
|
||||
initial_step = patterns.step # Should be 11
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=2)
|
||||
# Ensure tick() is called after select() to advance the step
|
||||
patterns.tick()
|
||||
# Since it's the same preset, step should not be reset, but tick() will advance it
|
||||
# So step should be initial_step + 1 (one tick call)
|
||||
assert patterns.step == initial_step + 1, f"Step should advance from {initial_step} to {initial_step + 1} (not reset), got {patterns.step}"
|
||||
print(" ✓ Step preserved when selecting same preset without step (tick advances it)")
|
||||
|
||||
# Select different preset with step
|
||||
patterns.edit("other_preset", {"p": "rainbow", "a": False})
|
||||
mock_espnow.clear()
|
||||
msg4 = {
|
||||
"v": "1",
|
||||
"select": {
|
||||
"step_device": ["other_preset", 5]
|
||||
}
|
||||
}
|
||||
mock_espnow.send_message(b"\xdd\xdd\xdd\xdd\xdd\xdd", msg4)
|
||||
run_main_loop_iterations(mock_espnow, patterns, settings, wdt, max_iterations=2)
|
||||
# Ensure tick() is called after select() to advance the step
|
||||
patterns.tick()
|
||||
|
||||
assert patterns.selected == "other_preset", "Should select other_preset"
|
||||
# Step is set to 5, then tick() advances it, so it should be 6
|
||||
assert patterns.step == 6, f"Step should be set to 5 then advanced to 6 by tick(), got {patterns.step}"
|
||||
print(" ✓ Step set correctly when switching presets")
|
||||
|
||||
|
||||
def test_preset_save_load():
|
||||
"""Test saving and loading presets to/from JSON."""
|
||||
print("\nTest 10: Preset save/load")
|
||||
settings = Settings()
|
||||
patterns = Presets(settings["led_pin"], settings["num_leds"])
|
||||
|
||||
patterns.edit("saved_preset", {
|
||||
"p": "blink",
|
||||
"d": 150,
|
||||
"b": 200,
|
||||
"c": [(1, 2, 3), (4, 5, 6)],
|
||||
"a": False,
|
||||
"n1": 1,
|
||||
"n2": 2,
|
||||
"n3": 3,
|
||||
"n4": 4,
|
||||
"n5": 5,
|
||||
"n6": 6,
|
||||
})
|
||||
assert patterns.save(), "Save should return True"
|
||||
|
||||
reloaded = Presets(settings["led_pin"], settings["num_leds"])
|
||||
assert reloaded.load(), "Load should return True"
|
||||
|
||||
preset = reloaded.presets.get("saved_preset")
|
||||
assert preset is not None, "Preset should be loaded"
|
||||
assert preset.p == "blink", "Pattern should be blink"
|
||||
assert preset.d == 150, "Delay should be 150"
|
||||
assert preset.b == 200, "Brightness should be 200"
|
||||
assert preset.c == [(1, 2, 3), (4, 5, 6)], "Colors should be restored as tuples"
|
||||
assert preset.a is False, "Auto should be False"
|
||||
assert (preset.n1, preset.n2, preset.n3, preset.n4, preset.n5, preset.n6) == (1, 2, 3, 4, 5, 6), "n1-n6 should match"
|
||||
try:
|
||||
os.remove("presets.json")
|
||||
except OSError:
|
||||
pass
|
||||
print(" ✓ Preset save/load works correctly")
|
||||
|
||||
|
||||
def main():
|
||||
"""Run all tests."""
|
||||
print("=" * 60)
|
||||
print("ESPNow Receive Functionality Tests")
|
||||
print("=" * 60)
|
||||
|
||||
try:
|
||||
test_version_check()
|
||||
test_preset_creation()
|
||||
test_color_conversion()
|
||||
test_preset_update()
|
||||
test_select()
|
||||
test_full_message()
|
||||
test_switch_presets()
|
||||
test_beat_functionality()
|
||||
test_select_with_step()
|
||||
test_preset_save_load()
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
print("All tests passed! ✓")
|
||||
print("=" * 60)
|
||||
except AssertionError as e:
|
||||
print("\n✗ Test failed:", e)
|
||||
raise
|
||||
except Exception as e:
|
||||
print("\n✗ Unexpected error:", e)
|
||||
raise
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user