add neopixel hw_test, relax time requirements on 800ms integration time.

Author: FoamyGuy

hw_tests/01_mode.py

@@ -80,7 +80,7 @@ def measure_update_rate(sensor, i2c_dev, timeout_s):
     raw2 = read_raw_lux(sensor)
     print(f"Raw after change: 0x{raw2:04X}")
     print(f"Update latency: {manual_time * 1000:.0f} ms")
-    test("Manual ~800ms cycle", 0.4 <= manual_time <= 1.5)
+    test("Manual ~800ms cycle", 0.2 <= manual_time <= 1.5)
 
     # --- MANUAL_CONTINUOUS (CONT=1) + 100ms: fast ---
     print("\n--- Manual continuous + 100ms (expect ~100ms) ---")

hw_tests/03_integration_time.py

@@ -101,9 +101,9 @@ def measure_update_rate(sensor, i2c_dev, int_time, settle_s, timeout_s):
 
     # --- 800ms (3 runs, median) ---
     print("\n--- 800ms integration ---")
-    t_slow = measure_update_rate(sensor, sensor, IntegrationTime.MS_400, 1.0, 2.0)
+    t_slow = measure_update_rate(sensor, sensor, IntegrationTime.MS_800, 1.0, 2.0)
     print(f"Median update time: {t_slow * 1000:.0f} ms")
-    test("800ms: 400-1500ms", 0.4 <= t_slow <= 1.5)
+    test("800ms: 200-1500ms", 0.2 <= t_slow <= 1.5)
 
     # --- Ordering is the key test ---
     print("\n--- Timing order ---")

hw_tests/06_neopixel.py

@@ -0,0 +1,233 @@
+# SPDX-FileCopyrightText: 2026 Tim Cocks for Adafruit Industries
+# SPDX-License-Identifier: MIT
+
+"""
+Hardware test: Drive an 8-pixel NeoPixel strip and verify the MAX44009
+responds with corresponding lux changes, including threshold interrupts.
+
+Wiring:
+    NeoPixel strip (8 pixels) data -> board.D9
+    MAX44009 INT pin               -> board.D10 (open-drain, external pull-up)
+
+The sensor should face the NeoPixels so changing pixel brightness
+directly changes the measured lux.
+"""
+
+import time
+
+import board
+import busio
+import digitalio
+import neopixel
+
+import adafruit_max44009
+from adafruit_max44009 import Mode
+
+NEOPIXEL_PIN = board.D9
+NUM_PIXELS = 8
+INT_PIN = board.D10
+
+# Time to allow the sensor to integrate a new light level before reading.
+# Default auto mode runs an 800ms cycle; allow a little margin.
+SETTLE = 1.0
+
+passed = 0
+failed = 0
+
+
+def test(name, condition):
+    global passed, failed
+    if condition:
+        print(f"PASS: {name}")
+        passed += 1
+    else:
+        print(f"FAIL: {name}")
+        failed += 1
+
+
+def set_pixels(pixels, level):
+    """Fill all pixels with a white level (0-255) and show."""
+    pixels.fill((level, level, level))
+    pixels.show()
+
+
+def read_stable_lux(sensor, samples=2):
+    """Read lux a few times, return the last sample."""
+    value = 0.0
+    for _ in range(samples):
+        time.sleep(SETTLE)
+        value = sensor.lux
+    return value
+
+
+pixels = None
+int_pin = None
+
+try:
+    i2c = busio.I2C(board.SCL, board.SDA)
+    sensor = adafruit_max44009.MAX44009(i2c)
+    test("Sensor found", True)
+
+    pixels = neopixel.NeoPixel(NEOPIXEL_PIN, NUM_PIXELS, brightness=1.0, auto_write=False)
+    set_pixels(pixels, 0)
+
+    int_pin = digitalio.DigitalInOut(INT_PIN)
+    int_pin.direction = digitalio.Direction.INPUT
+    int_pin.pull = digitalio.Pull.UP
+
+    # Use continuous auto mode for faster, clean readings.
+    sensor.mode = Mode.CONTINUOUS
+
+    print("\n=== MAX44009 NeoPixel Light Level Test ===\n")
+
+    # ------------------------------------------------------------------
+    # Part 1: brighter pixels -> higher lux
+    # ------------------------------------------------------------------
+    print("--- Brightness sweep ---")
+
+    set_pixels(pixels, 0)
+    lux_off = read_stable_lux(sensor)
+    print(f"Pixels OFF   (0)  -> {lux_off} lux")
+
+    set_pixels(pixels, 20)
+    lux_dim = read_stable_lux(sensor)
+    print(f"Pixels DIM   (20) -> {lux_dim} lux")
+
+    set_pixels(pixels, 100)
+    lux_mid = read_stable_lux(sensor)
+    print(f"Pixels MID   (100)-> {lux_mid} lux")
+
+    set_pixels(pixels, 255)
+    lux_bright = read_stable_lux(sensor)
+    print(f"Pixels FULL  (255)-> {lux_bright} lux")
+
+    # Valid readings
+    test("lux_off valid", lux_off == lux_off)
+    test("lux_dim valid", lux_dim == lux_dim)
+    test("lux_mid valid", lux_mid == lux_mid)
+    test("lux_bright valid", lux_bright == lux_bright)
+
+    # Monotonic increase with brightness. Allow a small absolute slack
+    # so sensor quantization at very low levels doesn't cause flaps.
+    slack = 0.5
+    test("dim > off", lux_dim > lux_off + slack)
+    test("mid > dim", lux_mid > lux_dim + slack)
+    test("bright > mid", lux_bright > lux_mid + slack)
+    test("bright >> off", lux_bright > lux_off + 5.0)
+
+    # ------------------------------------------------------------------
+    # Part 2: upper-threshold interrupt fires when light rises
+    # ------------------------------------------------------------------
+    print("\n--- Upper threshold interrupt ---")
+
+    # Park below threshold, pick an upper threshold between dim and bright.
+    set_pixels(pixels, 20)
+    time.sleep(SETTLE)
+    lux_low = sensor.lux
+    set_pixels(pixels, 255)
+    time.sleep(SETTLE)
+    lux_high = sensor.lux
+    print(f"Low level: {lux_low}  High level: {lux_high}")
+
+    upper = (lux_low + lux_high) / 2.0
+    if upper <= lux_low:
+        upper = lux_low * 2.0 + 1.0
+
+    # Return to low, prepare interrupt.
+    set_pixels(pixels, 20)
+    time.sleep(SETTLE)
+
+    sensor.interrupt_enabled = False
+    sensor.lower_threshold = 0.0
+    sensor.upper_threshold = upper
+    sensor.threshold_timer = 0
+    _ = sensor.interrupt_status  # clear pending
+    sensor.interrupt_enabled = True
+    time.sleep(SETTLE)
+
+    print(f"Upper threshold set to ~{sensor.upper_threshold} lux")
+    pin_val = int_pin.value
+    print(f"INT pin (below upper): {'HIGH' if pin_val else 'LOW'}")
+    test("INT HIGH when lux below upper threshold", pin_val == True)
+    test("Status clear below threshold", sensor.interrupt_status == False)
+
+    # Drive light above the upper threshold.
+    set_pixels(pixels, 255)
+    # Allow one full measurement cycle after change.
+    time.sleep(SETTLE + 0.5)
+
+    pin_val = int_pin.value
+    print(f"INT pin (above upper): {'HIGH' if pin_val else 'LOW'}")
+    test("INT LOW when lux above upper threshold", pin_val == False)
+    test("Status set above upper threshold", sensor.interrupt_status == True)
+
+    # After reading status the pin should release back to HIGH.
+    time.sleep(0.05)
+    test("INT returns HIGH after status read", int_pin.value == True)
+
+    # ------------------------------------------------------------------
+    # Part 3: lower-threshold interrupt fires when light drops
+    # ------------------------------------------------------------------
+    print("\n--- Lower threshold interrupt ---")
+
+    # Start bright, upper out of the way, lower between dim and bright.
+    set_pixels(pixels, 255)
+    time.sleep(SETTLE)
+
+    lower = (lux_low + lux_high) / 2.0
+    if lower <= lux_low:
+        lower = lux_low + 1.0
+
+    sensor.interrupt_enabled = False
+    sensor.upper_threshold = 188000.0  # effectively disabled
+    sensor.lower_threshold = lower
+    sensor.threshold_timer = 0
+    _ = sensor.interrupt_status  # clear pending
+    sensor.interrupt_enabled = True
+    time.sleep(SETTLE)
+
+    print(f"Lower threshold set to ~{sensor.lower_threshold} lux")
+    pin_val = int_pin.value
+    print(f"INT pin (above lower): {'HIGH' if pin_val else 'LOW'}")
+    test("INT HIGH when lux above lower threshold", pin_val == True)
+    test("Status clear above lower threshold", sensor.interrupt_status == False)
+
+    # Drop light below the lower threshold.
+    set_pixels(pixels, 0)
+    time.sleep(SETTLE + 0.5)
+
+    pin_val = int_pin.value
+    print(f"INT pin (below lower): {'HIGH' if pin_val else 'LOW'}")
+    test("INT LOW when lux below lower threshold", pin_val == False)
+    test("Status set below lower threshold", sensor.interrupt_status == True)
+
+    # ------------------------------------------------------------------
+    # Cleanup
+    # ------------------------------------------------------------------
+    sensor.interrupt_enabled = False
+    sensor.upper_threshold = 188000.0
+    sensor.lower_threshold = 0.0
+    sensor.threshold_timer = 255
+
+    print()
+    print(f"=== Summary: {passed} passed, {failed} failed ===")
+    print("ALL TESTS PASSED" if passed > 0 and failed == 0 else "SOME TESTS FAILED")
+
+except Exception as e:
+    print(f"FAIL: Unhandled exception: {e}")
+
+finally:
+    try:
+        if pixels is not None:
+            pixels.fill((0, 0, 0))
+            pixels.show()
+            pixels.deinit()
+    except Exception:
+        pass
+    try:
+        if int_pin is not None:
+            int_pin.deinit()
+    except Exception:
+        pass
+
+print("~~END~~")