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

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: px4-configuration
-Version: 0.1.0
+Version: 0.2.1
 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.8
+Requires-Python: >=3.10
 Requires-Dist: fastapi>=0.104.0
 Requires-Dist: mavsdk==3.0.1
 Requires-Dist: python-multipart>=0.0.6
@@ -60,7 +60,7 @@ pip install dist/px4_configuration-0.1.0-py3-none-any.whl
 
 ## Requirements
 
-- Python 3.8+
+- Python 3.10+
 - PX4 flight controller connected over serial (e.g. `/dev/pixhawk`)
 - User added to the `dialout` group for serial access (`sudo usermod -aG dialout $USER`)
 
@@ -76,7 +76,7 @@ _All scripts use a serial connection to talk to PX4._
 
 ## REST API (FastAPI)
 
-The companion computer can expose the same functionality through a REST API located in `px4_configuration/api/`.
+The companion computer can expose the same functionality through a REST API located in the `px4_configuration.api` package.
 
 ### Run the API server
 
@@ -93,20 +93,22 @@ uvicorn px4_configuration.api.main:app --host 0.0.0.0 --port 8000
 
 ### Endpoints
 
-- `GET /api/health` – health check
-- `POST /api/calibration/start` – start selected calibrations, returns Server-Sent Events (SSE) with progress
-- `POST /api/params/upload` – upload a `.params` file (multipart form), SSE progress stream
-- `POST /api/sdcard/upload` – upload a file (e.g. `extras.txt`) to the SD card, SSE progress stream
-- `WS /api/shell/connect` – interactive PX4 shell over WebSocket
+- `GET /health` – health check
+- `POST /calibration/start` – start selected calibrations, returns Server-Sent Events (SSE) with progress
+- `POST /params/upload` – upload a `.params` file (multipart form), SSE progress stream
+- `POST /sdcard/upload` – upload a file (e.g. `extras.txt`) to the SD card, SSE progress stream
+- `WS /shell/connect` – interactive PX4 shell over WebSocket
 
 All endpoints accept optional `port` and `baudrate` (defaults `/dev/pixhawk`, `2000000`). SSE responses emit JSON payloads with keys such as `type`, `message`, `progress`, etc.
 
 ### Calibration Message Structure
 
-The `/api/calibration/start` endpoint returns structured JSON messages via Server-Sent Events (SSE). Each calibration type has a specific message format:
+The `/calibration/start` endpoint returns structured JSON messages via Server-Sent Events (SSE). Each calibration type has a specific message format:
 
 #### Accelerometer Calibration
 
+The `/calibration/start` endpoint returns structured JSON messages via Server-Sent Events (SSE). Each calibration type has a specific message format:
+
 ```json
 {
   "type": "accelerometer_progress",

{px4_configuration-0.1.0 → px4_configuration-0.2.1}/README.md

@@ -45,7 +45,7 @@ pip install dist/px4_configuration-0.1.0-py3-none-any.whl
 
 ## Requirements
 
-- Python 3.8+
+- Python 3.10+
 - PX4 flight controller connected over serial (e.g. `/dev/pixhawk`)
 - User added to the `dialout` group for serial access (`sudo usermod -aG dialout $USER`)
 
@@ -61,7 +61,7 @@ _All scripts use a serial connection to talk to PX4._
 
 ## REST API (FastAPI)
 
-The companion computer can expose the same functionality through a REST API located in `px4_configuration/api/`.
+The companion computer can expose the same functionality through a REST API located in the `px4_configuration.api` package.
 
 ### Run the API server
 
@@ -78,20 +78,22 @@ uvicorn px4_configuration.api.main:app --host 0.0.0.0 --port 8000
 
 ### Endpoints
 
-- `GET /api/health` – health check
-- `POST /api/calibration/start` – start selected calibrations, returns Server-Sent Events (SSE) with progress
-- `POST /api/params/upload` – upload a `.params` file (multipart form), SSE progress stream
-- `POST /api/sdcard/upload` – upload a file (e.g. `extras.txt`) to the SD card, SSE progress stream
-- `WS /api/shell/connect` – interactive PX4 shell over WebSocket
+- `GET /health` – health check
+- `POST /calibration/start` – start selected calibrations, returns Server-Sent Events (SSE) with progress
+- `POST /params/upload` – upload a `.params` file (multipart form), SSE progress stream
+- `POST /sdcard/upload` – upload a file (e.g. `extras.txt`) to the SD card, SSE progress stream
+- `WS /shell/connect` – interactive PX4 shell over WebSocket
 
 All endpoints accept optional `port` and `baudrate` (defaults `/dev/pixhawk`, `2000000`). SSE responses emit JSON payloads with keys such as `type`, `message`, `progress`, etc.
 
 ### Calibration Message Structure
 
-The `/api/calibration/start` endpoint returns structured JSON messages via Server-Sent Events (SSE). Each calibration type has a specific message format:
+The `/calibration/start` endpoint returns structured JSON messages via Server-Sent Events (SSE). Each calibration type has a specific message format:
 
 #### Accelerometer Calibration
 
+The `/calibration/start` endpoint returns structured JSON messages via Server-Sent Events (SSE). Each calibration type has a specific message format:
+
 ```json
 {
   "type": "accelerometer_progress",

{px4_configuration-0.1.0 → px4_configuration-0.2.1}/px4_configuration/api/main.py

@@ -45,7 +45,7 @@ app.add_middleware(
 active_shell_connections: dict[str, ShellConnection] = {}
 
 
-@app.get("/api/px4/health", response_model=Px4HealthResponse)
+@app.get("/health", response_model=Px4HealthResponse)
 async def get_px4_health(
     port: Optional[str] = Query(None),
     baudrate: Optional[int] = Query(None),
@@ -57,7 +57,7 @@ async def get_px4_health(
 
     return await read_px4_health(port=port, baudrate=baudrate)
 
-@app.post("/api/calibration/start")
+@app.post("/calibration/start")
 async def start_calibration(request: CalibrationRequest):
     port = request.port or settings.default_port
     baudrate = request.baudrate or settings.default_baudrate
@@ -70,16 +70,16 @@ async def start_calibration(request: CalibrationRequest):
                 calibration_type=request.calibration_type,  # <-- enum here
             ):
                 # Convert dict -> SSE frame
-                yield f"data: {json.dumps(payload)}\n\n"
+                yield json.dumps(payload)
         except Exception as exc:
-            yield f"data: {json.dumps({'type': 'error', 'message': str(exc)})}\n\n"
+            yield json.dumps({'type': 'error', 'message': str(exc)})
         finally:
-            yield f"data: {json.dumps({'type': 'complete'})}\n\n"
+            yield json.dumps({'type': 'complete'})
 
     return EventSourceResponse(event_generator())
 
 
-@app.post("/api/params/upload")
+@app.post("/params/upload")
 async def upload_params(
     file: UploadFile = File(...),
     port: Optional[str] = Query(None, description="Serial port (default: /dev/pixhawk)"),
@@ -115,7 +115,7 @@ async def upload_params(
     return EventSourceResponse(event_generator())
 
 
-@app.post("/api/sdcard/upload")
+@app.post("/sdcard/upload")
 async def upload_sdcard_file(
     file: UploadFile = File(...),
     port: Optional[str] = Query(None, description="Serial port (default: /dev/pixhawk)"),
@@ -151,7 +151,7 @@ async def upload_sdcard_file(
     return EventSourceResponse(event_generator())
 
 
-@app.websocket("/api/shell/connect")
+@app.websocket("/shell/connect")
 async def shell_websocket(
     websocket: WebSocket,
     port: Optional[str] = Query(None, description="Serial port (default: /dev/pixhawk)"),

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

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-from enum import StrEnum
+from enum import Enum
 from typing import Literal, Optional, Dict, Any
 
 from pydantic import BaseModel, Field, ConfigDict
 
 
-class CalibrationType(StrEnum):
+class CalibrationType(Enum):
     """Supported calibration types."""
     GYROSCOPE = "gyroscope"
     ACCELEROMETER = "accelerometer"

{px4_configuration-0.1.0 → px4_configuration-0.2.1}/px4_configuration/api/services/calibration_service.py

@@ -53,8 +53,10 @@ async def calibrate_sensors(
             "message": "Starting gyroscope calibration...",
         }
 
+        prev: Dict[str, Any] | None = None
         async for progress_data in drone.calibration.calibrate_gyro():
-            structured_data = parse_gyroscope_progress(progress_data)
+            structured_data = parse_gyroscope_progress(progress_data, prev=prev)
+            prev = structured_data
             yield structured_data
 
         yield {
@@ -70,8 +72,10 @@ async def calibrate_sensors(
             "message": "Starting accelerometer calibration...",
         }
 
+        prev = None
         async for progress_data in drone.calibration.calibrate_accelerometer():
-            structured_data = parse_accelerometer_progress(progress_data)
+            structured_data = parse_accelerometer_progress(progress_data, prev=prev)
+            prev = structured_data
             yield structured_data
 
         yield {
@@ -87,8 +91,10 @@ async def calibrate_sensors(
             "message": "Starting magnetometer calibration...",
         }
 
+        prev = None
         async for progress_data in drone.calibration.calibrate_magnetometer():
-            structured_data = parse_magnetometer_progress(progress_data)
+            structured_data = parse_magnetometer_progress(progress_data, prev=prev)
+            prev = structured_data
             yield structured_data
 
         yield {
@@ -104,8 +110,10 @@ async def calibrate_sensors(
             "message": "Starting board level horizon calibration...",
         }
 
+        prev = None
         async for progress_data in drone.calibration.calibrate_level_horizon():
-            structured_data = parse_horizon_progress(progress_data)
+            structured_data = parse_horizon_progress(progress_data, prev=prev)
+            prev = structured_data
             yield structured_data
 
         yield {

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

@@ -0,0 +1,224 @@
+"""Service for PX4 health and calibration snapshot."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Optional, Dict, Any, Iterable
+
+from mavsdk import System
+
+from ..config import settings
+from ..models import Px4HealthResponse, CalibrationHealth
+
+
+async def _get_health_once(drone: System, timeout_s: float = 5.0):
+    """
+    Wait for the first telemetry.health() message.
+
+    Raises asyncio.TimeoutError if nothing is received within timeout_s.
+    """
+    async def _first():
+        async for health in drone.telemetry.health():
+            return health
+
+    return await asyncio.wait_for(_first(), timeout_s)
+
+
+async def _get_gps_info_once(drone: System, timeout_s: float = 5.0):
+    """
+    Wait for the first telemetry.gps_info() message.
+
+    Raises asyncio.TimeoutError if nothing is received within timeout_s.
+    """
+    async def _first():
+        async for gps_info in drone.telemetry.gps_info():
+            return gps_info
+
+    return await asyncio.wait_for(_first(), timeout_s)
+
+
+SENSOR_INDEXES: Iterable[int] = (0, 1, 2)
+
+
+async def _is_family_calibrated(
+    drone: System,
+    family: str,
+    indexes: Iterable[int] = SENSOR_INDEXES,
+) -> bool:
+    """
+    Param-based heuristic:
+
+    A sensor family (gyro/accel/mag) is considered calibrated if ANY
+    CAL_FAMILYn_ID != 0 for the probed indexes and the param read succeeds.
+    """
+    prefix_map = {
+        "gyro": "CAL_GYRO",
+        "accel": "CAL_ACC",
+        "mag": "CAL_MAG",
+    }
+    prefix = prefix_map.get(family)
+    if not prefix:
+        return False
+
+    for i in indexes:
+        name = f"{prefix}{i}_ID"
+        try:
+            sensor_id = await drone.param.get_param_int(name)
+        except Exception:
+            # Ignore this index if param read fails
+            continue
+        if sensor_id != 0:
+            return True
+
+    return False
+
+
+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 one-shot health snapshot.
+
+    - Uses PX4 CAL_* params to derive calibration health.
+    - Uses telemetry.health() for armable + positional flags.
+    - Uses telemetry.gps_info() for fix type + satellites.
+    - Returns Px4HealthResponse; never raises to the API layer.
+    """
+
+    # Fallback to global settings if not provided explicitly
+    port = port or settings.default_port
+    baudrate = baudrate or settings.default_baudrate
+    serial = f"serial://{port}:{baudrate}"
+
+    drone = System()
+
+    try:
+        # Connect to PX4
+        await drone.connect(system_address=serial)
+
+        # Optional: verify we actually got a connection state
+        async for state in drone.core.connection_state():
+            if not state.is_connected:
+                # Treat as disconnected; don't bother with the rest
+                return Px4HealthResponse(
+                    status="disconnected",
+                    connection_port=port,
+                    connection_baudrate=baudrate,
+                    calibration=None,
+                    gps_fix_type=None,
+                    satellites_used=None,
+                    armable=False,
+                    raw_health=None,
+                )
+            break
+
+        # -------- PARAM-BASED CALIBRATION (source of truth) --------
+        gyroscope_ok = await _is_family_calibrated(drone, "gyro")
+        accelerometer_ok = await _is_family_calibrated(drone, "accel")
+        magnetometer_ok = await _is_family_calibrated(drone, "mag")
+
+        calibration = CalibrationHealth(
+            gyroscope_ok=gyroscope_ok,
+            accelerometer_ok=accelerometer_ok,
+            magnetometer_ok=magnetometer_ok,
+        )
+
+        # -------- TELEMETRY HEALTH (for armable + debug) --------
+        try:
+            health = await _get_health_once(drone, timeout_s=timeout_s / 2)
+        except asyncio.TimeoutError:
+            health = None
+
+        # -------- GPS INFO (unchanged) --------
+        try:
+            gps_info = await _get_gps_info_once(drone, timeout_s=timeout_s / 2)
+        except asyncio.TimeoutError:
+            gps_info = None
+
+        gps_fix_type: Optional[str] = None
+        satellites_used: Optional[int] = None
+
+        if gps_info is not None:
+            if hasattr(gps_info.fix_type, "name"):
+                gps_fix_type = gps_info.fix_type.name.lower()
+            else:
+                gps_fix_type = str(gps_info.fix_type).lower()
+
+            satellites_used = int(getattr(gps_info, "num_satellites", 0))
+
+        # -------- STATUS + ARMABLE (respect your Literal) --------
+        armable: Optional[bool] = None
+        if health is not None:
+            armable = health.is_armable
+
+        # Map everything into your fixed status vocabulary:
+        # - disconnected: handled in exception / early return
+        # - ok: armable and all calibrated
+        # - degraded: anything else (not armable or missing calibration)
+        if armable and not calibration.requires_calibration:
+            status = "ok"
+        else:
+            status = "degraded"
+
+        # -------- RAW HEALTH FOR DEBUG/UI --------
+        raw_health: Dict[str, Any] = {}
+
+        # Telemetry-derived bits (if available)
+        if health is not None:
+            raw_health.update(
+                {
+                    "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_local_position_ok": getattr(health, "is_local_position_ok", None),
+                    "is_global_position_ok": getattr(health, "is_global_position_ok", None),
+                    "is_home_position_ok": getattr(health, "is_home_position_ok", None),
+                    "is_armable": health.is_armable,
+                }
+            )
+        else:
+            raw_health.update(
+                {
+                    "is_gyrometer_calibration_ok": None,
+                    "is_accelerometer_calibration_ok": None,
+                    "is_magnetometer_calibration_ok": None,
+                    "is_local_position_ok": None,
+                    "is_global_position_ok": None,
+                    "is_home_position_ok": None,
+                    "is_armable": None,
+                }
+            )
+
+        # Param-derived calibration snapshot as debug info (so you can see IDs in Swagger/UI later if you want)
+        raw_health["calibration_params"] = {
+            "source": "CAL_*_ID heuristic",
+            "gyroscope_ok": gyroscope_ok,
+            "accelerometer_ok": accelerometer_ok,
+            "magnetometer_ok": magnetometer_ok,
+        }
+
+        return Px4HealthResponse(
+            status=status,
+            connection_port=port,
+            connection_baudrate=baudrate,
+            calibration=calibration,
+            gps_fix_type=gps_fix_type,
+            satellites_used=satellites_used,
+            armable=armable,
+            raw_health=raw_health,
+        )
+
+    except (asyncio.TimeoutError, Exception):
+        # On any connection / telemetry failure, report "disconnected"
+        return Px4HealthResponse(
+            status="disconnected",
+            connection_port=port,
+            connection_baudrate=baudrate,
+            calibration=None,
+            gps_fix_type=None,
+            satellites_used=None,
+            armable=False,
+            raw_health=None,
+        )

{px4_configuration-0.1.0 → px4_configuration-0.2.1}/px4_configuration/api/utils/calibration_parser.py

@@ -5,7 +5,10 @@ from typing import Optional, Dict, Any, List
 import math
 
 
-def parse_accelerometer_progress(progress_data) -> Dict[str, Any]:
+def parse_accelerometer_progress(
+    progress_data,
+    prev: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
     """
     Parse accelerometer calibration progress data into structured format.
     
@@ -33,10 +36,11 @@ def parse_accelerometer_progress(progress_data) -> Dict[str, Any]:
             result["progress"] = float(progress_value)
     
     # Extract status text if available
+    pending_match = None
     if hasattr(progress_data, 'has_status_text') and progress_data.has_status_text:
         status_text = progress_data.status_text
         result["status_text"] = status_text
-        
+
         # Parse pending orientations (e.g., "pending: back front left right up down")
         pending_match = re.search(r'pending:\s*([a-z\s]+)', status_text, re.IGNORECASE)
         if pending_match:
@@ -65,31 +69,44 @@ def parse_accelerometer_progress(progress_data) -> Dict[str, Any]:
             except ValueError:
                 pass
         
-        # Determine current message/instruction
-        if "progress" in status_text.lower() and "<" in status_text and ">" in status_text:
+        # Determine current message/instruction (normalize to simple labels)
+        low = status_text.lower()
+        if "progress" in low and "<" in status_text and ">" in status_text:
             # This seems to be a completion indicator (e.g., "progress <102>")
             result["is_complete"] = True
             result["current_message"] = "complete"
-        elif "hold vehicle still" in status_text.lower():
+        elif pending_match:
+            result["current_message"] = "pending"
+        elif "hold vehicle still" in low:
             result["current_message"] = "hold_still"
-        elif "detected rest position" in status_text.lower():
+        elif "detected rest position" in low:
             result["current_message"] = "rest_detected"
-        elif "measuring" in status_text.lower():
+        elif "measuring" in low:
             result["current_message"] = "measuring"
-        elif "done, rotate" in status_text.lower():
+        elif "done, rotate" in low:
             result["current_message"] = "rotate"
-        elif "already completed" in status_text.lower():
+        elif "already completed" in low:
             result["current_message"] = "already_completed"
-        elif "orientation detected" in status_text.lower():
+        elif "orientation detected" in low:
             result["current_message"] = "orientation_detected"
         else:
             # Default: use the status text as message
             result["current_message"] = status_text
+
+    # Carry forward state from previous snapshot where appropriate
+    if prev:
+        if not result["pending_orientations"]:
+            result["pending_orientations"] = prev.get("pending_orientations", [])
+        if result["current_orientation"] is None:
+            result["current_orientation"] = prev.get("current_orientation")
     
     return result
 
 
-def parse_gyroscope_progress(progress_data) -> Dict[str, Any]:
+def parse_gyroscope_progress(
+    progress_data,
+    prev: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
     """
     Parse gyroscope calibration progress data into structured format.
     
@@ -126,11 +143,19 @@ def parse_gyroscope_progress(progress_data) -> Dict[str, Any]:
         result["status_text"] = status_text
         if status_text and not result["current_message"]:
             result["current_message"] = status_text
+
+    # Carry forward simple state where helpful
+    if prev:
+        if result["progress"] is None:
+            result["progress"] = prev.get("progress")
     
     return result
 
 
-def parse_magnetometer_progress(progress_data) -> Dict[str, Any]:
+def parse_magnetometer_progress(
+    progress_data,
+    prev: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
     """
     Parse magnetometer calibration progress data into structured format.
     
@@ -185,29 +210,40 @@ def parse_magnetometer_progress(progress_data) -> Dict[str, Any]:
                 result["current_orientation"] = match.group(1).lower()
                 break
         
-        # Determine current message/instruction
-        if "Rotate vehicle" in status_text:
+        # Determine current message/instruction (normalize)
+        low = status_text.lower()
+        if "rotate vehicle" in status_text:
             result["current_message"] = "rotate"
-        elif "hold vehicle still" in status_text.lower():
+        elif "hold vehicle still" in low:
             result["current_message"] = "hold_still"
-        elif "detected rest position" in status_text.lower():
+        elif "detected rest position" in low:
             result["current_message"] = "rest_detected"
-        elif "detected motion" in status_text.lower():
+        elif "detected motion" in low:
             result["current_message"] = "motion_detected"
-        elif "done, rotate" in status_text.lower():
+        elif "done, rotate" in low:
             result["current_message"] = "rotate"
-        elif "already completed" in status_text.lower():
+        elif "already completed" in low:
             result["current_message"] = "already_completed"
-        elif "orientation detected" in status_text.lower():
+        elif "orientation detected" in low:
             result["current_message"] = "orientation_detected"
         else:
             # Default: use the status text as message
             result["current_message"] = status_text
+
+    # Carry forward orientation / pending where appropriate
+    if prev:
+        if not result["pending_orientations"]:
+            result["pending_orientations"] = prev.get("pending_orientations", [])
+        if result["current_orientation"] is None:
+            result["current_orientation"] = prev.get("current_orientation")
     
     return result
 
 
-def parse_horizon_progress(progress_data) -> Dict[str, Any]:
+def parse_horizon_progress(
+    progress_data,
+    prev: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
     """
     Parse level horizon calibration progress data into structured format.
     
@@ -243,6 +279,11 @@ def parse_horizon_progress(progress_data) -> Dict[str, Any]:
         result["status_text"] = status_text
         if status_text and not result["current_message"]:
             result["current_message"] = status_text
+
+    # Carry forward simple state where helpful
+    if prev:
+        if result["progress"] is None:
+            result["progress"] = prev.get("progress")
     
     return result
 

{px4_configuration-0.1.0 → px4_configuration-0.2.1}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 name = "px4-configuration"
-version = "0.1.0"
+version = "0.2.1"
 description = "Tools and REST API for configuring PX4 from a companion computer"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 license = { text = "BSD-3-Clause" }
 authors = [
   { name = "Alex", email = "bonnefond@fly4future.com" }

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

@@ -1,131 +0,0 @@
-"""Service for PX4 health and calibration snapshot."""
-
-from __future__ import annotations
-
-import asyncio
-from typing import Optional, Dict, Any
-
-from mavsdk import System
-
-from ..config import settings
-from ..models import Px4HealthResponse, CalibrationHealth
-
-
-async def _get_health_once(drone: System, timeout_s: float = 5.0):
-    """
-    Wait for the first telemetry.health() message.
-
-    Raises asyncio.TimeoutError if nothing is received within timeout_s.
-    """
-    async def _first():
-        async for health in drone.telemetry.health():
-            return health
-
-    return await asyncio.wait_for(_first(), timeout_s)
-
-
-async def _get_gps_info_once(drone: System, timeout_s: float = 5.0):
-    """
-    Wait for the first telemetry.gps_info() message.
-
-    Raises asyncio.TimeoutError if nothing is received within timeout_s.
-    """
-    async def _first():
-        async for gps_info in drone.telemetry.gps_info():
-            return gps_info
-
-    return await asyncio.wait_for(_first(), timeout_s)
-
-
-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 one-shot health snapshot.
-
-    - Uses telemetry.health() for calibration + armable flags.
-    - Uses telemetry.gps_info() for fix type + satellites.
-    - Returns Px4HealthResponse; never raises to the API layer.
-    """
-
-    # Fallback to global settings if not provided explicitly
-    port = port or settings.default_port
-    baudrate = baudrate or settings.default_baudrate
-    serial = f"serial://{port}:{baudrate}"
-
-    drone = System()
-
-    try:
-        # Connect to PX4
-        await drone.connect(system_address=serial)
-
-        # Get health & GPS within the global timeout
-        health = await _get_health_once(drone, timeout_s=timeout_s / 2)
-        try:
-            gps_info = await _get_gps_info_once(drone, timeout_s=timeout_s / 2)
-        except asyncio.TimeoutError:
-            gps_info = None
-
-        # Build calibration health
-        calibration = CalibrationHealth(
-            gyroscope_ok=health.is_gyrometer_calibration_ok,
-            accelerometer_ok=health.is_accelerometer_calibration_ok,
-            magnetometer_ok=health.is_magnetometer_calibration_ok,
-        )
-
-        # GPS fields
-        gps_fix_type: Optional[str] = None
-        satellites_used: Optional[int] = None
-
-        if gps_info is not None:
-            # gps_info.fix_type is an enum; prefer its name
-            if hasattr(gps_info.fix_type, "name"):
-                gps_fix_type = gps_info.fix_type.name.lower()
-            else:
-                gps_fix_type = str(gps_info.fix_type).lower()
-
-            # MAVSDK docs: num_satellites = number of visible satellites in use
-            satellites_used = int(getattr(gps_info, "num_satellites", 0))
-
-        # High-level status heuristic
-        if calibration.requires_calibration:
-            status = "degraded"
-        else:
-            status = "ok"
-
-        # Raw health flags (optional, but handy for debugging / advanced UI)
-        raw_health: Dict[str, Any] = {
-            "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_local_position_ok": getattr(health, "is_local_position_ok", None),
-            "is_global_position_ok": getattr(health, "is_global_position_ok", None),
-            "is_home_position_ok": getattr(health, "is_home_position_ok", None),
-            "is_armable": health.is_armable,
-        }
-
-        return Px4HealthResponse(
-            status=status,
-            connection_port=port,
-            connection_baudrate=baudrate,
-            calibration=calibration,
-            gps_fix_type=gps_fix_type,
-            satellites_used=satellites_used,
-            armable=health.is_armable,
-            raw_health=raw_health,
-        )
-
-    except (asyncio.TimeoutError, Exception):
-        # On any connection / telemetry failure, report "disconnected"
-        return Px4HealthResponse(
-            status="disconnected",
-            connection_port=port,
-            connection_baudrate=baudrate,
-            calibration=None,
-            gps_fix_type=None,
-            satellites_used=None,
-            armable=False,
-            raw_health=None,
-        )