isar 1.33.5__tar.gz → 1.33.7__tar.gz

{isar-1.33.5 → isar-1.33.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.33.5
+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.5 → isar-1.33.7}/src/isar/apis/api.py

@@ -245,6 +245,40 @@ class API:
                 },
             },
         )
+        router.add_api_route(
+            path="/schedule/lockdown",
+            endpoint=self.scheduling_controller.lockdown,
+            methods=["POST"],
+            dependencies=[authentication_dependency],
+            summary="Send the robot to dock and ensure that it stays there",
+            responses={
+                HTTPStatus.OK.value: {"description": "Robot going to dock"},
+                HTTPStatus.CONFLICT.value: {
+                    "description": "Conflict - Invalid command in the current state"
+                },
+                HTTPStatus.INTERNAL_SERVER_ERROR.value: {
+                    "description": "Internal Server Error - Current state of state machine unknown"
+                },
+            },
+        )
+        router.add_api_route(
+            path="/schedule/release-lockdown",
+            endpoint=self.scheduling_controller.release_lockdown,
+            methods=["POST"],
+            dependencies=[authentication_dependency],
+            summary="Allow the robot to start missions again",
+            responses={
+                HTTPStatus.OK.value: {
+                    "description": "Robot is able to receive missions again"
+                },
+                HTTPStatus.CONFLICT.value: {
+                    "description": "Conflict - Invalid command in the current state"
+                },
+                HTTPStatus.INTERNAL_SERVER_ERROR.value: {
+                    "description": "Internal Server Error - Current state of state machine unknown"
+                },
+            },
+        )
         router.add_api_route(
             path="/schedule/release-intervention-needed",
             endpoint=self.scheduling_controller.release_intervention_needed,

{isar-1.33.5 → isar-1.33.7}/src/isar/apis/models/models.py

@@ -32,6 +32,11 @@ class MissionStartResponse(BaseModel):
     mission_not_started_reason: Optional[str] = None
 
 
+class LockdownResponse(BaseModel):
+    lockdown_started: bool
+    failure_reason: Optional[str] = None
+
+
 class RobotInfoResponse(BaseModel):
     robot_package: str
     isar_id: str

{isar-1.33.5 → isar-1.33.7}/src/isar/apis/schedule/scheduling_controller.py

@@ -254,6 +254,40 @@ class SchedulingController:
         self.scheduling_utilities.release_intervention_needed()
         self.logger.info("Released intervention needed state successfully")
 
+    @tracer.start_as_current_span("lockdown")
+    def lockdown(self) -> None:
+        self.logger.info("Received request to lockdown robot")
+
+        state: States = self.scheduling_utilities.get_state()
+
+        if state == States.Lockdown:
+            error_message = "Conflict - Lockdown command received in lockdown state"
+            self.logger.warning(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.CONFLICT,
+                detail=error_message,
+            )
+
+        self.scheduling_utilities.lock_down_robot()
+        self.logger.info("Lockdown started successfully")
+
+    @tracer.start_as_current_span("release_lockdown")
+    def release_lockdown(self) -> None:
+        self.logger.info("Received request to release robot lockdown")
+
+        state: States = self.scheduling_utilities.get_state()
+
+        if state != States.Lockdown:
+            error_message = f"Conflict - Release lockdown command received in invalid state - State: {state}"
+            self.logger.warning(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.CONFLICT,
+                detail=error_message,
+            )
+
+        self.scheduling_utilities.release_robot_lockdown()
+        self.logger.info("Released lockdown successfully")
+
     def _api_response(self, mission: Mission) -> StartMissionResponse:
         return StartMissionResponse(
             id=mission.id,

{isar-1.33.5 → isar-1.33.7}/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.5 → isar-1.33.7}/src/isar/models/events.py

@@ -4,7 +4,11 @@ from typing import Generic, Optional, TypeVar
 
 from transitions import State
 
-from isar.apis.models.models import ControlMissionResponse, MissionStartResponse
+from isar.apis.models.models import (
+    ControlMissionResponse,
+    LockdownResponse,
+    MissionStartResponse,
+)
 from isar.config.settings import settings
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
 from robot_interface.models.mission.mission import Mission
@@ -105,6 +109,12 @@ class APIRequests:
         self.release_intervention_needed: APIEvent[bool, bool] = APIEvent(
             "release_intervention_needed"
         )
+        self.send_to_lockdown: APIEvent[bool, LockdownResponse] = APIEvent(
+            "send_to_lockdown"
+        )
+        self.release_from_lockdown: APIEvent[bool, bool] = APIEvent(
+            "release_from_lockdown"
+        )
 
 
 class StateMachineEvents:
@@ -113,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:
@@ -122,12 +133,19 @@ 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"
         )
         self.mission_successfully_stopped: Event[bool] = Event(
             "mission_successfully_stopped"
         )
+        self.mission_failed_to_pause: Event[ErrorMessage] = Event(
+            "mission_failed_to_pause"
+        )
+        self.mission_successfully_paused: Event[bool] = Event(
+            "mission_successfully_paused"
+        )
 
 
 class SharedState:

{isar-1.33.5 → isar-1.33.7}/src/isar/robot/robot.py

@@ -9,6 +9,8 @@ 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
 from isar.robot.robot_stop_mission import RobotStopMissionThread
@@ -28,15 +30,22 @@ 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
+        self.pause_mission_thread: Optional[RobotPauseMissionThread] = None
         self.signal_thread_quitting: ThreadEvent = ThreadEvent()
 
     def stop(self) -> None:
         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()
@@ -50,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
 
@@ -111,12 +121,49 @@ class Robot(object):
             )
             self.stop_mission_thread.start()
 
+    def _pause_mission_request_handler(self, event: Event[bool]) -> None:
+        if event.consume_event():
+            if (
+                self.pause_mission_thread is not None
+                and self.pause_mission_thread.is_alive()
+            ):
+                self.logger.warning(
+                    "Received pause mission event while trying to pause a mission. Aborting pause attempt."
+                )
+                return
+            if (
+                self.start_mission_thread is not None
+                and self.start_mission_thread.is_alive()
+            ):
+                error_description = "Received pause mission event while trying to start a mission. Aborting pause attempt."
+                error_message = ErrorMessage(
+                    error_reason=ErrorReason.RobotStillStartingMissionException,
+                    error_description=error_description,
+                )
+                self.robot_service_events.mission_failed_to_stop.trigger_event(
+                    error_message
+                )
+                return
+            self.pause_mission_thread = RobotPauseMissionThread(
+                self.robot_service_events, self.robot, self.signal_thread_quitting
+            )
+            self.pause_mission_thread.start()
+
     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)
 
@@ -124,6 +171,8 @@ class Robot(object):
                 self.state_machine_events.task_status_request
             )
 
+            self._pause_mission_request_handler(self.state_machine_events.pause_mission)
+
             self._stop_mission_request_handler(self.state_machine_events.stop_mission)
 
         self.logger.info("Exiting robot service main thread")

isar-1.33.5/src/isar/robot/robot_status.py → isar-1.33.7/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.7/src/isar/robot/robot_pause_mission.py

@@ -0,0 +1,63 @@
+import logging
+import time
+from threading import Event, Thread
+from typing import Optional
+
+from isar.config.settings import settings
+from isar.models.events import RobotServiceEvents
+from robot_interface.models.exceptions.robot_exceptions import (
+    ErrorMessage,
+    RobotActionException,
+    RobotException,
+)
+from robot_interface.robot_interface import RobotInterface
+
+
+class RobotPauseMissionThread(Thread):
+    def __init__(
+        self,
+        robot_service_events: RobotServiceEvents,
+        robot: RobotInterface,
+        signal_thread_quitting: Event,
+    ):
+        self.logger = logging.getLogger("robot")
+        self.robot_service_events: RobotServiceEvents = robot_service_events
+        self.robot: RobotInterface = robot
+        self.signal_thread_quitting: Event = signal_thread_quitting
+        Thread.__init__(self, name="Robot pause mission thread")
+
+    def run(self) -> None:
+        retries = 0
+        error: Optional[ErrorMessage] = None
+        while retries < settings.STATE_TRANSITION_NUM_RETIRES:
+            if self.signal_thread_quitting.wait(0):
+                return
+
+            try:
+                self.robot.pause()
+            except (RobotActionException, RobotException) as e:
+                self.logger.warning(
+                    f"\nFailed to pause robot because: {e.error_description}"
+                    f"\nAttempting to pause the robot again"
+                )
+                retries += 1
+                error = ErrorMessage(
+                    error_reason=e.error_reason, error_description=e.error_description
+                )
+                time.sleep(settings.FSM_SLEEP_TIME)
+                continue
+            self.robot_service_events.mission_successfully_paused.trigger_event(True)
+            return
+
+        error_description = (
+            f"\nFailed to pause the robot after {retries} attempts because: "
+            f"{error.error_description}"
+            f"\nBe aware that the robot may still be moving even though a pause has "
+            "been attempted"
+        )
+
+        error_message = ErrorMessage(
+            error_reason=error.error_reason,
+            error_description=error_description,
+        )
+        self.robot_service_events.mission_failed_to_pause.trigger_event(error_message)

isar-1.33.7/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.5 → isar-1.33.7}/src/isar/robot/robot_stop_mission.py

@@ -24,7 +24,7 @@ class RobotStopMissionThread(Thread):
         self.robot_service_events: RobotServiceEvents = robot_service_events
         self.robot: RobotInterface = robot
         self.signal_thread_quitting: Event = signal_thread_quitting
-        Thread.__init__(self, name="Robot start mission thread")
+        Thread.__init__(self, name="Robot stop mission thread")
 
     def run(self) -> None:
         retries = 0

{isar-1.33.5 → isar-1.33.7}/src/isar/services/utilities/scheduling_utilities.py

@@ -322,14 +322,60 @@ class SchedulingUtilities:
         try:
             self._send_command(True, self.api_events.release_intervention_needed)
             self.logger.info("OK - Intervention needed state released")
+        except EventConflictError:
+            error_message = (
+                "Previous release intervention needed request is still being processed"
+            )
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
         except EventTimeoutError:
+            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)
+
+    def lock_down_robot(self) -> None:
+        """Lock down robot
+
+        Raises
+        ------
+        HTTPException 500 Internal Server Error
+            If the robot could not be locked down
+        """
+        try:
+            self._send_command(True, self.api_events.send_to_lockdown)
+            self.logger.info("OK - Robot sent into lockdown")
+        except EventConflictError:
+            error_message = "Previous lockdown request is still being processed"
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
+        except EventTimeoutError:
+            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)
+
+    def release_robot_lockdown(self) -> None:
+        """Release robot from lockdown
+
+        Raises
+        ------
+        HTTPException 500 Internal Server Error
+            If the robot could not be released from lockdown
+        """
+        try:
+            self._send_command(True, self.api_events.release_from_lockdown)
+            self.logger.info("OK - Robot released form lockdown")
+        except EventConflictError:
             error_message = (
-                "Internal Server Error - Failed to release intervention needed state"
+                "Previous release robot from lockdown request is still being processed"
             )
-            self.logger.error(error_message)
-            raise HTTPException(
-                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
+        except EventTimeoutError:
+            error_message = (
+                "Cannot release robot from lockdown as it is not in lockdown"
             )
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
 
     def _send_command(self, input: T1, api_event: APIEvent[T1, T2]) -> T2:
         if api_event.request.has_event():

{isar-1.33.5 → isar-1.33.7}/src/isar/state_machine/state_machine.py

@@ -18,15 +18,20 @@ 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.going_to_lockdown import GoingToLockdown
 from isar.state_machine.states.home import Home
 from isar.state_machine.states.intervention_needed import InterventionNeeded
+from isar.state_machine.states.lockdown import Lockdown
 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.pausing import Pausing
+from isar.state_machine.states.pausing_return_home import PausingReturnHome
 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.stopping import Stopping
+from isar.state_machine.states.stopping_go_to_lockdown import StoppingGoToLockdown
 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
@@ -102,8 +107,12 @@ class StateMachine(object):
         self.returning_home_state: State = ReturningHome(self)
         self.stopping_state: State = Stopping(self)
         self.paused_state: State = Paused(self)
+        self.pausing_state: State = Pausing(self)
         self.return_home_paused_state: State = ReturnHomePaused(self)
         self.stopping_return_home_state: State = StoppingReturnHome(self)
+        self.pausing_return_home_state: State = PausingReturnHome(self)
+        self.stopping_go_to_lockdown_state: State = StoppingGoToLockdown(self)
+        self.going_to_lockdown_state: State = GoingToLockdown(self)
 
         # States Waiting for mission
         self.await_next_mission_state: State = AwaitNextMission(self)
@@ -114,6 +123,7 @@ class StateMachine(object):
         self.offline_state: State = Offline(self)
         self.blocked_protective_stopping_state: State = BlockedProtectiveStop(self)
         self.recharging_state: State = Recharging(self)
+        self.lockdown_state: State = Lockdown(self)
 
         # Error and special status states
         self.unknown_status_state: State = UnknownStatus(self)
@@ -123,7 +133,9 @@ class StateMachine(object):
             self.returning_home_state,
             self.stopping_state,
             self.stopping_return_home_state,
+            self.pausing_return_home_state,
             self.paused_state,
+            self.pausing_state,
             self.return_home_paused_state,
             self.await_next_mission_state,
             self.home_state,
@@ -132,6 +144,9 @@ class StateMachine(object):
             self.unknown_status_state,
             self.intervention_needed_state,
             self.recharging_state,
+            self.stopping_go_to_lockdown_state,
+            self.going_to_lockdown_state,
+            self.lockdown_state,
         ]
 
         self.machine = Machine(
@@ -288,13 +303,14 @@ class StateMachine(object):
             timestamp=datetime.now(timezone.utc),
         )
 
-        self.mqtt_publisher.publish(
-            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),
-        )
+        if self.current_mission:
+            self.mqtt_publisher.publish(
+                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:
         """Publishes the task status to the MQTT Broker"""
@@ -384,6 +400,10 @@ class StateMachine(object):
             return RobotStatus.InterventionNeeded
         elif self.current_state == States.Recharging:
             return RobotStatus.Recharging
+        elif self.current_state == States.Lockdown:
+            return RobotStatus.Lockdown
+        elif self.current_state == States.GoingToLockdown:
+            return RobotStatus.GoingToLockdown
         else:
             return RobotStatus.Busy