diff --git a/test/patterns.py b/test/patterns.py index 5e02730..15872c2 100644 --- a/test/patterns.py +++ b/test/patterns.py @@ -1,45 +1,55 @@ #!/usr/bin/env python3 -import utime +import uasyncio as asyncio from machine import WDT from settings import Settings from patterns import Patterns -def run(): +async def main(): s = Settings() pin = s.get("led_pin", 10) num = s.get("num_leds", 30) p = Patterns(pin=pin, num_leds=num) - wdt = WDT(timeout=10000) + p.load() + print(p) + p.save() + # print(p) - # Baseline params - p.set_param("br", 64) - p.set_param("dl", 500) - p.set_param("cl", [(255, 0, 0), (0, 0, 255)]) - p.set_param("n1", 200) - p.set_param("n2", 200) - p.set_param("n3", 1) - p.set_param("n4", 1) - for name, fn in p.patterns.items(): - if fn is None: - continue - print(name) - p.set_param("pt", name) - - start = utime.ticks_ms() - while utime.ticks_diff(utime.ticks_ms(), start) < 2000: - p.tick() - wdt.feed() - utime.sleep_ms(10) + # wdt = WDT(timeout=10000) - p.set_param("pt", "off") - p.tick() - utime.sleep_ms(200) + # # Baseline params + # p.set_param("br", 64) + # p.set_param("dl", 500) + # p.set_param("cl", [(255, 0, 0), (0, 0, 255)]) + # p.set_param("n1", 200) + # p.set_param("n2", 200) + # p.set_param("n3", 1) + # p.set_param("n4", 1) + + # for name, fn in p.patterns.items(): + # if fn is None: + # continue + # print(name) + # p.set_param("pt", name) + # task = asyncio.create_task(p.run()) + # end = asyncio.get_event_loop().time() + 2.0 + # while asyncio.get_event_loop().time() < end: + # wdt.feed() + # await asyncio.sleep_ms(10) + # p.stopped = True + # await task + # p.stopped = False + + # p.set_param("pt", "off") + # task = asyncio.create_task(p.run()) + # await asyncio.sleep_ms(200) + # p.stopped = True + # await task if __name__ == "__main__": - run() + asyncio.run(main()) diff --git a/test/patterns/n_chase.py b/test/patterns/n_chase.py new file mode 100644 index 0000000..c45db0c --- /dev/null +++ b/test/patterns/n_chase.py @@ -0,0 +1,138 @@ +#!/usr/bin/env python3 +import uasyncio as asyncio +import utime +from machine import WDT +from settings import Settings +from patterns import Patterns + + +async def main(): + s = Settings() + pin = s.get("led_pin", 10) + num = s.get("num_leds", 30) + + p = Patterns(pin=pin, num_leds=num) + wdt = WDT(timeout=10000) + + # Test 1: Basic n_chase (n1=5, n2=5, n3=1, n4=1) + print("Test 1: Basic n_chase (n1=5, n2=5, n3=1, n4=1)") + p.set_param("br", 255) + p.set_param("dl", 200) + p.set_param("n1", 5) # 5 LEDs color0 + p.set_param("n2", 5) # 5 LEDs color1 + p.set_param("n3", 1) # Move 1 forward on even steps + p.set_param("n4", 1) # Move 1 forward on odd steps + p.set_param("cl", [(255, 0, 0), (0, 255, 0)]) # Red and Green + p.select("n_chase") + task = asyncio.create_task(p.run()) + start = utime.ticks_ms() + while utime.ticks_diff(utime.ticks_ms(), start) < 3000: + wdt.feed() + await asyncio.sleep_ms(10) + await p.stop() + await task + + # Test 2: Forward and backward (n3=2, n4=-1) + print("Test 2: Forward and backward (n3=2, n4=-1)") + p.stopped = False + p.set_param("n1", 3) + p.set_param("n2", 3) + p.set_param("n3", 2) # Move 2 forward on even steps + p.set_param("n4", -1) # Move 1 backward on odd steps + p.set_param("dl", 150) + p.set_param("cl", [(0, 0, 255), (255, 255, 0)]) # Blue and Yellow + p.select("n_chase") + task = asyncio.create_task(p.run()) + start = utime.ticks_ms() + while utime.ticks_diff(utime.ticks_ms(), start) < 3000: + wdt.feed() + await asyncio.sleep_ms(10) + await p.stop() + await task + + # Test 3: Large segments (n1=10, n2=5) + print("Test 3: Large segments (n1=10, n2=5, n3=3, n4=3)") + p.stopped = False + p.set_param("n1", 10) # 10 LEDs color0 + p.set_param("n2", 5) # 5 LEDs color1 + p.set_param("n3", 3) # Move 3 forward + p.set_param("n4", 3) # Move 3 forward + p.set_param("dl", 200) + p.set_param("cl", [(255, 128, 0), (128, 0, 255)]) # Orange and Purple + p.select("n_chase") + task = asyncio.create_task(p.run()) + start = utime.ticks_ms() + while utime.ticks_diff(utime.ticks_ms(), start) < 3000: + wdt.feed() + await asyncio.sleep_ms(10) + await p.stop() + await task + + # Test 4: Fast movement (n3=5, n4=5) + print("Test 4: Fast movement (n3=5, n4=5)") + p.stopped = False + p.set_param("n1", 4) + p.set_param("n2", 4) + p.set_param("n3", 5) # Move 5 forward + p.set_param("n4", 5) # Move 5 forward + p.set_param("dl", 100) + p.set_param("cl", [(255, 0, 255), (0, 255, 255)]) # Magenta and Cyan + p.select("n_chase") + task = asyncio.create_task(p.run()) + start = utime.ticks_ms() + while utime.ticks_diff(utime.ticks_ms(), start) < 2000: + wdt.feed() + await asyncio.sleep_ms(10) + await p.stop() + await task + + # Test 5: Backward movement (n3=-2, n4=-2) + print("Test 5: Backward movement (n3=-2, n4=-2)") + p.stopped = False + p.set_param("n1", 6) + p.set_param("n2", 4) + p.set_param("n3", -2) # Move 2 backward + p.set_param("n4", -2) # Move 2 backward + p.set_param("dl", 200) + p.set_param("cl", [(255, 255, 255), (0, 0, 0)]) # White and Black + p.select("n_chase") + task = asyncio.create_task(p.run()) + start = utime.ticks_ms() + while utime.ticks_diff(utime.ticks_ms(), start) < 3000: + wdt.feed() + await asyncio.sleep_ms(10) + await p.stop() + await task + + # Test 6: Alternating forward/backward (n3=3, n4=-2) + print("Test 6: Alternating forward/backward (n3=3, n4=-2)") + p.stopped = False + p.set_param("n1", 5) + p.set_param("n2", 5) + p.set_param("n3", 3) # Move 3 forward on even steps + p.set_param("n4", -2) # Move 2 backward on odd steps + p.set_param("dl", 250) + p.set_param("cl", [(255, 0, 0), (0, 255, 0)]) # Red and Green + p.select("n_chase") + task = asyncio.create_task(p.run()) + start = utime.ticks_ms() + while utime.ticks_diff(utime.ticks_ms(), start) < 4000: + wdt.feed() + await asyncio.sleep_ms(10) + await p.stop() + 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) + await p.stop() + await task + + +if __name__ == "__main__": + asyncio.run(main()) + + diff --git a/test/test_patterns_save_load.py b/test/test_patterns_save_load.py new file mode 100644 index 0000000..4afcd3b --- /dev/null +++ b/test/test_patterns_save_load.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python3 +""" +Test for saving and loading patterns +Run with: mpremote run test/test_patterns_save_load.py +""" + +import json +import uasyncio as asyncio +from settings import Settings +from patterns import Patterns + + +async def test_patterns_save_load(): + """Test saving and loading patterns""" + print("Testing patterns save and load functionality...") + + # Test 1: Initialize patterns and check initial state + print("\nTest 1: Initialize patterns") + s = Settings() + pin = s.get("led_pin", 10) + num_leds = s.get("num_leds", 30) + + p1 = Patterns(pin=pin, num_leds=num_leds) + print(f"Initial patterns count: {len(p1.patterns)}") + print(f"Available patterns: {list(p1.patterns.keys())}") + print(f"Selected pattern: {p1.selected}") + + # Test 2: Try to save patterns (will fail because patterns contain functions) + print("\nTest 2: Attempt to save patterns") + try: + result = p1.save() + if result: + print("✓ Patterns saved successfully") + else: + print("✗ Patterns save failed (expected - patterns contain functions)") + except Exception as e: + print(f"✗ Exception during save: {e}") + + # Test 3: Try to load patterns + print("\nTest 3: Attempt to load patterns") + try: + result = p1.load() + if result: + print("✓ Patterns loaded successfully") + print(f"Patterns after load: {list(p1.patterns.keys())}") + else: + print("✗ Patterns load failed") + except Exception as e: + print(f"✗ Exception during load: {e}") + + # Test 4: Test with empty patterns dict (simulating custom patterns) + print("\nTest 4: Test save/load with empty patterns dict") + p2 = Patterns(pin=pin, num_leds=num_leds) + # Store original patterns + original_patterns = p2.patterns.copy() + # Clear patterns to test save/load with empty dict + p2.patterns = {} + + try: + result = p2.save() + if result: + print("✓ Empty patterns dict saved successfully") + else: + print("✗ Failed to save empty patterns dict") + except Exception as e: + print(f"✗ Exception saving empty patterns: {e}") + + # Try to load + p3 = Patterns(pin=pin, num_leds=num_leds) + p3.patterns = {} # Start with empty + try: + result = p3.load() + if result: + print("✓ Patterns loaded successfully") + print(f"Patterns count after load: {len(p3.patterns)}") + else: + print("✗ Failed to load patterns") + except Exception as e: + print(f"✗ Exception loading patterns: {e}") + + # Restore original patterns + p2.patterns = original_patterns + p3.patterns = original_patterns + + # Test 5: Verify patterns object state + print("\nTest 5: Verify patterns object state") + print(f"Patterns object type: {type(p1)}") + print(f"Has save method: {hasattr(p1, 'save')}") + print(f"Has load method: {hasattr(p1, 'load')}") + print(f"PATTERNS_FILE: {p1.PATTERNS_FILE}") + + # Test 6: Test pattern selection persists + print("\nTest 6: Test pattern selection") + test_pattern = "rainbow" + if test_pattern in p1.patterns: + p1.select(test_pattern) + print(f"Selected pattern: {p1.selected}") + if p1.selected == test_pattern: + print("✓ Pattern selection works") + else: + print(f"✗ Pattern selection failed. Expected '{test_pattern}', got '{p1.selected}'") + else: + print(f"Pattern '{test_pattern}' not available") + + print("\n=== Patterns Save/Load test complete ===") + + +if __name__ == "__main__": + asyncio.run(test_patterns_save_load()) + diff --git a/test/test_save_load.py b/test/test_save_load.py new file mode 100644 index 0000000..2ebe493 --- /dev/null +++ b/test/test_save_load.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +""" +Test for saving and loading settings +Run with: mpremote run test/test_save_load.py +""" + +import json +import os +from settings import Settings +from patterns import Patterns + + +def test_save_load(): + """Test saving and loading settings""" + print("Testing save and load functionality...") + + # Test 1: Save settings + print("\nTest 1: Save settings") + settings1 = Settings() + + # Modify some settings + original_num_leds = settings1.get("num_leds", 50) + original_pattern = settings1.get("pattern", "off") + original_brightness = settings1.get("brightness", 127) + + settings1["num_leds"] = 100 + settings1["pattern"] = "rainbow" + settings1["brightness"] = 200 + settings1["delay"] = 150 + settings1["color1"] = "#ff0000" + settings1["color2"] = "#00ff00" + + print(f"Original num_leds: {original_num_leds}") + print(f"Setting num_leds to: {settings1['num_leds']}") + print(f"Setting pattern to: {settings1['pattern']}") + print(f"Setting brightness to: {settings1['brightness']}") + + # Save settings + settings1.save() + print("Settings saved") + + # Test 2: Load settings + print("\nTest 2: Load settings") + settings2 = Settings() + + # Verify loaded values + print(f"Loaded num_leds: {settings2['num_leds']}") + print(f"Loaded pattern: {settings2['pattern']}") + print(f"Loaded brightness: {settings2['brightness']}") + print(f"Loaded delay: {settings2.get('delay', 'not set')}") + print(f"Loaded color1: {settings2.get('color1', 'not set')}") + print(f"Loaded color2: {settings2.get('color2', 'not set')}") + + # Verify values match + if settings2["num_leds"] == 100: + print("✓ num_leds saved and loaded correctly") + else: + print(f"✗ num_leds mismatch! Expected 100, got {settings2['num_leds']}") + + if settings2["pattern"] == "rainbow": + print("✓ pattern saved and loaded correctly") + else: + print(f"✗ pattern mismatch! Expected 'rainbow', got '{settings2['pattern']}'") + + if settings2["brightness"] == 200: + print("✓ brightness saved and loaded correctly") + else: + print(f"✗ brightness mismatch! Expected 200, got {settings2['brightness']}") + + # Test 3: Test with patterns + print("\nTest 3: Test pattern persistence") + pin = settings2.get("led_pin", 10) + num_leds = settings2["num_leds"] + + patterns = Patterns(pin=pin, num_leds=num_leds, selected=settings2["pattern"]) + patterns.set_brightness(settings2["brightness"]) + patterns.set_delay(settings2["delay"]) + + print(f"Pattern selected: {patterns.selected}") + print(f"Pattern brightness: {patterns.brightness}") + print(f"Pattern delay: {patterns.delay}") + + if patterns.selected == settings2["pattern"]: + print("✓ Pattern selection persisted") + else: + print(f"✗ Pattern mismatch! Expected '{settings2['pattern']}', got '{patterns.selected}'") + + # Test 4: Restore original settings + print("\nTest 4: Restore original settings") + settings3 = Settings() + settings3["num_leds"] = original_num_leds + settings3["pattern"] = original_pattern + settings3["brightness"] = original_brightness + settings3.save() + print(f"Restored num_leds to: {original_num_leds}") + print(f"Restored pattern to: {original_pattern}") + print(f"Restored brightness to: {original_brightness}") + + # Verify restoration + settings4 = Settings() + if settings4["num_leds"] == original_num_leds: + print("✓ Settings restored correctly") + else: + print(f"✗ Restoration failed! Expected {original_num_leds}, got {settings4['num_leds']}") + + print("\n=== Save/Load test complete ===") + + +if __name__ == "__main__": + test_save_load() +