isar 1.26.4__tar.gz → 1.27.1__tar.gz

{isar-1.26.4 → isar-1.27.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.26.4
+Version: 1.27.1
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0
@@ -331,22 +331,29 @@ The system consists of two main components.
 The state machine handles interaction with the robots API and monitors the execution of missions. It also enables
 interacting with the robot before, during and after missions.
 
-The state machine is based on the [transitions](https://github.com/pytransitions/transitions) package for Python. An visualization of the state machine can be seen below:
-![State Machine](./docs/state_machine_diagram.png)
+The state machine is based on the [transitions](https://github.com/pytransitions/transitions) package for Python. The following are some visualizations of the state machine:
+
+Mission behavior without the robot status changed transition that enable the resting states to transition between each other if the robot status changes:
+![State Machine extended](./docs/extended_state_machine_diagram.png)
+
+Robot status changed transition:
+![State Machine robot status changed](./docs/robot_status_state_machine_diagram.png)
+
+Full state machine:
+![State Machine full](./docs/full_state_machine_diagram.png)
 
 In general the states
 
 ```
-States.Off,
-States.Stop,
+States.Stopping,
 States.Monitor,
 States.Paused,
 ```
 
-indicates that the state machine is already running. For running a mission the state machine need to be in the state
+indicates that the state machine is already running. For running a mission the state machine need to be in the states
 
 ```
-States.Idle
+States.Home, States.RobotStandingStill, States.AwaitNextMission or States.ReturningHome
 ```
 
 ### FastAPI

{isar-1.26.4 → isar-1.27.1}/README.md

@@ -189,22 +189,29 @@ The system consists of two main components.
 The state machine handles interaction with the robots API and monitors the execution of missions. It also enables
 interacting with the robot before, during and after missions.
 
-The state machine is based on the [transitions](https://github.com/pytransitions/transitions) package for Python. An visualization of the state machine can be seen below:
-![State Machine](./docs/state_machine_diagram.png)
+The state machine is based on the [transitions](https://github.com/pytransitions/transitions) package for Python. The following are some visualizations of the state machine:
+
+Mission behavior without the robot status changed transition that enable the resting states to transition between each other if the robot status changes:
+![State Machine extended](./docs/extended_state_machine_diagram.png)
+
+Robot status changed transition:
+![State Machine robot status changed](./docs/robot_status_state_machine_diagram.png)
+
+Full state machine:
+![State Machine full](./docs/full_state_machine_diagram.png)
 
 In general the states
 
 ```
-States.Off,
-States.Stop,
+States.Stopping,
 States.Monitor,
 States.Paused,
 ```
 
-indicates that the state machine is already running. For running a mission the state machine need to be in the state
+indicates that the state machine is already running. For running a mission the state machine need to be in the states
 
 ```
-States.Idle
+States.Home, States.RobotStandingStill, States.AwaitNextMission or States.ReturningHome
 ```
 
 ### FastAPI

isar-1.27.1/docs/update_state_diagram.py

@@ -0,0 +1,58 @@
+import os
+from pathlib import Path
+from typing import List
+
+from injector import Injector
+from transitions import State
+from transitions.extensions import GraphMachine
+
+from isar.modules import get_injector
+from isar.state_machine.state_machine import StateMachine
+from isar.state_machine.transitions.mission import get_mission_transitions
+from isar.state_machine.transitions.return_home import get_return_home_transitions
+from isar.state_machine.transitions.robot_status import get_robot_status_transitions
+
+
+def draw_diagram(states: List[State], transitions: List[dict], name: str):
+    machine = GraphMachine(states=states, initial="unknown_status", queued=True)
+    machine.add_transitions(transitions)
+    gp = machine.get_combined_graph()
+
+    state_machine_diagram_file = (
+        Path(__file__).parent.resolve().joinpath(Path(f"{name}.png"))
+    )
+
+    if os.path.isfile(state_machine_diagram_file):
+        os.remove(state_machine_diagram_file)
+
+    gp.draw(state_machine_diagram_file, prog="dot")
+
+
+if __name__ == "__main__":
+    injector: Injector = get_injector()
+    state_machine: StateMachine = injector.get(StateMachine)
+
+    mission_extended_transitions: List[dict] = []
+    for transition in get_mission_transitions(state_machine):
+        mission_extended_transitions.append(transition)
+
+    for transition in get_return_home_transitions(state_machine):
+        mission_extended_transitions.append(transition)
+
+    draw_diagram(
+        states=state_machine.states,
+        transitions=mission_extended_transitions,
+        name="mission_state_machine_diagram",
+    )
+
+    draw_diagram(
+        states=state_machine.states,
+        transitions=get_robot_status_transitions(state_machine),
+        name="robot_status_state_machine_diagram",
+    )
+
+    draw_diagram(
+        states=state_machine.states,
+        transitions=state_machine.transitions,
+        name="full_state_machine_diagram",
+    )

{isar-1.26.4 → isar-1.27.1}/src/isar/apis/api.py

@@ -150,6 +150,31 @@ class API:
                 HTTPStatus.CONFLICT.value: {
                     "description": "Conflict - Invalid command in the current state",
                 },
+                HTTPStatus.BAD_REQUEST.value: {
+                    "description": "Bad request - Robot does not have the capabilities to perform the mission",
+                },
+                HTTPStatus.INTERNAL_SERVER_ERROR.value: {
+                    "description": "Internal Server Error - Current state of state machine unknown",
+                },
+            },
+        )
+        router.add_api_route(
+            path="/schedule/return-home",
+            endpoint=self.scheduling_controller.return_home,
+            methods=["POST"],
+            dependencies=[authentication_dependency],
+            summary="Start return home mission",
+            responses={
+                HTTPStatus.OK.value: {
+                    "description": "Return home mission succesfully started",
+                    "model": StartMissionResponse,
+                },
+                HTTPStatus.UNPROCESSABLE_ENTITY.value: {
+                    "description": "Invalid body - The JSON is incorrect",
+                },
+                HTTPStatus.CONFLICT.value: {
+                    "description": "Conflict - Invalid command in the current state",
+                },
                 HTTPStatus.INTERNAL_SERVER_ERROR.value: {
                     "description": "Internal Server Error - Current state of state machine unknown",
                 },

{isar-1.26.4 → isar-1.27.1}/src/isar/apis/models/start_mission_definition.py

@@ -92,7 +92,7 @@ def to_isar_task(task_definition: StartMissionTaskDefinition) -> TASKS:
     if task_definition.type == TaskType.Inspection:
         return to_inspection_task(task_definition)
     elif task_definition.type == TaskType.ReturnToHome:
-        return create_return_to_home_task(task_definition)
+        return ReturnToHome()
     else:
         raise MissionPlannerError(
             f"Failed to create task: '{task_definition.type}' is not a valid"
@@ -162,11 +162,5 @@ def to_inspection_task(task_definition: StartMissionTaskDefinition) -> TASKS:
         )
 
 
-def create_return_to_home_task(
-    task_definition: StartMissionTaskDefinition,
-) -> ReturnToHome:
-    return ReturnToHome(pose=task_definition.pose.to_alitra_pose())
-
-
 def _build_mission_name() -> str:
     return f"{settings.PLANT_SHORT_NAME}{settings.ROBOT_NAME}{int(time.time())}"

{isar-1.26.4 → isar-1.27.1}/src/isar/apis/schedule/scheduling_controller.py

@@ -98,6 +98,16 @@ class SchedulingController:
         self.scheduling_utilities.start_mission(mission=mission)
         return self._api_response(mission)
 
+    def return_home(self) -> None:
+        self.logger.info("Received request to return home")
+
+        state: States = self.scheduling_utilities.get_state()
+        self.scheduling_utilities.verify_state_machine_ready_to_receive_return_home_mission(
+            state
+        )
+
+        self.scheduling_utilities.return_home()
+
     def pause_mission(self) -> ControlMissionResponse:
         self.logger.info("Received request to pause current mission")
 
@@ -142,7 +152,13 @@ class SchedulingController:
 
         state: States = self.scheduling_utilities.get_state()
 
-        if state == States.Off:
+        if (
+            state == States.UnknownStatus
+            or state == States.Stopping
+            or state == States.BlockedProtectiveStop
+            or state == States.Offline
+            or state == States.Home
+        ):
             error_message = (
                 f"Conflict - Stop command received in invalid state - State: {state}"
             )

{isar-1.26.4 → isar-1.27.1}/src/isar/config/settings.py

@@ -82,6 +82,9 @@ class Settings(BaseSettings):
     # FastAPI port
     API_PORT: int = Field(default=3000)
 
+    # Determines how long delay time should be allowed before returning home
+    RETURN_HOME_DELAY: int = Field(default=10)
+
     # Determines which mission planner module is used by ISAR
     MISSION_PLANNER: str = Field(default="local")
 
@@ -311,7 +314,7 @@ class RobotSettings(BaseSettings):
 
     # ISAR steps the robot is capable of performing
     # This should be set in the robot package settings.env file
-    CAPABILITIES: List[str] = Field(default=["return_to_home", "take_image"])
+    CAPABILITIES: List[str] = Field(default=["take_image"])
 
     # Model of the robot which ISAR is connected to
     # This should be set in the robot package settings.env file

{isar-1.26.4 → isar-1.27.1}/src/isar/models/communication/queues/events.py

@@ -29,6 +29,7 @@ class APIRequests:
         self.stop_mission: QueueIO = QueueIO(input_size=1, output_size=1)
         self.pause_mission: QueueIO = QueueIO(input_size=1, output_size=1)
         self.resume_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.return_home: QueueIO = QueueIO(input_size=1, output_size=1)
 
 
 class StateMachineEvents:

{isar-1.26.4 → isar-1.27.1}/src/isar/models/communication/queues/queue_utils.py

@@ -30,3 +30,9 @@ def check_for_event(queue: Queue[T]) -> Optional[T]:
         return queue.get(block=False)
     except Empty:
         return None
+
+
+def check_for_event_without_consumption(queue: Queue[T]) -> bool:
+    return (
+        queue.qsize() != 0
+    )  # Queue size is not reliable, but should be sufficient for this case

{isar-1.26.4 → isar-1.27.1}/src/isar/modules.py

@@ -70,12 +70,19 @@ class ApplicationContainer(containers.DeclarativeContainer):
     )
 
     # Storage
-    local_storage = providers.Singleton(LocalStorage)
-    blob_storage = providers.Singleton(BlobStorage, keyvault=keyvault)
-    slimm_storage = providers.Singleton(
-        SlimmStorage, request_handler=providers.Singleton(RequestHandler)
-    )
-    storage_handlers = providers.List(local_storage, blob_storage, slimm_storage)
+    storage_handlers_temp = []
+    if settings.STORAGE_LOCAL_ENABLED:
+        local_storage = providers.Singleton(LocalStorage)
+        storage_handlers_temp.append(local_storage)
+    if settings.STORAGE_BLOB_ENABLED:
+        blob_storage = providers.Singleton(BlobStorage, keyvault=keyvault)
+        storage_handlers_temp.append(blob_storage)
+    if settings.STORAGE_SLIMM_ENABLED:
+        slimm_storage = providers.Singleton(
+            SlimmStorage, request_handler=providers.Singleton(RequestHandler)
+        )
+        storage_handlers_temp.append(slimm_storage)
+    storage_handlers = providers.List(*storage_handlers_temp)
 
     # Mqtt client
     mqtt_client = (

{isar-1.26.4 → isar-1.27.1}/src/isar/robot/robot.py

@@ -11,11 +11,12 @@ from isar.models.communication.queues.events import (
     SharedState,
     StateMachineEvents,
 )
-from isar.models.communication.queues.queue_utils import check_for_event
+from isar.models.communication.queues.queue_utils import check_for_event, trigger_event
 from isar.robot.robot_start_mission import RobotStartMissionThread
 from isar.robot.robot_status import RobotStatusThread
 from isar.robot.robot_stop_mission import RobotStopMissionThread
 from isar.robot.robot_task_status import RobotTaskStatusThread
+from robot_interface.models.exceptions.robot_exceptions import ErrorMessage, ErrorReason
 from robot_interface.robot_interface import RobotInterface
 
 
@@ -94,6 +95,14 @@ class Robot(object):
                 self.stop_mission_thread_thread is not None
                 and self.start_mission_thread.is_alive()
             ):
+                error_description = "Received stop mission event while trying to start a mission. Aborting stop attempt."
+                error_message = ErrorMessage(
+                    error_reason=ErrorReason.RobotStillStartingMissionException,
+                    error_description=error_description,
+                )
+                trigger_event(
+                    self.robot_service_events.mission_failed_to_stop, error_message
+                )
                 return
             self.stop_mission_thread_thread = RobotStopMissionThread(
                 self.robot_service_events, self.robot, self.signal_thread_quitting

{isar-1.26.4 → isar-1.27.1}/src/isar/robot/robot_status.py

@@ -5,6 +5,7 @@ from threading import Event, Thread
 from isar.config.settings import settings
 from isar.models.communication.queues.events import SharedState
 from isar.models.communication.queues.queue_utils import update_shared_state
+from robot_interface.models.exceptions.robot_exceptions import RobotException
 from robot_interface.robot_interface import RobotInterface
 
 
@@ -19,7 +20,9 @@ class RobotStatusThread(Thread):
         self.shared_state: SharedState = shared_state
         self.robot: RobotInterface = robot
         self.signal_thread_quitting: Event = signal_thread_quitting
-        self.last_robot_status_poll_time: float = time.time()
+        self.last_robot_status_poll_time: float = (
+            time.time() - settings.ROBOT_API_STATUS_POLL_INTERVAL
+        )
         Thread.__init__(self, name="Robot status thread")
 
     def stop(self) -> None:
@@ -40,9 +43,12 @@ class RobotStatusThread(Thread):
         while not self.signal_thread_quitting.wait(0.001):
             if not self._is_ready_to_poll_for_status():
                 continue
+            try:
+                robot_status = self.robot.robot_status()
 
-            robot_status = self.robot.robot_status()
-
-            update_shared_state(self.shared_state.robot_status, robot_status)
-            self.last_robot_status_poll_time = time.time()
+                update_shared_state(self.shared_state.robot_status, robot_status)
+                self.last_robot_status_poll_time = time.time()
+            except RobotException as e:
+                self.logger.error(f"Failed to retrieve robot status: {e}")
+                continue
         self.logger.info("Exiting robot status thread")

{isar-1.26.4 → isar-1.27.1}/src/isar/robot/robot_task_status.py

@@ -50,15 +50,15 @@ class RobotTaskStatusThread(Thread):
 
             try:
                 task_status = self.robot.task_status(self.task_id)
-                self.request_status_failure_counter = 0
+                request_status_failure_counter = 0
             except (
                 RobotCommunicationTimeoutException,
                 RobotCommunicationException,
             ) as e:
-                self.request_status_failure_counter += 1
+                request_status_failure_counter += 1
                 self.logger.error(
                     f"Failed to get task status "
-                    f"{self.request_status_failure_counter} times because: "
+                    f"{request_status_failure_counter} times because: "
                     f"{e.error_description}"
                 )
 

{isar-1.26.4 → isar-1.27.1}/src/isar/services/utilities/scheduling_utilities.py

@@ -119,19 +119,47 @@ class SchedulingUtilities:
         return True
 
     def verify_state_machine_ready_to_receive_mission(self, state: States) -> bool:
-        """Verify that the state machine is idle and ready to receive a mission
+        """Verify that the state machine is ready to receive a mission
 
         Raises
         ------
         HTTPException 409 Conflict
-            If state machine is not idle and therefore can not start a new mission
+            If state machine is not home, robot standing still, awaiting next mission
+            or returning home and therefore cannot start a new mission
         """
-        if state != States.Idle:
-            error_message = f"Conflict - Robot is not idle - State: {state}"
-            self.logger.warning(error_message)
-            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
+        if (
+            state == States.RobotStandingStill
+            or state == States.Home
+            or state == States.AwaitNextMission
+            or state == States.ReturningHome
+        ):
+            return True
 
-        return True
+        error_message = f"Conflict - Robot is not home, robot standing still, awaiting next mission or returning home - State: {state}"
+        self.logger.warning(error_message)
+        raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
+
+    def verify_state_machine_ready_to_receive_return_home_mission(
+        self, state: States
+    ) -> bool:
+        """Verify that the state machine is ready to receive a return home mission
+
+        Raises
+        ------
+        HTTPException 409 Conflict
+            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
+        ):
+            return True
+
+        error_message = f"Conflict - Robot is not home, robot standing still or awaiting next mission - State: {state}"
+        self.logger.warning(error_message)
+        raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
 
     def start_mission(
         self,
@@ -157,6 +185,31 @@ class SchedulingUtilities:
             )
         self.logger.info("OK - Mission started in ISAR")
 
+    def return_home(
+        self,
+    ) -> None:
+        """Start return home mission
+
+        Raises
+        ------
+        HTTTPException 408 Request timeout
+            If there is a timeout while communicating with the state machine
+        """
+        try:
+            self._send_command(
+                True,
+                self.api_events.return_home,
+            )
+        except QueueTimeoutError:
+            error_message = (
+                "Internal Server Error - Failed to start return home mission in ISAR"
+            )
+            self.logger.error(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            )
+        self.logger.info("OK - Return home mission started in ISAR")
+
     def pause_mission(self) -> ControlMissionResponse:
         """Pause mission