petal-user-journey-coordinator 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

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"""
@@ -181,11 +188,12 @@ class PetalUserJourneyCoordinator(Petal):
             rectangle_a=self.rectangle_a,
             rectangle_b=self.rectangle_b,
             points_per_edge=self.points_per_edge,
-            corner_exclusion_radius=self.corner_exclusion_radius
+            corner_exclusion_radius=self.corner_exclusion_radius,
+            petal_name=self.name
         )
 
         # Initialize WiFi OptiTrack connectivity controller
-        self._wifi_optitrack_controller = WifiOptitrackConnectivityController(self._mqtt_proxy, logger)
+        self._wifi_optitrack_controller = WifiOptitrackConnectivityController(self._mqtt_proxy, logger, petal_name=self.name)
 
         # Initialize operation controllers
         self._operation_controllers = {
@@ -267,7 +275,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 +310,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 +344,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:
@@ -368,7 +376,12 @@ class PetalUserJourneyCoordinator(Petal):
         
         # Initialize pub/sub controllers now that topic_base is available
         self._pubsub_controllers: Dict[str, BasePubSubController] = {
-            "rc_value_stream": RCChannelsController(self._mqtt_proxy, self._mavlink_proxy, logger),
+            "rc_value_stream": RCChannelsController(
+                self._mqtt_proxy, 
+                self._mavlink_proxy, 
+                logger, 
+                petal_name=self.name
+            ),
             "pose_value_stream": PositionChannelsController(
                 mqtt_proxy=self._mqtt_proxy, 
                 mavlink_proxy=self._mavlink_proxy, 
@@ -379,11 +392,27 @@ class PetalUserJourneyCoordinator(Petal):
                 corner_exclusion_radius=self.corner_exclusion_radius,
                 max_matching_distance=self._trajectory_verification.max_matching_distance,
                 corner_points=self._trajectory_verification.corner_points, # Pass corner points here
-                reference_trajectory=self._trajectory_verification.reference_trajectory # Pass reference trajectory here
+                reference_trajectory=self._trajectory_verification.reference_trajectory, # Pass reference trajectory here
+                petal_name=self.name
+            ),
+            "ks_status_stream": KillSwitchController(
+                self._mqtt_proxy, 
+                self._mavlink_proxy, 
+                logger,
+                petal_name=self.name
             ),
-            "ks_status_stream": KillSwitchController(self._mqtt_proxy, self._mavlink_proxy, logger),
-            "mfs_a_status_stream": MultiFunctionalSwitchAController(self._mqtt_proxy, self._mavlink_proxy, logger),
-            "mfs_b_status_stream": MultiFunctionalSwitchBController(self._mqtt_proxy, self._mavlink_proxy, logger)
+            "mfs_a_status_stream": MultiFunctionalSwitchAController(
+                self._mqtt_proxy, 
+                self._mavlink_proxy, 
+                logger,
+                petal_name=self.name
+            ),
+            "mfs_b_status_stream": MultiFunctionalSwitchBController(
+                self._mqtt_proxy, 
+                self._mavlink_proxy, 
+                logger,
+                petal_name=self.name
+            )
         }
         
         # Initialize command handlers registry
@@ -414,40 +443,44 @@ class PetalUserJourneyCoordinator(Petal):
             # "Update": self._test_unregister_all_handlers,
 
             # Timeout operation commands
-            "petal-user-journey-coordinator/esc_calibration": self._esc_calibration_message_handler,
-            "petal-user-journey-coordinator/esc_force_run_all": self._esc_force_run_all_message_handler,
-            "petal-user-journey-coordinator/esc_force_run_single": self._esc_force_run_single_message_handler,
+            f"{self.name}/esc_calibration": self._esc_calibration_message_handler,
+            f"{self.name}/esc_force_run_all": self._esc_force_run_all_message_handler,
+            f"{self.name}/esc_force_run_single": self._esc_force_run_single_message_handler,
 
             # Parameter configuration commands
-            "petal-user-journey-coordinator/geometry": self._geometry_message_handler,
-            "petal-user-journey-coordinator/gps_module": self._gps_module_message_handler,
-            "petal-user-journey-coordinator/dist_module": self._dist_module_message_handler,
-            "petal-user-journey-coordinator/oflow_module": self._oflow_module_message_handler,
-            "petal-user-journey-coordinator/gps_spatial_offset": self._gps_spatial_offset_message_handler,
-            "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,
+            f"{self.name}/geometry": self._geometry_message_handler,
+            f"{self.name}/gps_module": self._gps_module_message_handler,
+            f"{self.name}/dist_module": self._dist_module_message_handler,
+            f"{self.name}/oflow_module": self._oflow_module_message_handler,
+            f"{self.name}/gps_spatial_offset": self._gps_spatial_offset_message_handler,
+            f"{self.name}/distance_spatial_offset": self._distance_spatial_offset_message_handler,
+            f"{self.name}/optical_flow_spatial_offset": self._optical_flow_spatial_offset_message_handler,
+            f"{self.name}/esc_update_calibration_limits": self._esc_update_calibration_limits_message_handler,
+            f"{self.name}/bulk_set_parameters": self._bulk_set_parameter_message_handler,
+            f"{self.name}/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,
-            "petal-user-journey-coordinator/unsubscribe_rc_value_stream": self._unsubscribe_rc_value_stream_handler,
-            "petal-user-journey-coordinator/subscribe_pose_value_stream": self._subscribe_pose_value_stream_handler,
-            "petal-user-journey-coordinator/unsubscribe_pose_value_stream": self._unsubscribe_pose_value_stream_handler,
-            "petal-user-journey-coordinator/subscribe_ks_status_stream": self._subscribe_ks_status_stream_handler,
-            "petal-user-journey-coordinator/unsubscribe_ks_status_stream": self._unsubscribe_ks_status_stream_handler,
-            "petal-user-journey-coordinator/subscribe_mfs_a_status_stream": self._subscribe_mfs_a_status_stream_handler,
-            "petal-user-journey-coordinator/unsubscribe_mfs_a_status_stream": self._unsubscribe_mfs_a_status_stream_handler,
-            "petal-user-journey-coordinator/subscribe_mfs_b_status_stream": self._subscribe_mfs_b_status_stream_handler,
-            "petal-user-journey-coordinator/unsubscribe_mfs_b_status_stream": self._unsubscribe_mfs_b_status_stream_handler,
-            "petal-user-journey-coordinator/unsubscribeall": self._unregister_all_handlers,
+            f"{self.name}/subscribe_rc_value_stream": self._subscribe_rc_value_stream_handler,
+            f"{self.name}/unsubscribe_rc_value_stream": self._unsubscribe_rc_value_stream_handler,
+            f"{self.name}/subscribe_pose_value_stream": self._subscribe_pose_value_stream_handler,
+            f"{self.name}/unsubscribe_pose_value_stream": self._unsubscribe_pose_value_stream_handler,
+            f"{self.name}/subscribe_ks_status_stream": self._subscribe_ks_status_stream_handler,
+            f"{self.name}/unsubscribe_ks_status_stream": self._unsubscribe_ks_status_stream_handler,
+            f"{self.name}/subscribe_mfs_a_status_stream": self._subscribe_mfs_a_status_stream_handler,
+            f"{self.name}/unsubscribe_mfs_a_status_stream": self._unsubscribe_mfs_a_status_stream_handler,
+            f"{self.name}/subscribe_mfs_b_status_stream": self._subscribe_mfs_b_status_stream_handler,
+            f"{self.name}/unsubscribe_mfs_b_status_stream": self._unsubscribe_mfs_b_status_stream_handler,
+            f"{self.name}/unsubscribeall": self._unregister_all_handlers,
             
             # Trajectory verification commands
-            "petal-user-journey-coordinator/verify_pos_yaw_directions": self._verify_pos_yaw_directions_handler,
-            "petal-user-journey-coordinator/verify_pos_yaw_directions_complete": self._verify_pos_yaw_directions_complete_handler,
+            f"{self.name}/verify_pos_yaw_directions": self._verify_pos_yaw_directions_handler,
+            f"{self.name}/verify_pos_yaw_directions_complete": self._verify_pos_yaw_directions_complete_handler,
             
             # 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,
+            f"{self.name}/connect_to_wifi_and_verify_optitrack": self._connect_to_wifi_and_verify_optitrack_handler,
+            f"{self.name}/set_static_ip_address": self._set_static_ip_address_handler,
+            # Reboot command
+            f"{self.name}/reboot_autopilot": self._reboot_px4_message_handler
         }
 
     async def _master_command_handler(self, topic: str, message: Dict[str, Any]):
@@ -476,6 +509,10 @@ class PetalUserJourneyCoordinator(Petal):
                 handler = self._command_handlers[command]
                 await handler(topic, message)
             else:
+                # if command does not start with petal-flight-log/, ignore it
+                if not command.startswith(f"{self.name}/"):
+                    logger.debug(f"Ignoring command not meant for this petal: {command}")
+                    return
                 error_msg = f"Unknown command: {command}"
                 logger.error(error_msg)
                 
@@ -518,13 +555,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 +616,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 +626,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 +636,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 +646,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 +667,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 +688,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 +714,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 +740,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 +766,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)
@@ -744,8 +781,8 @@ class PetalUserJourneyCoordinator(Petal):
             "waitResponse": True,
             "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(),
+            "command": f"{self.name}/subscribe_pose_value_stream",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {
                 "subscribed_stream_id": "real_time_pose",
                 "data_rate_hz": 10.0
@@ -761,8 +798,8 @@ class PetalUserJourneyCoordinator(Petal):
             "waitResponse": True,
             "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(),
+            "command": f"{self.name}/verify_pos_yaw_directions",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {
                 "start": True
             }
@@ -778,8 +815,8 @@ class PetalUserJourneyCoordinator(Petal):
             "waitResponse": True,
             "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(),
+            "command": f"{self.name}/verify_pos_yaw_directions_complete",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {}
         }
         await self._master_command_handler(topic, verify_complete_message)
@@ -789,8 +826,8 @@ class PetalUserJourneyCoordinator(Petal):
             "waitResponse": True,
             "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(),
+            "command": f"{self.name}/unsubscribe_pose_value_stream",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {
                 "unsubscribed_stream_id": "real_time_pose"
             }
@@ -799,14 +836,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
@@ -814,8 +846,8 @@ class PetalUserJourneyCoordinator(Petal):
             "waitResponse": True,
             "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(),
+            "command": f"{self.name}/connect_to_wifi_and_verify_optitrack",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {
                 "positioning_system_network_wifi_ssid": "Rob-Lab-C00060",
                 "positioning_system_network_wifi_pass": "kuri@1234!!",
@@ -830,14 +862,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
@@ -845,8 +872,8 @@ class PetalUserJourneyCoordinator(Petal):
             "waitResponse": True,
             "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(),
+            "command": f"{self.name}/set_static_ip_address",
+            "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,48 +884,23 @@ 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
         test_subscriptions = [
             {
-                "command": "petal-user-journey-coordinator/subscribe_rc_value_stream",
+                "command": f"{self.name}/subscribe_rc_value_stream",
                 "stream_id": "px4_rc_raw",
                 "data_rate_hz": 20.0
             },
             {
-                "command": "petal-user-journey-coordinator/subscribe_pose_value_stream", 
+                "command": f"{self.name}/subscribe_pose_value_stream", 
                 "stream_id": "real_time_pose",
                 "data_rate_hz": 10.0
             },
@@ -917,7 +919,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"]
@@ -948,8 +950,8 @@ class PetalUserJourneyCoordinator(Petal):
             "waitResponse": True,
             "messageId": f"test-unsubscribe-all-{datetime.now().timestamp()}",
             "deviceId": message.get("deviceId", "test-device"),
-            "command": "petal-user-journey-coordinator/unsubscribeall",
-            "timestamp": datetime.now().isoformat(),
+            "command": f"{self.name}/unsubscribeall",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "payload": {}
         }
         
@@ -1622,6 +1624,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 +2366,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 +2378,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 +2387,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 +2410,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 +2437,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 +2478,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 +2522,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))
+