isar 1.33.0__tar.gz → 1.33.2__tar.gz

{isar-1.33.0 → isar-1.33.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.0
+Version: 1.33.2
 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.0 → isar-1.33.2}/src/isar/apis/schedule/scheduling_controller.py

@@ -1,6 +1,5 @@
 import logging
 from http import HTTPStatus
-from threading import Lock
 
 from fastapi import Body, HTTPException, Path
 
@@ -29,7 +28,6 @@ class SchedulingController:
     ):
         self.scheduling_utilities: SchedulingUtilities = scheduling_utilities
         self.logger = logging.getLogger("api")
-        self.start_mission_lock: Lock = Lock()
 
     def start_mission_by_id(
         self,
@@ -77,67 +75,38 @@ class SchedulingController:
                 detail=error_message_no_mission_definition,
             )
 
-        if not self.start_mission_lock.acquire(blocking=False):
-            error_message_another_mission_starting: str = (
-                "Conflict - Another mission is currently being started"
-            )
-            self.logger.warning(error_message_another_mission_starting)
-            raise HTTPException(
-                status_code=HTTPStatus.CONFLICT,
-                detail=error_message_another_mission_starting,
-            )
+        state: States = self.scheduling_utilities.get_state()
+        self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
 
         try:
-            state: States = self.scheduling_utilities.get_state()
-            self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(
-                state
+            mission: Mission = to_isar_mission(
+                start_mission_definition=mission_definition
             )
-
-            try:
-                mission: Mission = to_isar_mission(
-                    start_mission_definition=mission_definition
-                )
-            except MissionPlannerError as e:
-                error_message = f"Bad Request - Cannot create ISAR mission: {e}"
-                self.logger.warning(error_message)
-                raise HTTPException(
-                    status_code=HTTPStatus.BAD_REQUEST,
-                    detail=error_message,
-                )
-
-            self.scheduling_utilities.verify_robot_capable_of_mission(
-                mission=mission, robot_capabilities=robot_settings.CAPABILITIES
+        except MissionPlannerError as e:
+            error_message = f"Bad Request - Cannot create ISAR mission: {e}"
+            self.logger.warning(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST,
+                detail=error_message,
             )
 
-            self.logger.info("Starting mission: %s", mission.id)
-            self.scheduling_utilities.start_mission(mission=mission)
-            return self._api_response(mission)
+        self.scheduling_utilities.verify_robot_capable_of_mission(
+            mission=mission, robot_capabilities=robot_settings.CAPABILITIES
+        )
 
-        finally:
-            self.start_mission_lock.release()
+        self.logger.info("Starting mission: %s", mission.id)
+        self.scheduling_utilities.start_mission(mission=mission)
+        return self._api_response(mission)
 
     def return_home(self) -> None:
         self.logger.info("Received request to return home")
 
-        if not self.start_mission_lock.acquire(blocking=False):
-            error_message_another_mission_starting: str = (
-                "Conflict - Another mission is currently being started"
-            )
-            self.logger.warning(error_message_another_mission_starting)
-            raise HTTPException(
-                status_code=HTTPStatus.CONFLICT,
-                detail=error_message_another_mission_starting,
-            )
-
-        try:
-            state: States = self.scheduling_utilities.get_state()
-            self.scheduling_utilities.verify_state_machine_ready_to_receive_return_home_mission(
-                state
-            )
+        state: States = self.scheduling_utilities.get_state()
+        self.scheduling_utilities.verify_state_machine_ready_to_receive_return_home_mission(
+            state
+        )
 
-            self.scheduling_utilities.return_home()
-        finally:
-            self.start_mission_lock.release()
+        self.scheduling_utilities.return_home()
 
     def pause_mission(self) -> ControlMissionResponse:
         self.logger.info("Received request to pause current mission")

{isar-1.33.0 → isar-1.33.2}/src/isar/config/settings.py

@@ -244,6 +244,11 @@ class Settings(BaseSettings):
         default="intervention_needed", validate_default=True
     )
 
+    # List of MQTT Topics Expiry
+    MQTT_ROBOT_HEARTBEAT_EXPIRY: int = Field(default=5)
+    MQTT_TELEMETRY_EXPIRY: int = Field(default=10)
+    MQTT_MISSION_AND_TASK_EXPIRY: int = Field(default=86400)
+
     # Logging
 
     #   Log handlers

{isar-1.33.0 → isar-1.33.2}/src/isar/models/events.py

@@ -17,12 +17,15 @@ T2 = TypeVar("T2")
 
 
 class Event(Queue[T]):
-    def __init__(self) -> None:
+    def __init__(self, name: str) -> None:
         super().__init__(maxsize=1)
+        self.name = name
 
     def trigger_event(self, data: T, timeout: int = None) -> None:
         try:
-            self.put(data, timeout=timeout)
+            # We always want a timeout when blocking for results, so that
+            # the thread will never get stuck waiting for a result
+            self.put(data, block=timeout is not None, timeout=timeout)
         except Exception:
             if timeout is not None:
                 raise EventTimeoutError
@@ -79,46 +82,62 @@ class APIEvent(Generic[T1, T2]):
     api to state machine while the response is from state machine to api.
     """
 
-    def __init__(self):
-        self.request: Event[T1] = Event()
-        self.response: Event[T2] = Event()
+    def __init__(self, name: str):
+        self.request: Event[T1] = Event("api-" + name + "-request")
+        self.response: Event[T2] = Event("api-" + name + "-request")
 
 
 class APIRequests:
     def __init__(self) -> None:
-        self.start_mission: APIEvent[Mission, MissionStartResponse] = 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()
+        self.start_mission: APIEvent[Mission, MissionStartResponse] = APIEvent(
+            "start_mission"
+        )
+        self.stop_mission: APIEvent[str, ControlMissionResponse] = APIEvent(
+            "stop_mission"
+        )
+        self.pause_mission: APIEvent[bool, ControlMissionResponse] = APIEvent(
+            "pause_mission"
+        )
+        self.resume_mission: APIEvent[bool, ControlMissionResponse] = APIEvent(
+            "resume_mission"
+        )
+        self.return_home: APIEvent[bool, bool] = APIEvent("return_home")
+        self.release_intervention_needed: APIEvent[bool, bool] = APIEvent(
+            "release_intervention_needed"
+        )
 
 
 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()
+        self.start_mission: Event[Mission] = Event("start_mission")
+        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")
 
 
 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()
+        self.task_status_updated: Event[TaskStatus] = Event("task_status_updated")
+        self.task_status_failed: Event[ErrorMessage] = Event("task_status_failed")
+        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.mission_failed_to_stop: Event[ErrorMessage] = Event(
+            "mission_failed_to_stop"
+        )
+        self.mission_successfully_stopped: Event[bool] = Event(
+            "mission_successfully_stopped"
+        )
 
 
 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()
-        self.robot_battery_level: Event[float] = Event()
+        self.state: Event[State] = Event("state")
+        self.robot_status: Event[RobotStatus] = Event("robot_status")
+        self.state_machine_current_task: Event[TASKS] = Event(
+            "state_machine_current_task"
+        )
+        self.robot_battery_level: Event[float] = Event("robot_battery_level")
 
 
 class EventTimeoutError(Exception):

{isar-1.33.0 → isar-1.33.2}/src/isar/services/service_connections/mqtt/mqtt_client.py

@@ -1,15 +1,24 @@
 import logging
 import os
+import time
 from queue import Empty, Queue
 
 import backoff
 from paho.mqtt import client as mqtt
 from paho.mqtt.client import Client
+from paho.mqtt.packettypes import PacketTypes
+from paho.mqtt.properties import Properties
 
 from isar.config.settings import settings
 from robot_interface.telemetry.mqtt_client import MqttClientInterface
 
 
+def props_expiry(seconds: int) -> Properties:
+    p = Properties(PacketTypes.PUBLISH)
+    p.MessageExpiryInterval = seconds
+    return p
+
+
 def _on_success(data: dict) -> None:
     logging.getLogger("mqtt_client").info("Connected to MQTT Broker")
     logging.getLogger("mqtt_client").debug(
@@ -53,7 +62,9 @@ class MqttClient(MqttClientInterface):
 
         self.port: int = settings.MQTT_PORT
 
-        self.client: Client = Client(mqtt.CallbackAPIVersion.VERSION1)
+        self.client: Client = Client(
+            protocol=mqtt.MQTTv5, callback_api_version=mqtt.CallbackAPIVersion.VERSION2
+        )
 
         self.client.enable_logger(logger=self.logger)
 
@@ -74,20 +85,36 @@ class MqttClient(MqttClientInterface):
 
         while True:
             if not self.client.is_connected():
+                time.sleep(0)  # avoid CPU spin
                 continue
             try:
-                topic, payload, qos, retain = self.mqtt_queue.get(timeout=1)
+                item = self.mqtt_queue.get(timeout=1)
+                if len(item) == 4:
+                    topic, payload, qos, retain = item
+                    properties = None
+                else:
+                    topic, payload, qos, retain, properties = item
             except Empty:
                 continue
 
-            self.publish(topic=topic, payload=payload, qos=qos, retain=retain)
+            self.publish(
+                topic=topic,
+                payload=payload,
+                qos=qos,
+                retain=retain,
+                properties=properties,
+            )
 
-    def on_connect(self, client, userdata, flags, rc):
-        self.logger.info("Connection returned result: " + mqtt.connack_string(rc))
+    def on_connect(self, client, userdata, flags, reason_code, properties):
+        self.logger.info(
+            "Connection returned result: " + mqtt.connack_string(reason_code)
+        )
 
-    def on_disconnect(self, client, userdata, rc):
-        if rc != 0:
-            self.logger.warning("Unexpected disconnection from MQTT Broker")
+    def on_disconnect(self, client, userdata, reason_code, properties):
+        if reason_code != 0:
+            self.logger.warning(
+                f"Unexpected disconnection from MQTT Broker, {reason_code}"
+            )
 
     @backoff.on_exception(
         backoff.expo,
@@ -102,6 +129,15 @@ class MqttClient(MqttClientInterface):
         self.logger.info("Host: %s, Port: %s", host, port)
         self.client.connect(host=host, port=port)
 
-    def publish(self, topic: str, payload: str, qos: int = 0, retain: bool = False):
+    def publish(
+        self,
+        topic: str,
+        payload: str,
+        qos: int = 0,
+        retain: bool = False,
+        properties=None,
+    ):
         self.logger.debug("Publishing message to topic: %s", topic)
-        self.client.publish(topic=topic, payload=payload, qos=qos, retain=retain)
+        self.client.publish(
+            topic=topic, payload=payload, qos=qos, retain=retain, properties=properties
+        )

{isar-1.33.0 → isar-1.33.2}/src/isar/services/service_connections/mqtt/robot_heartbeat_publisher.py

@@ -4,6 +4,7 @@ from datetime import datetime, timezone
 from queue import Queue
 
 from isar.config.settings import settings
+from isar.services.service_connections.mqtt.mqtt_client import props_expiry
 from robot_interface.telemetry.mqtt_client import MqttPublisher
 from robot_interface.telemetry.payloads import RobotHeartbeatPayload
 from robot_interface.utilities.json_service import EnhancedJSONEncoder
@@ -24,6 +25,8 @@ class RobotHeartbeatPublisher:
             self.mqtt_publisher.publish(
                 topic=settings.TOPIC_ISAR_ROBOT_HEARTBEAT,
                 payload=json.dumps(payload, cls=EnhancedJSONEncoder),
+                retain=True,
+                properties=props_expiry(settings.MQTT_ROBOT_HEARTBEAT_EXPIRY),
             )
 
             time.sleep(settings.ROBOT_HEARTBEAT_PUBLISH_INTERVAL)

{isar-1.33.0 → isar-1.33.2}/src/isar/services/utilities/scheduling_utilities.py

@@ -347,3 +347,6 @@ class SchedulingUtilities:
             api_event.request.clear_event()
             self.logger.error("No output received for command to state machine")
             raise e
+        finally:
+            api_event.request.clear_event()
+            api_event.response.clear_event()

{isar-1.33.0 → isar-1.33.2}/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.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
 from isar.state_machine.states.home import Home
@@ -285,10 +286,11 @@ class StateMachine(object):
         )
 
         self.mqtt_publisher.publish(
-            topic=settings.TOPIC_ISAR_MISSION,
+            topic=settings.TOPIC_ISAR_MISSION + f"/{self.current_mission.id}",
             payload=json.dumps(payload, cls=EnhancedJSONEncoder),
             qos=1,
             retain=True,
+            properties=props_expiry(settings.MQTT_MISSION_AND_TASK_EXPIRY),
         )
 
     def publish_task_status(self, task: TASKS) -> None:
@@ -316,10 +318,11 @@ class StateMachine(object):
         )
 
         self.mqtt_publisher.publish(
-            topic=settings.TOPIC_ISAR_TASK,
+            topic=settings.TOPIC_ISAR_TASK + f"/{task.id}",
             payload=json.dumps(payload, cls=EnhancedJSONEncoder),
             qos=1,
             retain=True,
+            properties=props_expiry(settings.MQTT_MISSION_AND_TASK_EXPIRY),
         )
 
     def publish_intervention_needed(self, error_message: str) -> None:
@@ -406,7 +409,7 @@ class StateMachine(object):
         )
 
     def _queue_empty_response(self) -> None:
-        self.events.api_requests.stop_mission.response.put(
+        self.events.api_requests.stop_mission.response.trigger_event(
             ControlMissionResponse(
                 mission_id="None",
                 mission_status="None",

{isar-1.33.0 → isar-1.33.2}/src/isar/state_machine/states/monitor.py

@@ -60,9 +60,7 @@ class Monitor(EventHandlerBase):
                 state_machine.logger.warning(
                     "Cancelling current mission due to low battery"
                 )
-                state_machine.current_mission = None
-                state_machine.current_task = None
-                return state_machine.request_return_home  # type: ignore
+                return state_machine.stop  # type: ignore
             return None
 
         event_handlers: List[EventHandlerMapping] = [

{isar-1.33.0 → isar-1.33.2}/src/isar/state_machine/states/returning_home.py

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Callable, List, Optional
 
 from isar.apis.models.models import MissionStartResponse
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
-from isar.models.events import Event, EventTimeoutError
+from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
     mission_failed_event_handler,
     mission_started_event_handler,
@@ -43,17 +43,14 @@ class ReturningHome(EventHandlerBase):
         ) -> Optional[Callable]:
             if event.has_event():
                 if not state_machine.battery_level_is_above_mission_start_threshold():
-                    try:
-                        state_machine.events.api_requests.start_mission.response.trigger_event(
-                            MissionStartResponse(
-                                mission_id=None,
-                                mission_started=False,
-                                mission_not_started_reason="Robot battery too low",
-                            ),
-                            timeout=1,  # This conflict can happen if two API requests are received at the same time
-                        )
-                    except EventTimeoutError:
-                        pass
+                    response = MissionStartResponse(
+                        mission_id=None,
+                        mission_started=False,
+                        mission_not_started_reason="Robot battery too low",
+                    )
+                    state_machine.events.api_requests.start_mission.response.trigger_event(
+                        response
+                    )
                     return None
                 return state_machine.stop  # type: ignore
             return None

{isar-1.33.0 → isar-1.33.2}/src/isar/state_machine/states/stopping.py

@@ -1,9 +1,11 @@
 import logging
 from typing import TYPE_CHECKING, Callable, List, Optional
 
+from isar.apis.models.models import ControlMissionResponse
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
 from isar.models.events import Event
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
@@ -15,6 +17,32 @@ class Stopping(EventHandlerBase):
         logger = logging.getLogger("state_machine")
         events = state_machine.events
 
+        def _stop_mission_cleanup() -> None:
+            if state_machine.current_mission is None:
+                state_machine._queue_empty_response()
+                state_machine.reset_state_machine()
+                return None
+
+            state_machine.current_mission.status = MissionStatus.Cancelled
+
+            for task in state_machine.current_mission.tasks:
+                if task.status in [
+                    TaskStatus.NotStarted,
+                    TaskStatus.InProgress,
+                    TaskStatus.Paused,
+                ]:
+                    task.status = TaskStatus.Cancelled
+
+            stopped_mission_response: ControlMissionResponse = (
+                state_machine._make_control_mission_response()
+            )
+            state_machine.events.api_requests.stop_mission.response.trigger_event(
+                stopped_mission_response
+            )
+            state_machine.publish_task_status(task=state_machine.current_task)
+            state_machine._finalize()
+            return None
+
         def _failed_stop_event_handler(
             event: Event[ErrorMessage],
         ) -> Optional[Callable]:
@@ -38,6 +66,11 @@ class Stopping(EventHandlerBase):
                 ):
                     return state_machine.return_home_mission_stopped  # type: ignore
                 else:
+                    _stop_mission_cleanup()
+                    if (
+                        not state_machine.battery_level_is_above_mission_start_threshold()
+                    ):
+                        return state_machine.request_return_home  # type: ignore
                     return state_machine.mission_stopped  # type: ignore
             return None
 

{isar-1.33.0 → isar-1.33.2}/src/isar/state_machine/transitions/functions/pause.py

@@ -29,7 +29,7 @@ def pause_mission(state_machine: "StateMachine") -> bool:
             paused_mission_response: ControlMissionResponse = (
                 state_machine._make_control_mission_response()
             )
-            state_machine.events.api_requests.pause_mission.response.put(
+            state_machine.events.api_requests.pause_mission.response.trigger_event(
                 paused_mission_response
             )
 

{isar-1.33.0 → isar-1.33.2}/src/isar/state_machine/transitions/functions/resume.py

@@ -35,7 +35,7 @@ def resume_mission(state_machine: "StateMachine") -> bool:
             resume_mission_response: ControlMissionResponse = (
                 state_machine._make_control_mission_response()
             )
-            state_machine.events.api_requests.resume_mission.response.put(
+            state_machine.events.api_requests.resume_mission.response.trigger_event(
                 resume_mission_response
             )
 

{isar-1.33.0 → isar-1.33.2}/src/isar/state_machine/transitions/functions/start_mission.py

@@ -13,7 +13,7 @@ from robot_interface.models.mission.status import MissionStatus, TaskStatus
 
 
 def acknowledge_mission(state_machine: "StateMachine") -> bool:
-    state_machine.events.api_requests.start_mission.response.put(
+    state_machine.events.api_requests.start_mission.response.trigger_event(
         MissionStartResponse(mission_started=True)
     )
     return True
@@ -66,14 +66,14 @@ def set_mission_to_in_progress(state_machine: "StateMachine") -> bool:
 
 
 def trigger_start_mission_event(state_machine: "StateMachine") -> bool:
-    state_machine.events.state_machine_events.start_mission.put(
+    state_machine.events.state_machine_events.start_mission.trigger_event(
         state_machine.current_mission
     )
     return True
 
 
 def _initialization_failed(state_machine: "StateMachine") -> None:
-    state_machine.events.api_requests.start_mission.response.put(
+    state_machine.events.api_requests.start_mission.response.trigger_event(
         MissionStartResponse(
             mission_started=False,
             mission_not_started_reason="Failed to initialize robot",

{isar-1.33.0 → isar-1.33.2}/src/isar/state_machine/transitions/functions/stop.py

@@ -12,38 +12,11 @@ def trigger_stop_mission_event(state_machine: "StateMachine") -> bool:
     return True
 
 
-def stop_mission_cleanup(state_machine: "StateMachine") -> bool:
-    if state_machine.current_mission is None:
-        state_machine._queue_empty_response()
-        state_machine.reset_state_machine()
-        return True
-
-    state_machine.current_mission.status = MissionStatus.Cancelled
-
-    for task in state_machine.current_mission.tasks:
-        if task.status in [
-            TaskStatus.NotStarted,
-            TaskStatus.InProgress,
-            TaskStatus.Paused,
-        ]:
-            task.status = TaskStatus.Cancelled
-
-    stopped_mission_response: ControlMissionResponse = (
-        state_machine._make_control_mission_response()
-    )
-    state_machine.events.api_requests.stop_mission.response.put(
-        stopped_mission_response
-    )
-    state_machine.publish_task_status(task=state_machine.current_task)
-    state_machine._finalize()
-    return True
-
-
 def stop_mission_failed(state_machine: "StateMachine") -> bool:
     stopped_mission_response: ControlMissionResponse = (
         state_machine._make_control_mission_response()
     )
-    state_machine.events.api_requests.stop_mission.response.put(
+    state_machine.events.api_requests.stop_mission.response.trigger_event(
         stopped_mission_response
     )
     return True
@@ -69,7 +42,7 @@ def stop_return_home_mission_cleanup(state_machine: "StateMachine") -> bool:
         stopped_mission_response: ControlMissionResponse = (
             state_machine._make_control_mission_response()
         )
-        state_machine.events.api_requests.stop_mission.response.put(
+        state_machine.events.api_requests.stop_mission.response.trigger_event(
             stopped_mission_response
         )
 
@@ -83,7 +56,7 @@ def stop_return_home_mission_failed(state_machine: "StateMachine") -> bool:
     stopped_mission_response: ControlMissionResponse = (
         state_machine._make_control_mission_response()
     )
-    state_machine.events.api_requests.stop_mission.response.put(
+    state_machine.events.api_requests.stop_mission.response.trigger_event(
         stopped_mission_response
     )
     return True

{isar-1.33.0 → isar-1.33.2}/src/isar/state_machine/transitions/mission.py

@@ -14,7 +14,6 @@ from isar.state_machine.transitions.functions.start_mission import (
     trigger_start_mission_event,
 )
 from isar.state_machine.transitions.functions.stop import (
-    stop_mission_cleanup,
     stop_mission_failed,
     stop_return_home_mission_cleanup,
     stop_return_home_mission_failed,
@@ -66,7 +65,6 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "trigger": "mission_stopped",
             "source": state_machine.stopping_state,
             "dest": state_machine.await_next_mission_state,
-            "before": def_transition(state_machine, stop_mission_cleanup),
         },
         {
             "trigger": "mission_stopping_failed",

{isar-1.33.0 → isar-1.33.2}/src/isar/state_machine/transitions/return_home.py

@@ -31,13 +31,13 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
                 state_machine.robot_standing_still_state,
                 state_machine.intervention_needed_state,
                 state_machine.monitor_state,
+                state_machine.stopping_state,
             ],
             "dest": state_machine.returning_home_state,
             "conditions": [
                 def_transition(state_machine, start_return_home_mission),
                 def_transition(state_machine, set_return_home_status),
                 def_transition(state_machine, initialize_robot),
-                def_transition(state_machine, initialize_robot),
             ],
             "before": def_transition(state_machine, trigger_start_mission_event),
         },