robopark 3.2.0 → 3.3.0

package/vision/motor_server.py

@@ -1,52 +1,52 @@
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.responses import JSONResponse
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
+from pydantic import BaseModel
 from typing import Optional, List
 import time
 import threading
-import json
-import os
-import hmac
-
-try:
-    import lgpio
-except ImportError:
-    lgpio = None
-
-app = FastAPI(title="RoboPark Motor Control API", version="1.2.0")
-
-ROBOT_NAME = os.getenv("ROBOPARK_ROBOT_NAME", "robot").strip() or "robot"
-
-MOTOR_API_TOKEN = (
-    os.getenv("ROBOPARK_MOTOR_TOKEN", "").strip()
-    or os.getenv("ROBOPARK_MESH_TOKEN", "").strip()
-)
-
-
-@app.middleware("http")
-async def require_motor_token(request: Request, call_next):
-    """Keep actuation private even if an operator accidentally changes the bind host."""
-    if MOTOR_API_TOKEN and request.url.path not in {"/", "/status"}:
-        supplied = request.headers.get("x-robopark-motor-token", "").strip()
-        if not supplied or not hmac.compare_digest(supplied, MOTOR_API_TOKEN):
-            return JSONResponse(status_code=401, content={"detail": "Invalid or missing motor token"})
-    return await call_next(request)
-
-# The dashboard never calls this service directly; robot-local services do.
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["http://127.0.0.1", "http://localhost"],
-    allow_credentials=False,
-    allow_methods=["GET", "POST", "PUT", "DELETE"],
-    allow_headers=["content-type", "x-robopark-motor-token"],
-)
+import json
+import os
+import hmac
+
+try:
+    import lgpio
+except ImportError:
+    lgpio = None
+
+app = FastAPI(title="RoboPark Motor Control API", version="1.2.0")
+
+ROBOT_NAME = os.getenv("ROBOPARK_ROBOT_NAME", "robot").strip() or "robot"
+
+MOTOR_API_TOKEN = (
+    os.getenv("ROBOPARK_MOTOR_TOKEN", "").strip()
+    or os.getenv("ROBOPARK_MESH_TOKEN", "").strip()
+)
+
+
+@app.middleware("http")
+async def require_motor_token(request: Request, call_next):
+    """Keep actuation private even if an operator accidentally changes the bind host."""
+    if MOTOR_API_TOKEN and request.url.path not in {"/", "/status"}:
+        supplied = request.headers.get("x-robopark-motor-token", "").strip()
+        if not supplied or not hmac.compare_digest(supplied, MOTOR_API_TOKEN):
+            return JSONResponse(status_code=401, content={"detail": "Invalid or missing motor token"})
+    return await call_next(request)
+
+# The dashboard never calls this service directly; robot-local services do.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://127.0.0.1", "http://localhost"],
+    allow_credentials=False,
+    allow_methods=["GET", "POST", "PUT", "DELETE"],
+    allow_headers=["content-type", "x-robopark-motor-token"],
+)
 
 # Storage file
-MOTORS_FILE = os.getenv(
-    "ROBOPARK_MOTORS_FILE",
-    os.path.expanduser("~/.robopark/motors.json"),
-)
+MOTORS_FILE = os.getenv(
+    "ROBOPARK_MOTORS_FILE",
+    os.path.expanduser("~/.robopark/motors.json"),
+)
 
 # In-memory storage
 motors = {}
@@ -54,11 +54,11 @@ active_motor = None
 remaining_seconds = 0
 last_action = "None"
 motor_thread = None
-stop_flag = False
-motor_error = None
-gpio_handle = None
-claimed_pins = set()
-motor_lock = threading.Lock()
+stop_flag = False
+motor_error = None
+gpio_handle = None
+claimed_pins = set()
+motor_lock = threading.Lock()
 
 # Load motors from file on startup
 def load_motors():
@@ -66,16 +66,16 @@ def load_motors():
     global motors
     try:
         if os.path.exists(MOTORS_FILE):
-            with open(MOTORS_FILE, 'r') as f:
-                motors = json.load(f)
-            motors = {
-                str(name): ({"name": str(name), "gpio": int(value), "active_high": True}
-                            if not isinstance(value, dict) else {
-                                "name": str(value.get("name") or name), "gpio": int(value["gpio"]),
-                                "active_high": bool(value.get("active_high", True)),
-                            })
-                for name, value in motors.items()
-            }
+            with open(MOTORS_FILE, 'r') as f:
+                motors = json.load(f)
+            motors = {
+                str(name): ({"name": str(name), "gpio": int(value), "active_high": True}
+                            if not isinstance(value, dict) else {
+                                "name": str(value.get("name") or name), "gpio": int(value["gpio"]),
+                                "active_high": bool(value.get("active_high", True)),
+                            })
+                for name, value in motors.items()
+            }
             print(f"[LOAD] Loaded {len(motors)} motors from {MOTORS_FILE}")
             for name, gpio in motors.items():
                 print(f"  - {name}: GPIO {gpio}")
@@ -85,16 +85,16 @@ def load_motors():
         print(f"[ERROR] Failed to load motors: {e}")
         motors = {}
 
-def save_motors():
+def save_motors():
     """Save motors to motors.json file"""
     try:
-        os.makedirs(os.path.dirname(os.path.abspath(MOTORS_FILE)), exist_ok=True)
-        temporary = f"{MOTORS_FILE}.tmp"
-        with open(temporary, 'w') as f:
-            json.dump(motors, f, indent=2)
-            f.flush()
-            os.fsync(f.fileno())
-        os.replace(temporary, MOTORS_FILE)
+        os.makedirs(os.path.dirname(os.path.abspath(MOTORS_FILE)), exist_ok=True)
+        temporary = f"{MOTORS_FILE}.tmp"
+        with open(temporary, 'w') as f:
+            json.dump(motors, f, indent=2)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(temporary, MOTORS_FILE)
         print(f"[SAVE] Motors saved to {MOTORS_FILE}")
     except Exception as e:
         print(f"[ERROR] Failed to save motors: {e}")
@@ -103,101 +103,101 @@ def save_motors():
 load_motors()
 
 # Request Models
-class MotorConfig(BaseModel):
-    name: str
-    gpio: int
-    active_high: bool = True
+class MotorConfig(BaseModel):
+    name: str
+    gpio: int
+    active_high: bool = True
 
-class UpdateMotorConfig(BaseModel):
-    name: str
-    gpio: int
-    active_high: bool = True
+class UpdateMotorConfig(BaseModel):
+    name: str
+    gpio: int
+    active_high: bool = True
 
-class TriggerMotor(BaseModel):
-    motor_name: str
-    seconds: float = 1.0
+class TriggerMotor(BaseModel):
+    motor_name: str
+    seconds: float = 1.0
 
 class StopMotors(BaseModel):
     motor_name: Optional[str] = None
 
-class TestConfig(BaseModel):
-    seconds_on: float = 0.3
-    seconds_pause: float = 0.2
+class TestConfig(BaseModel):
+    seconds_on: float = 0.3
+    seconds_pause: float = 0.2
     pins: Optional[List[int]] = None
 
 # Helper Functions
-def _motor_value(motor: dict, active: bool) -> int:
-    return int(active == bool(motor.get("active_high", True)))
-
-def _claim_motor(motor: dict) -> None:
-    global gpio_handle
-    pin = int(motor["gpio"])
-    if pin < 2 or pin > 27:
-        raise ValueError(f"BCM GPIO {pin} is outside 2..27")
-    if lgpio is None:
-        raise RuntimeError("lgpio is not installed; refusing simulated production actuation")
-    if gpio_handle is None:
-        gpio_handle = lgpio.gpiochip_open(0)
-    if pin not in claimed_pins:
-        lgpio.gpio_claim_output(gpio_handle, pin, _motor_value(motor, False))
-        claimed_pins.add(pin)
-
-def _write_motor(motor: dict, active: bool) -> None:
-    _claim_motor(motor)
-    lgpio.gpio_write(gpio_handle, int(motor["gpio"]), _motor_value(motor, active))
-
-def _all_off() -> None:
-    for motor in motors.values():
-        try:
-            if isinstance(motor, dict):
-                _write_motor(motor, False)
-        except Exception as exc:
-            print(f"[GPIO] failed to de-energize {motor}: {exc}")
-
-def run_motor_thread(motor_name: str, duration: float):
-    global active_motor, remaining_seconds, last_action, stop_flag, motor_error
-
-    motor = motors[motor_name]
-    started = time.monotonic()
-    print(f"[MOTOR] Starting {motor_name} for {duration:.3f} seconds")
-    try:
-        _write_motor(motor, True)
-        while not stop_flag and time.monotonic() - started < duration:
-            remaining_seconds = max(0, duration - (time.monotonic() - started))
-            time.sleep(min(0.05, remaining_seconds or 0.01))
-    except Exception as exc:
-        motor_error = f"{type(exc).__name__}: {exc}"
-        last_action = f"Failed {motor_name}: {motor_error}"
-        print(f"[ERROR] Motor {motor_name} failed: {motor_error}")
-    finally:
-        try:
-            _write_motor(motor, False)
-        finally:
-            with motor_lock:
-                active_motor = None
-                remaining_seconds = 0
-                stop_flag = False
-            print(f"[MOTOR] {motor_name} completed and GPIO is OFF")
-
-@app.on_event("shutdown")
-def shutdown_gpio() -> None:
-    global gpio_handle
-    _all_off()
-    if lgpio is not None and gpio_handle is not None:
-        try:
-            lgpio.gpiochip_close(gpio_handle)
-        finally:
-            gpio_handle = None
-            claimed_pins.clear()
+def _motor_value(motor: dict, active: bool) -> int:
+    return int(active == bool(motor.get("active_high", True)))
+
+def _claim_motor(motor: dict) -> None:
+    global gpio_handle
+    pin = int(motor["gpio"])
+    if pin < 2 or pin > 27:
+        raise ValueError(f"BCM GPIO {pin} is outside 2..27")
+    if lgpio is None:
+        raise RuntimeError("lgpio is not installed; refusing simulated production actuation")
+    if gpio_handle is None:
+        gpio_handle = lgpio.gpiochip_open(0)
+    if pin not in claimed_pins:
+        lgpio.gpio_claim_output(gpio_handle, pin, _motor_value(motor, False))
+        claimed_pins.add(pin)
+
+def _write_motor(motor: dict, active: bool) -> None:
+    _claim_motor(motor)
+    lgpio.gpio_write(gpio_handle, int(motor["gpio"]), _motor_value(motor, active))
+
+def _all_off() -> None:
+    for motor in motors.values():
+        try:
+            if isinstance(motor, dict):
+                _write_motor(motor, False)
+        except Exception as exc:
+            print(f"[GPIO] failed to de-energize {motor}: {exc}")
+
+def run_motor_thread(motor_name: str, duration: float):
+    global active_motor, remaining_seconds, last_action, stop_flag, motor_error
+
+    motor = motors[motor_name]
+    started = time.monotonic()
+    print(f"[MOTOR] Starting {motor_name} for {duration:.3f} seconds")
+    try:
+        _write_motor(motor, True)
+        while not stop_flag and time.monotonic() - started < duration:
+            remaining_seconds = max(0, duration - (time.monotonic() - started))
+            time.sleep(min(0.05, remaining_seconds or 0.01))
+    except Exception as exc:
+        motor_error = f"{type(exc).__name__}: {exc}"
+        last_action = f"Failed {motor_name}: {motor_error}"
+        print(f"[ERROR] Motor {motor_name} failed: {motor_error}")
+    finally:
+        try:
+            _write_motor(motor, False)
+        finally:
+            with motor_lock:
+                active_motor = None
+                remaining_seconds = 0
+                stop_flag = False
+            print(f"[MOTOR] {motor_name} completed and GPIO is OFF")
+
+@app.on_event("shutdown")
+def shutdown_gpio() -> None:
+    global gpio_handle
+    _all_off()
+    if lgpio is not None and gpio_handle is not None:
+        try:
+            lgpio.gpiochip_close(gpio_handle)
+        finally:
+            gpio_handle = None
+            claimed_pins.clear()
 
 # API Endpoints
 @app.get("/")
 async def root():
     return {
-        "message": "Motor Control API",
-        "version": "1.2.0",
-        "robot": ROBOT_NAME,
-        "authentication": "token" if MOTOR_API_TOKEN else "localhost-only",
+        "message": "Motor Control API",
+        "version": "1.2.0",
+        "robot": ROBOT_NAME,
+        "authentication": "token" if MOTOR_API_TOKEN else "localhost-only",
         "endpoints": ["/status", "/test", "/add-motor", "/trigger-motor", "/list-motors", "/stop-motors"]
     }
 
@@ -208,26 +208,26 @@ async def get_status():
         "status": status,
         "active_motor": active_motor,
         "remaining_seconds": remaining_seconds,
-        "last_action": last_action,
-        "error": motor_error,
-        "total_motors": len(motors),
-        "robot": ROBOT_NAME,
-        "gpio_available": lgpio is not None,
+        "last_action": last_action,
+        "error": motor_error,
+        "total_motors": len(motors),
+        "robot": ROBOT_NAME,
+        "gpio_available": lgpio is not None,
     }
 
 @app.post("/add-motor")
-async def add_motor(config: MotorConfig):
-    if config.gpio < 2 or config.gpio > 27:
-        raise HTTPException(status_code=422, detail="BCM GPIO must be in range 2..27")
-    if config.name in motors:
-        raise HTTPException(status_code=400, detail=f"Motor '{config.name}' already exists")
-    if any(int(item["gpio"]) == config.gpio for item in motors.values()):
-        raise HTTPException(status_code=409, detail=f"BCM GPIO {config.gpio} is already registered")
-
-    motors[config.name] = {
-        "name": config.name,
-        "gpio": config.gpio,
-        "active_high": config.active_high,
+async def add_motor(config: MotorConfig):
+    if config.gpio < 2 or config.gpio > 27:
+        raise HTTPException(status_code=422, detail="BCM GPIO must be in range 2..27")
+    if config.name in motors:
+        raise HTTPException(status_code=400, detail=f"Motor '{config.name}' already exists")
+    if any(int(item["gpio"]) == config.gpio for item in motors.values()):
+        raise HTTPException(status_code=409, detail=f"BCM GPIO {config.gpio} is already registered")
+
+    motors[config.name] = {
+        "name": config.name,
+        "gpio": config.gpio,
+        "active_high": config.active_high,
     }
     save_motors()
 
@@ -239,49 +239,49 @@ async def add_motor(config: MotorConfig):
         "motor": motors[config.name]
     }
 
-@app.get("/list-motors")
-async def list_motors():
+@app.get("/list-motors")
+async def list_motors():
     motor_list = list(motors.values())
     return {
         "status": "success",
         "count": len(motor_list),
-        "motors": motor_list
-    }
-
-@app.get("/discover")
-async def discover_motors():
-    """Return the relay registry and GPIO capability for fleet discovery."""
-    motor_list = list(motors.values())
-    return {
-        "status": "success",
-        "robot": ROBOT_NAME,
-        "gpio_available": lgpio is not None,
-        "count": len(motor_list),
-        "motors": motor_list,
-    }
+        "motors": motor_list
+    }
+
+@app.get("/discover")
+async def discover_motors():
+    """Return the relay registry and GPIO capability for fleet discovery."""
+    motor_list = list(motors.values())
+    return {
+        "status": "success",
+        "robot": ROBOT_NAME,
+        "gpio_available": lgpio is not None,
+        "count": len(motor_list),
+        "motors": motor_list,
+    }
 
 @app.put("/update-motor/{motor_name}")
-async def update_motor(motor_name: str, config: UpdateMotorConfig):
-    if config.gpio < 2 or config.gpio > 27:
-        raise HTTPException(status_code=422, detail="BCM GPIO must be in range 2..27")
+async def update_motor(motor_name: str, config: UpdateMotorConfig):
+    if config.gpio < 2 or config.gpio > 27:
+        raise HTTPException(status_code=422, detail="BCM GPIO must be in range 2..27")
     if motor_name not in motors:
         raise HTTPException(status_code=404, detail=f"Motor '{motor_name}' not found")
 
     if active_motor == motor_name:
         raise HTTPException(status_code=409, detail=f"Cannot update motor '{motor_name}' while it is running")
 
-    if config.name != motor_name and config.name in motors:
-        raise HTTPException(status_code=400, detail=f"Motor name '{config.name}' already exists")
-    if any(name != motor_name and int(item["gpio"]) == config.gpio for name, item in motors.items()):
-        raise HTTPException(status_code=409, detail=f"BCM GPIO {config.gpio} is already registered")
+    if config.name != motor_name and config.name in motors:
+        raise HTTPException(status_code=400, detail=f"Motor name '{config.name}' already exists")
+    if any(name != motor_name and int(item["gpio"]) == config.gpio for name, item in motors.items()):
+        raise HTTPException(status_code=409, detail=f"BCM GPIO {config.gpio} is already registered")
 
     if config.name != motor_name:
         del motors[motor_name]
 
-    motors[config.name] = {
-        "name": config.name,
-        "gpio": config.gpio,
-        "active_high": config.active_high,
+    motors[config.name] = {
+        "name": config.name,
+        "gpio": config.gpio,
+        "active_high": config.active_high,
     }
     save_motors()
 
@@ -313,30 +313,30 @@ async def delete_motor(motor_name: str):
     }
 
 @app.post("/trigger-motor")
-async def trigger_motor(config: TriggerMotor):
-    global motor_thread, stop_flag, active_motor, remaining_seconds, last_action, motor_error
+async def trigger_motor(config: TriggerMotor):
+    global motor_thread, stop_flag, active_motor, remaining_seconds, last_action, motor_error
 
     if config.motor_name not in motors:
         raise HTTPException(status_code=404, detail=f"Motor '{config.motor_name}' not found")
 
-    if config.seconds < 0.05 or config.seconds > 10.0:
-        raise HTTPException(status_code=422, detail="Pulse duration must be 0.05..10 seconds")
-
-    try:
-        _claim_motor(motors[config.motor_name])
-    except Exception as exc:
-        raise HTTPException(status_code=503, detail=f"GPIO is unavailable: {exc}") from exc
-
-    with motor_lock:
-        if active_motor:
-            raise HTTPException(status_code=409, detail=f"Motor '{active_motor}' is already running")
-        stop_flag = False
-        motor_error = None
-        active_motor = config.motor_name
-        remaining_seconds = config.seconds
-        last_action = f"Triggered {config.motor_name}"
-        motor_thread = threading.Thread(target=run_motor_thread, args=(config.motor_name, config.seconds), daemon=True)
-        motor_thread.start()
+    if config.seconds < 0.05 or config.seconds > 10.0:
+        raise HTTPException(status_code=422, detail="Pulse duration must be 0.05..10 seconds")
+
+    try:
+        _claim_motor(motors[config.motor_name])
+    except Exception as exc:
+        raise HTTPException(status_code=503, detail=f"GPIO is unavailable: {exc}") from exc
+
+    with motor_lock:
+        if active_motor:
+            raise HTTPException(status_code=409, detail=f"Motor '{active_motor}' is already running")
+        stop_flag = False
+        motor_error = None
+        active_motor = config.motor_name
+        remaining_seconds = config.seconds
+        last_action = f"Triggered {config.motor_name}"
+        motor_thread = threading.Thread(target=run_motor_thread, args=(config.motor_name, config.seconds), daemon=True)
+        motor_thread.start()
 
     return {
         "status": "success",
@@ -350,20 +350,20 @@ async def stop_motors(config: Optional[StopMotors] = None):
     global stop_flag, last_action
 
     try:
-        if not active_motor:
-            _all_off()
-            return {
+        if not active_motor:
+            _all_off()
+            return {
                 "status": "success",
                 "message": "No motors are currently running"
             }
 
-        stop_flag = True
-        last_action = f"Stopped {active_motor}"
+        stop_flag = True
+        last_action = f"Stopped {active_motor}"
 
         # Wait for thread to finish
-        if motor_thread and motor_thread.is_alive():
-            motor_thread.join(timeout=2)
-        _all_off()
+        if motor_thread and motor_thread.is_alive():
+            motor_thread.join(timeout=2)
+        _all_off()
 
         return {
             "status": "success",
@@ -381,30 +381,30 @@ async def stop_motors(config: Optional[StopMotors] = None):
         }
 
 @app.post("/test")
-async def run_test(config: TestConfig):
-    global last_action, active_motor, motor_error
-
-    if config.seconds_on < 0.05 or config.seconds_on > 10.0:
-        raise HTTPException(status_code=422, detail="Test pulse duration must be 0.05..10 seconds")
-    if config.seconds_pause < 0 or config.seconds_pause > 10.0:
-        raise HTTPException(status_code=422, detail="Test pause must be 0..10 seconds")
-
-    registered_pins = {int(m["gpio"]) for m in motors.values() if isinstance(m, dict)}
-    pins = config.pins if config.pins else sorted(registered_pins)
-    if not pins or any(pin not in registered_pins for pin in pins):
-        raise HTTPException(status_code=422, detail="Relay tests are limited to registered GPIO pins")
-    try:
-        for motor in motors.values():
-            if int(motor["gpio"]) in pins:
-                _claim_motor(motor)
-    except Exception as exc:
-        raise HTTPException(status_code=503, detail=f"GPIO is unavailable: {exc}") from exc
-
-    with motor_lock:
-        if active_motor:
-            raise HTTPException(status_code=409, detail="A motor is already running")
-        active_motor = "relay-test"
-        motor_error = None
+async def run_test(config: TestConfig):
+    global last_action, active_motor, motor_error
+
+    if config.seconds_on < 0.05 or config.seconds_on > 10.0:
+        raise HTTPException(status_code=422, detail="Test pulse duration must be 0.05..10 seconds")
+    if config.seconds_pause < 0 or config.seconds_pause > 10.0:
+        raise HTTPException(status_code=422, detail="Test pause must be 0..10 seconds")
+
+    registered_pins = {int(m["gpio"]) for m in motors.values() if isinstance(m, dict)}
+    pins = config.pins if config.pins else sorted(registered_pins)
+    if not pins or any(pin not in registered_pins for pin in pins):
+        raise HTTPException(status_code=422, detail="Relay tests are limited to registered GPIO pins")
+    try:
+        for motor in motors.values():
+            if int(motor["gpio"]) in pins:
+                _claim_motor(motor)
+    except Exception as exc:
+        raise HTTPException(status_code=503, detail=f"GPIO is unavailable: {exc}") from exc
+
+    with motor_lock:
+        if active_motor:
+            raise HTTPException(status_code=409, detail="A motor is already running")
+        active_motor = "relay-test"
+        motor_error = None
 
     print(f"[TEST] Running test sequence:")
     print(f"  - Seconds ON: {config.seconds_on}")
@@ -413,32 +413,32 @@ async def run_test(config: TestConfig):
 
     last_action = f"Test sequence started"
 
-    def test_sequence():
-        global last_action, active_motor, motor_error
-        try:
-            for pin in pins:
-                last_action = f"test:gpio:{pin}"
-                motor = next(m for m in motors.values() if int(m["gpio"]) == pin)
-                print(f">>> TESTING GPIO {pin}")
-                try:
-                    _write_motor(motor, True)
-                    time.sleep(config.seconds_on)
-                finally:
-                    _write_motor(motor, False)
-                print(f"[TEST] Pin {pin} OFF, pausing {config.seconds_pause}s")
-                time.sleep(config.seconds_pause)
-            last_action = "Test sequence completed"
-            print("[TEST] Test sequence completed")
-        except Exception as exc:
-            motor_error = f"{type(exc).__name__}: {exc}"
-            last_action = f"Relay test failed: {motor_error}"
-            print(f"[ERROR] Relay test failed: {motor_error}")
-        finally:
-            _all_off()
-            with motor_lock:
-                active_motor = None
-
-    test_thread = threading.Thread(target=test_sequence, daemon=True)
+    def test_sequence():
+        global last_action, active_motor, motor_error
+        try:
+            for pin in pins:
+                last_action = f"test:gpio:{pin}"
+                motor = next(m for m in motors.values() if int(m["gpio"]) == pin)
+                print(f">>> TESTING GPIO {pin}")
+                try:
+                    _write_motor(motor, True)
+                    time.sleep(config.seconds_on)
+                finally:
+                    _write_motor(motor, False)
+                print(f"[TEST] Pin {pin} OFF, pausing {config.seconds_pause}s")
+                time.sleep(config.seconds_pause)
+            last_action = "Test sequence completed"
+            print("[TEST] Test sequence completed")
+        except Exception as exc:
+            motor_error = f"{type(exc).__name__}: {exc}"
+            last_action = f"Relay test failed: {motor_error}"
+            print(f"[ERROR] Relay test failed: {motor_error}")
+        finally:
+            _all_off()
+            with motor_lock:
+                active_motor = None
+
+    test_thread = threading.Thread(target=test_sequence, daemon=True)
     test_thread.start()
 
     return {
@@ -456,12 +456,12 @@ if __name__ == "__main__":
     print("=" * 60)
     print("Motor Control API Server")
     print("=" * 60)
-    print("Starting server on http://127.0.0.1:8001")
+    print("Starting server on http://127.0.0.1:8001")
     print("API Documentation: http://localhost:8001/docs")
     print("ReDoc: http://localhost:8001/redoc")
     print("=" * 60)
-    uvicorn.run(
-        app,
-        host=os.getenv("ROBOPARK_MOTOR_HOST", "127.0.0.1"),
-        port=int(os.getenv("ROBOPARK_MOTOR_PORT", "8001")),
-    )
+    uvicorn.run(
+        app,
+        host=os.getenv("ROBOPARK_MOTOR_HOST", "127.0.0.1"),
+        port=int(os.getenv("ROBOPARK_MOTOR_PORT", "8001")),
+    )