Add automated test stand support and CI pipeline

- teststand.py: Test stand detection (checks /teststand_mode file) and
  sensor helpers for phototransistor, break-beam, and reflectance slide
- All test_hw_*.py: Skip wait_for_button() in teststand mode, use
  automated sensor verification where available (LED, servo, reflectance)
- run_all_hw_tests.py: Master runner that executes all test modules and
  outputs JSON results for CI parsing
- ci_hardware_test.py: Host-side script that detects Pico, syncs code,
  enables teststand mode, runs tests, and reports pass/fail
- hardware-test.yml: GitHub Actions workflow for self-hosted runner
  (hardware tests) and ubuntu (unit tests)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: bradamiller

.github/workflows/hardware-test.yml

@@ -0,0 +1,53 @@
+name: Hardware Integration Tests
+
+on:
+  push:
+    paths:
+      - 'XRPLib/**'
+      - 'tests/hardware/**'
+  pull_request:
+    paths:
+      - 'XRPLib/**'
+      - 'tests/hardware/**'
+  workflow_dispatch:  # Allow manual trigger
+
+jobs:
+  hardware-tests:
+    name: Run XRP Hardware Tests
+    runs-on: self-hosted-xrp-teststand  # Self-hosted runner with XRP test stand
+    timeout-minutes: 10
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install mpremote
+        run: pip install mpremote
+
+      - name: Run hardware tests
+        run: python scripts/ci_hardware_test.py
+
+  unit-tests:
+    name: Run Unit Tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install pytest
+        run: pip install pytest
+
+      - name: Run unit tests
+        run: pytest tests/unit/ -v

scripts/ci_hardware_test.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+CI host-side script for running hardware tests on an XRP test stand.
+
+This script runs on the CI host machine (not on the Pico). It:
+1. Detects the Pico's serial port
+2. Syncs the XRPLib code to the Pico
+3. Creates the /teststand_mode flag file
+4. Uploads and runs the hardware test suite
+5. Parses results and returns appropriate exit code
+
+Prerequisites:
+    pip install mpremote
+
+Usage:
+    python scripts/ci_hardware_test.py
+"""
+import subprocess
+import sys
+import json
+import re
+import os
+
+
+def run_cmd(args, check=True, capture=True):
+    """Run a command and return its output."""
+    print(f"  > {' '.join(args)}")
+    result = subprocess.run(
+        args,
+        capture_output=capture,
+        text=True,
+        timeout=300,  # 5 minute timeout
+    )
+    if check and result.returncode != 0:
+        print(f"  STDERR: {result.stderr}")
+        raise RuntimeError(f"Command failed: {' '.join(args)}")
+    return result
+
+
+def detect_pico():
+    """Verify mpremote can see a connected Pico."""
+    result = run_cmd(["mpremote", "connect", "list"])
+    if result.stdout.strip():
+        print(f"  Detected devices:\n{result.stdout}")
+        return True
+    else:
+        print("  No Pico detected!")
+        return False
+
+
+def sync_xrplib():
+    """Copy XRPLib source files to the Pico's lib directory."""
+    print("\nSyncing XRPLib to Pico...")
+    # Create lib/XRPLib directory on Pico
+    run_cmd(["mpremote", "mkdir", ":lib"], check=False)
+    run_cmd(["mpremote", "mkdir", ":lib/XRPLib"], check=False)
+
+    # Copy all .py files from XRPLib/
+    xrplib_dir = os.path.join(os.path.dirname(__file__), "..", "XRPLib")
+    for filename in os.listdir(xrplib_dir):
+        if filename.endswith(".py"):
+            src = os.path.join(xrplib_dir, filename)
+            dst = f":lib/XRPLib/{filename}"
+            run_cmd(["mpremote", "cp", src, dst])
+    print("  XRPLib synced.")
+
+
+def sync_test_files():
+    """Copy hardware test files to the Pico."""
+    print("\nSyncing test files to Pico...")
+    run_cmd(["mpremote", "mkdir", ":tests"], check=False)
+    run_cmd(["mpremote", "mkdir", ":tests/hardware"], check=False)
+
+    test_dir = os.path.join(os.path.dirname(__file__), "..", "tests", "hardware")
+    for filename in os.listdir(test_dir):
+        if filename.endswith(".py"):
+            src = os.path.join(test_dir, filename)
+            dst = f":tests/hardware/{filename}"
+            run_cmd(["mpremote", "cp", src, dst])
+    print("  Test files synced.")
+
+
+def ensure_teststand_mode():
+    """Create the /teststand_mode flag file on the Pico."""
+    print("\nSetting teststand mode...")
+    run_cmd(["mpremote", "exec", "f = open('/teststand_mode', 'w'); f.close()"])
+    print("  Teststand mode enabled.")
+
+
+def run_tests():
+    """Run the hardware test suite and capture output."""
+    print("\nRunning hardware tests...")
+    print("-" * 50)
+
+    result = run_cmd(
+        ["mpremote", "run", "tests/hardware/run_all_hw_tests.py"],
+        check=False,
+    )
+
+    print(result.stdout)
+    if result.stderr:
+        print(f"STDERR: {result.stderr}")
+
+    return result
+
+
+def parse_results(output):
+    """Parse the JSON results line from test output."""
+    for line in output.split("\n"):
+        if line.startswith("__RESULTS_JSON__:"):
+            json_str = line[len("__RESULTS_JSON__:"):]
+            return json.loads(json_str)
+    return None
+
+
+def main():
+    print("XRP Hardware Test CI Runner")
+    print("=" * 50)
+
+    # Step 1: Detect Pico
+    print("\nDetecting Pico...")
+    if not detect_pico():
+        print("\nFAIL: No Pico W detected. Check USB connection.")
+        sys.exit(1)
+
+    # Step 2: Sync code
+    sync_xrplib()
+    sync_test_files()
+
+    # Step 3: Enable teststand mode
+    ensure_teststand_mode()
+
+    # Step 4: Run tests
+    result = run_tests()
+
+    # Step 5: Parse and report
+    print("\n" + "=" * 50)
+    results = parse_results(result.stdout)
+
+    if results is None:
+        print("FAIL: Could not parse test results from output.")
+        sys.exit(1)
+
+    total = results["total_passed"] + results["total_failed"]
+    print(f"Final: {results['total_passed']}/{total} tests passed")
+
+    if results["total_failed"] > 0:
+        print(f"\n{results['total_failed']} test(s) FAILED:")
+        for mod in results["modules"]:
+            if mod["failed"] > 0 or mod["error"]:
+                print(f"  - {mod['name']}: {mod['failed']} failed")
+                if mod["error"]:
+                    print(f"    Error: {mod['error']}")
+        sys.exit(1)
+    else:
+        print("\nAll tests PASSED!")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

tests/hardware/run_all_hw_tests.py

@@ -0,0 +1,106 @@
+"""
+Master test runner for all hardware integration tests.
+Runs each test module sequentially and outputs a JSON summary.
+
+Usage:
+    mpremote run tests/hardware/run_all_hw_tests.py
+
+In teststand mode (file /teststand_mode exists on Pico), all tests
+run without manual intervention.
+"""
+import sys
+import time
+import json
+
+# Test modules to run, in order
+TEST_MODULES = [
+    ("Board", "test_hw_board"),
+    ("Motors", "test_hw_motors"),
+    ("Encoders", "test_hw_encoders"),
+    ("Drivetrain", "test_hw_drivetrain"),
+    ("Rangefinder", "test_hw_rangefinder"),
+    ("Reflectance", "test_hw_reflectance"),
+    ("IMU", "test_hw_imu"),
+    ("Servo", "test_hw_servo"),
+    ("Timing", "test_hw_timing"),
+]
+
+results = {
+    "total_passed": 0,
+    "total_failed": 0,
+    "modules": [],
+}
+
+
+def run_module(name, module_name):
+    """
+    Run a test module by importing it. Each module prints its own
+    PASS/FAIL lines and sets module-level `passed` and `failed` counters.
+    """
+    print()
+    print(f"{'='*50}")
+    print(f"Running: {name}")
+    print(f"{'='*50}")
+
+    module_result = {
+        "name": name,
+        "module": module_name,
+        "passed": 0,
+        "failed": 0,
+        "error": None,
+    }
+
+    try:
+        # Each test module runs its tests on import (top-level code)
+        mod = __import__(module_name)
+        module_result["passed"] = getattr(mod, "passed", 0)
+        module_result["failed"] = getattr(mod, "failed", 0)
+    except Exception as e:
+        module_result["error"] = str(e)
+        module_result["failed"] = 1
+        print(f"  ERROR: {e}")
+
+    results["total_passed"] += module_result["passed"]
+    results["total_failed"] += module_result["failed"]
+    results["modules"].append(module_result)
+
+    return module_result["failed"] == 0 and module_result["error"] is None
+
+
+# Check teststand mode
+try:
+    from teststand import is_teststand
+    mode = "TESTSTAND" if is_teststand() else "MANUAL"
+except ImportError:
+    mode = "MANUAL"
+
+print(f"XRP Hardware Test Runner — Mode: {mode}")
+print(f"Started at: {time.time()}")
+
+all_passed = True
+for name, module_name in TEST_MODULES:
+    if not run_module(name, module_name):
+        all_passed = False
+
+# Print summary
+print()
+print("=" * 50)
+print("SUMMARY")
+print("=" * 50)
+for mod in results["modules"]:
+    status = "PASS" if mod["failed"] == 0 and mod["error"] is None else "FAIL"
+    detail = f'{mod["passed"]} passed, {mod["failed"]} failed'
+    if mod["error"]:
+        detail += f' (ERROR: {mod["error"]})'
+    print(f"  [{status}] {mod['name']}: {detail}")
+
+print()
+print(f"Total: {results['total_passed']} passed, {results['total_failed']} failed")
+
+# Output machine-readable JSON on a tagged line for CI parsing
+print()
+print(f"__RESULTS_JSON__:{json.dumps(results)}")
+
+# Exit with appropriate code
+if not all_passed:
+    sys.exit(1)