px4-configuration 0.2.1__tar.gz → 0.2.2__tar.gz

{px4_configuration-0.2.1 → px4_configuration-0.2.2}/.gitignore

@@ -1,4 +1,5 @@
 .venv
 .vscode
 __pycache__/
-dist/
+dist/
+FRONTEND_API_*

{px4_configuration-0.2.1 → px4_configuration-0.2.2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: px4-configuration
-Version: 0.2.1
+Version: 0.2.2
 Summary: Tools and REST API for configuring PX4 from a companion computer
 Author-email: Alex <bonnefond@fly4future.com>
 License: BSD-3-Clause
 Requires-Python: >=3.10
 Requires-Dist: fastapi>=0.104.0
-Requires-Dist: mavsdk==3.0.1
+Requires-Dist: mavsdk==3.10.2
 Requires-Dist: python-multipart>=0.0.6
 Requires-Dist: sse-starlette>=1.6.5
 Requires-Dist: tqdm==4.67.1

{px4_configuration-0.2.1 → px4_configuration-0.2.2}/px4_configuration/api/__init__.py

@@ -1,5 +1,7 @@
 """PX4 Configuration REST API package."""
 
+from px4_configuration import __version__
+
 __all__ = [
     "config",
     "models",
@@ -7,5 +9,3 @@ __all__ = [
     "main",
 ]
 
-__version__ = "1.0.0"
-

{px4_configuration-0.2.1 → px4_configuration-0.2.2}/px4_configuration/api/config.py

@@ -3,6 +3,16 @@
 import os
 
 
+def _get_package_version() -> str:
+    """Read version from package metadata (pyproject.toml). Single source of truth."""
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+
+        return version("px4-configuration")
+    except Exception:
+        return "0.0.0"
+
+
 class Settings:
     """Application settings with defaults."""
 
@@ -10,9 +20,9 @@ class Settings:
     default_port: str = os.getenv("PX4_DEFAULT_PORT", "/dev/pixhawk")
     default_baudrate: int = int(os.getenv("PX4_DEFAULT_BAUDRATE", "2000000"))
 
-    # API settings
+    # API settings (version from pyproject.toml via package metadata)
     api_title: str = "PX4 Configuration API"
-    api_version: str = "1.0.0"
+    api_version: str = _get_package_version()
     api_description: str = (
         "REST API for configuring PX4 flight controller from companion computer"
     )

{px4_configuration-0.2.1 → px4_configuration-0.2.2}/px4_configuration/api/models.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Literal, Optional, Dict, Any
+from typing import Literal, Optional, Dict, Any, List
 
 from pydantic import BaseModel, Field, ConfigDict
 
@@ -59,6 +59,61 @@ class CalibrationHealth(BaseModel):
         """Whether the calibration is required."""
         return not (self.gyroscope_ok and self.accelerometer_ok and self.magnetometer_ok)
 
+
+class HealthAndArmingCheckProblem(BaseModel):
+    """A single health/arming check problem from PX4 Events."""
+
+    message: str = Field(..., description="Short, single-line message.")
+    description: str = Field(default="", description="Detailed description (optional).")
+    health_component: str = Field(default="", description="Associated component, e.g. 'gps'.")
+
+
+class HealthAndArmingCheckMode(BaseModel):
+    """Arming checks for a specific flight mode (from PX4 Events)."""
+
+    mode_name: str = Field(..., description="Mode name, e.g. 'Position'.")
+    can_arm_or_run: bool = Field(
+        ...,
+        description="If disarmed: whether arming is possible. If armed: whether the mode can be selected.",
+    )
+    problems: List[HealthAndArmingCheckProblem] = Field(
+        default_factory=list,
+        description="List of reported problems for this mode.",
+    )
+
+
+class HealthComponentReport(BaseModel):
+    """Health component report (e.g. GPS, Accelerometer) from PX4 Events."""
+
+    name: str = Field(..., description="Unique component name, e.g. 'gps'.")
+    label: str = Field(..., description="Human-readable label, e.g. 'GPS'.")
+    is_present: bool = Field(..., description="Whether the component is present.")
+    has_error: bool = Field(..., description="Whether the component has errors.")
+    has_warning: bool = Field(..., description="Whether the component has warnings.")
+
+
+class HealthAndArmingCheckReport(BaseModel):
+    """
+    Health and arming checks report from MAVSDK Events plugin.
+
+    Provides detailed readiness-to-fly information: current mode arming status,
+    per-component health, and all reported problems.
+    """
+
+    current_mode_intention: Optional[HealthAndArmingCheckMode] = Field(
+        default=None,
+        description="Report for the currently intended flight mode (can_arm_or_run, problems).",
+    )
+    health_components: List[HealthComponentReport] = Field(
+        default_factory=list,
+        description="Health components (e.g. gps, accelerometer) with present/error/warning flags.",
+    )
+    all_problems: List[HealthAndArmingCheckProblem] = Field(
+        default_factory=list,
+        description="Complete list of all reported problems.",
+    )
+
+
 class Px4HealthResponse(BaseModel):
     """
     High-level PX4 health snapshot.
@@ -111,6 +166,14 @@ class Px4HealthResponse(BaseModel):
         description="True if PX4 considers the vehicle armable.",
     )
 
+    arming_checks_report: Optional[HealthAndArmingCheckReport] = Field(
+        default=None,
+        description=(
+            "Detailed health and arming checks from MAVSDK Events plugin "
+            "(mode intention, health components, all problems). None if Events plugin unavailable."
+        ),
+    )
+
     raw_health: Optional[Dict[str, Any]] = Field(
         default=None,
         description=(

px4_configuration-0.2.2/px4_configuration/api/services/calibration_service.py

@@ -0,0 +1,236 @@
+"""Service for PX4 sensor calibration operations."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import AsyncGenerator, Dict, Any, Optional
+
+from mavsdk import System
+
+try:
+    from grpc import RpcError
+except ImportError:
+    # Fallback if grpc is not directly available (shouldn't happen with mavsdk)
+    RpcError = Exception
+
+from ..models import CalibrationType
+from ..utils.calibration_parser import (
+    parse_accelerometer_progress,
+    parse_gyroscope_progress,
+    parse_magnetometer_progress,
+    parse_horizon_progress,
+)
+
+
+def _format_grpc_error(exc: Exception) -> str:
+    """Format gRPC errors into user-friendly messages."""
+    error_msg = str(exc)
+    
+    if isinstance(exc, RpcError):
+        # Check for COMMAND_DENIED (PX4 rejected the command)
+        if "COMMAND_DENIED" in error_msg:
+            return (
+                "PX4 rejected the calibration command. "
+                "This may occur if: (1) a calibration is already in progress, "
+                "(2) the vehicle is armed or in flight, (3) the vehicle is not in the correct state. "
+                "Please ensure the vehicle is disarmed, on the ground, and no other calibration is running."
+            )
+        # Check for common gRPC error patterns
+        if "Connection reset by peer" in error_msg or "UNAVAILABLE" in error_msg:
+            return (
+                "Connection to PX4 device was lost. "
+                "This may occur if the device disconnected, rebooted, or the connection timed out. "
+                "Please check the device connection and try again."
+            )
+        elif "DEADLINE_EXCEEDED" in error_msg or "timeout" in error_msg.lower():
+            return (
+                "Connection timeout. The device may be unresponsive. "
+                "Please check the device connection and try again."
+            )
+        elif "PERMISSION_DENIED" in error_msg:
+            return "Permission denied. Please check device permissions."
+        else:
+            return f"gRPC error: {error_msg}"
+    
+    # For non-gRPC exceptions, return the error message as-is
+    return error_msg
+
+
+async def calibrate_sensors(
+    port: str,
+    baudrate: int,
+    calibration_type: CalibrationType,
+) -> AsyncGenerator[Dict[str, Any], None]:
+    """
+    Calibrate PX4 sensors and stream progress as structured dict payloads.
+
+    This function is transport-agnostic: it does NOT produce SSE-formatted strings.
+    It yields plain Python dicts suitable for JSON serialization. The API layer
+    (FastAPI endpoint) is responsible for converting these dicts into SSE frames.
+
+    The function properly handles connection cleanup and gRPC errors.
+    """
+
+    serial = f"serial://{port}:{baudrate}"
+    drone: Optional[System] = None
+
+    try:
+        # Initial status messages
+        yield {
+            "type": "status",
+            "message": f"Connecting to {port}...",
+        }
+
+        # Create and connect to the PX4 system
+        drone = System()
+        await drone.connect(system_address=serial)
+
+        # Wait for connection to be established
+        async for state in drone.core.connection_state():
+            if state.is_connected:
+                break
+
+        yield {
+            "type": "status",
+            "message": "Connected to device",
+        }
+
+        # Small delay to ensure connection is stable before starting calibration
+        # This helps avoid COMMAND_DENIED errors from rapid-fire requests
+        await asyncio.sleep(0.1)
+
+        # Dispatch based on calibration type
+        if calibration_type is CalibrationType.GYROSCOPE:
+            # Gyroscope calibration
+            yield {
+                "type": "status",
+                "message": "Starting gyroscope calibration...",
+            }
+
+            prev: Dict[str, Any] | None = None
+            try:
+                async for progress_data in drone.calibration.calibrate_gyro():
+                    structured_data = parse_gyroscope_progress(progress_data, prev=prev)
+                    prev = structured_data
+                    yield structured_data
+            except (RpcError, Exception) as exc:
+                yield {
+                    "type": "error",
+                    "message": f"Gyroscope calibration failed: {_format_grpc_error(exc)}",
+                }
+                raise
+
+            yield {
+                "type": "gyroscope_complete",
+                "message": "Gyroscope calibration finished",
+                "is_complete": True,
+            }
+
+        elif calibration_type is CalibrationType.ACCELEROMETER:
+            # Accelerometer calibration
+            yield {
+                "type": "status",
+                "message": "Starting accelerometer calibration...",
+            }
+
+            prev = None
+            try:
+                async for progress_data in drone.calibration.calibrate_accelerometer():
+                    structured_data = parse_accelerometer_progress(progress_data, prev=prev)
+                    prev = structured_data
+                    yield structured_data
+            except (RpcError, Exception) as exc:
+                yield {
+                    "type": "error",
+                    "message": f"Accelerometer calibration failed: {_format_grpc_error(exc)}",
+                }
+                raise
+
+            yield {
+                "type": "accelerometer_complete",
+                "message": "Accelerometer calibration finished",
+                "is_complete": True,
+            }
+
+        elif calibration_type is CalibrationType.MAGNETOMETER:
+            # Magnetometer calibration
+            yield {
+                "type": "status",
+                "message": "Starting magnetometer calibration...",
+            }
+
+            prev = None
+            try:
+                async for progress_data in drone.calibration.calibrate_magnetometer():
+                    structured_data = parse_magnetometer_progress(progress_data, prev=prev)
+                    prev = structured_data
+                    yield structured_data
+            except (RpcError, Exception) as exc:
+                yield {
+                    "type": "error",
+                    "message": f"Magnetometer calibration failed: {_format_grpc_error(exc)}",
+                }
+                raise
+
+            yield {
+                "type": "magnetometer_complete",
+                "message": "Magnetometer calibration finished",
+                "is_complete": True,
+            }
+
+        elif calibration_type is CalibrationType.HORIZON:
+            # Level horizon calibration
+            yield {
+                "type": "status",
+                "message": "Starting board level horizon calibration...",
+            }
+
+            prev = None
+            try:
+                async for progress_data in drone.calibration.calibrate_level_horizon():
+                    structured_data = parse_horizon_progress(progress_data, prev=prev)
+                    prev = structured_data
+                    yield structured_data
+            except (RpcError, Exception) as exc:
+                yield {
+                    "type": "error",
+                    "message": f"Horizon calibration failed: {_format_grpc_error(exc)}",
+                }
+                raise
+
+            yield {
+                "type": "horizon_complete",
+                "message": "Level horizon calibration finished",
+                "is_complete": True,
+            }
+
+        elif calibration_type is CalibrationType.ESC:
+            # ESC calibration not implemented yet
+            yield {
+                "type": "status",
+                "message": "Starting ESC calibration...",
+            }
+            yield {
+                "type": "warning",
+                "message": "ESC calibration not yet implemented",
+            }
+            yield {
+                "type": "status",
+                "message": "ESC calibration finished",
+            }
+
+    except (RpcError, Exception) as exc:
+        # Handle connection and gRPC errors
+        error_message = _format_grpc_error(exc)
+        yield {
+            "type": "error",
+            "message": f"Calibration failed: {error_message}",
+        }
+        raise
+
+    finally:
+        # Cleanup: Ensure the System object is properly released
+        # MAVSDK System objects are cleaned up when they go out of scope,
+        # but explicitly setting to None helps with resource management
+        if drone is not None:
+            drone = None

px4_configuration-0.2.2/px4_configuration/api/services/health_service.py

@@ -0,0 +1,215 @@
+"""Service for PX4 health and calibration snapshot."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Dict, Optional
+
+from mavsdk import System
+
+try:
+    from grpc import RpcError
+except ImportError:
+    # Fallback if grpc is not directly available (shouldn't happen with mavsdk)
+    RpcError = Exception
+
+from ..config import settings
+from ..models import (
+    Px4HealthResponse,
+    CalibrationHealth,
+    HealthAndArmingCheckReport,
+    HealthAndArmingCheckMode,
+    HealthAndArmingCheckProblem,
+    HealthComponentReport,
+)
+
+
+async def _get_stable_health(drone: System, duration_s: float = 2.0) -> Optional[Any]:
+    """
+    Stream health messages for the specified duration and return the latest.
+    This skips initial stale messages (all False) and gets accurate values.
+    """
+    latest_health = None
+    start_time = asyncio.get_event_loop().time()
+    
+    try:
+        async for health in drone.telemetry.health():
+            latest_health = health
+            elapsed = asyncio.get_event_loop().time() - start_time
+            if elapsed >= duration_s:
+                break
+    except Exception:
+        pass
+    
+    return latest_health
+
+
+def _convert_arming_checks_report(report: Any) -> HealthAndArmingCheckReport:
+    """Convert MAVSDK HealthAndArmingCheckReport to our Pydantic model."""
+    current = getattr(report, "current_mode_intention", None)
+    current_mode = None
+    if current is not None:
+        problems = [
+            HealthAndArmingCheckProblem(
+                message=getattr(p, "message", ""),
+                description=getattr(p, "description", ""),
+                health_component=getattr(p, "health_component", ""),
+            )
+            for p in (getattr(current, "problems", None) or [])
+        ]
+        current_mode = HealthAndArmingCheckMode(
+            mode_name=getattr(current, "mode_name", ""),
+            can_arm_or_run=getattr(current, "can_arm_or_run", False),
+            problems=problems,
+        )
+
+    health_components = [
+        HealthComponentReport(
+            name=getattr(c, "name", ""),
+            label=getattr(c, "label", ""),
+            is_present=getattr(c, "is_present", False),
+            has_error=getattr(c, "has_error", False),
+            has_warning=getattr(c, "has_warning", False),
+        )
+        for c in (getattr(report, "health_components", None) or [])
+    ]
+
+    all_problems = [
+        HealthAndArmingCheckProblem(
+            message=getattr(p, "message", ""),
+            description=getattr(p, "description", ""),
+            health_component=getattr(p, "health_component", ""),
+        )
+        for p in (getattr(report, "all_problems", None) or [])
+    ]
+
+    return HealthAndArmingCheckReport(
+        current_mode_intention=current_mode,
+        health_components=health_components,
+        all_problems=all_problems,
+    )
+
+
+async def _get_arming_checks_report(drone: System) -> Optional[HealthAndArmingCheckReport]:
+    """
+    Fetch health and arming checks report from MAVSDK Events plugin.
+    Returns None if Events plugin is not available (e.g. older PX4).
+    """
+    try:
+        report = await drone.events.get_health_and_arming_checks_report()
+        if report is None:
+            return None
+        return _convert_arming_checks_report(report)
+    except Exception:
+        return None
+
+
+async def read_px4_health(
+    port: Optional[str] = None,
+    baudrate: Optional[int] = None,
+    timeout_s: float = 10.0,
+) -> Px4HealthResponse:
+    """Connect to PX4 via MAVSDK and return a health snapshot using telemetry health flags."""
+
+    port = port or settings.default_port
+    baudrate = baudrate or settings.default_baudrate
+    serial = f"serial://{port}:{baudrate}"
+
+    drone: Optional[System] = None
+
+    try:
+        drone = System()
+        await drone.connect(system_address=serial)
+
+        # Wait for connection with timeout
+        connection_established = False
+        try:
+            async for state in drone.core.connection_state():
+                if state.is_connected:
+                    connection_established = True
+                    break
+                # Timeout if not connected within reasonable time
+                await asyncio.sleep(0.1)
+        except (RpcError, Exception):
+            connection_established = False
+
+        if not connection_established:
+            return Px4HealthResponse(
+                status="disconnected",
+                connection_port=port,
+                connection_baudrate=baudrate,
+                calibration=None,
+                gps_fix_type=None,
+                satellites_used=None,
+                armable=False,
+                arming_checks_report=None,
+                raw_health=None,
+            )
+
+        # Stream health for 2 seconds to get accurate values (skip initial stale messages)
+        health = await asyncio.wait_for(_get_stable_health(drone, duration_s=2.0), timeout_s)
+
+        if health is None:
+            return Px4HealthResponse(
+                status="disconnected",
+                connection_port=port,
+                connection_baudrate=baudrate,
+                calibration=None,
+                gps_fix_type=None,
+                satellites_used=None,
+                armable=False,
+                arming_checks_report=None,
+                raw_health=None,
+            )
+
+        # Use telemetry health flags directly
+        calibration = CalibrationHealth(
+            gyroscope_ok=health.is_gyrometer_calibration_ok,
+            accelerometer_ok=health.is_accelerometer_calibration_ok,
+            magnetometer_ok=health.is_magnetometer_calibration_ok,
+        )
+
+        # Determine status
+        status = "ok" if (health.is_armable and not calibration.requires_calibration) else "degraded"
+
+        # Minimal raw health for debugging
+        raw_health: Dict[str, Any] = {
+            "raw_health_message": str(health),
+            "is_gyrometer_calibration_ok": health.is_gyrometer_calibration_ok,
+            "is_accelerometer_calibration_ok": health.is_accelerometer_calibration_ok,
+            "is_magnetometer_calibration_ok": health.is_magnetometer_calibration_ok,
+            "is_armable": health.is_armable,
+        }
+
+        # Fetch detailed health and arming checks from Events plugin (optional)
+        arming_checks_report = await _get_arming_checks_report(drone)
+
+        return Px4HealthResponse(
+            status=status,
+            connection_port=port,
+            connection_baudrate=baudrate,
+            calibration=calibration,
+            gps_fix_type=None,
+            satellites_used=None,
+            armable=health.is_armable,
+            arming_checks_report=arming_checks_report,
+            raw_health=raw_health,
+        )
+
+    except (RpcError, Exception):
+        # Return disconnected status on any error
+        return Px4HealthResponse(
+            status="disconnected",
+            connection_port=port,
+            connection_baudrate=baudrate,
+            calibration=None,
+            gps_fix_type=None,
+            satellites_used=None,
+            armable=False,
+            arming_checks_report=None,
+            raw_health=None,
+        )
+    finally:
+        # Cleanup: Ensure the System object is properly released
+        if drone is not None:
+            drone = None

{px4_configuration-0.2.1 → px4_configuration-0.2.2}/px4_configuration/api/services/param_service.py

@@ -1,10 +1,16 @@
 """Service for PX4 parameter upload operations."""
 
 import json
-from typing import AsyncGenerator
+from typing import AsyncGenerator, Optional
 
 from mavsdk import System
 
+try:
+    from grpc import RpcError
+except ImportError:
+    # Fallback if grpc is not directly available (shouldn't happen with mavsdk)
+    RpcError = Exception
+
 
 async def upload_parameters(
     param_file_path: str,
@@ -13,7 +19,7 @@ async def upload_parameters(
 ) -> AsyncGenerator[str, None]:
     """Upload PX4 parameters from a .params file, streaming progress via SSE."""
 
-    drone = None
+    drone: Optional[System] = None
     try:
         drone = System()
         serial = f"serial://{port}:{baudrate}"
@@ -22,6 +28,12 @@ async def upload_parameters(
             json.dumps({"type": "status", "message": f"Connecting to {port}..."})
         )
         await drone.connect(system_address=serial)
+
+        # Wait for connection to be established
+        async for state in drone.core.connection_state():
+            if state.is_connected:
+                break
+
         yield "data: {}\n\n".format(
             json.dumps({"type": "status", "message": "Connected to device"})
         )
@@ -133,18 +145,25 @@ async def upload_parameters(
             )
         )
 
-    except Exception as exc:  # pragma: no cover - streaming generator
+    except (RpcError, Exception) as exc:  # pragma: no cover - streaming generator
+        error_msg = str(exc)
+        if isinstance(exc, RpcError):
+            if "Connection reset by peer" in error_msg or "UNAVAILABLE" in error_msg:
+                error_msg = (
+                    "Connection to PX4 device was lost. "
+                    "This may occur if the device disconnected, rebooted, or the connection timed out."
+                )
         yield "data: {}\n\n".format(
             json.dumps(
                 {
                     "type": "error",
-                    "message": f"Parameter upload failed: {exc}",
+                    "message": f"Parameter upload failed: {error_msg}",
                 }
             )
         )
         raise
     finally:
-        if drone:
-            # No explicit teardown required
-            pass
+        # Cleanup: Ensure the System object is properly released
+        if drone is not None:
+            drone = None