isar 1.33.2__tar.gz → 1.33.3__tar.gz

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

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

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

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

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

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

{isar-1.33.2 → isar-1.33.3}/src/isar/services/utilities/scheduling_utilities.py

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

{isar-1.33.2 → isar-1.33.3}/src/isar/state_machine/state_machine.py

@@ -24,9 +24,10 @@ from isar.state_machine.states.monitor import Monitor
 from isar.state_machine.states.offline import Offline
 from isar.state_machine.states.paused import Paused
 from isar.state_machine.states.recharging import Recharging
+from isar.state_machine.states.return_home_paused import ReturnHomePaused
 from isar.state_machine.states.returning_home import ReturningHome
-from isar.state_machine.states.robot_standing_still import RobotStandingStill
 from isar.state_machine.states.stopping import Stopping
+from isar.state_machine.states.stopping_return_home import StoppingReturnHome
 from isar.state_machine.states.unknown_status import UnknownStatus
 from isar.state_machine.states_enum import States
 from isar.state_machine.transitions.mission import get_mission_transitions
@@ -101,11 +102,12 @@ class StateMachine(object):
         self.returning_home_state: State = ReturningHome(self)
         self.stopping_state: State = Stopping(self)
         self.paused_state: State = Paused(self)
+        self.return_home_paused_state: State = ReturnHomePaused(self)
+        self.stopping_return_home_state: State = StoppingReturnHome(self)
 
         # States Waiting for mission
         self.await_next_mission_state: State = AwaitNextMission(self)
         self.home_state: State = Home(self)
-        self.robot_standing_still_state: State = RobotStandingStill(self)
         self.intervention_needed_state: State = InterventionNeeded(self)
 
         # Status states
@@ -120,10 +122,11 @@ class StateMachine(object):
             self.monitor_state,
             self.returning_home_state,
             self.stopping_state,
+            self.stopping_return_home_state,
             self.paused_state,
+            self.return_home_paused_state,
             self.await_next_mission_state,
             self.home_state,
-            self.robot_standing_still_state,
             self.offline_state,
             self.blocked_protective_stopping_state,
             self.unknown_status_state,
@@ -363,11 +366,12 @@ class StateMachine(object):
         )
 
     def _current_status(self) -> RobotStatus:
-        if (
-            self.current_state == States.RobotStandingStill
-            or self.current_state == States.AwaitNextMission
-        ):
+        if self.current_state == States.AwaitNextMission:
             return RobotStatus.Available
+        elif self.current_state == States.ReturnHomePaused:
+            return RobotStatus.ReturnHomePaused
+        elif self.current_state == States.Paused:
+            return RobotStatus.Paused
         elif self.current_state == States.Home:
             return RobotStatus.Home
         elif self.current_state == States.ReturningHome:

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

@@ -1,9 +1,9 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Callable, List, Optional
 
 from isar.eventhandlers.eventhandler import EventHandlerBase, EventHandlerMapping
+from isar.models.events import Event
 from isar.state_machine.utils.common_event_handlers import (
     return_home_event_handler,
-    robot_status_event_handler,
     start_mission_event_handler,
     stop_mission_event_handler,
 )
@@ -19,6 +19,17 @@ class Home(EventHandlerBase):
         events = state_machine.events
         shared_state = state_machine.shared_state
 
+        def _robot_status_event_handler(
+            event: Event[RobotStatus],
+        ) -> Optional[Callable]:
+            robot_status: RobotStatus = event.check()
+            if not (
+                robot_status == RobotStatus.Available
+                or robot_status == RobotStatus.Home
+            ):
+                return state_machine.robot_status_changed  # type: ignore
+            return None
+
         event_handlers: List[EventHandlerMapping] = [
             EventHandlerMapping(
                 name="start_mission_event",
@@ -40,9 +51,7 @@ class Home(EventHandlerBase):
             EventHandlerMapping(
                 name="robot_status_event",
                 event=shared_state.robot_status,
-                handler=lambda event: robot_status_event_handler(
-                    state_machine, RobotStatus.Home, event
-                ),
+                handler=_robot_status_event_handler,
             ),
         ]
         super().__init__(

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

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

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

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

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

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

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

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

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

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

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

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

{isar-1.33.2 → isar-1.33.3}/src/isar/state_machine/transitions/functions/pause.py

@@ -51,3 +51,41 @@ def pause_mission(state_machine: "StateMachine") -> bool:
 
     state_machine.logger.error("Failed to pause mission after multiple attempts.")
     return False
+
+
+def pause_return_home_mission(state_machine: "StateMachine") -> bool:
+    state_machine.logger.info("Pausing return home misson")
+
+    max_retries = settings.STATE_TRANSITION_NUM_RETIRES
+    retry_interval = settings.STATE_TRANSITION_RETRY_INTERVAL_SEC
+
+    for attempt in range(max_retries):
+        try:
+            state_machine.robot.pause()
+            state_machine.current_mission.status = MissionStatus.Paused
+            state_machine.current_task.status = TaskStatus.Paused
+
+            paused_mission_response: ControlMissionResponse = (
+                state_machine._make_control_mission_response()
+            )
+            state_machine.events.api_requests.pause_mission.response.trigger_event(
+                paused_mission_response
+            )
+
+            state_machine.logger.info("Return home mission paused successfully.")
+            return True
+        except RobotActionException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to pause return home mission failed: {e.error_description}"
+            )
+            time.sleep(retry_interval)
+        except RobotException as e:
+            state_machine.logger.warning(
+                f"Attempt {attempt + 1} to pause return home mission raised a RobotException: {e.error_description}"
+            )
+            time.sleep(retry_interval)
+
+    state_machine.logger.error(
+        "Failed to pause return home mission after multiple attempts."
+    )
+    return False

{isar-1.33.2 → isar-1.33.3}/src/isar/state_machine/transitions/functions/robot_status.py

@@ -11,14 +11,9 @@ def is_offline(state_machine: "StateMachine") -> bool:
     return robot_status == RobotStatus.Offline
 
 
-def is_available(state_machine: "StateMachine") -> bool:
+def is_available_or_home(state_machine: "StateMachine") -> bool:
     robot_status = state_machine.shared_state.robot_status.check()
-    return robot_status == RobotStatus.Available
-
-
-def is_home(state_machine: "StateMachine") -> bool:
-    robot_status = state_machine.shared_state.robot_status.check()
-    return robot_status == RobotStatus.Home
+    return robot_status == RobotStatus.Available or robot_status == RobotStatus.Home
 
 
 def is_blocked_protective_stop(state_machine: "StateMachine") -> bool: