robopark 2.8.35 → 3.0.0

package/vision/motor_server.py

@@ -1,4 +1,5 @@
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 from typing import Optional, List
@@ -6,20 +7,46 @@ import time
 import threading
 import json
 import os
+import hmac
 
-app = FastAPI(title="Motor Control API", version="1.0.0")
+try:
+    import lgpio
+except ImportError:
+    lgpio = None
 
-# CORS Configuration - Allow all origins for cross-origin requests
+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=["*"],  # Allows all origins
-    allow_credentials=True,
-    allow_methods=["*"],  # Allows all methods (GET, POST, PUT, DELETE, OPTIONS)
-    allow_headers=["*"],  # Allows all headers
+    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 = "motors.json"
+MOTORS_FILE = os.getenv(
+    "ROBOPARK_MOTORS_FILE",
+    os.path.expanduser("~/.robopark/motors.json"),
+)
 
 # In-memory storage
 motors = {}
@@ -28,6 +55,10 @@ 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()
 
 # Load motors from file on startup
 def load_motors():
@@ -37,6 +68,14 @@ def load_motors():
         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()
+            }
             print(f"[LOAD] Loaded {len(motors)} motors from {MOTORS_FILE}")
             for name, gpio in motors.items():
                 print(f"  - {name}: GPIO {gpio}")
@@ -49,8 +88,13 @@ def load_motors():
 def save_motors():
     """Save motors to motors.json file"""
     try:
-        with open(MOTORS_FILE, 'w') as f:
+        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}")
@@ -62,52 +106,98 @@ load_motors()
 class MotorConfig(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: int = 5
+    seconds: float = 1.0
 
 class StopMotors(BaseModel):
     motor_name: Optional[str] = None
 
 class TestConfig(BaseModel):
-    seconds_on: int = 2
-    seconds_pause: int = 1
+    seconds_on: float = 0.3
+    seconds_pause: float = 0.2
     pins: Optional[List[int]] = None
 
 # Helper Functions
-def run_motor_thread(motor_name: str, duration: int):
-    global active_motor, remaining_seconds, last_action, stop_flag
-
-    active_motor = motor_name
-    remaining_seconds = duration
-    last_action = f"Triggered {motor_name}"
-
-    print(f"[MOTOR] Starting {motor_name} for {duration} seconds")
-
-    # Simulate motor running
-    for i in range(duration):
-        if stop_flag:
-            print(f"[MOTOR] {motor_name} stopped by user")
-            break
-        remaining_seconds = duration - i
-        time.sleep(1)
-
-    active_motor = None
-    remaining_seconds = 0
-    stop_flag = False
-    print(f"[MOTOR] {motor_name} completed")
+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.0.0",
+        "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"]
     }
 
@@ -119,17 +209,25 @@ async def get_status():
         "active_motor": active_motor,
         "remaining_seconds": remaining_seconds,
         "last_action": last_action,
-        "total_motors": len(motors)
+        "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
+        "gpio": config.gpio,
+        "active_high": config.active_high,
     }
     save_motors()
 
@@ -150,8 +248,22 @@ async def list_motors():
         "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")
     if motor_name not in motors:
         raise HTTPException(status_code=404, detail=f"Motor '{motor_name}' not found")
 
@@ -160,13 +272,16 @@ async def update_motor(motor_name: str, config: UpdateMotorConfig):
 
     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
+        "gpio": config.gpio,
+        "active_high": config.active_high,
     }
     save_motors()
 
@@ -199,17 +314,29 @@ async def delete_motor(motor_name: str):
 
 @app.post("/trigger-motor")
 async def trigger_motor(config: TriggerMotor):
-    global motor_thread, stop_flag
+    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 active_motor:
-        raise HTTPException(status_code=409, detail=f"Motor '{active_motor}' is already running")
+    if config.seconds < 0.05 or config.seconds > 10.0:
+        raise HTTPException(status_code=422, detail="Pulse duration must be 0.05..10 seconds")
 
-    stop_flag = False
-    motor_thread = threading.Thread(target=run_motor_thread, args=(config.motor_name, config.seconds))
-    motor_thread.start()
+    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",
@@ -224,6 +351,7 @@ async def stop_motors(config: Optional[StopMotors] = None):
 
     try:
         if not active_motor:
+            _all_off()
             return {
                 "status": "success",
                 "message": "No motors are currently running"
@@ -235,6 +363,7 @@ async def stop_motors(config: Optional[StopMotors] = None):
         # Wait for thread to finish
         if motor_thread and motor_thread.is_alive():
             motor_thread.join(timeout=2)
+        _all_off()
 
         return {
             "status": "success",
@@ -253,12 +382,29 @@ async def stop_motors(config: Optional[StopMotors] = None):
 
 @app.post("/test")
 async def run_test(config: TestConfig):
-    global last_action
+    global last_action, active_motor, motor_error
 
-    if active_motor:
-        raise HTTPException(status_code=409, detail="A motor is already running")
+    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")
 
-    pins = config.pins if config.pins else list(range(1, 28))
+    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}")
@@ -267,19 +413,32 @@ async def run_test(config: TestConfig):
 
     last_action = f"Test sequence started"
 
-    # Simulate test sequence
     def test_sequence():
-        global last_action
-        for pin in pins:
-            last_action = f"test:gpio:{pin}"
-            print(f">>> TESTING GPIO {pin}")
-            time.sleep(config.seconds_on)
-            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")
-
-    test_thread = threading.Thread(target=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 {
@@ -297,8 +456,12 @@ if __name__ == "__main__":
     print("=" * 60)
     print("Motor Control API Server")
     print("=" * 60)
-    print("Starting server on http://0.0.0.0: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="0.0.0.0", port=8001)
+    uvicorn.run(
+        app,
+        host=os.getenv("ROBOPARK_MOTOR_HOST", "127.0.0.1"),
+        port=int(os.getenv("ROBOPARK_MOTOR_PORT", "8001")),
+    )

package/vision/requirements_camera.txt

@@ -0,0 +1,6 @@
+# Camera-only dependencies used by `robopark conversation up`.
+# OpenCV is supplied by apt on Raspberry Pi through --system-site-packages.
+Flask==3.0.0
+Flask-CORS==4.0.0
+requests>=2.31
+numpy>=2.1; python_version >= '3.13'

package/vision/requirements_motor.txt

@@ -0,0 +1,4 @@
+fastapi>=0.115
+uvicorn>=0.30
+pydantic>=2.7
+lgpio==0.2.2.0; platform_system == 'Linux'

package/vision/requirements_pi_unified.txt

@@ -68,6 +68,7 @@ pydantic==2.5.0
 # ============================================================================
 # HTTP requests
 requests==2.31.0
+groq>=0.11
 
 # CORS support
 python-multipart==0.0.6

package/vision/requirements_vision_agent.txt

@@ -0,0 +1,19 @@
+# Runtime requirements for the packaged RoboPark vision-agent.
+#
+# This intentionally excludes the legacy optional YOLO/GPIO stack from
+# requirements_pi_unified.txt. The packaged agent launches app_pi_clean.py and
+# audio_server_pi.py only. Raspberry Pi OpenCV/PyAudio/Picamera2 are supplied
+# by apt and exposed to ~/.robopark/venv through --system-site-packages.
+Flask==3.0.0
+Flask-CORS==4.0.0
+requests>=2.31
+fastapi>=0.115
+uvicorn[standard]>=0.30
+python-multipart>=0.0.12
+sounddevice>=0.4.6
+soundfile>=0.12.1
+groq>=0.11
+lgpio==0.2.2.0; platform_system == 'Linux'
+# Python 3.13 has no compatible NumPy 1.24 wheel. On older Pi images, use the
+# distro NumPy provided through system-site-packages instead.
+numpy>=2.1; python_version >= '3.13'