isar 1.33.6__py3-none-any.whl → 1.33.7__py3-none-any.whl

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/models/events.py

@@ -123,6 +123,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 +133,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/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/robot/robot_battery.py

@@ -0,0 +1,60 @@
+import logging
+import time
+from threading import Event, Thread
+
+from isar.config.settings import settings
+from isar.models.events import SharedState
+from robot_interface.models.exceptions.robot_exceptions import RobotException
+from robot_interface.robot_interface import RobotInterface
+
+
+class RobotBatteryThread(Thread):
+    def __init__(
+        self,
+        robot: RobotInterface,
+        signal_thread_quitting: Event,
+        shared_state: SharedState,
+    ):
+        self.logger = logging.getLogger("robot")
+        self.shared_state: SharedState = shared_state
+        self.robot: RobotInterface = robot
+        self.signal_thread_quitting: Event = signal_thread_quitting
+        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_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_battery_poll
+            > settings.ROBOT_API_BATTERY_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 not self._is_ready_to_poll_for_battery():
+                continue
+            try:
+                self.last_robot_battery_poll_time = time.time()
+
+                robot_battery_level = self.robot.get_battery_level()
+
+                self.shared_state.robot_battery_level.update(robot_battery_level)
+            except RobotException as e:
+                self.logger.error(f"Failed to retrieve robot battery level: {e}")
+                continue
+        self.logger.info("Exiting robot battery thread")

isar/robot/robot_status.py

@@ -3,7 +3,7 @@ import time
 from threading import Event, Thread
 
 from isar.config.settings import settings
-from isar.models.events import SharedState
+from isar.models.events import RobotServiceEvents, SharedState, StateMachineEvents
 from robot_interface.models.exceptions.robot_exceptions import RobotException
 from robot_interface.robot_interface import RobotInterface
 
@@ -14,26 +14,32 @@ class RobotStatusThread(Thread):
         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.last_robot_status_poll_time: float = (
-            time.time() - settings.ROBOT_API_STATUS_POLL_INTERVAL
-        )
+        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 > settings.ROBOT_API_STATUS_POLL_INTERVAL
-        )
+        return time_since_last_robot_status_poll > self.robot_status_poll_interval
 
     def run(self):
         if self.signal_thread_quitting.is_set():
@@ -42,16 +48,23 @@ class RobotStatusThread(Thread):
         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()
-                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)
+                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

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/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",

isar/state_machine/states/offline.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,20 +11,19 @@ if TYPE_CHECKING:
 class Offline(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.Offline:
-                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.Offline,
+                    status_changed_event=event,
+                    status_event=shared_state.robot_status,
+                ),
             ),
         ]
         super().__init__(

isar/state_machine/transitions/functions/robot_status.py

@@ -1,5 +1,7 @@
+import time
 from typing import TYPE_CHECKING
 
+from isar.config.settings import settings
 from robot_interface.models.mission.status import RobotStatus
 
 if TYPE_CHECKING:
@@ -19,3 +21,16 @@ def is_available_or_home(state_machine: "StateMachine") -> bool:
 def is_blocked_protective_stop(state_machine: "StateMachine") -> bool:
     robot_status = state_machine.shared_state.robot_status.check()
     return robot_status == RobotStatus.BlockedProtectiveStop
+
+
+def clear_robot_status(state_machine: "StateMachine") -> bool:
+    state_machine.events.state_machine_events.clear_robot_status.trigger_event(True)
+    start_time: float = time.time()
+    while time.time() - start_time < settings.CLEAR_ROBOT_STATUS_TIMEOUT:
+        if (
+            state_machine.events.robot_service_events.robot_status_cleared.consume_event()
+        ):
+            return True
+        time.sleep(settings.FSM_SLEEP_TIME)
+    state_machine.logger.error("Timed out waiting for robot status to be cleared")
+    return False

isar/state_machine/transitions/return_home.py

@@ -12,6 +12,7 @@ from isar.state_machine.transitions.functions.return_home import (
     should_retry_return_home,
     start_return_home_mission,
 )
+from isar.state_machine.transitions.functions.robot_status import clear_robot_status
 from isar.state_machine.transitions.functions.start_mission import (
     initialize_robot,
     trigger_start_mission_event,
@@ -58,11 +59,19 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
             "trigger": "returned_home",
             "source": state_machine.returning_home_state,
             "dest": state_machine.home_state,
+            "conditions": [
+                def_transition(state_machine, clear_robot_status),
+            ],
             "before": [
                 def_transition(state_machine, reset_return_home_failure_counter),
                 def_transition(state_machine, return_home_finished),
             ],
         },
+        {
+            "trigger": "returned_home",
+            "source": state_machine.returning_home_state,
+            "dest": state_machine.intervention_needed_state,
+        },
         {
             "trigger": "starting_recharging",
             "source": state_machine.returning_home_state,

isar/state_machine/utils/common_event_handlers.py

@@ -43,9 +43,12 @@ def return_home_event_handler(
 def robot_status_event_handler(
     state_machine: "StateMachine",
     expected_status: RobotStatus,
-    event: Event[RobotStatus],
+    status_changed_event: Event[bool],
+    status_event: Event[RobotStatus],
 ) -> Optional[Callable]:
-    robot_status: RobotStatus = event.check()
+    if not status_changed_event.consume_event():
+        return None
+    robot_status: Optional[RobotStatus] = status_event.check()
     if robot_status != expected_status:
         return state_machine.robot_status_changed  # type: ignore
     return None

{isar-1.33.6.dist-info → isar-1.33.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.6
+Version: 1.33.7
 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.dist-info → isar-1.33.7.dist-info}/RECORD

@@ -16,7 +16,7 @@ isar/config/configuration_error.py,sha256=rO6WOhafX6xvVib8WxV-eY483Z0PpN-9PxGsq5
 isar/config/log.py,sha256=f_mLLz5RSa0kZkdpi1m0iMdwwDc4RQp12mnT6gu2exE,1303
 isar/config/logging.conf,sha256=a7ZBvZkrMDaPU3eRGAjL_eZz6hZsa6BaRJOfx8mbnnM,629
 isar/config/open_telemetry.py,sha256=Lgu0lbRQA-zz6ZDoBKKk0whQex5w18jl1wjqWzHUGdg,3634
-isar/config/settings.py,sha256=5A_hxq6AFzg94ROz8yIK8KKZcygwJAosM4ROKJOeCfU,14243
+isar/config/settings.py,sha256=XMPU4d1V6FspjvMmto5TFmC8Slt8Nrpmn9n_tsyPTYk,14423
 isar/config/certs/ca-cert.pem,sha256=qoNljfad_qcMxhXJIUMLd7nT-Qwf_d4dYSdoOFEOE8I,2179
 isar/config/keyvault/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/config/keyvault/keyvault_error.py,sha256=zvPCsZLjboxsxthYkxpRERCTFxYV8R5WmACewAUQLwk,41
@@ -42,11 +42,12 @@ isar/mission_planner/mission_planner_interface.py,sha256=UgpPIM4FbrWOD7fGY3Ul64k
 isar/mission_planner/sequential_task_selector.py,sha256=66agRPHuJnEa1vArPyty4muTasAZ50XPjjrSaTdY_Cc,643
 isar/mission_planner/task_selector_interface.py,sha256=pnLeaGPIuyXThcflZ_A7YL2b2xQjFT88hAZidkMomxU,707
 isar/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/models/events.py,sha256=GzoOzwZA5PgPuI8Uc-bR3Kvrj-OJuSUIHPynZrkjgU8,5521
-isar/robot/robot.py,sha256=jeDVTWneDPFfHcpa4QUVx6DscE7gAiZ85UMuB-Xwm9o,6853
+isar/models/events.py,sha256=D3f5v0mmGlkIYT1ZSfSZILuMyVi4zDA-VxohuzRM6AA,5675
+isar/robot/robot.py,sha256=sn-JfJE6lC6Auo13fdS556Uwq_xZE6VSrR4DhNcgOno,7560
+isar/robot/robot_battery.py,sha256=goLdgmn61QCgE2Ja3YuiwE_sqJzIhCkS3u90sz1kdug,2089
 isar/robot/robot_pause_mission.py,sha256=BFTLVFOnCeuLlyz1Lu12_6EgYBhk8frsviCs-kGq7AA,2277
 isar/robot/robot_start_mission.py,sha256=RPYH9VtXDFdPqhOpt6kSbT17RHkJQPKkQ6d4784_pFE,3210
-isar/robot/robot_status.py,sha256=OXx18Qj0bvb2sKzn5-yKXWGdZ9GYyCOIgiTaGof-0Wc,2055
+isar/robot/robot_status.py,sha256=8201XW9SmYFLVjys9zk972a8ge9aEgCsdm-V1S2VTjM,2924
 isar/robot/robot_stop_mission.py,sha256=lKWY9LsBeeMsBZHJEN-Mfm2h3DYoBQT71TgEKlxw9ng,2269
 isar/robot/robot_task_status.py,sha256=jefIDfrbly7vWZztWA2zLmK5Yz1NSEytw2YUmprccNA,3161
 isar/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -67,13 +68,13 @@ isar/state_machine/state_machine.py,sha256=CUDTwPEOVpyV8up5bhVLKLkPDcc1mMx_Nchmq
 isar/state_machine/states_enum.py,sha256=EzqLHsNbR7KBMIY5Fa_CDaHm9v6g8UFzq9DJs4x0OU8,746
 isar/state_machine/states/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/state_machine/states/await_next_mission.py,sha256=3_KrK7nWu1Dm-VA3Rt1gwVsUbn9WuB7MoqLCfobGJSM,2749
-isar/state_machine/states/blocked_protective_stop.py,sha256=GEOvxnHXjpCsrh3aa8Idtn1zMYv5HLQzj9qQAq8HvaU,1180
+isar/state_machine/states/blocked_protective_stop.py,sha256=HJr_jH8OdHMuX8zhjlF5jtNAfMCxkA1X7nOGmkAz-RY,1263
 isar/state_machine/states/going_to_lockdown.py,sha256=RLMOH2lXiT3hQhfUtbBVAUfwKUd33yxbjq4uZDZ_Tkc,3388
-isar/state_machine/states/home.py,sha256=aWJYsGkv8zVaKZJ4OUbbRPHyI4j8Jj9Uy0PvLx6jI2U,2984
+isar/state_machine/states/home.py,sha256=mCwXSb9LygNpY4qaKEkEYC3nP-6HdsSGmEyjsENumgM,3396
 isar/state_machine/states/intervention_needed.py,sha256=A0QYz1vD1tDKAealihXDuoGuMLtXrRfn_AwFoaUhT_Q,1640
 isar/state_machine/states/lockdown.py,sha256=mWjhjtky5GbW6BLjsi2TsS0LXI-yq7l29FaqZ2TbTek,1375
 isar/state_machine/states/monitor.py,sha256=wmiJrbKntnNw9ExS6-VdJJuW2Q3Jzl9DozmZmEXJ0Cw,5285
-isar/state_machine/states/offline.py,sha256=5wdNzC1wG0cWrpuT_r_mk8UNFHA4QSyg8ejXUTAg4Io,1137
+isar/state_machine/states/offline.py,sha256=k1UdcRWLd6lJiL5cnpHKBkvMY4xZMt_x7XIauy-Rgww,1219
 isar/state_machine/states/paused.py,sha256=1ADoTJ3b137k7dmZYxeyGVhyrRF8qotxoV1NaWCbBUk,2870
 isar/state_machine/states/pausing.py,sha256=r0GywI1-JDOJLZEnxhnq_yFKza37eL45qHP0ir8SBsY,2762
 isar/state_machine/states/pausing_return_home.py,sha256=USyBLWpJqrsJ2hsdyW6i-gvEsog2l7OMJLdgIj-hq0Y,2808
@@ -85,25 +86,25 @@ isar/state_machine/states/stopping_go_to_lockdown.py,sha256=npbz0aFbbCpsEbmBYc8w
 isar/state_machine/states/stopping_return_home.py,sha256=ub952Ulas3a0lsV_dI4liBiInADo3zaPAGod2bPe_18,2985
 isar/state_machine/states/unknown_status.py,sha256=Y-g9cgme5zriyZ6YUzFRYhOvv9ZylCSwfaY8MJ7xEJ0,1791
 isar/state_machine/transitions/mission.py,sha256=lwXdC5Jn19gO-wrSaZp3_77mLnvj-CaBYZk61U-qgoo,8211
-isar/state_machine/transitions/return_home.py,sha256=0tB2n07_eq7J3-Aq3v5ob8Mh-yyCkSNu07OgD9NkCY0,6374
+isar/state_machine/transitions/return_home.py,sha256=ho4Nae-C5BaxVFciFL546EuoMSDIWLqT58E8bNraW4o,6749
 isar/state_machine/transitions/robot_status.py,sha256=qJMurCpuficOiXs9us4lZJ5p_kOFSwKxJigiXfB1OS8,2430
 isar/state_machine/transitions/functions/fail_mission.py,sha256=fBwLW22d8MyrH4047hb3eXn87yLq4v5SkLSIhV9Ge5k,947
 isar/state_machine/transitions/functions/finish_mission.py,sha256=TRQrk7HdllmAkwsp25HRZAFAk46Y1hLx3jmkIAKrHDI,1442
 isar/state_machine/transitions/functions/pause.py,sha256=QCIKTpB_CAkUVaSy02i2cpLJAWx3-qGN5RPbK9L2qPY,983
 isar/state_machine/transitions/functions/resume.py,sha256=SAu4hWomPlrvO0lnpc6uM3rj79Bwq01acnaTEvNbO9U,2116
 isar/state_machine/transitions/functions/return_home.py,sha256=5WPO40MtuRKm9-NtyrS6m0IVEit14MXfMKjgZ2sCXRU,1666
-isar/state_machine/transitions/functions/robot_status.py,sha256=2P3EfP2c06GY-LUquyBTyHn1Ard31Hl3UeT-e-VaIWE,768
+isar/state_machine/transitions/functions/robot_status.py,sha256=bA8G5WtY7TA88MKpdOcR6qftFjW8OttntmptZDXpTKg,1365
 isar/state_machine/transitions/functions/start_mission.py,sha256=tIpZzYXCoeC6ZWj18UB4DiZuICpxfzFUK23wfunad7Q,2864
 isar/state_machine/transitions/functions/stop.py,sha256=4idsNh7v6CRJivD36oKnVmdKlP7mSugTLCh9n12R1-U,2114
 isar/state_machine/transitions/functions/utils.py,sha256=Wa72Ocq4QT1E6qkpEJZQ3h5o33pGvx7Tlkt2JZ2Grbk,314
-isar/state_machine/utils/common_event_handlers.py,sha256=yFZzTmTLVWzHU4RNW3q9gc6NU9eajNn50L-vt6geH38,6318
+isar/state_machine/utils/common_event_handlers.py,sha256=LqXPB4qojzz0LqKF14g4pUd0HYBqZiCV83I4UMgy9DY,6450
 isar/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/storage/blob_storage.py,sha256=d44z3XpZDUbiKwN8Av2gytTJxnefMXrp5VhiGm4PWxU,3703
 isar/storage/local_storage.py,sha256=Rn-iiiz9DI7PzIhevOMshPIaqzJaqBXeVJMQRhVSl2M,2191
 isar/storage/storage_interface.py,sha256=x-imVeQTdL6dCaTaPTHpXwCR6N4e27WxK_Vpumg0x-Y,1230
 isar/storage/uploader.py,sha256=oaGhHqYrtyvJoFUuD7ZyBgdPNkYaSgQokQZkAjmd4vI,10702
 isar/storage/utilities.py,sha256=oLH0Rp7UtrQQdilfITnmXO1Z0ExdeDhBImYHid55vBA,3449
-isar-1.33.6.dist-info/licenses/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
+isar-1.33.7.dist-info/licenses/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
 robot_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/robot_interface.py,sha256=A6t19lcNU_6AfkYKY5DaF0sheym_SZEAawbfaj36Kjk,8997
 robot_interface/test_robot_interface.py,sha256=FV1urn7SbsMyWBIcTKjsBwAG4IsXeZ6pLHE0mA9EGGs,692
@@ -127,8 +128,8 @@ robot_interface/telemetry/payloads.py,sha256=RfLlm_te-bV_xcLtbBx27bgE8gkwPAhWBTF
 robot_interface/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/utilities/json_service.py,sha256=9N1zijW7K4d3WFR2autpaS8U9o1ibymiOX-6stTKCyk,1243
 robot_interface/utilities/uuid_string_factory.py,sha256=_NQIbBQ56w0qqO0MUDP6aPpHbxW7ATRhK8HnQiBSLkc,76
-isar-1.33.6.dist-info/METADATA,sha256=vYkbIytrQRoVeNmSZw0byZnvMgocqVQ2ttxSQ9xS-2g,31190
-isar-1.33.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-isar-1.33.6.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
-isar-1.33.6.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
-isar-1.33.6.dist-info/RECORD,,
+isar-1.33.7.dist-info/METADATA,sha256=azNe_j08RzYztSEwtbNt_zov9uaQauwP34HW3NuZwF4,31190
+isar-1.33.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+isar-1.33.7.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
+isar-1.33.7.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
+isar-1.33.7.dist-info/RECORD,,