isar 1.25.9__py3-none-any.whl → 1.26.0__py3-none-any.whl

isar/apis/models/start_mission_definition.py

@@ -12,13 +12,14 @@ from robot_interface.models.mission.task import (
     TASKS,
     RecordAudio,
     ReturnToHome,
+    TakeGasMeasurement,
     TakeImage,
     TakeThermalImage,
     TakeThermalVideo,
     TakeVideo,
-    TakeGasMeasurement,
     ZoomDescription,
 )
+from robot_interface.utilities.uuid_string_factory import uuid4_string
 
 
 class InspectionTypes(str, Enum):
@@ -74,11 +75,11 @@ def to_isar_mission(
     if not isar_tasks:
         raise MissionPlannerError("Mission does not contain any valid tasks")
 
-    isar_mission_name: str
-    if start_mission_definition.name:
-        isar_mission_name = start_mission_definition.name
-    else:
-        isar_mission_name = _build_mission_name()
+    isar_mission_name: str = (
+        start_mission_definition.name
+        if start_mission_definition.name
+        else _build_mission_name()
+    )
 
     start_pose = None
     if start_mission_definition.start_pose:
@@ -106,113 +107,59 @@ def to_inspection_task(task_definition: StartMissionTaskDefinition) -> TASKS:
     inspection_definition = task_definition.inspection
 
     if inspection_definition.type == InspectionTypes.image:
-        if task_definition.id:
-            return TakeImage(
-                id=task_definition.id,
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                target=task_definition.inspection.inspection_target.to_alitra_position(),
-                metadata=task_definition.inspection.metadata,
-                zoom=task_definition.zoom,
-            )
-        else:
-            return TakeImage(
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                target=task_definition.inspection.inspection_target.to_alitra_position(),
-                metadata=task_definition.inspection.metadata,
-                zoom=task_definition.zoom,
-            )
+        return TakeImage(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            target=task_definition.inspection.inspection_target.to_alitra_position(),
+            metadata=task_definition.inspection.metadata,
+            zoom=task_definition.zoom,
+        )
     elif inspection_definition.type == InspectionTypes.video:
-        if task_definition.id:
-            return TakeVideo(
-                id=task_definition.id,
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                target=task_definition.inspection.inspection_target.to_alitra_position(),
-                duration=inspection_definition.duration,
-                metadata=task_definition.inspection.metadata,
-                zoom=task_definition.zoom,
-            )
-        else:
-            return TakeVideo(
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                target=task_definition.inspection.inspection_target.to_alitra_position(),
-                duration=inspection_definition.duration,
-                metadata=task_definition.inspection.metadata,
-                zoom=task_definition.zoom,
-            )
+        return TakeVideo(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            target=task_definition.inspection.inspection_target.to_alitra_position(),
+            duration=inspection_definition.duration,
+            metadata=task_definition.inspection.metadata,
+            zoom=task_definition.zoom,
+        )
     elif inspection_definition.type == InspectionTypes.thermal_image:
-        if task_definition.id:
-            return TakeThermalImage(
-                id=task_definition.id,
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                target=task_definition.inspection.inspection_target.to_alitra_position(),
-                metadata=task_definition.inspection.metadata,
-                zoom=task_definition.zoom,
-            )
-        else:
-            return TakeThermalImage(
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                target=task_definition.inspection.inspection_target.to_alitra_position(),
-                metadata=task_definition.inspection.metadata,
-                zoom=task_definition.zoom,
-            )
+        return TakeThermalImage(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            target=task_definition.inspection.inspection_target.to_alitra_position(),
+            metadata=task_definition.inspection.metadata,
+            zoom=task_definition.zoom,
+        )
     elif inspection_definition.type == InspectionTypes.thermal_video:
-        if task_definition.id:
-            return TakeThermalVideo(
-                id=task_definition.id,
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                target=task_definition.inspection.inspection_target.to_alitra_position(),
-                duration=inspection_definition.duration,
-                metadata=task_definition.inspection.metadata,
-                zoom=task_definition.zoom,
-            )
-        else:
-            return TakeThermalVideo(
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                target=task_definition.inspection.inspection_target.to_alitra_position(),
-                duration=inspection_definition.duration,
-                metadata=task_definition.inspection.metadata,
-                zoom=task_definition.zoom,
-            )
+        return TakeThermalVideo(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            target=task_definition.inspection.inspection_target.to_alitra_position(),
+            duration=inspection_definition.duration,
+            metadata=task_definition.inspection.metadata,
+            zoom=task_definition.zoom,
+        )
     elif inspection_definition.type == InspectionTypes.audio:
-        if task_definition.id:
-            return RecordAudio(
-                id=task_definition.id,
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                target=task_definition.inspection.inspection_target.to_alitra_position(),
-                duration=inspection_definition.duration,
-                metadata=task_definition.inspection.metadata,
-            )
-        else:
-            return RecordAudio(
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                target=task_definition.inspection.inspection_target.to_alitra_position(),
-                duration=inspection_definition.duration,
-                metadata=task_definition.inspection.metadata,
-            )
+        return RecordAudio(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            target=task_definition.inspection.inspection_target.to_alitra_position(),
+            duration=inspection_definition.duration,
+            metadata=task_definition.inspection.metadata,
+        )
     elif inspection_definition.type == InspectionTypes.gas_measurement:
-        if task_definition.id:
-            return TakeGasMeasurement(
-                id=task_definition.id,
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                metadata=task_definition.inspection.metadata,
-            )
-        else:
-            return TakeGasMeasurement(
-                robot_pose=task_definition.pose.to_alitra_pose(),
-                tag_id=task_definition.tag,
-                metadata=task_definition.inspection.metadata,
-            )
+        return TakeGasMeasurement(
+            id=task_definition.id if task_definition.id else uuid4_string(),
+            robot_pose=task_definition.pose.to_alitra_pose(),
+            tag_id=task_definition.tag,
+            metadata=task_definition.inspection.metadata,
+        )
     else:
         raise ValueError(
             f"Inspection type '{inspection_definition.type}' not supported"

isar/apis/robot_control/robot_controller.py

@@ -1,11 +1,12 @@
 import logging
 
+from fastapi import HTTPException
 from injector import inject
 
 from isar.apis.models.models import RobotInfoResponse
 from isar.config.settings import robot_settings, settings
 from isar.services.utilities.robot_utilities import RobotUtilities
-from fastapi import HTTPException
+from robot_interface.models.robots.media import MediaConfig
 
 
 class RobotController:
@@ -17,8 +18,8 @@ class RobotController:
         self.robot_utilities: RobotUtilities = robot_utilities
         self.logger = logging.getLogger("api")
 
-    def generate_media_config(self):
-        media_config = self.robot_utilities.generate_media_config()
+    def generate_media_config(self) -> MediaConfig:
+        media_config: MediaConfig = self.robot_utilities.generate_media_config()
         if media_config is None:
             raise HTTPException(
                 status_code=204,
@@ -26,7 +27,7 @@ class RobotController:
             )
         return media_config
 
-    def get_info(self):
+    def get_info(self) -> RobotInfoResponse:
         return RobotInfoResponse(
             robot_package=settings.ROBOT_PACKAGE,
             isar_id=settings.ISAR_ID,

isar/apis/schedule/scheduling_controller.py

@@ -8,9 +8,9 @@ from injector import inject
 
 from isar.apis.models.models import (
     ControlMissionResponse,
-    TaskResponse,
     InputPose,
     StartMissionResponse,
+    TaskResponse,
 )
 from isar.apis.models.start_mission_definition import (
     StartMissionDefinition,
@@ -45,12 +45,6 @@ class SchedulingController:
             title="Mission ID",
             description="ID-number for predefined mission",
         ),
-        initial_pose: Optional[InputPose] = Body(
-            default=None,
-            description="The starting point of the mission. Used for initial "
-            "localization of robot",
-            embed=True,
-        ),
         return_pose: Optional[InputPose] = Body(
             default=None,
             description="End pose of the mission. The robot return to the specified "
@@ -72,15 +66,9 @@ class SchedulingController:
             mission=mission, robot_capabilities=robot_settings.CAPABILITIES
         )
 
-        initial_pose_alitra: Optional[Pose] = (
-            initial_pose.to_alitra_pose() if initial_pose else None
-        )
-
         self.logger.info(f"Starting mission with ISAR Mission ID: '{mission.id}'")
 
-        self.scheduling_utilities.start_mission(
-            mission=mission, initial_pose=initial_pose_alitra
-        )
+        self.scheduling_utilities.start_mission(mission=mission)
 
         return self._api_response(mission)
 
@@ -92,12 +80,6 @@ class SchedulingController:
             title="Mission Definition",
             description="Description of the mission in json format",
         ),
-        initial_pose: Optional[InputPose] = Body(
-            default=None,
-            description="The starting point of the mission. Used for initial "
-            "localization of robot",
-            embed=True,
-        ),
         return_pose: Optional[InputPose] = Body(
             default=None,
             description="End pose of the mission. The robot return to the specified "
@@ -135,14 +117,8 @@ class SchedulingController:
             mission=mission, robot_capabilities=robot_settings.CAPABILITIES
         )
 
-        initial_pose_alitra: Optional[Pose] = (
-            initial_pose.to_alitra_pose() if initial_pose else None
-        )
-
         self.logger.info(f"Starting mission: {mission.id}")
-        self.scheduling_utilities.start_mission(
-            mission=mission, initial_pose=initial_pose_alitra
-        )
+        self.scheduling_utilities.start_mission(mission=mission)
         return self._api_response(mission)
 
     def pause_mission(self) -> ControlMissionResponse:
@@ -152,7 +128,6 @@ class SchedulingController:
 
         if state not in [
             States.Monitor,
-            States.Initiate,
         ]:
             error_message = (
                 f"Conflict - Pause command received in invalid state - State: {state}"
@@ -245,10 +220,7 @@ class SchedulingController:
         self.logger.info(
             f"Starting move arm mission with ISAR Mission ID: '{mission.id}'"
         )
-        self.scheduling_utilities.start_mission(
-            mission=mission,
-            initial_pose=None,
-        )
+        self.scheduling_utilities.start_mission(mission=mission)
         return self._api_response(mission)
 
     def _api_response(self, mission: Mission) -> StartMissionResponse:

isar/apis/security/authentication.py

@@ -50,7 +50,7 @@ class Authenticator:
         enabled_string = "enabled" if self.authentication_enabled else "disabled"
         self.logger.info(f"API authentication is {enabled_string}")
 
-    def should_authenticate(self):
+    def should_authenticate(self) -> bool:
         return self.authentication_enabled
 
     def get_scheme(self):
@@ -58,7 +58,7 @@ class Authenticator:
             return validate_has_role
         return NoSecurity
 
-    async def load_config(self):
+    async def load_config(self) -> None:
         """
         Load OpenID config on startup.
         """

isar/config/settings.env

@@ -1,7 +1,5 @@
 ISAR_ROBOT_PACKAGE = isar_robot
 
-ISAR_RUN_MISSION_BY_TASK = true
-
 ISAR_STORAGE_LOCAL_ENABLED = true
 ISAR_STORAGE_BLOB_ENABLED = false
 ISAR_STORAGE_SLIMM_ENABLED = false
@@ -12,7 +10,7 @@ ISAR_LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED = false
 ISAR_MQTT_ENABLED = true
 ISAR_MQTT_SSL_ENABLED = true
 
-ISAR_AUTHENTICATION_ENABLED = false
+ISAR_AUTHENTICATION_ENABLED = true
 
 ISAR_PLANT_SHORT_NAME = HUA
 

isar/config/settings.py

@@ -62,7 +62,7 @@ class Settings(BaseSettings):
     REQUEST_STATUS_COMMUNICATION_RECONNECT_DELAY: float = Field(default=10)
 
     # Number of attempts to stop the robot before giving up
-    STOP_ROBOT_ATTEMPTS_LIMIT: int = Field(default=10)
+    STOP_ROBOT_ATTEMPTS_LIMIT: int = Field(default=3)
 
     # Number of attempts to stop the robot before giving up
     UPLOAD_FAILURE_ATTEMPTS_LIMIT: int = Field(default=10)
@@ -111,7 +111,7 @@ class Settings(BaseSettings):
     # Enabling this requires certain resources available for OAuth2 authentication
     # Currently supported authentication is Azure AD
     # (https://github.com/Intility/fastapi-azure-auth)
-    AUTHENTICATION_ENABLED: bool = Field(default=False)
+    AUTHENTICATION_ENABLED: bool = Field(default=True)
 
     # Tenant ID for the Azure tenant with your Azure Active Directory application
     AZURE_TENANT_ID: str = Field(default="3aa4a235-b6e2-48d5-9195-7fcf05b459b0")
@@ -169,13 +169,13 @@ class Settings(BaseSettings):
     # submitted with the results once they have been uploaded.
 
     # Four digit code indicating facility
-    PLANT_CODE: str = Field(default="1320")
+    PLANT_CODE: str = Field(default="1210")
 
     # Name of the facility the robot is operating in
-    PLANT_NAME: str = Field(default="Kårstø")
+    PLANT_NAME: str = Field(default="Huldra")
 
     # Shortname of the facility the robot is operating in
-    PLANT_SHORT_NAME: str = Field(default="KAA")
+    PLANT_SHORT_NAME: str = Field(default="HUA")
 
     # Country the robot is operating in
     COUNTRY: str = Field(default="Norway")

isar/models/communication/message.py

@@ -1,7 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
-
-from alitra import Pose
 
 from robot_interface.models.mission.mission import Mission
 
@@ -9,4 +6,3 @@ from robot_interface.models.mission.mission import Mission
 @dataclass
 class StartMissionMessage:
     mission: Mission
-    initial_pose: Optional[Pose]

isar/models/communication/queues/queue_utils.py

@@ -0,0 +1,27 @@
+import queue
+from typing import Any
+
+from isar.models.communication.queues.queue_io import QueueIO
+from isar.models.communication.queues.status_queue import StatusQueue
+
+
+def trigger_event(queueio: QueueIO, data: Any = None) -> None:
+    queueio.input.put(data if data is not None else True)
+
+
+def check_shared_state(queueio: StatusQueue) -> Any:
+    try:
+        return queueio.check()
+    except queue.Empty:
+        return None
+
+
+def update_shared_state(queueio: StatusQueue, data: Any = None) -> None:
+    queueio.update(data if data is not None else True)
+
+
+def check_for_event(queueio: QueueIO) -> Any:
+    try:
+        return queueio.input.get(block=False)
+    except queue.Empty:
+        return None

isar/models/communication/queues/queues.py

@@ -7,13 +7,31 @@ from isar.models.communication.queues.status_queue import StatusQueue
 
 class Queues:
     def __init__(self) -> None:
-        self.start_mission: QueueIO = QueueIO(input_size=1, output_size=1)
-        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.single_action: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.api_start_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.api_stop_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.api_pause_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.api_resume_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+
+        self.state_machine_start_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.state_machine_stop_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.state_machine_pause_mission: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.state_machine_task_status_request: QueueIO = QueueIO(
+            input_size=1, output_size=1
+        )
+        self.state_machine_robot_status_request: QueueIO = QueueIO(
+            input_size=1, output_size=1
+        )
+        self.state_machine_current_task: StatusQueue = StatusQueue()
+
+        self.robot_task_status: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.robot_task_status_failed: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.robot_mission_started: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.robot_mission_failed: QueueIO = QueueIO(input_size=1, output_size=1)
+        self.robot_status_changed: QueueIO = QueueIO(input_size=1, output_size=1)
+
         self.upload_queue: Queue = Queue(maxsize=10)
         self.state: StatusQueue = StatusQueue()
+        self.robot_status: StatusQueue = StatusQueue()
 
         if settings.MQTT_ENABLED:
             self.mqtt_queue: Queue = Queue()

isar/robot/robot.py

@@ -0,0 +1,91 @@
+import logging
+from threading import Event
+from typing import Optional
+
+from injector import inject
+
+from isar.models.communication.queues.queue_io import QueueIO
+from isar.models.communication.queues.queue_utils import check_for_event
+from isar.models.communication.queues.queues import Queues
+from isar.robot.robot_start_mission import RobotStartMissionThread
+from isar.robot.robot_status import RobotStatusThread
+from isar.robot.robot_task_status import RobotTaskStatusThread
+from robot_interface.robot_interface import RobotInterface
+
+
+class Robot(object):
+
+    @inject
+    def __init__(self, queues: Queues, robot: RobotInterface):
+        self.logger = logging.getLogger("robot")
+        self.queues: Queues = queues
+        self.robot: RobotInterface = robot
+        self.start_mission_thread: Optional[RobotStartMissionThread] = None
+        self.robot_status_thread: Optional[RobotStatusThread] = None
+        self.robot_task_status_thread: Optional[RobotTaskStatusThread] = None
+        self.signal_thread_quitting: Event = Event()
+
+    def stop(self) -> None:
+        self.signal_thread_quitting.set()
+        if self.robot_status_thread is not None and self.robot_status_thread.is_alive():
+            self.robot_status_thread.join()
+        if (
+            self.robot_task_status_thread is not None
+            and self.robot_status_thread.is_alive()
+        ):
+            self.robot_task_status_thread.join()
+        if (
+            self.start_mission_thread is not None
+            and self.robot_status_thread.is_alive()
+        ):
+            self.start_mission_thread.join()
+        self.robot_status_thread = None
+        self.robot_task_status_thread = None
+        self.start_mission_thread = None
+
+    def _check_and_handle_start_mission(self, queue: QueueIO) -> None:
+        start_mission = check_for_event(queue)
+        if start_mission is not None:
+            if (
+                self.start_mission_thread is not None
+                and self.start_mission_thread.is_alive()
+            ):
+                self.logger.warning(
+                    "Attempted to start mission while another mission was starting."
+                )
+                self.start_mission_thread.join()
+            self.start_mission_thread = RobotStartMissionThread(
+                self.queues,
+                self.robot,
+                self.signal_thread_quitting,
+                start_mission,
+            )
+            self.start_mission_thread.start()
+
+    def _check_and_handle_task_status_request(self, queue: QueueIO) -> None:
+        task_id = check_for_event(queue)
+        if task_id:
+            self.robot_task_status_thread = RobotTaskStatusThread(
+                self.queues, self.robot, self.signal_thread_quitting, task_id
+            )
+            self.robot_task_status_thread.start()
+
+    def run(self) -> None:
+        self.robot_status_thread = RobotStatusThread(
+            self.queues, self.robot, self.signal_thread_quitting
+        )
+        self.robot_status_thread.start()
+
+        while True:
+            if self.signal_thread_quitting.is_set():
+                break
+
+            self._check_and_handle_start_mission(
+                self.queues.state_machine_start_mission
+            )
+
+            self._check_and_handle_task_status_request(
+                self.queues.state_machine_task_status_request
+            )
+
+        self.logger.info("Exiting robot service main thread")

isar/robot/robot_start_mission.py

@@ -0,0 +1,73 @@
+import logging
+from threading import Event, Thread
+from typing import Optional
+
+from isar.config.settings import settings
+from isar.models.communication.queues.queue_utils import trigger_event
+from isar.models.communication.queues.queues import Queues
+from isar.services.utilities.threaded_request import ThreadedRequest
+from robot_interface.models.exceptions.robot_exceptions import (
+    ErrorMessage,
+    RobotException,
+    RobotInfeasibleMissionException,
+)
+from robot_interface.models.mission.mission import Mission
+from robot_interface.robot_interface import RobotInterface
+
+
+class RobotStartMissionThread(Thread):
+
+    def __init__(
+        self,
+        queues: Queues,
+        robot: RobotInterface,
+        signal_thread_quitting: Event,
+        mission: Mission,
+    ):
+        self.logger = logging.getLogger("robot")
+        self.queues: Queues = queues
+        self.robot: RobotInterface = robot
+        self.start_mission_thread: Optional[ThreadedRequest] = None
+        self.signal_thread_quitting: Event = signal_thread_quitting
+        self.mission = mission
+        Thread.__init__(self, name="Robot start mission thread")
+
+    def run(self):
+        retries = 0
+        started_mission = False
+        try:
+            while not started_mission:
+                if self.signal_thread_quitting.wait(0):
+                    return
+                try:
+                    self.robot.initiate_mission(self.mission)
+                except RobotException as e:
+                    retries += 1
+                    self.logger.warning(
+                        f"Initiating failed #: {str(retries)} "
+                        f"because: {e.error_description}"
+                    )
+
+                    if retries >= settings.INITIATE_FAILURE_COUNTER_LIMIT:
+                        error_description = (
+                            f"Mission will be cancelled after failing to initiate "
+                            f"{settings.INITIATE_FAILURE_COUNTER_LIMIT} times because: "
+                            f"{e.error_description}"
+                        )
+
+                        trigger_event(
+                            self.queues.robot_mission_failed,
+                            ErrorMessage(
+                                error_reason=e.error_reason,
+                                error_description=error_description,
+                            ),
+                        )
+                started_mission = True
+        except RobotInfeasibleMissionException as e:
+            trigger_event(
+                self.queues.robot_mission_failed,
+                ErrorMessage(
+                    error_reason=e.error_reason, error_description=e.error_description
+                ),
+            )
+        trigger_event(self.queues.robot_mission_started)