isar 1.33.1__tar.gz → 1.33.3__tar.gz

{isar-1.33.1 → isar-1.33.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.1
+Version: 1.33.3
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0
@@ -369,7 +369,7 @@ States.Paused,
 indicates that the state machine is already running. For running a mission the state machine need to be in the states
 
 ```
-States.Home, States.RobotStandingStill, States.AwaitNextMission or States.ReturningHome
+States.Home, States.AwaitNextMission or States.ReturningHome
 ```
 
 ### FastAPI

{isar-1.33.1 → isar-1.33.3}/README.md

@@ -225,7 +225,7 @@ States.Paused,
 indicates that the state machine is already running. For running a mission the state machine need to be in the states
 
 ```
-States.Home, States.RobotStandingStill, States.AwaitNextMission or States.ReturningHome
+States.Home, States.AwaitNextMission or States.ReturningHome
 ```
 
 ### FastAPI

{isar-1.33.1 → isar-1.33.3}/src/isar/apis/schedule/scheduling_controller.py

@@ -115,6 +115,7 @@ class SchedulingController:
 
         if state not in [
             States.Monitor,
+            States.ReturningHome,
         ]:
             error_message = (
                 f"Conflict - Pause command received in invalid state - State: {state}"
@@ -135,7 +136,7 @@ class SchedulingController:
 
         state: States = self.scheduling_utilities.get_state()
 
-        if state != States.Paused:
+        if state not in [States.Paused, States.ReturnHomePaused]:
             error_message = (
                 f"Conflict - Resume command received in invalid state - State: {state}"
             )
@@ -167,6 +168,7 @@ class SchedulingController:
             or state == States.BlockedProtectiveStop
             or state == States.Offline
             or state == States.Home
+            or state == States.ReturningHome
         ):
             error_message = (
                 f"Conflict - Stop command received in invalid state - State: {state}"

{isar-1.33.1 → isar-1.33.3}/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.1 → isar-1.33.3}/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.1 → isar-1.33.3}/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.1 → isar-1.33.3}/src/isar/services/utilities/scheduling_utilities.py

@@ -129,13 +129,13 @@ class SchedulingUtilities:
         ------
         HTTPException 409 Conflict
             If state machine is not home, robot standing still, awaiting next mission
-            or returning home and therefore cannot start a new mission
+            return home paused or returning home and therefore cannot start a new mission
         """
         if (
-            state == States.RobotStandingStill
-            or state == States.Home
+            state == States.Home
             or state == States.AwaitNextMission
             or state == States.ReturningHome
+            or state == States.ReturnHomePaused
         ):
             return True
 
@@ -154,11 +154,7 @@ class SchedulingUtilities:
             If state machine is not home, robot standing still or awaiting next mission
             and therefore cannot start a new return home mission
         """
-        if (
-            state == States.RobotStandingStill
-            or state == States.Home
-            or state == States.AwaitNextMission
-        ):
+        if state == States.Home or state == States.AwaitNextMission:
             return True
 
         error_message = f"Conflict - Robot is not home, robot standing still or awaiting next mission - State: {state}"
@@ -336,7 +332,7 @@ class SchedulingUtilities:
             )
 
     def _send_command(self, input: T1, api_event: APIEvent[T1, T2]) -> T2:
-        if api_event.request.has_event() or api_event.response.has_event():
+        if api_event.request.has_event():
             raise EventConflictError("API event has already been sent")
 
         try:

{isar-1.33.1 → isar-1.33.3}/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
@@ -23,9 +24,10 @@ from isar.state_machine.states.monitor import Monitor
 from isar.state_machine.states.offline import Offline
 from isar.state_machine.states.paused import Paused
 from isar.state_machine.states.recharging import Recharging
+from isar.state_machine.states.return_home_paused import ReturnHomePaused
 from isar.state_machine.states.returning_home import ReturningHome
-from isar.state_machine.states.robot_standing_still import RobotStandingStill
 from isar.state_machine.states.stopping import Stopping
+from isar.state_machine.states.stopping_return_home import StoppingReturnHome
 from isar.state_machine.states.unknown_status import UnknownStatus
 from isar.state_machine.states_enum import States
 from isar.state_machine.transitions.mission import get_mission_transitions
@@ -100,11 +102,12 @@ class StateMachine(object):
         self.returning_home_state: State = ReturningHome(self)
         self.stopping_state: State = Stopping(self)
         self.paused_state: State = Paused(self)
+        self.return_home_paused_state: State = ReturnHomePaused(self)
+        self.stopping_return_home_state: State = StoppingReturnHome(self)
 
         # States Waiting for mission
         self.await_next_mission_state: State = AwaitNextMission(self)
         self.home_state: State = Home(self)
-        self.robot_standing_still_state: State = RobotStandingStill(self)
         self.intervention_needed_state: State = InterventionNeeded(self)
 
         # Status states
@@ -119,10 +122,11 @@ class StateMachine(object):
             self.monitor_state,
             self.returning_home_state,
             self.stopping_state,
+            self.stopping_return_home_state,
             self.paused_state,
+            self.return_home_paused_state,
             self.await_next_mission_state,
             self.home_state,
-            self.robot_standing_still_state,
             self.offline_state,
             self.blocked_protective_stopping_state,
             self.unknown_status_state,
@@ -285,10 +289,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 +321,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:
@@ -360,11 +366,12 @@ class StateMachine(object):
         )
 
     def _current_status(self) -> RobotStatus:
-        if (
-            self.current_state == States.RobotStandingStill
-            or self.current_state == States.AwaitNextMission
-        ):
+        if self.current_state == States.AwaitNextMission:
             return RobotStatus.Available
+        elif self.current_state == States.ReturnHomePaused:
+            return RobotStatus.ReturnHomePaused
+        elif self.current_state == States.Paused:
+            return RobotStatus.Paused
         elif self.current_state == States.Home:
             return RobotStatus.Home
         elif self.current_state == States.ReturningHome:

{isar-1.33.1 → isar-1.33.3}/src/isar/state_machine/states/home.py

@@ -1,9 +1,9 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Callable, List, Optional
 
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
     return_home_event_handler,
-    robot_status_event_handler,
     start_mission_event_handler,
     stop_mission_event_handler,
 )
@@ -19,6 +19,17 @@ 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
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="start_mission_event",
@@ -40,9 +51,7 @@ class Home(EventHandlerBase):
             EventHandlerMapping(
                 name="robot_status_event",
                 event=shared_state.robot_status,
-                handler=lambda event: robot_status_event_handler(
-                    state_machine, RobotStatus.Home, event
-                ),
+                handler=_robot_status_event_handler,
             ),
         ]
         super().__init__(

{isar-1.33.1 → isar-1.33.3}/src/isar/state_machine/states/paused.py

@@ -1,6 +1,8 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Callable, List, Optional
 
+from isar.config.settings import settings
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
@@ -10,6 +12,22 @@ class Paused(EventHandlerBase):
 
     def __init__(self, state_machine: "StateMachine"):
         events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        def _robot_battery_level_updated_handler(
+            event: Event[float],
+        ) -> Optional[Callable]:
+            battery_level: float = event.check()
+            if battery_level < settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+                state_machine.publish_mission_aborted(
+                    "Robot battery too low to continue mission", True
+                )
+                state_machine._finalize()
+                state_machine.logger.warning(
+                    "Cancelling current mission due to low battery"
+                )
+                return state_machine.stop  # type: ignore
+            return None
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
@@ -22,6 +40,11 @@ class Paused(EventHandlerBase):
                 event=events.api_requests.resume_mission.request,
                 handler=lambda event: state_machine.resume if event.consume_event() else None,  # type: ignore
             ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=_robot_battery_level_updated_handler,
+            ),
         ]
         super().__init__(
             state_name="paused",

isar-1.33.3/src/isar/state_machine/states/return_home_paused.py

@@ -0,0 +1,66 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.apis.models.models import MissionStartResponse
+from isar.config.settings import settings
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from robot_interface.models.mission.mission import Mission
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class ReturnHomePaused(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+        shared_state = state_machine.shared_state
+
+        def _robot_battery_level_updated_handler(
+            event: Event[float],
+        ) -> Optional[Callable]:
+            battery_level: float = event.check()
+            if battery_level < settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+                return state_machine.resume  # type: ignore
+            return None
+
+        def _start_mission_event_handler(
+            event: Event[Mission],
+        ) -> Optional[Callable]:
+            if event.has_event():
+                if not state_machine.battery_level_is_above_mission_start_threshold():
+                    state_machine.events.api_requests.start_mission.request.consume_event()
+                    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_return_home  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="resume_return_home_event",
+                event=events.api_requests.resume_mission.request,
+                handler=lambda event: state_machine.resume if event.consume_event() else None,  # type: ignore
+            ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=_robot_battery_level_updated_handler,
+            ),
+            EventHandlerMapping(
+                name="start_mission_event",
+                event=events.api_requests.start_mission.request,
+                handler=_start_mission_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="return_home_paused",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

{isar-1.33.1 → isar-1.33.3}/src/isar/state_machine/states/returning_home.py

@@ -6,7 +6,6 @@ from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
     mission_failed_event_handler,
     mission_started_event_handler,
-    stop_mission_event_handler,
     task_status_event_handler,
     task_status_failed_event_handler,
 )
@@ -24,6 +23,11 @@ class ReturningHome(EventHandlerBase):
         self.failed_return_home_attemps: int = 0
         events = state_machine.events
 
+        def _pause_mission_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if event.consume_event():
+                return state_machine.pause  # type: ignore
+            return None
+
         def _handle_task_completed(status: TaskStatus):
             if status != TaskStatus.Successful:
                 state_machine.current_mission.error_message = ErrorMessage(
@@ -43,6 +47,7 @@ class ReturningHome(EventHandlerBase):
         ) -> Optional[Callable]:
             if event.has_event():
                 if not state_machine.battery_level_is_above_mission_start_threshold():
+                    state_machine.events.api_requests.start_mission.request.consume_event()
                     response = MissionStartResponse(
                         mission_id=None,
                         mission_started=False,
@@ -52,14 +57,14 @@ class ReturningHome(EventHandlerBase):
                         response
                     )
                     return None
-                return state_machine.stop  # type: ignore
+                return state_machine.stop_return_home  # type: ignore
             return None
 
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
-                name="stop_mission_event",
-                event=events.api_requests.stop_mission.request,
-                handler=lambda event: stop_mission_event_handler(state_machine, event),
+                name="pause_mission_event",
+                event=events.api_requests.pause_mission.request,
+                handler=_pause_mission_event_handler,
             ),
             EventHandlerMapping(
                 name="mission_started_event",

{isar-1.33.1 → isar-1.33.3}/src/isar/state_machine/states/stopping.py

@@ -1,4 +1,3 @@
-import logging
 from typing import TYPE_CHECKING, Callable, List, Optional
 
 from isar.apis.models.models import ControlMissionResponse
@@ -14,7 +13,6 @@ if TYPE_CHECKING:
 class Stopping(EventHandlerBase):
 
     def __init__(self, state_machine: "StateMachine"):
-        logger = logging.getLogger("state_machine")
         events = state_machine.events
 
         def _stop_mission_cleanup() -> None:
@@ -48,30 +46,15 @@ class Stopping(EventHandlerBase):
         ) -> Optional[Callable]:
             error_message: Optional[ErrorMessage] = event.consume_event()
             if error_message is not None:
-                logger.warning(error_message.error_description)
-                if (
-                    state_machine.current_mission is not None
-                    and state_machine.current_mission._is_return_to_home_mission()
-                ):
-                    return state_machine.return_home_mission_stopping_failed  # type: ignore
-                else:
-                    return state_machine.mission_stopping_failed  # type: ignore
+                return state_machine.mission_stopping_failed  # type: ignore
             return None
 
         def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
             if event.consume_event():
-                if (
-                    state_machine.current_mission is not None
-                    and state_machine.current_mission._is_return_to_home_mission()
-                ):
-                    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
+                _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
 
         event_handlers: List[EventHandlerMapping] = [

isar-1.33.3/src/isar/state_machine/states/stopping_return_home.py

@@ -0,0 +1,73 @@
+import logging
+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
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.mission import Mission
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class StoppingReturnHome(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        logger = logging.getLogger("state_machine")
+        events = state_machine.events
+
+        def _failed_stop_event_handler(
+            event: Event[ErrorMessage],
+        ) -> Optional[Callable]:
+            error_message: Optional[ErrorMessage] = event.consume_event()
+            if error_message is not None:
+                logger.warning(error_message.error_description)
+                mission: Mission = (
+                    state_machine.events.api_requests.start_mission.request.consume_event()
+                )
+                state_machine.events.api_requests.start_mission.response.trigger_event(
+                    MissionStartResponse(
+                        mission_id=mission.id,
+                        mission_started=False,
+                        mission_not_started_reason="Failed to cancel return home mission",
+                    )
+                )
+                return state_machine.return_home_mission_stopping_failed  # type: ignore
+            return None
+
+        def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if event.consume_event():
+                mission: Mission = (
+                    state_machine.events.api_requests.start_mission.request.consume_event()
+                )
+
+                state_machine.reset_state_machine()
+
+                if mission:
+                    state_machine.start_mission(mission=mission)
+                    return state_machine.request_mission_start  # type: ignore
+
+                state_machine.logger.error(
+                    "Stopped return home without a new mission to start"
+                )
+                return state_machine.request_return_home  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="failed_stop_event",
+                event=events.robot_service_events.mission_failed_to_stop,
+                handler=_failed_stop_event_handler,
+            ),
+            EventHandlerMapping(
+                name="successful_stop_event",
+                event=events.robot_service_events.mission_successfully_stopped,
+                handler=_successful_stop_event_handler,
+            ),
+        ]
+        super().__init__(
+            state_name="stopping_return_home",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

{isar-1.33.1 → isar-1.33.3}/src/isar/state_machine/states_enum.py

@@ -5,10 +5,11 @@ class States(str, Enum):
     Monitor = "monitor"
     ReturningHome = "returning_home"
     Stopping = "stopping"
+    StoppingReturnHome = "stopping_return_home"
     Paused = "paused"
+    ReturnHomePaused = "return_home_paused"
     AwaitNextMission = "await_next_mission"
     Home = "home"
-    RobotStandingStill = "robot_standing_still"
     Offline = "offline"
     BlockedProtectiveStop = "blocked_protective_stop"
     UnknownStatus = "unknown_status"