px4-configuration 0.1.0__py3-none-any.whl

px4_configuration/api/services/health_service.py

@@ -0,0 +1,131 @@
+"""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,
+        )

px4_configuration/api/services/param_service.py

@@ -0,0 +1,150 @@
+"""Service for PX4 parameter upload operations."""
+
+import json
+from typing import AsyncGenerator
+
+from mavsdk import System
+
+
+async def upload_parameters(
+    param_file_path: str,
+    port: str,
+    baudrate: int,
+) -> AsyncGenerator[str, None]:
+    """Upload PX4 parameters from a .params file, streaming progress via SSE."""
+
+    drone = None
+    try:
+        drone = System()
+        serial = f"serial://{port}:{baudrate}"
+
+        yield "data: {}\n\n".format(
+            json.dumps({"type": "status", "message": f"Connecting to {port}..."})
+        )
+        await drone.connect(system_address=serial)
+        yield "data: {}\n\n".format(
+            json.dumps({"type": "status", "message": "Connected to device"})
+        )
+
+        param_plugin = drone.param
+        yield "data: {}\n\n".format(
+            json.dumps({"type": "status", "message": "Fetching current parameters..."})
+        )
+        params = await param_plugin.get_all_params()
+        float_params = params.float_params
+        int_params = params.int_params
+        custom_params = params.custom_params
+        int_param_names = [p.name for p in int_params]
+        float_param_names = [p.name for p in float_params]
+        custom_param_names = [p.name for p in custom_params]
+
+        yield "data: {}\n\n".format(
+            json.dumps({"type": "status", "message": "Checking if vehicle is landed..."})
+        )
+        async for is_in_air in drone.telemetry.in_air():
+            if is_in_air:
+                yield "data: {}\n\n".format(
+                    json.dumps(
+                        {
+                            "type": "warning",
+                            "message": "Waiting until vehicle is landed...",
+                        }
+                    )
+                )
+            else:
+                break
+
+        yield "data: {}\n\n".format(
+            json.dumps(
+                {
+                    "type": "status",
+                    "message": "Uploading parameters... Please do not arm the vehicle!",
+                }
+            )
+        )
+
+        with open(param_file_path, "r", encoding="utf-8") as param_file:
+            total_lines = sum(
+                1 for line in param_file if line.strip() and not line.startswith("#")
+            )
+
+        uploaded_count = 0
+        with open(param_file_path, "r", encoding="utf-8") as param_file:
+            for line in param_file:
+                if line.startswith("#") or not line.strip():
+                    continue
+
+                columns = line.strip().split(",")
+                if len(columns) < 2:
+                    continue
+
+                name = columns[0].strip()
+                value = columns[1].strip()
+
+                try:
+                    if name in int_param_names:
+                        await drone.param.set_param_int(name, int(value))
+                    elif name in float_param_names:
+                        await drone.param.set_param_float(name, float(value))
+                    elif name in custom_param_names:
+                        await drone.param.set_param_custom(name, value)
+                    else:
+                        yield "data: {}\n\n".format(
+                            json.dumps(
+                                {
+                                    "type": "warning",
+                                    "message": f"Parameter {name} not found, skipping",
+                                }
+                            )
+                        )
+                        continue
+
+                    uploaded_count += 1
+                    yield "data: {}\n\n".format(
+                        json.dumps(
+                            {
+                                "type": "progress",
+                                "message": f"Uploaded {name} = {value}",
+                                "progress": uploaded_count,
+                                "total": total_lines,
+                            }
+                        )
+                    )
+                except Exception as exc:  # pragma: no cover - streaming generator
+                    yield "data: {}\n\n".format(
+                        json.dumps(
+                            {
+                                "type": "error",
+                                "message": f"Failed to set {name}: {exc}",
+                            }
+                        )
+                    )
+
+        yield "data: {}\n\n".format(
+            json.dumps({"type": "status", "message": "Parameters uploaded, rebooting..."})
+        )
+        await drone.action.reboot()
+        yield "data: {}\n\n".format(
+            json.dumps(
+                {
+                    "type": "success",
+                    "message": "Parameters uploaded and vehicle rebooted",
+                }
+            )
+        )
+
+    except Exception as exc:  # pragma: no cover - streaming generator
+        yield "data: {}\n\n".format(
+            json.dumps(
+                {
+                    "type": "error",
+                    "message": f"Parameter upload failed: {exc}",
+                }
+            )
+        )
+        raise
+    finally:
+        if drone:
+            # No explicit teardown required
+            pass
+

px4_configuration/api/services/sdcard_service.py

@@ -0,0 +1,89 @@
+"""Service for uploading files to PX4 SD card via FTP."""
+
+import json
+from typing import AsyncGenerator
+
+from mavsdk import System
+
+
+async def upload_to_sdcard(
+    file_path: str,
+    port: str,
+    baudrate: int,
+    remote_path: str = "/fs/microsd/etc",
+) -> AsyncGenerator[str, None]:
+    """Upload a file to the PX4 SD card via MAVSDK FTP and stream progress."""
+
+    drone = None
+    try:
+        drone = System()
+        serial = f"serial://{port}:{baudrate}"
+
+        yield "data: {}\n\n".format(
+            json.dumps({"type": "status", "message": f"Connecting to {port}..."})
+        )
+        await drone.connect(system_address=serial)
+        yield "data: {}\n\n".format(
+            json.dumps({"type": "status", "message": "Connected to device"})
+        )
+
+        yield "data: {}\n\n".format(
+            json.dumps(
+                {
+                    "type": "status",
+                    "message": f"Listing directory {remote_path}...",
+                }
+            )
+        )
+        try:
+            directory_list = await drone.ftp.list_directory(remote_path)
+            yield "data: {}\n\n".format(
+                json.dumps(
+                    {
+                        "type": "status",
+                        "message": f"Directory listing: {directory_list}",
+                    }
+                )
+            )
+        except Exception as exc:  # pragma: no cover
+            yield "data: {}\n\n".format(
+                json.dumps(
+                    {
+                        "type": "warning",
+                        "message": f"Could not list directory: {exc}",
+                    }
+                )
+            )
+
+        yield "data: {}\n\n".format(
+            json.dumps(
+                {
+                    "type": "status",
+                    "message": f"Uploading {file_path} to {remote_path}...",
+                }
+            )
+        )
+        async for progress_data in drone.ftp.upload(file_path, remote_path):
+            yield "data: {}\n\n".format(
+                json.dumps({"type": "progress", "data": str(progress_data)})
+            )
+
+        yield "data: {}\n\n".format(
+            json.dumps({"type": "success", "message": "File uploaded successfully"})
+        )
+
+    except Exception as exc:  # pragma: no cover - streaming generator
+        yield "data: {}\n\n".format(
+            json.dumps(
+                {
+                    "type": "error",
+                    "message": f"SD card upload failed: {exc}",
+                }
+            )
+        )
+        raise
+    finally:
+        if drone:
+            # No explicit teardown required
+            pass
+

px4_configuration/api/services/shell_service.py

@@ -0,0 +1,65 @@
+"""Service for PX4 shell connection management."""
+
+import asyncio
+from typing import Optional
+
+from mavsdk import System
+
+
+class ShellConnection:
+    """Manage a persistent MAVSDK shell connection with queued output."""
+
+    def __init__(self, port: str, baudrate: int) -> None:
+        self.port = port
+        self.baudrate = baudrate
+        self.drone: Optional[System] = None
+        self.output_queue: "asyncio.Queue[str]" = asyncio.Queue()
+        self.connected = False
+
+    async def connect(self) -> None:
+        """Establish connection to PX4 and start shell monitoring."""
+
+        self.drone = System()
+        serial = f"serial://{self.port}:{self.baudrate}"
+        await self.drone.connect(system_address=serial)
+
+        async for state in self.drone.core.connection_state():
+            if state.is_connected:
+                self.connected = True
+                break
+
+        asyncio.create_task(self._observe_shell())
+
+    async def _observe_shell(self) -> None:
+        """Monitor shell output and place data into the queue."""
+
+        if not self.drone:
+            return
+
+        try:
+            async for output in self.drone.shell.receive():
+                await self.output_queue.put(output)
+        except Exception as exc:  # pragma: no cover - streaming loop
+            await self.output_queue.put(f"Error receiving shell output: {exc}")
+
+    async def send_command(self, command: str) -> None:
+        """Send a command to the PX4 shell."""
+
+        if not self.connected or not self.drone:
+            raise RuntimeError("Not connected to PX4")
+        await self.drone.shell.send(command)
+
+    async def receive_output(self) -> Optional[str]:
+        """Receive shell output (non-blocking)."""
+
+        try:
+            return await asyncio.wait_for(self.output_queue.get(), timeout=0.1)
+        except asyncio.TimeoutError:
+            return None
+
+    async def disconnect(self) -> None:
+        """Close the connection if required."""
+
+        self.connected = False
+        # MAVSDK handles cleanup on garbage collection; nothing else required here.
+

px4_configuration/api/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility functions for the PX4 configuration API."""

px4_configuration/api/utils/calibration_parser.py

@@ -0,0 +1,248 @@
+"""Parser for extracting structured data from MAVSDK calibration progress updates."""
+
+import re
+from typing import Optional, Dict, Any, List
+import math
+
+
+def parse_accelerometer_progress(progress_data) -> Dict[str, Any]:
+    """
+    Parse accelerometer calibration progress data into structured format.
+    
+    Args:
+        progress_data: ProgressData object from mavsdk
+        
+    Returns:
+        Dictionary with structured calibration information
+    """
+    result: Dict[str, Any] = {
+        "type": "accelerometer_progress",
+        "progress": None,
+        "status_text": None,
+        "pending_orientations": [],
+        "current_orientation": None,
+        "current_message": None,
+        "result": None,
+        "is_complete": False,
+    }
+    
+    # Extract progress if available
+    if hasattr(progress_data, 'has_progress') and progress_data.has_progress:
+        progress_value = progress_data.progress
+        if not (math.isnan(progress_value) if isinstance(progress_value, float) else False):
+            result["progress"] = float(progress_value)
+    
+    # Extract status text if available
+    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:
+            orientations = [o.strip() for o in pending_match.group(1).split() if o.strip()]
+            result["pending_orientations"] = orientations
+        
+        # Parse current orientation being measured
+        orientation_patterns = [
+            r'(\w+)\s+orientation detected',
+            r'(\w+)\s+side result:',
+            r'(\w+)\s+side done',
+            r'Hold still, measuring (\w+) side',
+        ]
+        for pattern in orientation_patterns:
+            match = re.search(pattern, status_text, re.IGNORECASE)
+            if match:
+                result["current_orientation"] = match.group(1).lower()
+                break
+        
+        # Extract result values (e.g., "down side result: [0.020 0.819 -9.750]")
+        result_match = re.search(r'result:\s*\[([\d\.\-\s]+)\]', status_text)
+        if result_match:
+            try:
+                values = [float(v) for v in result_match.group(1).split()]
+                result["result"] = values
+            except ValueError:
+                pass
+        
+        # Determine current message/instruction
+        if "progress" in status_text.lower() 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():
+            result["current_message"] = "hold_still"
+        elif "detected rest position" in status_text.lower():
+            result["current_message"] = "rest_detected"
+        elif "measuring" in status_text.lower():
+            result["current_message"] = "measuring"
+        elif "done, rotate" in status_text.lower():
+            result["current_message"] = "rotate"
+        elif "already completed" in status_text.lower():
+            result["current_message"] = "already_completed"
+        elif "orientation detected" in status_text.lower():
+            result["current_message"] = "orientation_detected"
+        else:
+            # Default: use the status text as message
+            result["current_message"] = status_text
+    
+    return result
+
+
+def parse_gyroscope_progress(progress_data) -> Dict[str, Any]:
+    """
+    Parse gyroscope calibration progress data into structured format.
+    
+    Gyroscope calibration only provides progress values (0.0 to 1.0) without status text.
+    The vehicle should be kept still during calibration.
+    
+    Args:
+        progress_data: ProgressData object from mavsdk
+        
+    Returns:
+        Dictionary with structured calibration information
+    """
+    result: Dict[str, Any] = {
+        "type": "gyroscope_progress",
+        "progress": None,
+        "status_text": None,
+        "current_message": None,
+        "is_complete": False,
+    }
+    
+    if hasattr(progress_data, 'has_progress') and progress_data.has_progress:
+        progress_value = progress_data.progress
+        if not (math.isnan(progress_value) if isinstance(progress_value, float) else False):
+            result["progress"] = float(progress_value)
+            # Mark as complete when progress reaches 1.0
+            if result["progress"] >= 1.0:
+                result["is_complete"] = True
+                result["current_message"] = "complete"
+            else:
+                result["current_message"] = "calibrating"
+    
+    if hasattr(progress_data, 'has_status_text') and progress_data.has_status_text:
+        status_text = progress_data.status_text
+        result["status_text"] = status_text
+        if status_text and not result["current_message"]:
+            result["current_message"] = status_text
+    
+    return result
+
+
+def parse_magnetometer_progress(progress_data) -> Dict[str, Any]:
+    """
+    Parse magnetometer calibration progress data into structured format.
+    
+    Magnetometer calibration involves rotating the vehicle through different orientations
+    while progress increments from 0.0 to 1.0.
+    
+    Args:
+        progress_data: ProgressData object from mavsdk
+        
+    Returns:
+        Dictionary with structured calibration information
+    """
+    result: Dict[str, Any] = {
+        "type": "magnetometer_progress",
+        "progress": None,
+        "status_text": None,
+        "pending_orientations": [],
+        "current_orientation": None,
+        "current_message": None,
+        "is_complete": False,
+    }
+    
+    # Extract progress if available
+    if hasattr(progress_data, 'has_progress') and progress_data.has_progress:
+        progress_value = progress_data.progress
+        if not (math.isnan(progress_value) if isinstance(progress_value, float) else False):
+            result["progress"] = float(progress_value)
+            # Mark as complete when progress reaches 1.0
+            if result["progress"] >= 1.0:
+                result["is_complete"] = True
+    
+    # Extract status text if available
+    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:
+            orientations = [o.strip() for o in pending_match.group(1).split() if o.strip()]
+            result["pending_orientations"] = orientations
+        
+        # Parse current orientation being measured
+        orientation_patterns = [
+            r'(\w+)\s+orientation detected',
+            r'(\w+)\s+side done',
+            r'(\w+)\s+side already completed',
+        ]
+        for pattern in orientation_patterns:
+            match = re.search(pattern, status_text, re.IGNORECASE)
+            if match:
+                result["current_orientation"] = match.group(1).lower()
+                break
+        
+        # Determine current message/instruction
+        if "Rotate vehicle" in status_text:
+            result["current_message"] = "rotate"
+        elif "hold vehicle still" in status_text.lower():
+            result["current_message"] = "hold_still"
+        elif "detected rest position" in status_text.lower():
+            result["current_message"] = "rest_detected"
+        elif "detected motion" in status_text.lower():
+            result["current_message"] = "motion_detected"
+        elif "done, rotate" in status_text.lower():
+            result["current_message"] = "rotate"
+        elif "already completed" in status_text.lower():
+            result["current_message"] = "already_completed"
+        elif "orientation detected" in status_text.lower():
+            result["current_message"] = "orientation_detected"
+        else:
+            # Default: use the status text as message
+            result["current_message"] = status_text
+    
+    return result
+
+
+def parse_horizon_progress(progress_data) -> Dict[str, Any]:
+    """
+    Parse level horizon calibration progress data into structured format.
+    
+    Horizon calibration only provides progress values (0.0 to 1.0) without status text.
+    
+    Args:
+        progress_data: ProgressData object from mavsdk
+        
+    Returns:
+        Dictionary with structured calibration information
+    """
+    result: Dict[str, Any] = {
+        "type": "horizon_progress",
+        "progress": None,
+        "status_text": None,
+        "current_message": None,
+        "is_complete": False,
+    }
+    
+    if hasattr(progress_data, 'has_progress') and progress_data.has_progress:
+        progress_value = progress_data.progress
+        if not (math.isnan(progress_value) if isinstance(progress_value, float) else False):
+            result["progress"] = float(progress_value)
+            # Mark as complete when progress reaches 1.0
+            if result["progress"] >= 1.0:
+                result["is_complete"] = True
+                result["current_message"] = "complete"
+            else:
+                result["current_message"] = "calibrating"
+    
+    if hasattr(progress_data, 'has_status_text') and progress_data.has_status_text:
+        status_text = progress_data.status_text
+        result["status_text"] = status_text
+        if status_text and not result["current_message"]:
+            result["current_message"] = status_text
+    
+    return result
+