isar 1.33.6__tar.gz → 1.33.8__tar.gz

{isar-1.33.6 → isar-1.33.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.6
+Version: 1.33.8
 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.33.6 → isar-1.33.8}/src/isar/config/settings.py

@@ -59,6 +59,9 @@ class Settings(BaseSettings):
     # issues
     REQUEST_STATUS_COMMUNICATION_RECONNECT_DELAY: float = Field(default=10)
 
+    # Time allowed to clear the robot status before giving up
+    CLEAR_ROBOT_STATUS_TIMEOUT: int = Field(default=3)
+
     # Number of attempts for state transitions resume and pause if failed
     STATE_TRANSITION_NUM_RETIRES: int = Field(default=10)
 
@@ -78,6 +81,7 @@ class Settings(BaseSettings):
     ROBOT_STATUS_PUBLISH_INTERVAL: float = Field(default=1)
     ROBOT_HEARTBEAT_PUBLISH_INTERVAL: float = Field(default=1)
     ROBOT_INFO_PUBLISH_INTERVAL: float = Field(default=5)
+    ROBOT_API_BATTERY_POLL_INTERVAL: float = Field(default=5)
     ROBOT_API_STATUS_POLL_INTERVAL: float = Field(default=5)
     THREAD_CHECK_INTERVAL: float = Field(default=0.01)
 

{isar-1.33.6 → isar-1.33.8}/src/isar/models/events.py

@@ -42,6 +42,8 @@ class Event(Queue[T]):
             if timeout is not None:
                 raise EventTimeoutError
             return None
+        except ValueError:
+            raise EventConflictError
 
     def clear_event(self) -> None:
         while True:
@@ -49,6 +51,8 @@ class Event(Queue[T]):
                 self.get(block=False)
             except Empty:
                 break
+            except ValueError:
+                break
 
     def has_event(self) -> bool:
         return (
@@ -123,6 +127,7 @@ class StateMachineEvents:
         self.stop_mission: Event[bool] = Event("stop_mission")
         self.pause_mission: Event[bool] = Event("pause_mission")
         self.task_status_request: Event[str] = Event("task_status_request")
+        self.clear_robot_status: Event[bool] = Event("clear_robot_status")
 
 
 class RobotServiceEvents:
@@ -132,6 +137,7 @@ class RobotServiceEvents:
         self.mission_started: Event[bool] = Event("mission_started")
         self.mission_failed: Event[ErrorMessage] = Event("mission_failed")
         self.robot_status_changed: Event[bool] = Event("robot_status_changed")
+        self.robot_status_cleared: Event[bool] = Event("robot_status_cleared")
         self.mission_failed_to_stop: Event[ErrorMessage] = Event(
             "mission_failed_to_stop"
         )

isar-1.33.8/src/isar/models/status.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class IsarStatus(Enum):
+    Available = "available"
+    ReturnHomePaused = "returnhomepaused"
+    Paused = "paused"
+    Busy = "busy"
+    Home = "home"
+    Offline = "offline"
+    BlockedProtectiveStop = "blockedprotectivestop"
+    ReturningHome = "returninghome"
+    InterventionNeeded = "interventionneeded"
+    Recharging = "recharging"
+    Lockdown = "lockdown"
+    GoingToLockdown = "goingtolockdown"

{isar-1.33.6 → isar-1.33.8}/src/isar/robot/robot.py

@@ -9,6 +9,7 @@ from isar.models.events import (
     SharedState,
     StateMachineEvents,
 )
+from isar.robot.robot_battery import RobotBatteryThread
 from isar.robot.robot_pause_mission import RobotPauseMissionThread
 from isar.robot.robot_start_mission import RobotStartMissionThread
 from isar.robot.robot_status import RobotStatusThread
@@ -29,6 +30,7 @@ class Robot(object):
         self.shared_state: SharedState = shared_state
         self.robot: RobotInterface = robot
         self.start_mission_thread: Optional[RobotStartMissionThread] = None
+        self.robot_battery_thread: Optional[RobotBatteryThread] = None
         self.robot_status_thread: Optional[RobotStatusThread] = None
         self.robot_task_status_thread: Optional[RobotTaskStatusThread] = None
         self.stop_mission_thread: Optional[RobotStopMissionThread] = None
@@ -39,6 +41,11 @@ class Robot(object):
         self.signal_thread_quitting.set()
         if self.robot_status_thread is not None and self.robot_status_thread.is_alive():
             self.robot_status_thread.join()
+        if (
+            self.robot_battery_thread is not None
+            and self.robot_battery_thread.is_alive()
+        ):
+            self.robot_battery_thread.join()
         if (
             self.robot_task_status_thread is not None
             and self.robot_task_status_thread.is_alive()
@@ -52,6 +59,7 @@ class Robot(object):
         if self.stop_mission_thread is not None and self.stop_mission_thread.is_alive():
             self.stop_mission_thread.join()
         self.robot_status_thread = None
+        self.robot_battery_thread = None
         self.robot_task_status_thread = None
         self.start_mission_thread = None
 
@@ -143,10 +151,19 @@ class Robot(object):
 
     def run(self) -> None:
         self.robot_status_thread = RobotStatusThread(
-            self.robot, self.signal_thread_quitting, self.shared_state
+            robot=self.robot,
+            signal_thread_quitting=self.signal_thread_quitting,
+            shared_state=self.shared_state,
+            state_machine_events=self.state_machine_events,
+            robot_service_events=self.robot_service_events,
         )
         self.robot_status_thread.start()
 
+        self.robot_battery_thread = RobotBatteryThread(
+            self.robot, self.signal_thread_quitting, self.shared_state
+        )
+        self.robot_battery_thread.start()
+
         while not self.signal_thread_quitting.wait(0):
             self._start_mission_event_handler(self.state_machine_events.start_mission)
 

isar-1.33.6/src/isar/robot/robot_status.py → isar-1.33.8/src/isar/robot/robot_battery.py

@@ -8,7 +8,7 @@ from robot_interface.models.exceptions.robot_exceptions import RobotException
 from robot_interface.robot_interface import RobotInterface
 
 
-class RobotStatusThread(Thread):
+class RobotBatteryThread(Thread):
     def __init__(
         self,
         robot: RobotInterface,
@@ -19,20 +19,24 @@ class RobotStatusThread(Thread):
         self.shared_state: SharedState = shared_state
         self.robot: RobotInterface = robot
         self.signal_thread_quitting: Event = signal_thread_quitting
-        self.last_robot_status_poll_time: float = (
-            time.time() - settings.ROBOT_API_STATUS_POLL_INTERVAL
-        )
-        Thread.__init__(self, name="Robot status thread")
+        self.last_robot_battery_poll_time: float = time.time()
+        self.force_battery_poll_next_iteration: bool = True
+        Thread.__init__(self, name="Robot battery thread")
 
     def stop(self) -> None:
         return
 
-    def _is_ready_to_poll_for_status(self) -> bool:
-        time_since_last_robot_status_poll = (
-            time.time() - self.last_robot_status_poll_time
+    def _is_ready_to_poll_for_battery(self) -> bool:
+        if self.force_battery_poll_next_iteration:
+            self.force_battery_poll_next_iteration = False
+            return True
+
+        time_since_last_robot_battery_poll = (
+            time.time() - self.last_robot_battery_poll_time
         )
         return (
-            time_since_last_robot_status_poll > settings.ROBOT_API_STATUS_POLL_INTERVAL
+            time_since_last_robot_battery_poll
+            > settings.ROBOT_API_BATTERY_POLL_INTERVAL
         )
 
     def run(self):
@@ -42,17 +46,15 @@ class RobotStatusThread(Thread):
         thread_check_interval = settings.THREAD_CHECK_INTERVAL
 
         while not self.signal_thread_quitting.wait(thread_check_interval):
-            if not self._is_ready_to_poll_for_status():
+            if not self._is_ready_to_poll_for_battery():
                 continue
             try:
-                self.last_robot_status_poll_time = time.time()
+                self.last_robot_battery_poll_time = time.time()
 
-                robot_status = self.robot.robot_status()
                 robot_battery_level = self.robot.get_battery_level()
 
-                self.shared_state.robot_status.update(robot_status)
                 self.shared_state.robot_battery_level.update(robot_battery_level)
             except RobotException as e:
-                self.logger.error(f"Failed to retrieve robot status: {e}")
+                self.logger.error(f"Failed to retrieve robot battery level: {e}")
                 continue
-        self.logger.info("Exiting robot status thread")
+        self.logger.info("Exiting robot battery thread")

isar-1.33.8/src/isar/robot/robot_status.py

@@ -0,0 +1,71 @@
+import logging
+import time
+from threading import Event, Thread
+
+from isar.config.settings import settings
+from isar.models.events import RobotServiceEvents, SharedState, StateMachineEvents
+from robot_interface.models.exceptions.robot_exceptions import RobotException
+from robot_interface.robot_interface import RobotInterface
+
+
+class RobotStatusThread(Thread):
+    def __init__(
+        self,
+        robot: RobotInterface,
+        signal_thread_quitting: Event,
+        shared_state: SharedState,
+        robot_service_events: RobotServiceEvents,
+        state_machine_events: StateMachineEvents,
+    ):
+        self.logger = logging.getLogger("robot")
+        self.shared_state: SharedState = shared_state
+        self.robot_service_events: RobotServiceEvents = robot_service_events
+        self.state_machine_events: StateMachineEvents = state_machine_events
+        self.robot: RobotInterface = robot
+        self.signal_thread_quitting: Event = signal_thread_quitting
+        self.robot_status_poll_interval: float = settings.ROBOT_API_STATUS_POLL_INTERVAL
+        self.last_robot_status_poll_time: float = time.time()
+        self.force_status_poll_next_iteration: bool = True
+        Thread.__init__(self, name="Robot status thread")
+
+    def stop(self) -> None:
+        return
+
+    def _is_ready_to_poll_for_status(self) -> bool:
+        if self.force_status_poll_next_iteration:
+            self.force_status_poll_next_iteration = False
+            return True
+
+        time_since_last_robot_status_poll = (
+            time.time() - self.last_robot_status_poll_time
+        )
+        return time_since_last_robot_status_poll > self.robot_status_poll_interval
+
+    def run(self):
+        if self.signal_thread_quitting.is_set():
+            return
+
+        thread_check_interval = settings.THREAD_CHECK_INTERVAL
+
+        while not self.signal_thread_quitting.wait(thread_check_interval):
+            if self.state_machine_events.clear_robot_status.consume_event() is not None:
+                self.shared_state.robot_status.clear_event()
+                self.robot_service_events.robot_status_changed.clear_event()
+                self.robot_service_events.robot_status_cleared.trigger_event(True)
+                self.force_status_poll_next_iteration = True
+
+            if not self._is_ready_to_poll_for_status():
+                continue
+
+            try:
+                self.last_robot_status_poll_time = time.time()
+
+                robot_status = self.robot.robot_status()
+
+                if robot_status is not self.shared_state.robot_status.check():
+                    self.shared_state.robot_status.update(robot_status)
+                    self.robot_service_events.robot_status_changed.trigger_event(True)
+            except RobotException as e:
+                self.logger.error(f"Failed to retrieve robot status: {e}")
+                continue
+        self.logger.info("Exiting robot status thread")

{isar-1.33.6 → isar-1.33.8}/src/isar/services/utilities/scheduling_utilities.py

@@ -94,6 +94,12 @@ class SchedulingUtilities:
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
                 detail="Could not plan mission",
             )
+        except Exception as e:
+            self.logger.error(e)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                detail="Could not return mission",
+            )
 
     def verify_robot_capable_of_mission(
         self, mission: Mission, robot_capabilities: List[str]
@@ -171,6 +177,10 @@ class SchedulingUtilities:
         ------
         HTTTPException 408 Request timeout
             If there is a timeout while communicating with the state machine
+        HTTPException 409 Conflict
+            If the state machine is not ready to receive a mission
+        HTTPException 500 Internal Server Error
+            If there is an unexpected error while sending the mission to the state machine
         """
         try:
             mission_start_response = self._send_command(
@@ -195,6 +205,14 @@ class SchedulingUtilities:
             )
             self.logger.warning(error_message)
             raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
+        except Exception as e:
+            error_message = (
+                f"Unexpected error while sending mission to state machine: {e}"
+            )
+            self.logger.error(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            )
         self.logger.info("OK - Mission started in ISAR")
 
     def return_home(
@@ -206,6 +224,10 @@ class SchedulingUtilities:
         ------
         HTTTPException 408 Request timeout
             If there is a timeout while communicating with the state machine
+        HTTPException 409 Conflict
+            If the state machine is not ready to receive a return home mission
+        HTTPException 500 Internal Server Error
+            If there is an unexpected error while sending the return home command
         """
         try:
             self._send_command(
@@ -220,6 +242,12 @@ class SchedulingUtilities:
             error_message = "State machine has entered a state which cannot start a return home mission"
             self.logger.warning(error_message)
             raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
+        except Exception as e:
+            error_message = f"Unexpected error while sending return home command: {e}"
+            self.logger.error(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            )
         self.logger.info("OK - Return home mission started in ISAR")
 
     def pause_mission(self) -> ControlMissionResponse:
@@ -229,6 +257,8 @@ class SchedulingUtilities:
         ------
         HTTTPException 408 Request timeout
             If there is a timeout while communicating with the state machine
+        HTTPException 409 Conflict
+            If the state machine is not in a state which can pause a mission
         """
         try:
             response = self._send_command(True, self.api_events.pause_mission)
@@ -244,6 +274,12 @@ class SchedulingUtilities:
             )
             self.logger.warning(error_message)
             raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
+        except Exception as e:
+            error_message = f"Unexpected error while pausing mission: {e}"
+            self.logger.error(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            )
 
     def resume_mission(self) -> ControlMissionResponse:
         """Resume mission
@@ -252,6 +288,10 @@ class SchedulingUtilities:
         ------
         HTTTPException 408 Request timeout
             If there is a timeout while communicating with the state machine
+        HTTPException 409 Conflict
+            If the state machine is not in a state which can resume a mission
+        HTTPException 500 Internal Server Error
+            If there is an unexpected error while resuming the mission
         """
         try:
             response = self._send_command(True, self.api_events.resume_mission)
@@ -267,6 +307,12 @@ class SchedulingUtilities:
             raise HTTPException(
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
             )
+        except Exception as e:
+            error_message = f"Unexpected error while resuming mission: {e}"
+            self.logger.error(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            )
 
     def stop_mission(self, mission_id: str = "") -> ControlMissionResponse:
         """Stop mission
@@ -279,6 +325,10 @@ class SchedulingUtilities:
             The request was understood, but attempting to stop the mission failed
         HTTPException 408 Request timeout
             If there is a timeout while communicating with the state machine
+        HTTPException 409 Conflict
+            If the state machine is not in a state which can stop a mission
+        HTTPException 500 Internal Server Error
+            If there is an unexpected error while stopping the mission
         """
         try:
             stop_mission_response: ControlMissionResponse = self._send_command(
@@ -293,7 +343,7 @@ class SchedulingUtilities:
                 )
 
             if stop_mission_response.mission_status != MissionStatus.Cancelled.value:
-                error_message = "Failed to stop mission"
+                error_message = f"Failed to stop mission, mission status is {stop_mission_response.mission_status}"
                 self.logger.error(error_message)
                 raise HTTPException(
                     status_code=HTTPStatus.CONFLICT, detail=error_message
@@ -308,6 +358,14 @@ class SchedulingUtilities:
             )
             self.logger.warning(error_message)
             raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
+        except HTTPException as e:
+            raise e
+        except Exception as e:
+            error_message = f"Unexpected error while stopping mission: {e}"
+            self.logger.error(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            )
         self.logger.info("OK - Mission successfully stopped")
         return stop_mission_response
 
@@ -316,6 +374,10 @@ class SchedulingUtilities:
 
         Raises
         ------
+        HTTPException 409 Conflict
+            If the state machine is not in intervention needed state
+        HTTPException 408 Request timeout
+            If there is a timeout while communicating with the state machine
         HTTPException 500 Internal Server Error
             If the intervention needed state could not be released
         """
@@ -332,12 +394,22 @@ class SchedulingUtilities:
             error_message = "Cannot release intervention needed as it is not in intervention needed state"
             self.logger.warning(error_message)
             raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
+        except Exception as e:
+            error_message = (
+                f"Unexpected error while releasing intervention needed state: {e}"
+            )
+            self.logger.error(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            )
 
     def lock_down_robot(self) -> None:
         """Lock down robot
 
         Raises
         ------
+        HTTPException 409 Conflict
+            If the state machine is not in a state which can be locked down
         HTTPException 500 Internal Server Error
             If the robot could not be locked down
         """
@@ -352,12 +424,20 @@ class SchedulingUtilities:
             error_message = "Cannot send robot to lockdown as it is already in lockdown"
             self.logger.warning(error_message)
             raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
+        except Exception as e:
+            error_message = f"Unexpected error while locking down robot: {e}"
+            self.logger.error(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            )
 
     def release_robot_lockdown(self) -> None:
         """Release robot from lockdown
 
         Raises
         ------
+        HTTPException 409 Conflict
+            If the state machine is not in lockdown
         HTTPException 500 Internal Server Error
             If the robot could not be released from lockdown
         """
@@ -376,6 +456,12 @@ class SchedulingUtilities:
             )
             self.logger.warning(error_message)
             raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
+        except Exception as e:
+            error_message = f"Unexpected error while releasing robot from lockdown: {e}"
+            self.logger.error(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            )
 
     def _send_command(self, input: T1, api_event: APIEvent[T1, T2]) -> T2:
         if api_event.request.has_event():

{isar-1.33.6 → isar-1.33.8}/src/isar/state_machine/state_machine.py

@@ -15,6 +15,7 @@ from isar.mission_planner.task_selector_interface import (
     TaskSelectorStop,
 )
 from isar.models.events import Events, SharedState
+from isar.models.status import IsarStatus
 from isar.services.service_connections.mqtt.mqtt_client import props_expiry
 from isar.state_machine.states.await_next_mission import AwaitNextMission
 from isar.state_machine.states.blocked_protective_stop import BlockedProtectiveStop
@@ -45,15 +46,15 @@ from robot_interface.models.exceptions.robot_exceptions import (
 )
 from robot_interface.models.inspection.inspection import Inspection
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.status import RobotStatus, TaskStatus
+from robot_interface.models.mission.status import TaskStatus
 from robot_interface.models.mission.task import TASKS, InspectionTask, Task
 from robot_interface.robot_interface import RobotInterface
 from robot_interface.telemetry.mqtt_client import MqttClientInterface
 from robot_interface.telemetry.payloads import (
     InterventionNeededPayload,
+    IsarStatusPayload,
     MissionAbortedPayload,
     MissionPayload,
-    RobotStatusPayload,
     TaskPayload,
 )
 from robot_interface.utilities.json_service import EnhancedJSONEncoder
@@ -213,6 +214,9 @@ class StateMachine(object):
             self.send_task_status()
 
     def battery_level_is_above_mission_start_threshold(self):
+        if not self.shared_state.robot_battery_level.check():
+            self.logger.warning("Battery level is None")
+            return False
         return (
             not self.shared_state.robot_battery_level.check()
             < settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
@@ -367,7 +371,7 @@ class StateMachine(object):
         if not self.mqtt_publisher:
             return
 
-        payload: RobotStatusPayload = RobotStatusPayload(
+        payload: IsarStatusPayload = IsarStatusPayload(
             isar_id=settings.ISAR_ID,
             robot_name=settings.ROBOT_NAME,
             status=self._current_status(),
@@ -381,31 +385,31 @@ class StateMachine(object):
             retain=True,
         )
 
-    def _current_status(self) -> RobotStatus:
+    def _current_status(self) -> IsarStatus:
         if self.current_state == States.AwaitNextMission:
-            return RobotStatus.Available
+            return IsarStatus.Available
         elif self.current_state == States.ReturnHomePaused:
-            return RobotStatus.ReturnHomePaused
+            return IsarStatus.ReturnHomePaused
         elif self.current_state == States.Paused:
-            return RobotStatus.Paused
+            return IsarStatus.Paused
         elif self.current_state == States.Home:
-            return RobotStatus.Home
+            return IsarStatus.Home
         elif self.current_state == States.ReturningHome:
-            return RobotStatus.ReturningHome
+            return IsarStatus.ReturningHome
         elif self.current_state == States.Offline:
-            return RobotStatus.Offline
+            return IsarStatus.Offline
         elif self.current_state == States.BlockedProtectiveStop:
-            return RobotStatus.BlockedProtectiveStop
+            return IsarStatus.BlockedProtectiveStop
         elif self.current_state == States.InterventionNeeded:
-            return RobotStatus.InterventionNeeded
+            return IsarStatus.InterventionNeeded
         elif self.current_state == States.Recharging:
-            return RobotStatus.Recharging
+            return IsarStatus.Recharging
         elif self.current_state == States.Lockdown:
-            return RobotStatus.Lockdown
+            return IsarStatus.Lockdown
         elif self.current_state == States.GoingToLockdown:
-            return RobotStatus.GoingToLockdown
+            return IsarStatus.GoingToLockdown
         else:
-            return RobotStatus.Busy
+            return IsarStatus.Busy
 
     def _log_state_transition(self, next_state) -> None:
         """Logs all state transitions that are not self-transitions."""

{isar-1.33.6 → isar-1.33.8}/src/isar/state_machine/states/blocked_protective_stop.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, List
 
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
-from isar.models.events import Event
+from isar.state_machine.utils.common_event_handlers import robot_status_event_handler
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
@@ -11,19 +11,19 @@ if TYPE_CHECKING:
 class BlockedProtectiveStop(EventHandlerBase):
 
     def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
         shared_state = state_machine.shared_state
 
-        def _robot_status_event_handler(event: Event[RobotStatus]):
-            robot_status: RobotStatus = event.check()
-            if robot_status != RobotStatus.BlockedProtectiveStop:
-                return state_machine.robot_status_changed  # type: ignore
-            return None
-
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="robot_status_event",
-                event=shared_state.robot_status,
-                handler=_robot_status_event_handler,
+                event=events.robot_service_events.robot_status_changed,
+                handler=lambda event: robot_status_event_handler(
+                    state_machine=state_machine,
+                    expected_status=RobotStatus.BlockedProtectiveStop,
+                    status_changed_event=event,
+                    status_event=shared_state.robot_status,
+                ),
             ),
         ]
         super().__init__(

{isar-1.33.6 → isar-1.33.8}/src/isar/state_machine/states/home.py

@@ -20,17 +20,6 @@ class Home(EventHandlerBase):
         events = state_machine.events
         shared_state = state_machine.shared_state
 
-        def _robot_status_event_handler(
-            event: Event[RobotStatus],
-        ) -> Optional[Callable]:
-            robot_status: RobotStatus = event.check()
-            if not (
-                robot_status == RobotStatus.Available
-                or robot_status == RobotStatus.Home
-            ):
-                return state_machine.robot_status_changed  # type: ignore
-            return None
-
         def _send_to_lockdown_event_handler(event: Event[bool]):
             should_send_robot_home: bool = event.consume_event()
             if should_send_robot_home:
@@ -40,6 +29,21 @@ class Home(EventHandlerBase):
                 return state_machine.reached_lockdown  # type: ignore
             return None
 
+        def _robot_status_event_handler(
+            state_machine: "StateMachine",
+            status_changed_event: Event[bool],
+            status_event: Event[RobotStatus],
+        ) -> Optional[Callable]:
+            if not status_changed_event.consume_event():
+                return None
+            robot_status: Optional[RobotStatus] = status_event.check()
+            if not (
+                robot_status == RobotStatus.Available
+                or robot_status == RobotStatus.Home
+            ):
+                return state_machine.robot_status_changed  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="start_mission_event",
@@ -60,8 +64,12 @@ class Home(EventHandlerBase):
             ),
             EventHandlerMapping(
                 name="robot_status_event",
-                event=shared_state.robot_status,
-                handler=_robot_status_event_handler,
+                event=events.robot_service_events.robot_status_changed,
+                handler=lambda event: _robot_status_event_handler(
+                    state_machine=state_machine,
+                    status_changed_event=event,
+                    status_event=shared_state.robot_status,
+                ),
             ),
             EventHandlerMapping(
                 name="send_to_lockdown_event",