isar 1.34.2__py3-none-any.whl → 1.34.4__py3-none-any.whl

isar/models/status.py

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

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/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,10 +324,12 @@ 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:
+                    self.logger.exception("Failed to collect task status")
                     break
 
                 if current_task.status != new_task_status:
@@ -350,8 +356,14 @@ class RobotMonitorMissionThread(Thread):
 
             try:
                 new_mission_status = self._get_mission_status(self.current_mission.id)
-            except RobotMissionStatusException:
+            except RobotMissionStatusException as e:
                 self.logger.exception("Failed to collect mission status")
+                self.robot_service_events.mission_failed.trigger_event(
+                    ErrorMessage(
+                        error_reason=e.error_reason,
+                        error_description=e.error_description,
+                    )
+                )
                 break
             if new_mission_status != last_mission_status:
                 self.current_mission.status = new_mission_status

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/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/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/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/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/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/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/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/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/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/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/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,

isar/state_machine/states/stopping_go_to_recharge.py

@@ -0,0 +1,51 @@
+from typing import TYPE_CHECKING, Callable, List, Optional
+
+from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class StoppingGoToRecharge(EventHandlerBase):
+
+    def __init__(self, state_machine: "StateMachine"):
+        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 None:
+                return None
+
+            return state_machine.mission_stopping_failed  # type: ignore
+
+        def _successful_stop_event_handler(event: Event[bool]) -> Optional[Callable]:
+            if not event.consume_event():
+                return None
+
+            state_machine.publish_mission_aborted(
+                "Robot battery too low to continue mission", True
+            )
+
+            return state_machine.request_recharging_mission  # type: ignore
+
+        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_go_to_recharge",
+            state_machine=state_machine,
+            event_handler_mappings=event_handlers,
+        )

isar/state_machine/states_enum.py

@@ -20,6 +20,8 @@ class States(str, Enum):
     StoppingGoToLockdown = "stopping_go_to_lockdown"
     GoingToLockdown = "going_to_lockdown"
     Lockdown = "lockdown"
+    GoingToRecharging = "going_to_recharging"
+    StoppingGoToRecharge = "stopping_go_to_recharge"
 
     def __repr__(self):
         return self.value

isar/state_machine/transitions/functions/resume.py

@@ -10,6 +10,7 @@ from isar.config.settings import settings
 from robot_interface.models.exceptions.robot_exceptions import (
     RobotActionException,
     RobotException,
+    RobotNoMissionRunningException,
 )
 
 
@@ -32,6 +33,12 @@ def resume_mission(state_machine: "StateMachine") -> bool:
 
             state_machine.logger.info("Mission resumed successfully.")
             return True
+        except RobotNoMissionRunningException as e:
+            state_machine.logger.error(
+                f"Failed to resume mission: {e.error_reason}. {e.error_description}"
+            )
+            # TODO: this will make it go to paused, instead of awaitnextmission
+            return False
         except RobotActionException as e:
             state_machine.logger.warning(
                 f"Attempt {attempt + 1} to resume mission failed: {e.error_description}"

isar/state_machine/transitions/mission.py

@@ -110,6 +110,12 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.stopping_go_to_lockdown_state,
             "before": def_transition(state_machine, trigger_stop_mission_event),
         },
+        {
+            "trigger": "stop_go_to_recharge",
+            "source": state_machine.monitor_state,
+            "dest": state_machine.stopping_go_to_recharge_state,
+            "before": def_transition(state_machine, trigger_stop_mission_event),
+        },
         {
             "trigger": "stop_return_home",
             "source": [
@@ -140,7 +146,10 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
         },
         {
             "trigger": "mission_stopping_failed",
-            "source": state_machine.stopping_go_to_lockdown_state,
+            "source": [
+                state_machine.stopping_go_to_lockdown_state,
+                state_machine.stopping_go_to_recharge_state,
+            ],
             "dest": state_machine.monitor_state,
         },
         {

isar/state_machine/transitions/return_home.py

@@ -61,7 +61,7 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
         },
         {
             "trigger": "starting_recharging",
-            "source": state_machine.returning_home_state,
+            "source": state_machine.going_to_recharging_state,
             "dest": state_machine.recharging_state,
             "before": [
                 def_transition(state_machine, reset_return_home_failure_counter),
@@ -69,7 +69,7 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
         },
         {
             "trigger": "starting_recharging",
-            "source": state_machine.lockdown_state,
+            "source": [state_machine.lockdown_state, state_machine.home_state],
             "dest": state_machine.recharging_state,
         },
         {
@@ -86,7 +86,10 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
         },
         {
             "trigger": "return_home_failed",
-            "source": state_machine.returning_home_state,
+            "source": [
+                state_machine.returning_home_state,
+                state_machine.going_to_recharging_state,
+            ],
             "dest": state_machine.intervention_needed_state,
             "before": [
                 def_transition(
@@ -112,14 +115,36 @@ def get_return_home_transitions(state_machine: "StateMachine") -> List[dict]:
                 def_transition(state_machine, initialize_robot),
             ],
         },
+        {
+            "trigger": "request_recharging_mission",
+            "source": [
+                state_machine.stopping_go_to_recharge_state,
+                state_machine.await_next_mission_state,
+            ],
+            "dest": state_machine.going_to_recharging_state,
+            "conditions": [
+                def_transition(state_machine, start_return_home_mission),
+                def_transition(state_machine, initialize_robot),
+            ],
+        },
         {
             "trigger": "go_to_lockdown",
             "source": [
                 state_machine.returning_home_state,
                 state_machine.return_home_paused_state,
+                state_machine.going_to_recharging_state,
             ],
             "dest": state_machine.going_to_lockdown_state,
         },
+        {
+            "trigger": "go_to_recharging",
+            "source": [
+                state_machine.returning_home_state,
+                state_machine.return_home_paused_state,
+                state_machine.home_state,
+            ],
+            "dest": state_machine.going_to_recharging_state,
+        },
         {
             "trigger": "reached_lockdown",
             "source": [

{isar-1.34.2.dist-info → isar-1.34.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.34.2
+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.2.dist-info → isar-1.34.4.dist-info}/RECORD

@@ -41,15 +41,15 @@ isar/mission_planner/local_planner.py,sha256=Mkg3vvUBF1jImfQnaFvXLNpKVadR21X4mwD
 isar/mission_planner/mission_planner_interface.py,sha256=UgpPIM4FbrWOD7fGY3Ul64k3uYb8wo0FwSWGewYoVbc,485
 isar/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/models/events.py,sha256=lwjq745VWJLRLdqNke58sWMRt8zz75hUt7t0QkbLsFU,5602
-isar/models/status.py,sha256=RCsf0p6FEsOFr4FGA6wekRdJIPrCOHMYuteXs2Mwwhk,430
-isar/robot/robot.py,sha256=gppNNm_4yjjU3fqWrgBP1VaMcQqHXw8eJk2H41mhLco,10703
+isar/models/status.py,sha256=qPQdeE_6yB-twWtTHdeUMmSLMjbtWNGLHJOF_aucqx4,474
+isar/robot/robot.py,sha256=bVzD4psVOCc7La1DjwTeRUmxFWwWp-3TwMdmcyoFOwU,11996
 isar/robot/robot_battery.py,sha256=goLdgmn61QCgE2Ja3YuiwE_sqJzIhCkS3u90sz1kdug,2089
-isar/robot/robot_monitor_mission.py,sha256=OIb7bLbld68pgnKkzgmkoUDINxSEvRtcaEXyQLioScc,15308
-isar/robot/robot_pause_mission.py,sha256=BFTLVFOnCeuLlyz1Lu12_6EgYBhk8frsviCs-kGq7AA,2277
-isar/robot/robot_start_mission.py,sha256=RPYH9VtXDFdPqhOpt6kSbT17RHkJQPKkQ6d4784_pFE,3210
+isar/robot/robot_monitor_mission.py,sha256=mdnTZlhBgr-lWsAQRyP_vXiu3DYl-4joC0myZmgcw1o,15938
+isar/robot/robot_pause_mission.py,sha256=MpK3YEux7k0Ks8Orv7Iz7ADhiEC8X_9LQZ5mK7e1a90,2247
+isar/robot/robot_start_mission.py,sha256=KO_gUNEYvjNJ3eSkH-umUOEezwpLKIYBEuF_eot4rIM,2683
 isar/robot/robot_status.py,sha256=dfAls3s8_Vha7ZMLSYngELqsdpaEpcweAWRHanQj8u8,2361
-isar/robot/robot_stop_mission.py,sha256=noLqg7zdd0TMOOIqj-60tOQ_1wLOKOuUSkPIxZ3j1Ks,2211
-isar/robot/robot_upload_inspection.py,sha256=CFPz6JNinLO5M2MQG6AzYK0jl1hhwi8zaqITeB5A9EU,2659
+isar/robot/robot_stop_mission.py,sha256=CaXLsZjjazHmydU9iR7uOWUHtJ2zvKh4ItUbkWY5sIk,2321
+isar/robot/robot_upload_inspection.py,sha256=uCc9nuH1Am5uxD2Tgnm4ZTOm0tQnud0F6eHs0rSUfvY,2539
 isar/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/services/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isar/services/auth/azure_credentials.py,sha256=9PlwGe5FrPRbW2dp0go7LMp8_l_FRvL8xOXotXwzRDo,364
@@ -64,34 +64,36 @@ isar/services/utilities/robot_utilities.py,sha256=4zCigsLXfqDC8POHchktSq81zr1_pT
 isar/services/utilities/scheduling_utilities.py,sha256=AcoMWpNfNJ-IRu5ulLNtriLTKIVgog47im0yQ_ECanQ,20442
 isar/services/utilities/threaded_request.py,sha256=py4G-_RjnIdHljmKFAcQ6ddqMmp-ZYV39Ece-dqRqjs,1874
 isar/state_machine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/state_machine/state_machine.py,sha256=lUT-lvtH2r0_ZKLs9AaXx80RWRDJv209w443LpF0G8o,11527
-isar/state_machine/states_enum.py,sha256=EzqLHsNbR7KBMIY5Fa_CDaHm9v6g8UFzq9DJs4x0OU8,746
+isar/state_machine/state_machine.py,sha256=xd9GISbN-N73k8fme2zctg7H6Ur5Zl27PAg--xmj34k,12038
+isar/state_machine/states_enum.py,sha256=XaFJ1GJMVACE5aw3oYxP-GPT6ucLXhnIMGOu5nTLVnI,845
 isar/state_machine/states/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-isar/state_machine/states/await_next_mission.py,sha256=H1QN62S6iUYzLgyzK8UVG-0PEWGiCDdsIOjWC7BWD_Q,2742
+isar/state_machine/states/await_next_mission.py,sha256=MlIyFbiu6odQuX0H7Y1vg9_ay-ZzsTFtraX7yyIOxkY,3433
 isar/state_machine/states/blocked_protective_stop.py,sha256=HJr_jH8OdHMuX8zhjlF5jtNAfMCxkA1X7nOGmkAz-RY,1263
 isar/state_machine/states/going_to_lockdown.py,sha256=qOmJt5V51_fhJobIzzFyFW-sxfoktG8_Vt9a4N-EmWs,2725
-isar/state_machine/states/home.py,sha256=nIuHVDEYkMuoGTdf0nTUlOaNblYVDoZdl_njeE2sFNQ,3161
+isar/state_machine/states/going_to_recharging.py,sha256=Ubn7YvKs4gr6rlII9BLt2aamIBYIIY9QfcQN-yn1HtY,3051
+isar/state_machine/states/home.py,sha256=BNIuKYjRPGLjcVXfrJLyNM7sab6HB95hFr_n2MWoZpM,3837
 isar/state_machine/states/intervention_needed.py,sha256=nv7054e9gBJQ4-Mshs8cczqnD0IN-N-_5qvUR-cNcUM,1633
 isar/state_machine/states/lockdown.py,sha256=ZFw9XMDENECuH3lh89RKeU_3CTzW0ZBvqCKptFJG5xo,1364
-isar/state_machine/states/monitor.py,sha256=UIvqU2uNashm-ZCYuGr3GkpuwWbmuGC7ipG_XSHgO34,4514
+isar/state_machine/states/monitor.py,sha256=o68TMYMoYccnbyXsVsIehuYdvMv3FqZYNzFI3oIdl44,4471
 isar/state_machine/states/offline.py,sha256=k1UdcRWLd6lJiL5cnpHKBkvMY4xZMt_x7XIauy-Rgww,1219
-isar/state_machine/states/paused.py,sha256=F5XIzIcnR7_BvIDyMu8CWEdsmXRukUFTYy0-H1ldWeo,2849
+isar/state_machine/states/paused.py,sha256=pR8ZuETs-OAl6oUEZGRCfXAZgQyeDeA8KcOKA1b8c1Y,2922
 isar/state_machine/states/pausing.py,sha256=CJf_wqpajizv-UY3gL8ctHbPbVP-jXkLsaQiCgfCod4,2138
 isar/state_machine/states/pausing_return_home.py,sha256=bQjNp8cC90x7yoTLccrx3oIdaj9at-34p9ez1OqKrmE,2184
 isar/state_machine/states/recharging.py,sha256=TSCZuWhDKBW47peeP73k7aBD4_SEMOOdD1GgOdAq6lk,2447
-isar/state_machine/states/return_home_paused.py,sha256=rr5iy8u6zaTMZAGtlf1HlroVShjytxKjE6t-wGym8nU,3355
-isar/state_machine/states/returning_home.py,sha256=7bWLE2HU0rObPzM2evY8Wzl9hmerJMS0xaRt4vs3tFQ,5318
+isar/state_machine/states/return_home_paused.py,sha256=cm2svV5l1dkDzFkGN0v3ZBEk7x8knU8E2u7N-jmFM7A,3428
+isar/state_machine/states/returning_home.py,sha256=d_VSxLL5qKl6UYGWs-rTv6mhTbw2cvuECrAEyrntugU,5851
 isar/state_machine/states/stopping.py,sha256=MhIU1kZCjOQpZBZ5EQ299zdvBWNaDNVdksh7Zw4Hk68,2208
 isar/state_machine/states/stopping_go_to_lockdown.py,sha256=yl0HFxIBKFCWGQixTULuYb_Z-dwrPeI8TioZ9AQf1Lk,2264
+isar/state_machine/states/stopping_go_to_recharge.py,sha256=eu2rPxeBJbQCNKlIxn9HJ7qZ21Fz81W-HKg8Le8gZtE,1861
 isar/state_machine/states/stopping_return_home.py,sha256=HtoZfSXWLGCRChITZCKjOufowwZzQaJLCZGaYsjP1mE,2854
 isar/state_machine/states/unknown_status.py,sha256=Vu07Sk90zFVInf3XdzFl5IaYrdrYaGO7Na7qAOGwjIk,1871
-isar/state_machine/transitions/mission.py,sha256=o3UG9klPqZnWTYVjTFOXYiMFxfbrWIxRvcaTfcqYW_0,7396
-isar/state_machine/transitions/return_home.py,sha256=aLOK7t7Us_TrDhtxhwW4XaIGxB_gU3Drg2uJFuOjS54,5558
+isar/state_machine/transitions/mission.py,sha256=5H4ZvmsNn3kcaVSC7dN0C2JumzRlqq-daARtexxPgHk,7754
+isar/state_machine/transitions/return_home.py,sha256=42o3etvJeBaWK4bJfqwtFLpSzeJFhsu_UalzLW4CzPA,6525
 isar/state_machine/transitions/robot_status.py,sha256=7fEXHBBo8A6z8eUeNXs01xQ87l26siPB3kyTSbcnPcc,2738
 isar/state_machine/transitions/functions/fail_mission.py,sha256=NFPGIPE0EtefUETbf8Z8plBWghcRQBrbup5xaxF3h6Y,604
 isar/state_machine/transitions/functions/finish_mission.py,sha256=K9paNVz0wbWSkCWvVBaKTM54vdHBH-TNuqG1EstEI8w,229
 isar/state_machine/transitions/functions/pause.py,sha256=8cQIvXDb1hKS-K6-a0fmcqJHde0FRzS-n4N8_EBSA3w,1089
-isar/state_machine/transitions/functions/resume.py,sha256=HWmM1T4jvMPq3by4rns9G0lKUtWMegkFkGtbILvzfKE,1600
+isar/state_machine/transitions/functions/resume.py,sha256=pO2PSLQsXDXGJuFDPb6TqUJ87515OcyZBo3iGSYHZ3g,1932
 isar/state_machine/transitions/functions/return_home.py,sha256=UBXOfYKlvsmpnmUeKFkc2483fdY9pX70F4pmndjCs8Y,1148
 isar/state_machine/transitions/functions/robot_status.py,sha256=dVh0cY6KLt0xcZ2jBQWt4GbR_CPJvrQZWhP3GEpDCZY,1105
 isar/state_machine/transitions/functions/start_mission.py,sha256=1Op-Dutfmbc6kH1bHHu7obQ5I1G5jnYoH4wx5qSXoI0,1254
@@ -104,13 +106,13 @@ isar/storage/local_storage.py,sha256=Rn-iiiz9DI7PzIhevOMshPIaqzJaqBXeVJMQRhVSl2M
 isar/storage/storage_interface.py,sha256=x-imVeQTdL6dCaTaPTHpXwCR6N4e27WxK_Vpumg0x-Y,1230
 isar/storage/uploader.py,sha256=0BBrxyZGGRkNxGeZeoREucegs4yKUow2523oLEie07o,10841
 isar/storage/utilities.py,sha256=oLH0Rp7UtrQQdilfITnmXO1Z0ExdeDhBImYHid55vBA,3449
-isar-1.34.2.dist-info/licenses/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
+isar-1.34.4.dist-info/licenses/LICENSE,sha256=3fc2-ebLwHWwzfQbulGNRdcNob3SBQeCfEVUDYxsuqw,14058
 robot_interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/robot_interface.py,sha256=3JAVCzg4WV4gYgDxGfdmXPPlVETmwyoqLh7QZJMerKU,9886
 robot_interface/test_robot_interface.py,sha256=FV1urn7SbsMyWBIcTKjsBwAG4IsXeZ6pLHE0mA9EGGs,692
 robot_interface/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/models/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robot_interface/models/exceptions/robot_exceptions.py,sha256=UFya2u-slcf2ebc3ZVCs-Kp1SS9PQvKdWInYMBEQ8BY,10404
+robot_interface/models/exceptions/robot_exceptions.py,sha256=B08Om0poV2XWfI3b7nG0dkwU0CoWUUHLuyQnPpPNQec,10885
 robot_interface/models/initialize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/models/inspection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/models/inspection/inspection.py,sha256=cjAvekL8r82s7bgukWeXpYylHvJG_oRSCJNISPVCvZg,2238
@@ -128,8 +130,8 @@ robot_interface/telemetry/payloads.py,sha256=A0SWiG609k6o6-Y3vhDWE6an2-_m7D_ND85
 robot_interface/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 robot_interface/utilities/json_service.py,sha256=9N1zijW7K4d3WFR2autpaS8U9o1ibymiOX-6stTKCyk,1243
 robot_interface/utilities/uuid_string_factory.py,sha256=_NQIbBQ56w0qqO0MUDP6aPpHbxW7ATRhK8HnQiBSLkc,76
-isar-1.34.2.dist-info/METADATA,sha256=ArvN55GfJYYtkePQzFkV0d3ebH4AvfAsvDOTGMXFq7Y,28866
-isar-1.34.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-isar-1.34.2.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
-isar-1.34.2.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
-isar-1.34.2.dist-info/RECORD,,
+isar-1.34.4.dist-info/METADATA,sha256=k6ub1kgGNic9LAtm8-lgZNtNUk3-LDnz0mU0fgq7KJI,28866
+isar-1.34.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+isar-1.34.4.dist-info/entry_points.txt,sha256=TFam7uNNw7J0iiDYzsH2gfG0u1eV1wh3JTw_HkhgKLk,49
+isar-1.34.4.dist-info/top_level.txt,sha256=UwIML2RtuQKCyJJkatcSnyp6-ldDjboB9k9JgKipO-U,21
+isar-1.34.4.dist-info/RECORD,,

robot_interface/models/exceptions/robot_exceptions.py

@@ -24,6 +24,7 @@ class ErrorReason(str, Enum):
     RobotTransformException = "robot_transform_exception"
     RobotUnknownErrorException = "robot_unknown_error_exception"
     RobotDisconnectedException = "robot_disconnected_exception"
+    RobotNoMissionRunningException = "robot_no_mission_running_exception"
 
 
 @dataclass
@@ -53,6 +54,18 @@ class RobotCommunicationException(RobotException):
     pass
 
 
+# An exception which should be thrown by the robot package if it is unable to
+# complete a request as there is no ongoing mission.
+class RobotNoMissionRunningException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotNoMissionRunningException,
+            error_description=error_description,
+        )
+
+    pass
+
+
 # An exception which should be thrown by the robot package if the communication has timed
 # out and ISAR should retry the request.
 class RobotCommunicationTimeoutException(RobotException):