isar 1.34.3__tar.gz → 1.34.4__tar.gz

isar-1.34.4/.github/workflows/execute_stale_labeler.yml

@@ -0,0 +1,17 @@
+name: Execute stale labeler
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "35 6 * * *"
+
+permissions:
+  contents: read
+  actions: write
+  issues: write
+  pull-requests: write
+
+jobs:
+  labels:
+    uses: equinor/armada/.github/workflows/mark_issues_and_prs_as_stale.yml@main
+    secrets:
+      STALE_ISSUE_TOKEN: ${{ secrets.GITHUB_TOKEN }}

isar-1.34.4/.github/workflows/synchronize_labels.yml

@@ -0,0 +1,13 @@
+name: Execute label synchronization
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  issues: write
+
+jobs:
+  labels:
+    uses: equinor/armada/.github/workflows/synchronize_labels.yml@main
+    secrets:
+      LABEL_SYNC_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{isar-1.34.3 → isar-1.34.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.34.3
+Version: 1.34.4
 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.34.3 → isar-1.34.4}/src/isar/models/status.py

@@ -14,3 +14,4 @@ class IsarStatus(Enum):
     Recharging = "recharging"
     Lockdown = "lockdown"
     GoingToLockdown = "goingtolockdown"
+    GoingToRecharging = "goingtorecharging"

{isar-1.34.3 → isar-1.34.4}/src/isar/robot/robot.py

@@ -70,6 +70,10 @@ class Robot(object):
             self.start_mission_thread.join()
         if self.stop_mission_thread is not None and self.stop_mission_thread.is_alive():
             self.stop_mission_thread.join()
+        for thread in self.upload_inspection_threads:
+            if thread.is_alive():
+                thread.join()
+        self.upload_inspection_threads = []
         self.robot_status_thread = None
         self.robot_battery_thread = None
         self.start_mission_thread = None
@@ -82,8 +86,14 @@ class Robot(object):
         ):
             self.start_mission_thread.join()
             mission = self.start_mission_thread.mission
+            error_message = self.start_mission_thread.error_message
             self.start_mission_thread = None
 
+            if error_message:
+                self.robot_service_events.mission_failed.trigger_event(error_message)
+            else:
+                self.robot_service_events.mission_started.trigger_event(True)
+
             if (
                 self.monitor_mission_thread is not None
                 and self.monitor_mission_thread.is_alive()
@@ -131,6 +141,24 @@ class Robot(object):
                     True
                 )
 
+    def _pause_mission_done_handler(self) -> None:
+        if (
+            self.pause_mission_thread is not None
+            and not self.pause_mission_thread.is_alive()
+        ):
+            self.pause_mission_thread.join()
+            error_message = self.pause_mission_thread.error_message
+            self.pause_mission_thread = None
+
+            if error_message:
+                self.robot_service_events.mission_failed_to_pause.trigger_event(
+                    error_message
+                )
+            else:
+                self.robot_service_events.mission_successfully_paused.trigger_event(
+                    True
+                )
+
     def _start_mission_event_handler(self, event: Event[Mission]) -> None:
         start_mission = event.consume_event()
         if start_mission is not None:
@@ -144,7 +172,6 @@ class Robot(object):
                 self.start_mission_thread.join()
 
             self.start_mission_thread = RobotStartMissionThread(
-                self.robot_service_events,
                 self.robot,
                 self.signal_thread_quitting,
                 start_mission,
@@ -204,7 +231,7 @@ class Robot(object):
                 )
                 return
             self.pause_mission_thread = RobotPauseMissionThread(
-                self.robot_service_events, self.robot, self.signal_thread_quitting
+                self.robot, self.signal_thread_quitting
             )
             self.pause_mission_thread.start()
 
@@ -220,15 +247,20 @@ class Robot(object):
             self.upload_inspection_threads.append(upload_inspection_thread)
             upload_inspection_thread.start()
 
-        def _join_threads(thread: RobotUploadInspectionThread) -> bool:
-            if thread.is_done():
-                thread.join()
-                return True
-            return False
+    def _upload_inspection_done_handler(self):
+        if len(self.upload_inspection_threads) > 0:
+
+            def _join_threads(thread: RobotUploadInspectionThread) -> bool:
+                if not thread.is_alive():
+                    thread.join()
+                    return True
+                return False
 
-        self.upload_inspection_threads[:] = [
-            thread for thread in self.upload_inspection_threads if _join_threads(thread)
-        ]
+            self.upload_inspection_threads[:] = [
+                thread
+                for thread in self.upload_inspection_threads
+                if _join_threads(thread)
+            ]
 
     def run(self) -> None:
         self.robot_status_thread = RobotStatusThread(
@@ -260,4 +292,8 @@ class Robot(object):
 
             self._stop_mission_done_handler()
 
+            self._pause_mission_done_handler()
+
+            self._upload_inspection_done_handler()
+
         self.logger.info("Exiting robot service main thread")

{isar-1.34.3 → isar-1.34.4}/src/isar/robot/robot_monitor_mission.py

@@ -86,6 +86,10 @@ class RobotMonitorMissionThread(Thread):
             if self.signal_thread_quitting.wait(0) or self.signal_mission_stopped.wait(
                 0
             ):
+                failed_task_error = ErrorMessage(
+                    error_reason=ErrorReason.RobotTaskStatusException,
+                    error_description="Task status collection was cancelled by monitor thread exit",
+                )
                 break
             if request_status_failure_counter > 0:
                 time.sleep(settings.REQUEST_STATUS_COMMUNICATION_RECONNECT_DELAY)
@@ -320,7 +324,8 @@ class RobotMonitorMissionThread(Thread):
                     new_task_status = self._get_task_status(current_task.id)
                 except RobotTaskStatusException as e:
                     self.logger.error(
-                        "Failed to collect task status", e.error_description
+                        "Failed to collect task status. Error description: %s",
+                        e.error_description,
                     )
                     break
                 except Exception:

{isar-1.34.3 → isar-1.34.4}/src/isar/robot/robot_pause_mission.py

@@ -4,11 +4,11 @@ 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,
+    RobotNoMissionRunningException,
 )
 from robot_interface.robot_interface import RobotInterface
 
@@ -16,14 +16,13 @@ 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
+        self.error_message: Optional[ErrorMessage] = None
         Thread.__init__(self, name="Robot pause mission thread")
 
     def run(self) -> None:
@@ -35,6 +34,11 @@ class RobotPauseMissionThread(Thread):
 
             try:
                 self.robot.pause()
+            except RobotNoMissionRunningException as e:
+                error = ErrorMessage(
+                    error_reason=e.error_reason, error_description=e.error_description
+                )
+                break
             except (RobotActionException, RobotException) as e:
                 self.logger.warning(
                     f"\nFailed to pause robot because: {e.error_description}"
@@ -46,7 +50,6 @@ class RobotPauseMissionThread(Thread):
                 )
                 time.sleep(settings.FSM_SLEEP_TIME)
                 continue
-            self.robot_service_events.mission_successfully_paused.trigger_event(True)
             return
 
         error_description = (
@@ -56,8 +59,7 @@ class RobotPauseMissionThread(Thread):
             "been attempted"
         )
 
-        error_message = ErrorMessage(
+        self.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.34.3 → isar-1.34.4}/src/isar/robot/robot_start_mission.py

@@ -1,8 +1,8 @@
 import logging
 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,
     RobotException,
@@ -15,23 +15,21 @@ from robot_interface.robot_interface import RobotInterface
 class RobotStartMissionThread(Thread):
     def __init__(
         self,
-        robot_service_events: RobotServiceEvents,
         robot: RobotInterface,
         signal_thread_quitting: Event,
         mission: Mission,
     ):
         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
         self.mission = mission
+        self.error_message: Optional[ErrorMessage] = None
         Thread.__init__(self, name="Robot start mission thread")
 
     def run(self):
         retries = 0
-        started_mission = False
         try:
-            while not started_mission:
+            while True:
                 if self.signal_thread_quitting.wait(0):
                     return
                 try:
@@ -40,11 +38,9 @@ class RobotStartMissionThread(Thread):
                     self.logger.error(
                         f"Mission is infeasible and cannot be scheduled because: {e.error_description}"
                     )
-                    self.robot_service_events.mission_failed.trigger_event(
-                        ErrorMessage(
-                            error_reason=e.error_reason,
-                            error_description=e.error_description,
-                        )
+                    self.error_message = ErrorMessage(
+                        error_reason=e.error_reason,
+                        error_description=e.error_description,
                     )
 
                     break
@@ -62,23 +58,15 @@ class RobotStartMissionThread(Thread):
                             f"{e.error_description}"
                         )
 
-                        self.robot_service_events.mission_failed.trigger_event(
-                            ErrorMessage(
-                                error_reason=e.error_reason,
-                                error_description=e.error_description,
-                            )
+                        self.error_message = ErrorMessage(
+                            error_reason=e.error_reason,
+                            error_description=e.error_description,
                         )
                         break
 
                     continue
-
-                started_mission = True
+                break
         except RobotInfeasibleMissionException as e:
-            self.robot_service_events.mission_failed.trigger_event(
-                ErrorMessage(
-                    error_reason=e.error_reason, error_description=e.error_description
-                ),
+            self.error_message = ErrorMessage(
+                error_reason=e.error_reason, error_description=e.error_description
             )
-
-        if started_mission:
-            self.robot_service_events.mission_started.trigger_event(True)

{isar-1.34.3 → isar-1.34.4}/src/isar/robot/robot_stop_mission.py

@@ -9,6 +9,7 @@ from robot_interface.models.exceptions.robot_exceptions import (
     ErrorReason,
     RobotActionException,
     RobotException,
+    RobotNoMissionRunningException,
 )
 from robot_interface.robot_interface import RobotInterface
 
@@ -38,6 +39,8 @@ class RobotStopMissionThread(Thread):
 
             try:
                 self.robot.stop()
+            except RobotNoMissionRunningException:
+                return
             except (RobotActionException, RobotException) as e:
                 self.logger.warning(
                     f"\nFailed to stop robot because: {e.error_description}"

{isar-1.34.3 → isar-1.34.4}/src/isar/robot/robot_upload_inspection.py

@@ -27,15 +27,11 @@ class RobotUploadInspectionThread(Thread):
         self.task: TASKS = task
         self.upload_queue = upload_queue
         self.mission: Mission = mission
-        self._is_done = False
         Thread.__init__(self, name=f"Robot inspection upload thread - {task.id}")
 
     def stop(self) -> None:
         return
 
-    def is_done(self) -> bool:
-        return self._is_done
-
     def run(self):
         try:
             inspection: Inspection = self.robot.get_inspection(task=self.task)
@@ -77,4 +73,3 @@ class RobotUploadInspectionThread(Thread):
         self.logger.info(
             f"Inspection result: {str(inspection.id)[:8]} queued for upload"
         )
-        self._is_done = True

{isar-1.34.3 → isar-1.34.4}/src/isar/state_machine/state_machine.py

@@ -14,6 +14,7 @@ from isar.models.status import IsarStatus
 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.going_to_recharging import GoingToRecharging
 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
@@ -27,6 +28,7 @@ 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_go_to_recharge import StoppingGoToRecharge
 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
@@ -95,7 +97,9 @@ class StateMachine(object):
         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.stopping_go_to_recharge_state: State = StoppingGoToRecharge(self)
         self.going_to_lockdown_state: State = GoingToLockdown(self)
+        self.going_to_recharging_state: State = GoingToRecharging(self)
 
         # States Waiting for mission
         self.await_next_mission_state: State = AwaitNextMission(self)
@@ -130,6 +134,8 @@ class StateMachine(object):
             self.stopping_go_to_lockdown_state,
             self.going_to_lockdown_state,
             self.lockdown_state,
+            self.going_to_recharging_state,
+            self.stopping_go_to_recharge_state,
         ]
 
         self.machine = Machine(
@@ -279,6 +285,8 @@ class StateMachine(object):
             return IsarStatus.Lockdown
         elif self.current_state == States.GoingToLockdown:
             return IsarStatus.GoingToLockdown
+        elif self.current_state == States.GoingToRecharging:
+            return IsarStatus.GoingToRecharging
         else:
             return IsarStatus.Busy
 

{isar-1.34.3 → isar-1.34.4}/src/isar/state_machine/states/await_next_mission.py

@@ -22,6 +22,7 @@ class AwaitNextMission(EventHandlerBase):
 
     def __init__(self, state_machine: "StateMachine"):
         events = state_machine.events
+        shared_state = state_machine.shared_state
 
         def _send_to_lockdown_event_handler(
             event: Event[bool],
@@ -35,6 +36,18 @@ class AwaitNextMission(EventHandlerBase):
             )
             return state_machine.request_lockdown_mission  # type: ignore
 
+        def _robot_battery_level_updated_handler(
+            event: Event[float],
+        ) -> Optional[Callable]:
+            battery_level: float = event.check()
+            if (
+                battery_level is None
+                or battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
+            ):
+                return None
+
+            return state_machine.request_recharging_mission  # type: ignore
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="start_mission_event",
@@ -58,6 +71,11 @@ class AwaitNextMission(EventHandlerBase):
                 event=events.api_requests.send_to_lockdown.request,
                 handler=_send_to_lockdown_event_handler,
             ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=_robot_battery_level_updated_handler,
+            ),
         ]
 
         timers: List[TimeoutHandlerMapping] = [

isar-1.34.4/src/isar/state_machine/states/going_to_recharging.py

@@ -0,0 +1,81 @@
+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 robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+from robot_interface.models.mission.status import MissionStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class GoingToRecharging(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        events = state_machine.events
+
+        def _mission_failed_event_handler(
+            event: Event[Optional[ErrorMessage]],
+        ) -> Optional[Callable]:
+            mission_failed: Optional[ErrorMessage] = event.consume_event()
+            if mission_failed is None:
+                return None
+
+            state_machine.logger.warning(
+                f"Failed to go to recharging because: "
+                f"{mission_failed.error_description}"
+            )
+            return state_machine.return_home_failed  # type: ignore
+
+        def _mission_status_event_handler(
+            event: Event[MissionStatus],
+        ) -> Optional[Callable]:
+            mission_status: Optional[MissionStatus] = event.consume_event()
+
+            if not mission_status or mission_status in [
+                MissionStatus.InProgress,
+                MissionStatus.NotStarted,
+                MissionStatus.Paused,
+            ]:
+                return None
+
+            if mission_status != MissionStatus.Successful:
+                return state_machine.return_home_failed  # type: ignore
+
+            return state_machine.starting_recharging  # type: ignore
+
+        def _send_to_lockdown_event_handler(
+            event: Event[bool],
+        ) -> Optional[Callable]:
+            should_lockdown: bool = event.consume_event()
+            if not should_lockdown:
+                return None
+
+            events.api_requests.send_to_lockdown.response.trigger_event(
+                LockdownResponse(lockdown_started=True)
+            )
+            return state_machine.go_to_lockdown  # type: ignore
+
+        event_handlers: List[EventHandlerMapping] = [
+            EventHandlerMapping(
+                name="mission_failed_event",
+                event=events.robot_service_events.mission_failed,
+                handler=_mission_failed_event_handler,
+            ),
+            EventHandlerMapping(
+                name="mission_status_event",
+                event=events.robot_service_events.mission_status_updated,
+                handler=_mission_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="going_to_recharging",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

{isar-1.34.3 → isar-1.34.4}/src/isar/state_machine/states/home.py

@@ -1,6 +1,7 @@
 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
 from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
@@ -44,6 +45,18 @@ class Home(EventHandlerBase):
                 return state_machine.robot_status_changed  # type: ignore
             return None
 
+        def _robot_battery_level_updated_handler(
+            event: Event[float],
+        ) -> Optional[Callable]:
+            battery_level: float = event.check()
+            if (
+                battery_level is None
+                or battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
+            ):
+                return None
+
+            return state_machine.starting_recharging  # type: ignore
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="start_mission_event",
@@ -72,6 +85,11 @@ class Home(EventHandlerBase):
                 event=events.api_requests.send_to_lockdown.request,
                 handler=_send_to_lockdown_event_handler,
             ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                event=shared_state.robot_battery_level,
+                handler=_robot_battery_level_updated_handler,
+            ),
         ]
         super().__init__(
             state_name="home",

{isar-1.34.3 → isar-1.34.4}/src/isar/state_machine/states/monitor.py

@@ -30,16 +30,16 @@ class Monitor(EventHandlerBase):
             event: Event[float],
         ) -> Optional[Callable]:
             battery_level: float = event.check()
-            if battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+            if (
+                battery_level is None
+                or battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
+            ):
                 return None
 
-            state_machine.publish_mission_aborted(
-                "Robot battery too low to continue mission", True
-            )
             state_machine.logger.warning(
                 "Cancelling current mission due to low battery"
             )
-            return state_machine.stop  # type: ignore
+            return state_machine.stop_go_to_recharge  # type: ignore
 
         def _send_to_lockdown_event_handler(
             event: Event[bool],

{isar-1.34.3 → isar-1.34.4}/src/isar/state_machine/states/paused.py

@@ -19,7 +19,10 @@ class Paused(EventHandlerBase):
             event: Event[float],
         ) -> Optional[Callable]:
             battery_level: float = event.check()
-            if battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+            if (
+                battery_level is None
+                or battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
+            ):
                 return None
 
             state_machine.publish_mission_aborted(

{isar-1.34.3 → isar-1.34.4}/src/isar/state_machine/states/return_home_paused.py

@@ -21,7 +21,10 @@ class ReturnHomePaused(EventHandlerBase):
         ) -> Optional[Callable]:
             battery_level: float = event.check()
 
-            if battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD:
+            if (
+                battery_level is None
+                or battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
+            ):
                 return None
 
             return state_machine.resume  # type: ignore

{isar-1.34.3 → isar-1.34.4}/src/isar/state_machine/states/returning_home.py

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING, Callable, List, Optional
 
 from isar.apis.models.models import LockdownResponse, MissionStartResponse
+from isar.config.settings import settings
 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
@@ -17,6 +18,7 @@ class ReturningHome(EventHandlerBase):
     def __init__(self, state_machine: "StateMachine"):
         self.failed_return_home_attemps: int = 0
         events = state_machine.events
+        shared_state = state_machine.shared_state
 
         def _pause_mission_event_handler(event: Event[bool]) -> Optional[Callable]:
             if not event.consume_event():
@@ -59,10 +61,7 @@ class ReturningHome(EventHandlerBase):
                     return state_machine.return_home_failed  # type: ignore
 
                 self.failed_return_home_attemps = 0
-                if not state_machine.battery_level_is_above_mission_start_threshold():
-                    return state_machine.starting_recharging  # type: ignore
-                else:
-                    return state_machine.returned_home  # type: ignore
+                return state_machine.returned_home  # type: ignore
             return None
 
         def _send_to_lockdown_event_handler(
@@ -89,6 +88,18 @@ class ReturningHome(EventHandlerBase):
                 return state_machine.return_home_failed  # type: ignore
             return None
 
+        def _robot_battery_level_updated_handler(
+            event: Event[float],
+        ) -> Optional[Callable]:
+            battery_level: float = event.check()
+            if (
+                battery_level is None
+                or battery_level >= settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
+            ):
+                return None
+
+            return state_machine.go_to_recharging  # type: ignore
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="pause_mission_event",
@@ -117,6 +128,11 @@ class ReturningHome(EventHandlerBase):
                 event=events.robot_service_events.mission_status_updated,
                 handler=_mission_status_event_handler,
             ),
+            EventHandlerMapping(
+                name="robot_battery_update_event",
+                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,