isar 1.31.0__tar.gz → 1.32.0__tar.gz

{isar-1.31.0 → isar-1.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.31.0
+Version: 1.32.0
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0

{isar-1.31.0 → isar-1.32.0}/requirements.txt

@@ -31,7 +31,7 @@ azure-identity==1.23.1
     #   isar (pyproject.toml)
 azure-keyvault-secrets==4.10.0
     # via isar (pyproject.toml)
-azure-monitor-opentelemetry==1.6.7
+azure-monitor-opentelemetry==1.6.13
     # via isar (pyproject.toml)
 azure-monitor-opentelemetry-exporter==1.0.0b40
     # via
@@ -117,7 +117,7 @@ numpy==2.3.2
     #   scipy
 oauthlib==3.3.1
     # via requests-oauthlib
-opentelemetry-api==1.35.0
+opentelemetry-api==1.36.0
     # via
     #   azure-core-tracing-opentelemetry
     #   azure-monitor-opentelemetry-exporter
@@ -137,17 +137,17 @@ opentelemetry-api==1.35.0
     #   opentelemetry-instrumentation-wsgi
     #   opentelemetry-sdk
     #   opentelemetry-semantic-conventions
-opentelemetry-exporter-otlp==1.35.0
+opentelemetry-exporter-otlp==1.36.0
     # via isar (pyproject.toml)
-opentelemetry-exporter-otlp-proto-common==1.35.0
+opentelemetry-exporter-otlp-proto-common==1.36.0
     # via
     #   opentelemetry-exporter-otlp-proto-grpc
     #   opentelemetry-exporter-otlp-proto-http
-opentelemetry-exporter-otlp-proto-grpc==1.35.0
+opentelemetry-exporter-otlp-proto-grpc==1.36.0
     # via opentelemetry-exporter-otlp
-opentelemetry-exporter-otlp-proto-http==1.35.0
+opentelemetry-exporter-otlp-proto-http==1.36.0
     # via opentelemetry-exporter-otlp
-opentelemetry-instrumentation==0.56b0
+opentelemetry-instrumentation==0.57b0
     # via
     #   opentelemetry-instrumentation-asgi
     #   opentelemetry-instrumentation-dbapi
@@ -159,38 +159,38 @@ opentelemetry-instrumentation==0.56b0
     #   opentelemetry-instrumentation-urllib
     #   opentelemetry-instrumentation-urllib3
     #   opentelemetry-instrumentation-wsgi
-opentelemetry-instrumentation-asgi==0.56b0
+opentelemetry-instrumentation-asgi==0.57b0
     # via opentelemetry-instrumentation-fastapi
-opentelemetry-instrumentation-dbapi==0.56b0
+opentelemetry-instrumentation-dbapi==0.57b0
     # via opentelemetry-instrumentation-psycopg2
-opentelemetry-instrumentation-django==0.56b0
+opentelemetry-instrumentation-django==0.57b0
     # via azure-monitor-opentelemetry
-opentelemetry-instrumentation-fastapi==0.56b0
+opentelemetry-instrumentation-fastapi==0.57b0
     # via
     #   azure-monitor-opentelemetry
     #   isar (pyproject.toml)
-opentelemetry-instrumentation-flask==0.56b0
+opentelemetry-instrumentation-flask==0.57b0
     # via azure-monitor-opentelemetry
-opentelemetry-instrumentation-psycopg2==0.56b0
+opentelemetry-instrumentation-psycopg2==0.57b0
     # via azure-monitor-opentelemetry
-opentelemetry-instrumentation-requests==0.56b0
+opentelemetry-instrumentation-requests==0.57b0
     # via azure-monitor-opentelemetry
-opentelemetry-instrumentation-urllib==0.56b0
+opentelemetry-instrumentation-urllib==0.57b0
     # via azure-monitor-opentelemetry
-opentelemetry-instrumentation-urllib3==0.56b0
+opentelemetry-instrumentation-urllib3==0.57b0
     # via azure-monitor-opentelemetry
-opentelemetry-instrumentation-wsgi==0.56b0
+opentelemetry-instrumentation-wsgi==0.57b0
     # via
     #   opentelemetry-instrumentation-django
     #   opentelemetry-instrumentation-flask
-opentelemetry-proto==1.35.0
+opentelemetry-proto==1.36.0
     # via
     #   opentelemetry-exporter-otlp-proto-common
     #   opentelemetry-exporter-otlp-proto-grpc
     #   opentelemetry-exporter-otlp-proto-http
 opentelemetry-resource-detector-azure==0.1.5
     # via azure-monitor-opentelemetry
-opentelemetry-sdk==1.35.0
+opentelemetry-sdk==1.36.0
     # via
     #   azure-monitor-opentelemetry
     #   azure-monitor-opentelemetry-exporter
@@ -198,7 +198,7 @@ opentelemetry-sdk==1.35.0
     #   opentelemetry-exporter-otlp-proto-grpc
     #   opentelemetry-exporter-otlp-proto-http
     #   opentelemetry-resource-detector-azure
-opentelemetry-semantic-conventions==0.56b0
+opentelemetry-semantic-conventions==0.57b0
     # via
     #   opentelemetry-instrumentation
     #   opentelemetry-instrumentation-asgi
@@ -211,7 +211,7 @@ opentelemetry-semantic-conventions==0.56b0
     #   opentelemetry-instrumentation-urllib3
     #   opentelemetry-instrumentation-wsgi
     #   opentelemetry-sdk
-opentelemetry-util-http==0.56b0
+opentelemetry-util-http==0.57b0
     # via
     #   opentelemetry-instrumentation-asgi
     #   opentelemetry-instrumentation-django

{isar-1.31.0 → isar-1.32.0}/src/isar/apis/api.py

@@ -245,6 +245,24 @@ class API:
                 },
             },
         )
+        router.add_api_route(
+            path="/schedule/release-intervention-needed",
+            endpoint=self.scheduling_controller.release_intervention_needed,
+            methods=["POST"],
+            dependencies=[authentication_dependency],
+            summary="Release the intervention needed state",
+            responses={
+                HTTPStatus.OK.value: {
+                    "description": "Robot released from intervention needed state"
+                },
+                HTTPStatus.CONFLICT.value: {
+                    "description": "Conflict - Invalid command in the current state"
+                },
+                HTTPStatus.INTERNAL_SERVER_ERROR.value: {
+                    "description": "Internal Server Error - Current state of state machine unknown"
+                },
+            },
+        )
         router.add_api_route(
             path="/schedule/move_arm/{arm_pose_literal}",
             endpoint=self.scheduling_controller.start_move_arm_mission,

{isar-1.31.0 → isar-1.32.0}/src/isar/apis/schedule/scheduling_controller.py

@@ -256,6 +256,22 @@ class SchedulingController:
         self.scheduling_utilities.start_mission(mission=mission)
         return self._api_response(mission)
 
+    def release_intervention_needed(self) -> None:
+        self.logger.info("Received request to release intervention needed state")
+
+        state: States = self.scheduling_utilities.get_state()
+
+        if state != States.InterventionNeeded:
+            error_message = f"Conflict - Release intervention needed command received in invalid state - State: {state}"
+            self.logger.warning(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.CONFLICT,
+                detail=error_message,
+            )
+
+        self.scheduling_utilities.release_intervention_needed()
+        self.logger.info("Released intervention needed state successfully")
+
     def _api_response(self, mission: Mission) -> StartMissionResponse:
         return StartMissionResponse(
             id=mission.id,

{isar-1.31.0 → isar-1.32.0}/src/isar/config/log.py

@@ -5,11 +5,10 @@ from importlib.resources import as_file, files
 import yaml
 from uvicorn.logging import ColourizedFormatter
 
-from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
 
 
-def setup_loggers(keyvault: Keyvault) -> None:
+def setup_loggers() -> None:
     log_levels: dict = settings.LOG_LEVELS
     log_config = load_log_config()
 

isar-1.32.0/src/isar/config/logging.conf

@@ -0,0 +1,37 @@
+version: 1
+formatters:
+  simple:
+    format: '%(asctime)s - %(levelname)s - %(name)s - %(message)s'
+  colourized:
+    style: "{"
+    format: "{asctime} - {levelprefix:<8} - {name} - {message}"
+loggers:
+  console:
+    handlers: []
+    propagate: no
+  main:
+    handlers: []
+    propagate: no
+  api:
+    handlers: []
+    propagate: no
+  mqtt:
+    handlers: []
+    propagate: no
+  state_machine:
+    handlers: []
+    propagate: no
+  uploader:
+    handlers: []
+    propagate: no
+  urllib3:
+    handlers: []
+  uvicorn:
+    handlers: []
+    propagate: no
+  azure:
+    handlers: []
+    propagate: no
+root:
+  level: DEBUG
+  handlers: []

{isar-1.31.0 → isar-1.32.0}/src/isar/config/open_telemetry.py

@@ -1,6 +1,5 @@
 import logging
 
-from azure.identity import ManagedIdentityCredential
 from azure.monitor.opentelemetry.exporter import (
     AzureMonitorLogExporter,
     AzureMonitorTraceExporter,
@@ -57,12 +56,7 @@ def get_azure_monitor_exporters() -> (
     Else use Azure Managed Identity to create Azure Monitor Exporters.
     """
     connection_string = settings.APPLICATIONINSIGHTS_CONNECTION_STRING
-    if connection_string:
-        trace_exporter = AzureMonitorTraceExporter(connection_string=connection_string)
-        log_exporter = AzureMonitorLogExporter(connection_string=connection_string)
-    else:
-        credential = ManagedIdentityCredential()
-        trace_exporter = AzureMonitorTraceExporter(credential=credential)
-        log_exporter = AzureMonitorLogExporter(credential=credential)
+    trace_exporter = AzureMonitorTraceExporter(connection_string=connection_string)
+    log_exporter = AzureMonitorLogExporter(connection_string=connection_string)
 
     return trace_exporter, log_exporter

{isar-1.31.0 → isar-1.32.0}/src/isar/config/settings.py

@@ -224,6 +224,9 @@ class Settings(BaseSettings):
         default="robot_heartbeat", validate_default=True
     )
     TOPIC_ISAR_STARTUP: str = Field(default="startup", validate_default=True)
+    TOPIC_ISAR_INTERVENTION_NEEDED: str = Field(
+        default="intervention_needed", validate_default=True
+    )
 
     # Logging
 
@@ -275,6 +278,7 @@ class Settings(BaseSettings):
         "TOPIC_ISAR_INSPECTION_RESULT",
         "TOPIC_ISAR_INSPECTION_VALUE",
         "TOPIC_ISAR_STARTUP",
+        "TOPIC_ISAR_INTERVENTION_NEEDED",
     )
     @classmethod
     def prefix_isar_topics(cls, v: Any, info: ValidationInfo):

isar-1.32.0/src/isar/eventhandlers/eventhandler.py

@@ -0,0 +1,93 @@
+import logging
+import time
+from copy import deepcopy
+from dataclasses import dataclass
+from threading import Event as ThreadEvent
+from typing import TYPE_CHECKING, Callable, Generic, List, Optional, TypeVar
+
+from transitions import State
+
+from isar.config.settings import settings
+from isar.models.events import Event
+
+T = TypeVar("T")
+
+
+@dataclass
+class EventHandlerMapping(Generic[T]):
+    name: str
+    event: Event[T]
+    handler: Callable[[Event[T]], Optional[Callable]]
+
+
+@dataclass
+class TimeoutHandlerMapping:
+    name: str
+    timeout_in_seconds: float
+    handler: Callable[[], Optional[Callable]]
+
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class EventHandlerBase(State):
+    def __init__(
+        self,
+        state_machine: "StateMachine",
+        state_name: str,
+        event_handler_mappings: List[EventHandlerMapping],
+        timers: List[TimeoutHandlerMapping] = [],
+    ) -> None:
+
+        super().__init__(name=state_name, on_enter=self.start)
+        self.state_machine: "StateMachine" = state_machine
+        self.logger = logging.getLogger("state_machine")
+        self.events = state_machine.events
+        self.signal_state_machine_to_stop: ThreadEvent = (
+            state_machine.signal_state_machine_to_stop
+        )
+        self.event_handler_mappings = event_handler_mappings
+        self.state_name: str = state_name
+        self.timers = timers
+
+    def start(self) -> None:
+        self.state_machine.update_state()
+        self._run()
+
+    def stop(self) -> None:
+        return
+
+    def _run(self) -> None:
+        should_exit_state: bool = False
+        timers = deepcopy(self.timers)
+        entered_time = time.time()
+        while True:
+            if self.signal_state_machine_to_stop.is_set():
+                self.logger.info(
+                    "Stopping state machine from %s state", self.state_name
+                )
+                break
+
+            for timer in timers:
+                if time.time() - entered_time > timer.timeout_in_seconds:
+                    transition_func = timer.handler()
+                    timers.remove(timer)
+                    if transition_func is not None:
+                        transition_func()
+                        should_exit_state = True
+                        break
+
+            if should_exit_state:
+                break
+
+            for handler_mapping in self.event_handler_mappings:
+                transition_func = handler_mapping.handler(handler_mapping.event)
+                if transition_func is not None:
+                    transition_func()
+                    should_exit_state = True
+                    break
+
+            if should_exit_state:
+                break
+            time.sleep(settings.FSM_SLEEP_TIME)

isar-1.32.0/src/isar/models/events.py

@@ -0,0 +1,119 @@
+from collections import deque
+from queue import Empty, Queue
+from typing import Generic, Optional, TypeVar
+
+from transitions import State
+
+from isar.apis.models.models import ControlMissionResponse
+from isar.config.settings import settings
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.status import RobotStatus, TaskStatus
+from robot_interface.models.mission.task import TASKS
+
+T = TypeVar("T")
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+
+
+class Event(Queue[T]):
+    def __init__(self) -> None:
+        super().__init__(maxsize=1)
+
+    def trigger_event(self, data: T) -> None:
+        self.put(data)
+
+    def consume_event(self, timeout: int = None) -> Optional[T]:
+        try:
+            return self.get(block=timeout is not None, timeout=timeout)
+        except Empty:
+            if timeout is not None:
+                raise EventTimeoutError
+            return None
+
+    def clear_event(self) -> None:
+        while True:
+            try:
+                self.get(block=False)
+            except Empty:
+                break
+
+    def has_event(self) -> bool:
+        return (
+            self.qsize() != 0
+        )  # Queue size is not reliable, but should be sufficient for this case
+
+    def check(self) -> Optional[T]:
+        if not self._qsize():
+            return None
+        with self.mutex:
+            queueList = list(self.queue)
+            return queueList.pop()
+
+    def update(self, item: T):
+        with self.mutex:
+            self.queue: deque[T] = deque()
+            self.queue.append(item)
+
+
+class Events:
+    def __init__(self) -> None:
+        self.api_requests: APIRequests = APIRequests()
+        self.state_machine_events: StateMachineEvents = StateMachineEvents()
+        self.robot_service_events: RobotServiceEvents = RobotServiceEvents()
+
+        self.upload_queue: Queue = Queue(maxsize=10)
+
+        if settings.MQTT_ENABLED:
+            self.mqtt_queue: Queue = Queue()
+
+
+class APIEvent(Generic[T1, T2]):
+    """
+    Creates input and output event. The events are defined such that the input is from
+    api to state machine while the output is from state machine to api.
+    """
+
+    def __init__(self):
+        self.input: Event[T1] = Event()
+        self.output: Event[T2] = Event()
+
+
+class APIRequests:
+    def __init__(self) -> None:
+        self.start_mission: APIEvent[Mission, bool] = APIEvent()
+        self.stop_mission: APIEvent[str, ControlMissionResponse] = APIEvent()
+        self.pause_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
+        self.resume_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
+        self.return_home: APIEvent[bool, bool] = APIEvent()
+        self.release_intervention_needed: APIEvent[bool, bool] = APIEvent()
+
+
+class StateMachineEvents:
+    def __init__(self) -> None:
+        self.start_mission: Event[Mission] = Event()
+        self.stop_mission: Event[bool] = Event()
+        self.pause_mission: Event[bool] = Event()
+        self.task_status_request: Event[str] = Event()
+
+
+class RobotServiceEvents:
+    def __init__(self) -> None:
+        self.task_status_updated: Event[TaskStatus] = Event()
+        self.task_status_failed: Event[ErrorMessage] = Event()
+        self.mission_started: Event[bool] = Event()
+        self.mission_failed: Event[ErrorMessage] = Event()
+        self.robot_status_changed: Event[bool] = Event()
+        self.mission_failed_to_stop: Event[ErrorMessage] = Event()
+        self.mission_successfully_stopped: Event[bool] = Event()
+
+
+class SharedState:
+    def __init__(self) -> None:
+        self.state: Event[State] = Event()
+        self.robot_status: Event[RobotStatus] = Event()
+        self.state_machine_current_task: Event[TASKS] = Event()
+
+
+class EventTimeoutError(Exception):
+    pass

{isar-1.31.0 → isar-1.32.0}/src/isar/modules.py

@@ -12,7 +12,7 @@ from isar.config.settings import settings
 from isar.mission_planner.local_planner import LocalPlanner
 from isar.mission_planner.sequential_task_selector import SequentialTaskSelector
 from isar.mission_planner.task_selector_interface import TaskSelectorInterface
-from isar.models.communication.queues.events import Events, SharedState
+from isar.models.events import Events, SharedState
 from isar.robot.robot import Robot
 from isar.services.utilities.robot_utilities import RobotUtilities
 from isar.services.utilities.scheduling_utilities import SchedulingUtilities

{isar-1.31.0 → isar-1.32.0}/src/isar/robot/robot.py

@@ -1,20 +1,20 @@
 import logging
-from queue import Queue
-from threading import Event
+from threading import Event as ThreadEvent
 from typing import Optional
 
-from isar.models.communication.queues.events import (
+from isar.models.events import (
+    Event,
     Events,
     RobotServiceEvents,
     SharedState,
     StateMachineEvents,
 )
-from isar.models.communication.queues.queue_utils import check_for_event, trigger_event
 from isar.robot.robot_start_mission import RobotStartMissionThread
 from isar.robot.robot_status import RobotStatusThread
 from isar.robot.robot_stop_mission import RobotStopMissionThread
 from isar.robot.robot_task_status import RobotTaskStatusThread
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage, ErrorReason
+from robot_interface.models.mission.mission import Mission
 from robot_interface.robot_interface import RobotInterface
 
 
@@ -31,7 +31,7 @@ class Robot(object):
         self.robot_status_thread: Optional[RobotStatusThread] = None
         self.robot_task_status_thread: Optional[RobotTaskStatusThread] = None
         self.stop_mission_thread: Optional[RobotStopMissionThread] = None
-        self.signal_thread_quitting: Event = Event()
+        self.signal_thread_quitting: ThreadEvent = ThreadEvent()
 
     def stop(self) -> None:
         self.signal_thread_quitting.set()
@@ -53,8 +53,8 @@ class Robot(object):
         self.robot_task_status_thread = None
         self.start_mission_thread = None
 
-    def _check_and_handle_start_mission(self, event: Queue) -> None:
-        start_mission = check_for_event(event)
+    def _start_mission_event_handler(self, event: Event[Mission]) -> None:
+        start_mission = event.consume_event()
         if start_mission is not None:
             if (
                 self.start_mission_thread is not None
@@ -72,8 +72,8 @@ class Robot(object):
             )
             self.start_mission_thread.start()
 
-    def _check_and_handle_task_status_request(self, event: Queue[str]) -> None:
-        task_id: str = check_for_event(event)
+    def _task_status_request_handler(self, event: Event[str]) -> None:
+        task_id: str = event.consume_event()
         if task_id:
             self.robot_task_status_thread = RobotTaskStatusThread(
                 self.robot_service_events,
@@ -83,8 +83,8 @@ class Robot(object):
             )
             self.robot_task_status_thread.start()
 
-    def _check_and_handle_stop_mission(self, event: Queue) -> None:
-        if check_for_event(event):
+    def _stop_mission_request_handler(self, event: Event[bool]) -> None:
+        if event.consume_event():
             if (
                 self.stop_mission_thread is not None
                 and self.stop_mission_thread.is_alive()
@@ -102,8 +102,8 @@ class Robot(object):
                     error_reason=ErrorReason.RobotStillStartingMissionException,
                     error_description=error_description,
                 )
-                trigger_event(
-                    self.robot_service_events.mission_failed_to_stop, error_message
+                self.robot_service_events.mission_failed_to_stop.trigger_event(
+                    error_message
                 )
                 return
             self.stop_mission_thread = RobotStopMissionThread(
@@ -118,14 +118,12 @@ class Robot(object):
         self.robot_status_thread.start()
 
         while not self.signal_thread_quitting.wait(0):
-            self._check_and_handle_start_mission(
-                self.state_machine_events.start_mission
-            )
+            self._start_mission_event_handler(self.state_machine_events.start_mission)
 
-            self._check_and_handle_task_status_request(
+            self._task_status_request_handler(
                 self.state_machine_events.task_status_request
             )
 
-            self._check_and_handle_stop_mission(self.state_machine_events.stop_mission)
+            self._stop_mission_request_handler(self.state_machine_events.stop_mission)
 
         self.logger.info("Exiting robot service main thread")

{isar-1.31.0 → isar-1.32.0}/src/isar/robot/robot_start_mission.py

@@ -2,11 +2,7 @@ import logging
 from threading import Event, Thread
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import RobotServiceEvents
-from isar.models.communication.queues.queue_utils import (
-    trigger_event,
-    trigger_event_without_data,
-)
+from isar.models.events import RobotServiceEvents
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
     RobotException,
@@ -44,13 +40,13 @@ class RobotStartMissionThread(Thread):
                     self.logger.error(
                         f"Mission is infeasible and cannot be scheduled because: {e.error_description}"
                     )
-                    trigger_event(
-                        self.robot_service_events.mission_failed,
+                    self.robot_service_events.mission_failed.trigger_event(
                         ErrorMessage(
                             error_reason=e.error_reason,
                             error_description=e.error_description,
-                        ),
+                        )
                     )
+
                     break
                 except RobotException as e:
                     retries += 1
@@ -66,12 +62,11 @@ class RobotStartMissionThread(Thread):
                             f"{e.error_description}"
                         )
 
-                        trigger_event(
-                            self.robot_service_events.mission_failed,
+                        self.robot_service_events.mission_failed.trigger_event(
                             ErrorMessage(
                                 error_reason=e.error_reason,
                                 error_description=e.error_description,
-                            ),
+                            )
                         )
                         break
 
@@ -79,12 +74,11 @@ class RobotStartMissionThread(Thread):
 
                 started_mission = True
         except RobotInfeasibleMissionException as e:
-            trigger_event(
-                self.robot_service_events.mission_failed,
+            self.robot_service_events.mission_failed.trigger_event(
                 ErrorMessage(
                     error_reason=e.error_reason, error_description=e.error_description
                 ),
             )
 
         if started_mission:
-            trigger_event_without_data(self.robot_service_events.mission_started)
+            self.robot_service_events.mission_started.trigger_event(True)

{isar-1.31.0 → isar-1.32.0}/src/isar/robot/robot_status.py

@@ -3,8 +3,7 @@ import time
 from threading import Event, Thread
 
 from isar.config.settings import settings
-from isar.models.communication.queues.events import SharedState
-from isar.models.communication.queues.queue_utils import update_shared_state
+from isar.models.events import SharedState
 from robot_interface.models.exceptions.robot_exceptions import RobotException
 from robot_interface.robot_interface import RobotInterface
 
@@ -49,7 +48,7 @@ class RobotStatusThread(Thread):
                 self.last_robot_status_poll_time = time.time()
 
                 robot_status = self.robot.robot_status()
-                update_shared_state(self.shared_state.robot_status, robot_status)
+                self.shared_state.robot_status.update(robot_status)
             except RobotException as e:
                 self.logger.error(f"Failed to retrieve robot status: {e}")
                 continue