petal-user-journey-coordinator 0.1.5__tar.gz → 0.1.6__tar.gz

{petal_user_journey_coordinator-0.1.5 → petal_user_journey_coordinator-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: petal-user-journey-coordinator
-Version: 0.1.5
+Version: 0.1.6
 Summary: A petal for the DroneLeaf ecosystem
 Author-Email: Khalil Al Handawi <khalil.alhandawi@droneleaf.io>
 License: MIT

{petal_user_journey_coordinator-0.1.5 → petal_user_journey_coordinator-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "petal-user-journey-coordinator"
-version = "0.1.5"
+version = "0.1.6"
 description = "A petal for the DroneLeaf ecosystem"
 authors = [
     { name = "Khalil Al Handawi", email = "khalil.alhandawi@droneleaf.io" },
@@ -41,6 +41,6 @@ test = [
     "pytest-asyncio>=1.0.0",
     "anyio>=4.9.0",
     "pytest-cov>=6.2.1",
-    "petal-app-manager==0.1.46",
+    "petal-app-manager>=0.1.50",
     "leaf-pymavlink>=0.1.11",
 ]

{petal_user_journey_coordinator-0.1.5 → petal_user_journey_coordinator-0.1.6}/src/petal_user_journey_coordinator/data_model.py

@@ -1,57 +1,59 @@
 from pydantic import BaseModel, Field, field_validator, ValidationError
-from typing import Dict, Any, List, Union, Optional, Callable
+from typing import Dict, Any, List, Literal, Union, Optional, Callable
 from datetime import datetime
 
-
 class ParameterBaseModel(BaseModel):
     """Base fields for flight records"""
     parameter_name: str = Field(..., description="Parameter name")
     parameter_value: Union[str,int,float] = Field(..., description="Value of the parameter")
+    parameter_type: Optional[Literal['UINT8','INT8','UINT16','INT16','UINT32','INT32','UINT64','INT64','REAL32','REAL64']] = Field(default=None, description="Type of the parameter")
 
     model_config = {
         "json_schema_extra": {
             "example": {
                 "parameter_name": "CA_ROTOR_COUNT",
-                "parameter_value": 4
+                "parameter_value": 4,
+                "parameter_type": "UINT8"
             }
         }
     }
 
 
-class ParameterRequestModel(BaseModel):
-    """Base fields for flight records"""
-    parameter_name: str = Field(..., description="Parameter name")
+class ParameterResult(BaseModel):
+    """Individual parameter result"""
+    name: str = Field(..., description="Name of the parameter")
+    value: Optional[Union[str,int,float]] = Field(None, description="Decoded value of the parameter")
+    raw: Optional[Union[str,int,float]] = Field(None, description="Raw value of the parameter")
+    type: Optional[int] = Field(None, description="Type of the parameter")
+    count: Optional[int] = Field(None, description="Total number of parameters")
+    index: Optional[int] = Field(None, description="Index of the parameter")
+    error: Optional[str] = Field(default=None, description="Error message if setting the parameter failed")
+    success: Optional[bool] = Field(default=None, description="Whether setting the parameter was successful")
 
     model_config = {
         "json_schema_extra": {
             "example": {
-                "parameter_name": "CA_ROTOR_COUNT"
+                "name": "CA_ROTOR_COUNT",
+                "value": 4,
+                "raw": 4.0,
+                "type": 6,
+                "count": 1053,
+                "index": 65535,
+                "error": None,
+                "success": True
             }
         }
     }
 
 
-class MQTTMessage(BaseModel):
-    """MQTT message model"""
-    waitResponse: bool = Field(..., description="Whether to wait for a response")
-    messageId: str = Field(..., description="Unique message ID")
-    deviceId: str = Field(..., description="Device ID")
-    command: str = Field(..., description="Command to execute")
-    timestamp: str = Field(..., description="Timestamp of the message")
-    payload: Dict[str, Any] = Field(..., description="Message payload")
+class ParameterRequestModel(BaseModel):
+    """Base fields for flight records"""
+    parameter_name: str = Field(..., description="Parameter name")
 
     model_config = {
         "json_schema_extra": {
             "example": {
-                "waitResponse": True,
-                "messageId": "kkkss8fepn-1756665973142-bptyoj06z",
-                "deviceId": "Instance-a92c5505-ccdb-4ac7-b0fe-74f4fa5fc5b9",
-                "command": "Update",
-                "payload": {
-                    "source": "web-client",
-                    "app": "leaf-fc"
-                },
-                "timestamp": "2025-08-31T18:46:13.142Z"
+                "parameter_name": "CA_ROTOR_COUNT"
             }
         }
     }
@@ -554,3 +556,81 @@ class SetStaticIpAddressResponse(BaseModel):
             }
         }
     }
+
+
+class BulkParameterSetRequest(BaseModel):
+    """Request model for bulk parameter setting"""
+    parameters: List[ParameterBaseModel] = Field(..., description="List of parameters to set")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "parameters": [
+                    {
+                        "parameter_name": "CA_ROTOR_COUNT",
+                        "parameter_value": 4,
+                        "parameter_type": "UINT8"
+                    },
+                    {
+                        "parameter_name": "VTO_LOITER_ALT",
+                        "parameter_value": 80.0,
+                        "parameter_type": "REAL32"
+                    }
+                ]
+            }
+        }   
+    }
+
+
+class BulkParameterGetRequest(BaseModel):
+    """Request model for bulk parameter getting"""
+    parameter_names: List[str] = Field(..., description="List of parameter names to get")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "parameter_names": [
+                    "CA_ROTOR_COUNT",
+                    "VTO_LOITER_ALT"
+                ]
+            }
+        }   
+    }
+
+
+class BulkParameterResponse(BaseModel):
+    """Response model for bulk parameter setting"""
+    success: bool = Field(..., description="Whether all parameters were set successfully")
+    results: Dict[str, ParameterResult] = Field(..., description="Results for each parameter set attempt")
+    timestamp: str = Field(..., description="Timestamp of the operation")
+
+    model_config = {
+        "json_schema_extra": {
+            "example": {
+                "success": True,
+                "results": {
+                    "CA_ROTOR_COUNT": {
+                        "name": "CA_ROTOR_COUNT",
+                        "value": 4,
+                        "raw": 4.0,
+                        "type": 6,
+                        "count": 1053,
+                        "index": 65535,
+                        "error": None,
+                        "success": True
+                    },
+                    "VTO_LOITER_ALT": {
+                        "name": "VTO_LOITER_ALT",
+                        "value": 80.0,
+                        "raw": 80.0,
+                        "type": 9,
+                        "count": 1053,
+                        "index": 1047,
+                        "error": None,
+                        "success": True
+                    }
+                },
+                "timestamp": "2023-01-01T00:00:00Z"
+            }
+        }
+    }

{petal_user_journey_coordinator-0.1.5 → petal_user_journey_coordinator-0.1.6}/src/petal_user_journey_coordinator/plugin.py

@@ -6,7 +6,7 @@ import asyncio
 import math
 import numpy as np
 from typing import Dict, Any, List, Union, Optional, Callable
-from datetime import datetime
+from datetime import datetime, timezone
 import threading
 from enum import Enum
 import time
@@ -21,6 +21,7 @@ from petal_app_manager.proxies import (
     RedisProxy
 )
 from petal_app_manager import Config
+from petal_app_manager.models import MQTTMessage
 
 import json, math
 from pymavlink import mavutil
@@ -66,7 +67,7 @@ from .controllers import (
 
 from .data_model import (
     # generic payloads
-    MQTTMessage,
+    BulkParameterSetRequest,
     SubscribePayload,
     UnsubscribePayload,
 
@@ -89,9 +90,15 @@ from .data_model import (
     MavlinkParametersResponseModel,
     RotorCountParameter,
     DistanceModulePayload,
-    OpticalFlowModulePayload
+    OpticalFlowModulePayload,
+    BulkParameterSetRequest,
+    BulkParameterGetRequest,
+    BulkParameterResponse
 )
 
+from petal_app_manager.models.mavlink import (
+    RebootAutopilotResponse
+)
 
 class OperationMode(Enum):
     """Enumeration of operation modes"""
@@ -267,7 +274,7 @@ class PetalUserJourneyCoordinator(Petal):
             self._active_handlers[stream_name] = {
                 "stream_id": stream_id,
                 "rate_hz": rate_hz,
-                "started_at": datetime.now().isoformat(),
+                "started_at": datetime.now(timezone.utc).isoformat(),
                 "controller": self._pubsub_controllers.get(stream_name)
             }
         logger.info(f"Tracking subscription for {stream_name} (ID: {stream_id}, Rate: {rate_hz} Hz)")
@@ -302,7 +309,7 @@ class PetalUserJourneyCoordinator(Petal):
                 "status": "success",
                 "message": "No active handlers to unregister",
                 "unsubscribed_streams": [],
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now(timezone.utc).isoformat()
             }
         
         unsubscribed_streams = []
@@ -336,7 +343,7 @@ class PetalUserJourneyCoordinator(Petal):
             "status": "success" if not failed_streams else "partial_success",
             "message": f"Unsubscribed from {len(unsubscribed_streams)} streams",
             "unsubscribed_streams": unsubscribed_streams,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now(timezone.utc).isoformat()
         }
         
         if failed_streams:
@@ -427,6 +434,8 @@ class PetalUserJourneyCoordinator(Petal):
             "petal-user-journey-coordinator/distance_spatial_offset": self._distance_spatial_offset_message_handler,
             "petal-user-journey-coordinator/optical_flow_spatial_offset": self._optical_flow_spatial_offset_message_handler,
             "petal-user-journey-coordinator/esc_update_calibration_limits": self._esc_update_calibration_limits_message_handler,
+            "petal-user-journey-coordinator/bulk_set_parameters": self._bulk_set_parameter_message_handler,
+            "petal-user-journey-coordinator/bulk_get_parameters": self._bulk_get_parameter_message_handler,
             
             # Pub/Sub stream commands
             "petal-user-journey-coordinator/subscribe_rc_value_stream": self._subscribe_rc_value_stream_handler,
@@ -448,6 +457,9 @@ class PetalUserJourneyCoordinator(Petal):
             # WiFi OptiTrack connectivity commands
             "petal-user-journey-coordinator/connect_to_wifi_and_verify_optitrack": self._connect_to_wifi_and_verify_optitrack_handler,
             "petal-user-journey-coordinator/set_static_ip_address": self._set_static_ip_address_handler,
+
+            # Reboot command
+            "petal-user-journey-coordinator/reboot_autopilot": self._reboot_px4_message_handler
         }
 
     async def _master_command_handler(self, topic: str, message: Dict[str, Any]):
@@ -518,13 +530,9 @@ class PetalUserJourneyCoordinator(Petal):
             except Exception as e:
                 logger.error(f"Failed to send error response: {e}")
 
+    @http_action(method="POST", path="/test/esc-calibration")
     async def _test_esc_calibration_message_handler(self, topic: str, message: Dict[str, Any]):
         """Test handler for ESC calibration with enhanced workflow."""
-        # allow only one call
-        if getattr(self, "_test_esc_calibration_called", False):
-            logger.warning("ESC calibration test has already been called.")
-            return
-        self._test_esc_calibration_called = True
 
         # Test Step 1: Initialize and configure ESC calibration
         test_payload = {
@@ -583,6 +591,7 @@ class PetalUserJourneyCoordinator(Petal):
         
         logger.info("✅ ESC calibration test sequence completed!")
 
+    @http_action(method="POST", path="/test/geometry")
     async def _test_geometry_message_handler(self, topic: str, message: Dict[str, Any]):
         # intercept payload
         test_payload = {
@@ -592,6 +601,7 @@ class PetalUserJourneyCoordinator(Petal):
         # Use the dynamically created handler directly
         await self._rotor_count_message_handler(topic, message)
 
+    @http_action(method="POST", path="/test/dist-module")
     async def _test_dist_module_message_handler(self, topic: str, message: Dict[str, Any]):
         """Test handler for distance module configuration."""
         # Test with LiDAR Lite v3
@@ -601,6 +611,7 @@ class PetalUserJourneyCoordinator(Petal):
         message["payload"] = test_payload
         await self._dist_module_message_handler(topic, message)
 
+    @http_action(method="POST", path="/test/oflow-module")
     async def _test_oflow_module_message_handler(self, topic: str, message: Dict[str, Any]):
         """Test handler for optical flow module configuration."""
         # Test with ARK Flow
@@ -610,6 +621,7 @@ class PetalUserJourneyCoordinator(Petal):
         message["payload"] = test_payload
         await self._oflow_module_message_handler(topic, message)
 
+    @http_action(method="POST", path="/test/subscribe-rc-value-stream")
     async def _test_subscribe_rc_value_stream_handler(self, topic: str, message: Dict[str, Any]):
         # intercept payload
         test_payload = {
@@ -630,6 +642,7 @@ class PetalUserJourneyCoordinator(Petal):
 
         await self._unsubscribe_rc_value_stream_handler(topic, message)
 
+    @http_action(method="POST", path="/test/subscribe-real-time-pose")
     async def _test_subscribe_real_time_pose_handler(self, topic: str, message: Dict[str, Any]):
         # intercept payload
         test_payload = {
@@ -650,6 +663,7 @@ class PetalUserJourneyCoordinator(Petal):
 
         await self._unsubscribe_real_time_pose_handler(topic, message)
 
+    @http_action(method="POST", path="/test/kill-switch-stream")
     async def _test_kill_switch_stream_handler(self, topic: str, message: Dict[str, Any]):
         """Test handler for kill switch stream."""
         logger.info("Running kill switch stream test")
@@ -675,6 +689,7 @@ class PetalUserJourneyCoordinator(Petal):
         
         logger.info("Kill switch stream test completed")
 
+    @http_action(method="POST", path="/test/mfs-a-stream")
     async def _test_mfs_a_stream_handler(self, topic: str, message: Dict[str, Any]):
         """Test handler for Multi-functional Switch A stream."""
         logger.info("Running Multi-functional Switch A stream test")
@@ -700,6 +715,7 @@ class PetalUserJourneyCoordinator(Petal):
         
         logger.info("Multi-functional Switch A stream test completed")
 
+    @http_action(method="POST", path="/test/mfs-b-stream")
     async def _test_mfs_b_stream_handler(self, topic: str, message: Dict[str, Any]):
         """Test handler for Multi-functional Switch B stream."""
         logger.info("Running Multi-functional Switch B stream test")
@@ -725,14 +741,10 @@ class PetalUserJourneyCoordinator(Petal):
         
         logger.info("Multi-functional Switch B stream test completed")
 
+    @http_action(method="POST", path="/test/verify-pos-yaw-directions")
     async def _test_verify_pos_yaw_directions_handler(self, topic: str, message: Dict[str, Any]):
         """Test handler for trajectory verification with the new command structure."""
         
-        if getattr(self, "_test_verification_trajectory", False):
-            logger.warning("Trajectory verification test has already been called.")
-            return
-        self._test_verification_trajectory = True
-        
         logger.info("Running trajectory verification test with new command structure")
         
         # Configure trajectory collection rate (optional - demonstrates the feature)
@@ -745,7 +757,7 @@ class PetalUserJourneyCoordinator(Petal):
             "messageId": f"test-pose-subscribe-{datetime.now().timestamp()}",
             "deviceId": message.get("deviceId", "test-device"),
             "command": "petal-user-journey-coordinator/subscribe_pose_value_stream",
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {
                 "subscribed_stream_id": "real_time_pose",
                 "data_rate_hz": 10.0
@@ -762,7 +774,7 @@ class PetalUserJourneyCoordinator(Petal):
             "messageId": f"test-verify-start-{datetime.now().timestamp()}",
             "deviceId": message.get("deviceId", "test-device"),
             "command": "petal-user-journey-coordinator/verify_pos_yaw_directions",
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {
                 "start": True
             }
@@ -779,7 +791,7 @@ class PetalUserJourneyCoordinator(Petal):
             "messageId": f"test-verify-complete-{datetime.now().timestamp()}",
             "deviceId": message.get("deviceId", "test-device"),
             "command": "petal-user-journey-coordinator/verify_pos_yaw_directions_complete",
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {}
         }
         await self._master_command_handler(topic, verify_complete_message)
@@ -790,7 +802,7 @@ class PetalUserJourneyCoordinator(Petal):
             "messageId": f"test-pose-unsubscribe-{datetime.now().timestamp()}",
             "deviceId": message.get("deviceId", "test-device"),
             "command": "petal-user-journey-coordinator/unsubscribe_pose_value_stream",
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {
                 "unsubscribed_stream_id": "real_time_pose"
             }
@@ -799,14 +811,9 @@ class PetalUserJourneyCoordinator(Petal):
         
         logger.info("Trajectory verification test completed")
 
+    @http_action(method="POST", path="/test/connect-to-wifi-and-verify-optitrack")
     async def _test_connect_to_wifi_and_verify_optitrack_handler(self, topic: str, message: Dict[str, Any]):
-        """Test handler for WiFi and OptiTrack connectivity verification."""
-        # allow only one call
-        if getattr(self, "_test_wifi", False):
-            logger.warning("Wifi test has already been called.")
-            return
-        self._test_wifi = True
-        
+        """Test handler for WiFi and OptiTrack connectivity verification."""        
         logger.info("Running WiFi and OptiTrack connectivity verification test")
         
         # Create test message with proper command structure
@@ -815,7 +822,7 @@ class PetalUserJourneyCoordinator(Petal):
             "messageId": f"test-wifi-optitrack-{datetime.now().timestamp()}",
             "deviceId": message.get("deviceId", "test-device"),
             "command": "petal-user-journey-coordinator/connect_to_wifi_and_verify_optitrack",
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {
                 "positioning_system_network_wifi_ssid": "Rob-Lab-C00060",
                 "positioning_system_network_wifi_pass": "kuri@1234!!",
@@ -830,14 +837,9 @@ class PetalUserJourneyCoordinator(Petal):
         await self._master_command_handler(topic, test_message)
         logger.info("WiFi and OptiTrack connectivity test completed")
 
+    @http_action(method="POST", path="/test/set-static-ip-address")
     async def _test_set_static_ip_address_handler(self, topic: str, message: Dict[str, Any]):
         """Test handler for static IP address configuration."""
-        # allow only one call
-        if getattr(self, "_test_static_ip", False):
-            logger.warning("Static IP test has already been called.")
-            return
-        self._test_static_ip = True
-
         logger.info("Running static IP address configuration test")
         
         # Create test message with proper command structure
@@ -846,7 +848,7 @@ class PetalUserJourneyCoordinator(Petal):
             "messageId": f"test-static-ip-{datetime.now().timestamp()}",
             "deviceId": message.get("deviceId", "test-device"),
             "command": "petal-user-journey-coordinator/set_static_ip_address",
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {
                 "positioning_system_network_wifi_subnet": "255.255.255.0",
                 "positioning_system_network_server_ip_address": "10.0.0.27"
@@ -857,37 +859,12 @@ class PetalUserJourneyCoordinator(Petal):
         await self._master_command_handler(topic, test_message)
         logger.info("Static IP address configuration test completed")
 
-    def _create_test_command_message(self, command: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Helper method to create properly formatted command messages for testing.
-        
-        Args:
-            command: The command to execute (e.g., "petal-user-journey-coordinator/verify_pos_yaw_directions")
-            payload: The payload data for the command
-            
-        Returns:
-            Properly formatted MQTT message dict
-        """
-        return {
-            "waitResponse": True,
-            "messageId": f"test-{command.replace('/', '-')}-{datetime.now().timestamp()}",
-            "deviceId": "test-device",
-            "command": command,
-            "timestamp": datetime.now().isoformat(),
-            "payload": payload
-        }
-
+    @http_action(method="POST", path="/test/unregister-all-handlers")
     async def _test_unregister_all_handlers(self, topic: str, message: Dict[str, Any]):
         """
         Test handler that subscribes to multiple streams and then tests unsubscribe all functionality.
         This demonstrates the complete workflow of subscription tracking and bulk unsubscribe.
         """
-        # Allow only one call
-        if getattr(self, "_test_unsubscribe_all", False):
-            logger.warning("Unsubscribe all test has already been called.")
-            return
-        self._test_unsubscribe_all = True
-
         logger.info("Running unsubscribe all functionality test")
 
         # List of streams to subscribe to for testing
@@ -917,7 +894,7 @@ class PetalUserJourneyCoordinator(Petal):
                     "messageId": f"test-subscribe-{subscription['stream_id']}-{datetime.now().timestamp()}",
                     "deviceId": message.get("deviceId", "test-device"),
                     "command": subscription["command"],
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "payload": {
                         "subscribed_stream_id": subscription["stream_id"],
                         "data_rate_hz": subscription["data_rate_hz"]
@@ -949,7 +926,7 @@ class PetalUserJourneyCoordinator(Petal):
             "messageId": f"test-unsubscribe-all-{datetime.now().timestamp()}",
             "deviceId": message.get("deviceId", "test-device"),
             "command": "petal-user-journey-coordinator/unsubscribeall",
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {}
         }
         
@@ -1622,6 +1599,387 @@ class PetalUserJourneyCoordinator(Petal):
                     response_data={"status": "error", "message": str(e)}
                 )
 
+    @http_action(method="POST", path="/mqtt/bulk_set_parameters")
+    async def _bulk_set_parameter_message_handler(self, topic: str, message: Dict[str, Any]):
+        """
+        Handle bulk set parameter MQTT messages.
+        
+        This handler processes requests to set multiple parameters in bulk,
+        ensuring no active operations are in progress before applying changes.
+        """
+        try:
+            # Parse base MQTT message
+            mqtt_msg = MQTTMessage(**message)
+            message_id = mqtt_msg.messageId
+            
+            # Check if controller is in emergency mode
+            for controller in self._active_controllers.values():
+                if controller is not None and controller.is_active:
+                    error_msg = "Bulk parameter configuration blocked - Active operation in progress"
+                    logger.warning(f"[{message_id}] {error_msg}")
+                    if mqtt_msg.waitResponse:
+                        await self._mqtt_proxy.send_command_response(
+                            message_id=message_id,
+                            response_data={
+                                "status": "error",
+                                "message": error_msg,
+                                "error_code": "OPERATION_ACTIVE"
+                            }
+                        )
+                    return
+            
+            # Process payload using the mavlink proxy bulk set parameter helper
+            payload = BulkParameterSetRequest(**mqtt_msg.payload)
+            parameters = payload.parameters
+
+            if not parameters:
+                error_msg = "No parameters provided for bulk set"
+                logger.error(f"[{message_id}] {error_msg}")
+                if mqtt_msg.waitResponse:
+                    await self._mqtt_proxy.send_command_response(
+                        message_id=message_id,
+                        response_data={
+                            "status": "error",
+                            "message": error_msg,
+                            "error_code": "NO_PARAMETERS_PROVIDED"
+                        }
+                    )
+                return
+            
+            logger.info(f"Setting bulk PX4 parameters for {self.name}")
+
+            results = {}
+            set_param_dict = {}
+            for parameter in parameters:
+                set_param_dict[parameter.parameter_name] = (
+                    parameter.parameter_value, 
+                    parameter.parameter_type
+                )
+
+            confirmed = await self._mavlink_proxy.set_params_bulk_lossy(
+                set_param_dict,
+                max_in_flight=6,
+                resend_interval=0.8,
+                max_retries=5,
+                timeout_total=10.0,
+            )
+
+            if not confirmed:
+                error_msg = "No parameters were confirmed after bulk set"
+                logger.error(f"[{message_id}] {error_msg}")
+                if mqtt_msg.waitResponse:
+                    await self._mqtt_proxy.send_command_response(
+                        message_id=message_id,
+                        response_data={
+                            "status": "error",
+                            "message": error_msg,
+                            "error_code": "NO_PARAMETERS_CONFIRMED"
+                        }
+                    )
+                return
+
+            # check that all requested parameters were confirmed
+            success = True
+            for parameter in parameters:
+                pname = parameter.parameter_name
+                if pname in confirmed:
+                    results[pname] = confirmed[pname]
+                    # check that the set value matches the requested value
+                    confirmed_value = results[pname].get("value")
+                    if confirmed_value == parameter.parameter_value:
+                        results[pname]["success"] = True
+                    else:
+                        results[pname]["success"] = False
+                        results[pname]["error"] = f"Parameter value mismatch: requested {parameter.parameter_value}, got {confirmed_value}"
+                        success = False
+                else:
+                    results[pname] = {
+                        "name": pname,
+                        "error": "Parameter value could not be retrieved after set",
+                        "success": False
+                    }
+                    success = False
+
+            payload = {
+                "results": results,
+                "success": success,
+                # timestamp must be string
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }
+
+            payload = BulkParameterResponse(**payload)
+            sanitized_response = _json_safe(payload.model_dump())
+
+            logger.info(f"[{message_id}] Successfully processed bulk parameter configuration")
+
+            # Send response if requested
+            if mqtt_msg.waitResponse:
+                if not success:
+                    logger.warning(f"[{message_id}] Some parameters could not be set successfully")
+                    await self._mqtt_proxy.send_command_response(
+                        message_id=message_id,
+                        response_data={
+                            "status": "error",
+                            "message": f"Bulk parameter set completed - some parameters failed",
+                            "data": sanitized_response
+                        }
+                    )
+                else:
+                    await self._mqtt_proxy.send_command_response(
+                        message_id=message_id,
+                        response_data={
+                            "status": "success",
+                            "message": f"Bulk parameter set completed - {len(results)} parameters processed",
+                            "data": sanitized_response
+                        }
+                    )
+                    
+        except ValidationError as ve:
+            error_msg = f"Invalid bulk parameter payload: {ve}"
+            logger.error(f"Bulk parameter config validation error: {error_msg}")
+            if mqtt_msg.waitResponse:
+                await self._mqtt_proxy.send_command_response(
+                    message_id=message_id,
+                    response_data={
+                        "status": "error",
+                        "message": error_msg,
+                        "error_code": "VALIDATION_ERROR"
+                    }
+                )
+                
+        except Exception as e:
+            error_msg = f"Bulk parameter handler error: {str(e)}"
+            logger.error(f"Unexpected bulk parameter error: {error_msg}")
+            if mqtt_msg.waitResponse:
+                await self._mqtt_proxy.send_command_response(
+                    message_id=message_id,
+                    response_data={
+                        "status": "error",
+                        "message": error_msg,
+                        "error_code": "HANDLER_ERROR"
+                    }
+                )
+
+    @http_action(method="POST", path="/mqtt/bulk_get_parameters")
+    async def _bulk_get_parameter_message_handler(self, topic: str, message: Dict[str, Any]):
+        """
+        Handle bulk get parameter MQTT messages.
+        
+        This handler processes requests to get multiple parameters in bulk,
+        ensuring no active operations are in progress before retrieving values.
+        """
+        try:
+            # Parse base MQTT message
+            mqtt_msg = MQTTMessage(**message)
+            message_id = mqtt_msg.messageId
+            
+            # Check if controller is in emergency mode
+            for controller in self._active_controllers.values():
+                if controller is not None and controller.is_active:
+                    error_msg = "Bulk parameter retrieval blocked - Active operation in progress"
+                    logger.warning(f"[{message_id}] {error_msg}")
+                    if mqtt_msg.waitResponse:
+                        await self._mqtt_proxy.send_command_response(
+                            message_id=message_id,
+                            response_data={
+                                "status": "error",
+                                "message": error_msg,
+                                "error_code": "OPERATION_ACTIVE"
+                            }
+                        )
+                    return
+            
+            # Process payload using the mavlink proxy bulk get parameter helper
+            payload = BulkParameterGetRequest(**mqtt_msg.payload)
+            parameter_names = payload.parameter_names
+
+            if not parameter_names:
+                error_msg = "No parameter names provided for bulk get"
+                logger.error(f"[{message_id}] {error_msg}")
+                if mqtt_msg.waitResponse:
+                    await self._mqtt_proxy.send_command_response(
+                        message_id=message_id,
+                        response_data={
+                            "status": "error",
+                            "message": error_msg,
+                            "error_code": "NO_PARAMETER_NAMES_PROVIDED"
+                        }
+                    )
+                return
+
+            logger.info(f"Getting bulk PX4 parameters for {self.name}")
+
+            parameters = await self._mavlink_proxy.get_params_bulk_lossy(
+                names=parameter_names,
+                max_in_flight=6,
+                resend_interval=0.8,
+                max_retries=5,
+                timeout_total=10.0,
+                inter_send_delay=0.05,
+            )
+
+            if not parameters:
+                error_msg = "No parameters were confirmed after bulk get"
+                logger.error(f"[{message_id}] {error_msg}")
+                if mqtt_msg.waitResponse:
+                    await self._mqtt_proxy.send_command_response(
+                        message_id=message_id,
+                        response_data={
+                            "status": "error",
+                            "message": error_msg,
+                            "error_code": "NO_PARAMETERS_CONFIRMED"
+                        }
+                    )
+
+            success = True
+            for parameter in parameter_names:
+                if parameter not in parameters:
+                    parameters[parameter] = {
+                        "name": parameter,
+                        "error": "Parameter value could not be retrieved",
+                        "success": False
+                    }
+                    success = False
+                else:
+                    parameters[parameter]["success"] = True
+
+            payload = {
+                "results": parameters,
+                "success": success,
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }
+
+            payload = BulkParameterResponse(**payload)
+            sanitized_response = _json_safe(payload.model_dump())
+
+            logger.info(f"[{message_id}] Successfully processed bulk parameter retrieval")
+
+            # Send response if requested
+            if mqtt_msg.waitResponse:
+                if not success:
+                    logger.warning(f"[{message_id}] Some parameters could not be retrieved successfully")
+                    await self._mqtt_proxy.send_command_response(
+                        message_id=message_id,
+                        response_data={
+                            "status": "error",
+                            "message": f"Bulk parameter get completed - some parameters failed",
+                            "data": sanitized_response
+                        }
+                    )
+                else:
+                    await self._mqtt_proxy.send_command_response(
+                        message_id=message_id,
+                        response_data={
+                            "status": "success",
+                            "message": f"Bulk parameter get completed - {len(parameters)} parameters processed",
+                            "data": sanitized_response
+                        }
+                    )
+        
+        except ValidationError as ve:
+            error_msg = f"Invalid bulk parameter get payload: {ve}"
+            logger.error(f"Bulk parameter get validation error: {error_msg}")
+            if mqtt_msg.waitResponse:
+                await self._mqtt_proxy.send_command_response(
+                    message_id=message_id,
+                    response_data={
+                        "status": "error",
+                        "message": error_msg,
+                        "error_code": "VALIDATION_ERROR"
+                    }
+                )
+
+        except Exception as e:
+            error_msg = f"Bulk parameter get handler error: {str(e)}"
+            logger.error(f"Unexpected bulk parameter get error: {error_msg}")
+            if mqtt_msg.waitResponse:
+                await self._mqtt_proxy.send_command_response(
+                    message_id=message_id,
+                    response_data={
+                        "status": "error",
+                        "message": error_msg,
+                        "error_code": "HANDLER_ERROR"
+                    }
+                )
+
+    @http_action(method="POST", path="/mqtt/reboot_px4")
+    async def _reboot_px4_message_handler(self, topic: str, message: Dict[str, Any]):
+        """Handle reboot PX4 MQTT messages."""
+        try:
+            # Parse base MQTT message
+            mqtt_msg = MQTTMessage(**message)
+            message_id = mqtt_msg.messageId
+
+            # Check if controller is in emergency mode
+            for controller in self._active_controllers.values():
+                if controller is not None and controller.is_active:
+                    error_msg = "PX4 reboot blocked - Active operation in progress"
+                    logger.warning(f"[{message_id}] {error_msg}")
+                    if mqtt_msg.waitResponse:
+                        await self._mqtt_proxy.send_command_response(
+                            message_id=message_id,
+                            response_data={
+                                "status": "error",
+                                "message": error_msg,
+                                "error_code": "OPERATION_ACTIVE"
+                            }
+                        )
+
+                    return
+                
+            logger.info(f"Restarting PX4 for {self.name} petal")
+            reboot_response = await self._mavlink_proxy.reboot_autopilot(
+                reboot_onboard_computer=False,
+                timeout=5.0
+            )
+
+            if not reboot_response.success:
+                error_msg = "PX4 reboot command failed or timed out"
+                logger.error(f"[{message_id}] {error_msg}")
+                if mqtt_msg.waitResponse:
+                    await self._mqtt_proxy.send_command_response(
+                        message_id=message_id,
+                        response_data={
+                            "status": "error",
+                            "message": error_msg,
+                            "error_code": "REBOOT_FAILED",
+                            "data": _json_safe(reboot_response.model_dump())
+                        }
+                    )
+                return
+            
+            logger.info(f"[{message_id}] PX4 reboot command successful")
+
+            if mqtt_msg.waitResponse:
+                await self._mqtt_proxy.send_command_response(
+                    message_id=message_id,
+                    response_data={
+                        "status": "success",
+                        "message": "PX4 reboot command successful",
+                        "data": _json_safe(reboot_response.model_dump())
+                    }
+                )
+        except ValidationError as ve:
+            error_msg = f"Invalid PX4 reboot payload: {ve}"
+            logger.error(f"PX4 reboot validation error: {error_msg}")
+            if mqtt_msg.waitResponse:
+                await self._mqtt_proxy.send_command_response(
+                    message_id=message_id,
+                    response_data={
+                        "status": "error",
+                        "message": error_msg,
+                        "error_code": "VALIDATION_ERROR"
+                    }
+                )
+        except Exception as e:
+            logger.error(f"Error handling PX4 reboot message: {e}")
+            if mqtt_msg and mqtt_msg.waitResponse:
+                await self._mqtt_proxy.send_command_response(
+                    message_id=mqtt_msg.messageId,
+                    response_data={"status": "error", "message": str(e)}
+                )
+                return
+
     def _create_parameter_message_handler(self, handler_key: str, config_type: str):
         """
         Factory method to create parameter message handlers with minimal boilerplate.
@@ -1983,11 +2341,7 @@ class PetalUserJourneyCoordinator(Petal):
         
         return status
     
-    @http_action(
-        method="GET", 
-        path="/health", 
-        description="Health check endpoint for this petal"
-    )
+    @http_action(method="GET", path="/health")
     async def health_check(self):
         """
         Health check endpoint that reports proxy requirements and petal status.
@@ -1999,7 +2353,7 @@ class PetalUserJourneyCoordinator(Petal):
         health_info = {
             "petal_name": self.name,
             "petal_version": self.version,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "status": "healthy",
             "required_proxies": self.get_required_proxies(),
             "optional_proxies": self.get_optional_proxies(),
@@ -2008,11 +2362,7 @@ class PetalUserJourneyCoordinator(Petal):
         
         return health_info
     
-    @http_action(
-        method="GET", 
-        path="/px4-parameter", 
-        description="get a specific PX4 parameter"
-    )
+    @http_action(method="GET", path="/px4-parameter")
     async def get_px4_parameter(self, data: ParameterRequestModel) -> MavlinkParameterResponseModel:
         """
         Get a specific PX4 parameter value.
@@ -2035,17 +2385,13 @@ class PetalUserJourneyCoordinator(Petal):
             return {
                 "parameter_name": parameter_name,
                 "parameter_value": parameter_value,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now(timezone.utc).isoformat()
             }
         except TimeoutError as exc:
             logger.error(f"Timeout while waiting for PX4 parameter: {str(exc)}")
             raise HTTPException(status_code=504, detail=str(exc))
     
-    @http_action(
-        method="GET", 
-        path="/px4-parameters", 
-        description="get a specific PX4 parameter"
-    )
+    @http_action(method="GET", path="/px4-parameters")
     async def get_all_parameters(self) -> MavlinkParametersResponseModel:
         """
         Get a specific PX4 parameter value.
@@ -2066,18 +2412,14 @@ class PetalUserJourneyCoordinator(Petal):
                 )
             payload = {
                 "parameters": parameters,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now(timezone.utc).isoformat()
             }
             return _json_safe(payload)   # ← sanitize before FastAPI encodes
         except TimeoutError as exc:
             logger.error(f"Timeout while waiting for PX4 parameter: {str(exc)}")
             raise HTTPException(status_code=504, detail=str(exc))
         
-    @http_action(
-        method="POST", 
-        path="/px4-parameter", 
-        description="set a specific PX4 parameter"
-    )
+    @http_action(method="POST", path="/px4-parameter")
     async def set_px4_parameter(self, data: ParameterBaseModel) -> ParameterResponseModel:
         """
         Get a specific PX4 parameter value.
@@ -2111,18 +2453,14 @@ class PetalUserJourneyCoordinator(Petal):
             payload = {
                 "parameter_name": parameter_name,
                 "parameter_value": parameter_value,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now(timezone.utc).isoformat()
             }
             return _json_safe(payload)   # ← sanitize before FastAPI encodes
         except TimeoutError as exc:
             logger.error(f"Timeout while waiting for PX4 parameter: {str(exc)}")
             raise HTTPException(status_code=504, detail=str(exc))
 
-    @http_action(
-        method="POST", 
-        path="/rotor-count", 
-        description="set a specific PX4 parameter"
-    )
+    @http_action(method="POST", path="/rotor-count")
     async def set_rotor_count(self, data: RotorCountParameter) -> ParameterResponseModel:
         """
         Get a specific PX4 parameter value.
@@ -2159,9 +2497,160 @@ class PetalUserJourneyCoordinator(Petal):
             payload = {
                 "parameter_name": parameter_name,
                 "parameter_value": parameter_value,
-                "timestamp": datetime.now().isoformat()
+                "timestamp": datetime.now(timezone.utc).isoformat()
             }
             return _json_safe(payload)   # ← sanitize before FastAPI encodes
         except TimeoutError as exc:
             logger.error(f"Timeout while waiting for PX4 parameter: {str(exc)}")
             raise HTTPException(status_code=504, detail=str(exc))
+
+    @http_action(method="POST", path="/bulk-px4-parameters")
+    async def set_bulk_px4_parameters(self, data: BulkParameterSetRequest) -> BulkParameterResponse:
+        """
+        Set multiple PX4 parameters in bulk.
+        """
+
+        parameters = data.parameters
+
+        if not parameters:
+            logger.error("No parameters provided for bulk set")
+            raise HTTPException(
+                status_code=400,
+                detail="No parameters provided",
+                headers={"source": "bulk_px4_parameters"}
+            )
+
+        logger.info(f"Setting bulk PX4 parameters for {self.name}")
+
+        results = {}
+        try:
+            set_param_dict = {}
+            for parameter in parameters:
+                set_param_dict[parameter.parameter_name] = (
+                    parameter.parameter_value, 
+                    parameter.parameter_type
+                )
+
+            confirmed = await self._mavlink_proxy.set_params_bulk_lossy(
+                set_param_dict,
+                max_in_flight=6,
+                resend_interval=0.8,
+                max_retries=5,
+                timeout_total=10.0,
+            )
+
+            # confirmed[pname] = {
+            #     "name": pname,
+            #     "value": decoded_value,
+            #     "raw": float(pkt.param_value),
+            #     "type": pkt.param_type,
+            #     "count": pkt.param_count,
+            #     "index": pkt.param_index,
+            # }
+
+            if not confirmed:
+                logger.error("No parameters were set in bulk PX4 parameter set")
+                raise HTTPException(
+                    status_code=500,
+                    detail="No parameters were set",
+                    headers={"source": "bulk_px4_parameters"}
+                )
+
+            # check that all requested parameters were confirmed
+            success = True
+            for parameter in parameters:
+                pname = parameter.parameter_name
+                if pname in confirmed:
+                    results[pname] = confirmed[pname]
+                    # check that the set value matches the requested value
+                    confirmed_value = results[pname].get("value")
+                    if confirmed_value == parameter.parameter_value:
+                        results[pname]["success"] = True
+                    else:
+                        results[pname]["success"] = False
+                        results[pname]["error"] = f"Parameter value mismatch: requested {parameter.parameter_value}, got {confirmed_value}"
+                        success = False
+                else:
+                    results[pname] = {
+                        "name": pname,
+                        "error": "Parameter value could not be retrieved after set",
+                        "success": False
+                    }
+                    success = False
+
+            payload = {
+                "results": results,
+                "success": success,
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }
+
+            payload = BulkParameterResponse(**payload)
+            return _json_safe(payload.model_dump())   # ← sanitize before FastAPI encodes
+
+        except TimeoutError as exc:
+            logger.error(f"Timeout while setting bulk PX4 parameters: {str(exc)}")
+            raise HTTPException(status_code=504, detail=str(exc))
+        except Exception as e:
+            logger.error(f"Error while setting bulk PX4 parameters: {str(e)}")
+            raise HTTPException(status_code=500, detail=str(e))
+
+    @http_action(method="GET", path="/bulk-px4-parameters")
+    async def get_bulk_px4_parameters(self, data: BulkParameterGetRequest) -> BulkParameterResponse:
+        """
+        Get multiple PX4 parameters in bulk.
+        """
+        parameter_names = data.parameter_names
+
+        if not parameter_names:
+            logger.error("No parameter names provided for bulk get")
+            raise HTTPException(
+                status_code=400,
+                detail="No parameter names provided",
+                headers={"source": "bulk_px4_parameters"}
+            )
+
+        logger.info(f"Getting bulk PX4 parameters for {self.name}")
+
+        try:
+
+            parameters = await self._mavlink_proxy.get_params_bulk_lossy(
+                names=parameter_names,
+                timeout_total=6.0,
+                max_retries=4,
+                max_in_flight=6,
+                resend_interval=0.8,
+                inter_send_delay=0.02,
+            )
+
+            if not parameters:
+                logger.error("No parameters were retrieved in bulk PX4 parameter get")
+                raise HTTPException(
+                    status_code=500,
+                    detail="No parameters were retrieved",
+                    headers={"source": "bulk_px4_parameters"}
+                )
+            
+            success = True
+            for parameter in parameter_names:
+                if parameter not in parameters:
+                    parameters[parameter] = {
+                        "name": parameter,
+                        "error": "Parameter value could not be retrieved",
+                        "success": False
+                    }
+                    success = False
+                else:
+                    parameters[parameter]["success"] = True
+
+
+            payload = {
+                "success": success,
+                "results": parameters,
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            }
+            parameters = BulkParameterResponse(**payload)
+            return _json_safe(parameters.model_dump())   # ← sanitize before FastAPI encodes
+        except TimeoutError as exc:
+            logger.error(f"Timeout while getting bulk PX4 parameters: {str(exc)}")
+            raise HTTPException(status_code=504, detail=str(exc))
+