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

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/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/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/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:
@@ -128,6 +138,12 @@ class RobotServiceEvents:
         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/robot/robot.py

@@ -9,6 +9,7 @@ from isar.models.events import (
     SharedState,
     StateMachineEvents,
 )
+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
@@ -31,6 +32,7 @@ class Robot(object):
         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:
@@ -111,6 +113,34 @@ 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
@@ -124,6 +154,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/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/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/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/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
 

isar/state_machine/states/await_next_mission.py

@@ -1,11 +1,13 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Callable, List, Optional
 
+from isar.apis.models.models import LockdownResponse
 from isar.config.settings import settings
 from isar.eventhandlers.eventhandler import (
     EventHandlerBase,
     EventHandlerMapping,
     TimeoutHandlerMapping,
 )
+from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
     return_home_event_handler,
     start_mission_event_handler,
@@ -21,6 +23,17 @@ class AwaitNextMission(EventHandlerBase):
     def __init__(self, state_machine: "StateMachine"):
         events = state_machine.events
 
+        def _send_to_lockdown_event_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            should_lockdown: bool = event.consume_event()
+            if should_lockdown:
+                events.api_requests.send_to_lockdown.response.trigger_event(
+                    LockdownResponse(lockdown_started=True)
+                )
+                return state_machine.request_lockdown_mission  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="start_mission_event",
@@ -39,6 +52,11 @@ class AwaitNextMission(EventHandlerBase):
                 event=events.api_requests.return_home.request,
                 handler=lambda event: stop_mission_event_handler(state_machine, event),
             ),
+            EventHandlerMapping(
+                name="send_to_lockdown_event",
+                event=events.api_requests.send_to_lockdown.request,
+                handler=_send_to_lockdown_event_handler,
+            ),
         ]
 
         timers: List[TimeoutHandlerMapping] = [

isar/state_machine/states/going_to_lockdown.py

@@ -0,0 +1,80 @@
+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 (
+    mission_started_event_handler,
+    task_status_event_handler,
+    task_status_failed_event_handler,
+)
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage, ErrorReason
+from robot_interface.models.mission.status import TaskStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class GoingToLockdown(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _handle_task_completed(status: TaskStatus):
+            if status != TaskStatus.Successful:
+                state_machine.current_mission.error_message = ErrorMessage(
+                    error_reason=ErrorReason.RobotActionException,
+                    error_description="Lock down mission failed.",
+                )
+                return state_machine.lockdown_mission_failed  # type: ignore
+            return state_machine.reached_lockdown  # type: ignore
+
+        def _mission_failed_event_handler(
+            event: Event[Optional[ErrorMessage]],
+        ) -> Optional[Callable]:
+            mission_failed: Optional[ErrorMessage] = event.consume_event()
+            if mission_failed is not None:
+                state_machine.logger.warning(
+                    f"Failed to initiate mission "
+                    f"{str(state_machine.current_mission.id)[:8]} because: "
+                    f"{mission_failed.error_description}"
+                )
+                state_machine.current_mission.error_message = ErrorMessage(
+                    error_reason=mission_failed.error_reason,
+                    error_description=mission_failed.error_description,
+                )
+                return state_machine.lockdown_mission_failed  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="mission_started_event",
+                event=events.robot_service_events.mission_started,
+                handler=lambda event: mission_started_event_handler(
+                    state_machine, event
+                ),
+            ),
+            EventHandlerMapping(
+                name="mission_failed_event",
+                event=events.robot_service_events.mission_failed,
+                handler=_mission_failed_event_handler,
+            ),
+            EventHandlerMapping(
+                name="task_status_failed_event",
+                event=events.robot_service_events.task_status_failed,
+                handler=lambda event: task_status_failed_event_handler(
+                    state_machine, _handle_task_completed, event
+                ),
+            ),
+            EventHandlerMapping(
+                name="task_status_event",
+                event=events.robot_service_events.task_status_updated,
+                handler=lambda event: task_status_event_handler(
+                    state_machine, _handle_task_completed, event
+                ),
+            ),
+        ]
+        super().__init__(
+            state_name="going_to_lockdown",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/home.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Callable, List, Optional
 
+from isar.apis.models.models import LockdownResponse
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
 from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
@@ -30,6 +31,15 @@ class Home(EventHandlerBase):
                 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:
+                events.api_requests.send_to_lockdown.response.trigger_event(
+                    LockdownResponse(lockdown_started=True)
+                )
+                return state_machine.reached_lockdown  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="start_mission_event",
@@ -53,6 +63,11 @@ class Home(EventHandlerBase):
                 event=shared_state.robot_status,
                 handler=_robot_status_event_handler,
             ),
+            EventHandlerMapping(
+                name="send_to_lockdown_event",
+                event=events.api_requests.send_to_lockdown.request,
+                handler=_send_to_lockdown_event_handler,
+            ),
         ]
         super().__init__(
             state_name="home",

isar/state_machine/states/lockdown.py

@@ -0,0 +1,37 @@
+from typing import TYPE_CHECKING, List
+
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Lockdown(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _release_from_lockdown_handler(event: Event[bool]):
+            should_release_from_lockdown: bool = event.consume_event()
+            if should_release_from_lockdown:
+                events.api_requests.release_from_lockdown.response.trigger_event(True)
+                if state_machine.battery_level_is_above_mission_start_threshold():
+                    return state_machine.release_from_lockdown  # type: ignore
+                else:
+                    return state_machine.starting_recharging  # type: ignore
+            return None
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="release_from_lockdown",
+                event=events.api_requests.release_from_lockdown.request,
+                handler=_release_from_lockdown_handler,
+            ),
+        ]
+
+        super().__init__(
+            state_name="lockdown",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states/monitor.py

@@ -63,6 +63,17 @@ class Monitor(EventHandlerBase):
                 return state_machine.stop  # type: ignore
             return None
 
+        def _send_to_lockdown_event_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            should_lockdown: bool = event.consume_event()
+            if should_lockdown:
+                state_machine.logger.warning(
+                    "Cancelling current mission due to robot going to lockdown"
+                )
+                return state_machine.stop_go_to_lockdown  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="stop_mission_event",
@@ -107,6 +118,11 @@ class Monitor(EventHandlerBase):
                 event=shared_state.robot_battery_level,
                 handler=_robot_battery_level_updated_handler,
             ),
+            EventHandlerMapping(
+                name="send_to_lockdown_event",
+                event=events.api_requests.send_to_lockdown.request,
+                handler=_send_to_lockdown_event_handler,
+            ),
         ]
         super().__init__(
             state_name="monitor",