isar 1.22.4__tar.gz → 1.23.1__tar.gz

{isar-1.22.4 → isar-1.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: isar
-Version: 1.22.4
+Version: 1.23.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

{isar-1.22.4 → isar-1.23.1}/src/isar/apis/api.py

@@ -213,6 +213,7 @@ class API:
             methods=["POST"],
             dependencies=[authentication_dependency],
             summary="Drive to the provided pose",
+            deprecated=True,
             responses={
                 HTTPStatus.OK.value: {
                     "description": "Drive to succesfully started",

{isar-1.22.4 → isar-1.23.1}/src/isar/apis/models/models.py

@@ -3,16 +3,13 @@ from typing import List, Optional
 from alitra import Frame, Orientation, Pose, Position
 from pydantic import BaseModel, Field
 
-
-class StepResponse(BaseModel):
-    id: str
-    type: str
+from robot_interface.models.mission.task import TaskTypes
 
 
 class TaskResponse(BaseModel):
     id: str
     tag_id: Optional[str] = None
-    steps: List[StepResponse]
+    type: TaskTypes
 
 
 class StartMissionResponse(BaseModel):
@@ -25,8 +22,6 @@ class ControlMissionResponse(BaseModel):
     mission_status: str
     task_id: str
     task_status: str
-    step_id: str
-    step_status: str
 
 
 class RobotInfoResponse(BaseModel):

isar-1.23.1/src/isar/apis/models/start_mission_definition.py

@@ -0,0 +1,226 @@
+import time
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from alitra import Frame, Orientation, Pose, Position
+from pydantic import BaseModel, Field
+
+from isar.apis.models.models import InputPose, InputPosition
+from isar.config.settings import settings
+from isar.mission_planner.mission_planner_interface import MissionPlannerError
+from robot_interface.models.inspection.inspection import Inspection, InspectionMetadata
+from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.task import (
+    TASKS,
+    DockingProcedure,
+    Localize,
+    RecordAudio,
+    ReturnToHome,
+    TakeImage,
+    TakeThermalImage,
+    TakeThermalVideo,
+    TakeVideo,
+)
+from robot_interface.models.mission.task import Task
+
+
+class InspectionTypes(str, Enum):
+    image: str = "Image"
+    thermal_image: str = "ThermalImage"
+    video: str = "Video"
+    thermal_video: str = "ThermalVideo"
+    audio: str = "Audio"
+
+
+class TaskType(str, Enum):
+    Inspection: str = "inspection"
+    Localization: str = "localization"
+    ReturnToHome: str = "return_to_home"
+    Dock: str = "dock"
+
+
+class StartMissionInspectionDefinition(BaseModel):
+    type: InspectionTypes = Field(default=InspectionTypes.image)
+    inspection_target: InputPosition
+    analysis_type: Optional[str] = None
+    duration: Optional[float] = None
+    metadata: Optional[dict] = None
+    id: Optional[str] = None
+
+
+class StartMissionTaskDefinition(BaseModel):
+    type: TaskType = Field(default=TaskType.Inspection)
+    pose: InputPose
+    inspection: StartMissionInspectionDefinition
+    tag: Optional[str] = None
+    id: Optional[str] = None
+
+
+class StartMissionDefinition(BaseModel):
+    tasks: List[StartMissionTaskDefinition]
+    id: Optional[str] = None
+    name: Optional[str] = None
+    start_pose: Optional[InputPose] = None
+    dock: Optional[bool] = None
+    undock: Optional[bool] = None
+
+
+def to_isar_mission(start_mission_definition: StartMissionDefinition) -> Mission:
+    isar_tasks: List[TASKS] = []
+
+    for start_mission_task_definition in start_mission_definition.tasks:
+        task: TASKS = create_isar_task(start_mission_task_definition)
+        if start_mission_task_definition.id:
+            task.id = start_mission_task_definition.id
+        isar_tasks.append(task)
+
+    if not isar_tasks:
+        raise MissionPlannerError("Mission does not contain any valid tasks")
+
+    check_for_duplicate_ids(isar_tasks)
+
+    isar_mission: Mission = Mission(tasks=isar_tasks)
+
+    isar_mission.dock = start_mission_definition.dock
+    isar_mission.undock = start_mission_definition.undock
+
+    if start_mission_definition.name:
+        isar_mission.name = start_mission_definition.name
+    else:
+        isar_mission.name = _build_mission_name()
+
+    if start_mission_definition.id:
+        isar_mission.id = start_mission_definition.id
+
+    if start_mission_definition.start_pose:
+        input_pose: InputPose = start_mission_definition.start_pose
+        input_frame: Frame = Frame(name=input_pose.frame_name)
+        input_position: Position = Position(
+            input_pose.position.x,
+            input_pose.position.y,
+            input_pose.position.z,
+            input_frame,
+        )
+        input_orientation: Orientation = Orientation(
+            input_pose.orientation.x,
+            input_pose.orientation.y,
+            input_pose.orientation.z,
+            input_pose.orientation.w,
+            input_frame,
+        )
+        isar_mission.start_pose = Pose(
+            position=input_position, orientation=input_orientation, frame=input_frame
+        )
+
+    return isar_mission
+
+
+def check_for_duplicate_ids(items: List[TASKS]):
+    duplicate_ids = get_duplicate_ids(items=items)
+    if len(duplicate_ids) > 0:
+        raise MissionPlannerError(
+            f"Failed to create as there were duplicate IDs which is not allowed "
+            f"({duplicate_ids})"
+        )
+
+
+def create_isar_task(start_mission_task_definition) -> TASKS:
+
+    if start_mission_task_definition.type == TaskType.Inspection:
+        return create_inspection_task(start_mission_task_definition)
+    elif start_mission_task_definition.type == TaskType.Localization:
+        return create_localization_task(start_mission_task_definition)
+    elif start_mission_task_definition.type == TaskType.ReturnToHome:
+        return create_return_to_home_task(start_mission_task_definition)
+    elif start_mission_task_definition.type == TaskType.Dock:
+        return create_dock_task()
+    else:
+        raise MissionPlannerError(
+            f"Failed to create task: '{start_mission_task_definition.type}' is not a valid"
+        )
+
+
+def create_inspection_task(
+    start_mission_task_definition: StartMissionTaskDefinition,
+) -> TASKS:
+
+    if start_mission_task_definition.inspection.type == InspectionTypes.image:
+        return TakeImage(
+            target=start_mission_task_definition.inspection.inspection_target.to_alitra_position(),
+            tag_id=start_mission_task_definition.tag,
+            robot_pose=start_mission_task_definition.pose.to_alitra_pose(),
+            metadata=start_mission_task_definition.inspection.metadata,
+        )
+    elif start_mission_task_definition.inspection.type == InspectionTypes.video:
+        return TakeVideo(
+            target=start_mission_task_definition.inspection.inspection_target.to_alitra_position(),
+            duration=start_mission_task_definition.inspection.duration,
+            tag_id=start_mission_task_definition.tag,
+            robot_pose=start_mission_task_definition.pose.to_alitra_pose(),
+            metadata=start_mission_task_definition.inspection.metadata,
+        )
+
+    elif start_mission_task_definition.inspection.type == InspectionTypes.thermal_image:
+        return TakeThermalImage(
+            target=start_mission_task_definition.inspection.inspection_target.to_alitra_position(),
+            tag_id=start_mission_task_definition.tag,
+            robot_pose=start_mission_task_definition.pose.to_alitra_pose(),
+            metadata=start_mission_task_definition.inspection.metadata,
+        )
+
+    elif start_mission_task_definition.inspection.type == InspectionTypes.thermal_video:
+        return TakeThermalVideo(
+            target=start_mission_task_definition.inspection.inspection_target.to_alitra_position(),
+            duration=start_mission_task_definition.inspection.duration,
+            tag_id=start_mission_task_definition.tag,
+            robot_pose=start_mission_task_definition.pose.to_alitra_pose(),
+            metadata=start_mission_task_definition.inspection.metadata,
+        )
+
+    elif start_mission_task_definition.inspection.type == InspectionTypes.audio:
+        return RecordAudio(
+            target=start_mission_task_definition.inspection.inspection_target.to_alitra_position(),
+            duration=start_mission_task_definition.inspection.duration,
+            tag_id=start_mission_task_definition.tag,
+            robot_pose=start_mission_task_definition.pose.to_alitra_pose(),
+            metadata=start_mission_task_definition.inspection.metadata,
+        )
+    else:
+        raise ValueError(
+            f"Inspection type '{start_mission_task_definition.inspection.type}' not supported"
+        )
+
+
+def create_localization_task(
+    start_mission_task_definition: StartMissionTaskDefinition,
+) -> Localize:
+    return Localize(
+        localization_pose=start_mission_task_definition.pose.to_alitra_pose()
+    )
+
+
+def create_return_to_home_task(
+    start_mission_task_definition: StartMissionTaskDefinition,
+) -> ReturnToHome:
+    return ReturnToHome(pose=start_mission_task_definition.pose.to_alitra_pose())
+
+
+def create_dock_task() -> DockingProcedure:
+    return DockingProcedure(behavior="dock")
+
+
+def get_duplicate_ids(items: List[TASKS]) -> List[str]:
+    unique_ids: List[str] = []
+    duplicate_ids: List[str] = []
+    for item in items:
+        id: str = item.id
+        if id not in unique_ids:
+            unique_ids.append(id)
+        else:
+            duplicate_ids.append(id)
+
+    return duplicate_ids
+
+
+def _build_mission_name() -> str:
+    return f"{settings.PLANT_SHORT_NAME}{settings.ROBOT_NAME}{int(time.time())}"

{isar-1.22.4 → isar-1.23.1}/src/isar/apis/schedule/scheduling_controller.py

@@ -1,6 +1,6 @@
 import logging
 from http import HTTPStatus
-from typing import List, Optional
+from typing import Optional
 
 from alitra import Pose
 from fastapi import Body, HTTPException, Path
@@ -21,8 +21,8 @@ from isar.mission_planner.mission_planner_interface import MissionPlannerError
 from isar.services.utilities.scheduling_utilities import SchedulingUtilities
 from isar.state_machine.states_enum import States
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.step import (
-    DriveToPose,
+from robot_interface.models.mission.task import (
+    TASKS,
     Localize,
     MoveArm,
     ReturnToHome,
@@ -67,8 +67,7 @@ class SchedulingController:
         mission: Mission = self.scheduling_utilities.get_mission(mission_id)
         if return_pose:
             pose: Pose = return_pose.to_alitra_pose()
-            step: DriveToPose = DriveToPose(pose=pose)
-            mission.tasks.append(Task(steps=[step]))
+            mission.tasks.append(ReturnToHome(pose=pose))
 
         self.scheduling_utilities.verify_robot_capable_of_mission(
             mission=mission, robot_capabilities=robot_settings.CAPABILITIES
@@ -136,8 +135,7 @@ class SchedulingController:
         )
         if return_pose:
             pose: Pose = return_pose.to_alitra_pose()
-            step: DriveToPose = DriveToPose(pose=pose)
-            mission.tasks.append(Task(steps=[step]))
+            mission.tasks.append(ReturnToHome(pose=pose))
 
         initial_pose_alitra: Optional[Pose] = (
             initial_pose.to_alitra_pose() if initial_pose else None
@@ -211,7 +209,7 @@ class SchedulingController:
         target_pose: InputPose = Body(
             default=None,
             title="Target Pose",
-            description="The target pose for the drive_to step",
+            description="The target pose for the drive_to task",
         ),
     ) -> StartMissionResponse:
         self.logger.info("Received request to start new drive-to mission")
@@ -221,8 +219,7 @@ class SchedulingController:
         self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
 
         pose: Pose = target_pose.to_alitra_pose()
-        step: DriveToPose = DriveToPose(pose=pose)
-        mission: Mission = Mission(tasks=[Task(steps=[step])])
+        mission: Mission = Mission(tasks=[ReturnToHome(pose=pose)])
 
         self.logger.info(
             f"Starting drive to mission with ISAR Mission ID: '{mission.id}'"
@@ -246,8 +243,7 @@ class SchedulingController:
         self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
 
         pose: Pose = localization_pose.to_alitra_pose()
-        step: Localize = Localize(localization_pose=pose)
-        mission: Mission = Mission(tasks=[Task(steps=[step])])
+        mission: Mission = Mission(tasks=[Localize(localization_pose=pose)])
 
         self.logger.info(
             f"Starting localization mission with ISAR Mission ID: '{mission.id}'"
@@ -294,8 +290,7 @@ class SchedulingController:
 
         self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
 
-        step: MoveArm = MoveArm(arm_pose=arm_pose_literal)
-        mission: Mission = Mission(tasks=[Task(steps=[step])])
+        mission: Mission = Mission(tasks=[MoveArm(arm_pose=arm_pose_literal)])
 
         self.logger.info(
             f"Starting move arm mission with ISAR Mission ID: '{mission.id}'"
@@ -322,9 +317,5 @@ class SchedulingController:
             tasks=[self._task_api_response(task) for task in mission.tasks],
         )
 
-    def _task_api_response(self, task: Task) -> TaskResponse:
-        steps: List[dict] = []
-        for step in task.steps:
-            steps.append({"id": step.id, "type": step.__class__.__name__})
-
-        return TaskResponse(id=task.id, tag_id=task.tag_id, steps=steps)
+    def _task_api_response(self, task: TASKS) -> TaskResponse:
+        return TaskResponse(id=task.id, tag_id=task.tag_id, type=task.type)

isar-1.23.1/src/isar/config/predefined_missions/default.json

@@ -0,0 +1,74 @@
+{
+  "id": "1",
+  "tasks": [
+    {
+      "type": "take_image",
+      "robot_pose": {
+        "position": {
+          "x": -2,
+          "y": -2,
+          "z": 0,
+          "frame": "asset"
+        },
+        "orientation": {
+          "x": 0,
+          "y": 0,
+          "z": 0.4794255,
+          "w": 0.8775826,
+          "frame": "asset"
+        },
+        "frame": "asset"
+      },
+      "target": {
+        "x": 2,
+        "y": 2,
+        "z": 0,
+        "frame": "robot"
+      }
+    },
+    {
+      "type": "take_thermal_image",
+      "robot_pose": {
+        "position": {
+          "x": -2,
+          "y": 2,
+          "z": 0,
+          "frame": "asset"
+        },
+        "orientation": {
+          "x": 0,
+          "y": 0,
+          "z": 0.4794255,
+          "w": 0.8775826,
+          "frame": "asset"
+        },
+        "frame": "asset"
+      },
+      "target": {
+        "x": 2,
+        "y": 2,
+        "z": 0,
+        "frame": "robot"
+      }
+    },
+    {
+      "type": "return_to_home",
+      "pose": {
+        "position": {
+          "x": 2,
+          "y": 2,
+          "z": 0,
+          "frame": "asset"
+        },
+        "orientation": {
+          "x": 0,
+          "y": 0,
+          "z": 0.4794255,
+          "w": 0.8775826,
+          "frame": "asset"
+        },
+        "frame": "asset"
+      }
+    }
+  ]
+}

isar-1.23.1/src/isar/config/predefined_missions/default_turtlebot.json

@@ -0,0 +1,106 @@
+{
+  "id": "2",
+  "tasks": [
+    {
+      "type": "take_image",
+      "robot_pose": {
+        "position": {
+          "x": -3.6,
+          "y": 4,
+          "z": 0,
+          "frame": "asset"
+        },
+        "orientation": {
+          "x": 0,
+          "y": 0,
+          "z": -0.7286672256879113,
+          "w": -0.6848660759820616,
+          "frame": "asset"
+        },
+        "frame": "asset"
+      },
+      "target": {
+        "x": -4.7,
+        "y": 4.9,
+        "z": 0,
+        "frame": "robot"
+      }
+    },
+
+    {
+      "type": "take_image",
+      "robot_pose": {
+        "position": {
+          "x": 4.7,
+          "y": 3,
+          "z": 0,
+          "frame": "asset"
+        },
+        "orientation": {
+          "x": 0,
+          "y": 0,
+          "z": 0.5769585,
+          "w": 0.8167734,
+          "frame": "asset"
+        },
+        "frame": "asset"
+      },
+      "target": {
+        "x": 5.6,
+        "y": 5.2,
+        "z": 0,
+        "frame": "robot"
+      }
+    },
+    {
+      "type": "take_thermal_image",
+      "robot_pose": {
+        "position": {
+          "x": 4.7,
+          "y": 3,
+          "z": 0,
+          "frame": "asset"
+        },
+        "orientation": {
+          "x": 0,
+          "y": 0,
+          "z": 0.5769585,
+          "w": 0.8167734,
+          "frame": "asset"
+        },
+        "frame": "asset"
+      },
+      "target": {
+        "x": 3.1,
+        "y": 5.2,
+        "z": 0,
+        "frame": "robot"
+      }
+    },
+    {
+      "type": "take_thermal_image",
+      "robot_pose": {
+        "position": {
+          "x": 0.95,
+          "y": 2.6,
+          "z": 0,
+          "frame": "asset"
+        },
+        "orientation": {
+          "x": 0,
+          "y": 0,
+          "z": -0.6992469,
+          "w": 0.7148802,
+          "frame": "asset"
+        },
+        "frame": "asset"
+      },
+      "target": {
+        "x": 1.9,
+        "y": 1.9,
+        "z": 0,
+        "frame": "robot"
+      }
+    }
+  ]
+}

{isar-1.22.4 → isar-1.23.1}/src/isar/config/settings.env

@@ -1,6 +1,6 @@
 ISAR_ROBOT_PACKAGE = isar_robot
 
-ISAR_RUN_MISSION_STEPWISE = true
+ISAR_RUN_MISSION_BY_TASK = true
 
 ISAR_STORAGE_LOCAL_ENABLED = true
 ISAR_STORAGE_BLOB_ENABLED = false

{isar-1.22.4 → isar-1.23.1}/src/isar/config/settings.py

@@ -26,7 +26,7 @@ class Settings(BaseSettings):
     ROBOT_PACKAGE: str = Field(default="isar_robot")
 
     # The run mode of the robot (stepwise or full mission)
-    RUN_MISSION_STEPWISE: bool = Field(default=True)
+    RUN_MISSION_BY_TASK: bool = Field(default=True)
 
     # Determines the local path in which results from missions are stored
     LOCAL_STORAGE_PATH: str = Field(default="./results")
@@ -327,7 +327,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=["drive_to_pose", "take_image"])
+    CAPABILITIES: List[str] = Field(default=["return_to_home", "take_image"])
 
     # Model of the robot which ISAR is connected to
     # This should be set in the robot package settings.env file
@@ -345,6 +345,6 @@ class RobotSettings(BaseSettings):
 
 robot_settings = RobotSettings()
 
-if not settings.RUN_MISSION_STEPWISE:  # If mission-wise, do not run localize missions
+if not settings.RUN_MISSION_BY_TASK:  # If mission-wise, do not run localize missions
     if "localize" in robot_settings.CAPABILITIES:
         robot_settings.CAPABILITIES.remove("localize")

{isar-1.22.4 → isar-1.23.1}/src/isar/mission_planner/local_planner.py

@@ -1,5 +1,6 @@
 import logging
 from pathlib import Path
+from typing import List, Optional
 
 from alitra import Frame
 from injector import inject
@@ -13,6 +14,7 @@ from isar.mission_planner.mission_planner_interface import (
 from isar.services.readers.base_reader import BaseReader, BaseReaderError
 from robot_interface.models.mission.mission import Mission
 
+
 logger = logging.getLogger("api")
 
 
@@ -38,6 +40,7 @@ class LocalPlanner(MissionPlannerInterface):
     @staticmethod
     def read_mission_from_file(mission_path: Path) -> Mission:
         mission_dict: dict = BaseReader.read_json(location=mission_path)
+
         mission: Mission = BaseReader.dict_to_dataclass(
             dataclass_dict=mission_dict,
             target_dataclass=Mission,

{isar-1.22.4 → isar-1.23.1}/src/isar/mission_planner/sequential_task_selector.py

@@ -4,7 +4,7 @@ from isar.mission_planner.task_selector_interface import (
     TaskSelectorInterface,
     TaskSelectorStop,
 )
-from robot_interface.models.mission.task import Task
+from robot_interface.models.mission.task import TASKS, Task
 
 
 class SequentialTaskSelector(TaskSelectorInterface):
@@ -12,11 +12,11 @@ class SequentialTaskSelector(TaskSelectorInterface):
         super().__init__()
         self._iterator: Iterator = None
 
-    def initialize(self, tasks: List[Task]) -> None:
+    def initialize(self, tasks: List[TASKS]) -> None:
         super().initialize(tasks=tasks)
         self._iterator = iter(self.tasks)
 
-    def next_task(self) -> Task:
+    def next_task(self) -> TASKS:
         try:
             return next(self._iterator)
         except StopIteration:

{isar-1.22.4 → isar-1.23.1}/src/isar/mission_planner/task_selector_interface.py

@@ -1,18 +1,18 @@
 from abc import ABCMeta, abstractmethod
 from typing import List
 
-from robot_interface.models.mission.task import Task
+from robot_interface.models.mission.task import TASKS, Task
 
 
 class TaskSelectorInterface(metaclass=ABCMeta):
     def __init__(self) -> None:
-        self.tasks: List[Task] = None
+        self.tasks: List[TASKS] = None
 
-    def initialize(self, tasks: List[Task]) -> None:
+    def initialize(self, tasks: List[TASKS]) -> None:
         self.tasks = tasks
 
     @abstractmethod
-    def next_task(self) -> Task:
+    def next_task(self) -> TASKS:
         """
         Returns
         -------

{isar-1.22.4 → isar-1.23.1}/src/isar/script.py

@@ -63,7 +63,7 @@ def print_startup_info():
     print_setting(fillchar="-")
     print_setting("Robot package", settings.ROBOT_PACKAGE)
     print_setting("Robot name", settings.ROBOT_NAME)
-    print_setting("Run mission stepwise", settings.RUN_MISSION_STEPWISE)
+    print_setting("Run mission stepwise", settings.RUN_MISSION_BY_TASK)
     print_setting("Running on port", settings.API_PORT)
     print_setting("Mission planner", settings.MISSION_PLANNER)
     print_setting("Using local storage", settings.STORAGE_LOCAL_ENABLED)

{isar-1.22.4 → isar-1.23.1}/src/isar/services/service_connections/mqtt/mqtt_client.py

@@ -99,7 +99,7 @@ class MqttClient(MqttClientInterface):
     )
     def connect(self, host: str, port: int) -> None:
         self.logger.info("Attempting to connect to MQTT Broker")
-        self.logger.debug(f"Host: {host}, Port: {port}")
+        self.logger.info(f"Host: {host}, Port: {port}")
         self.client.connect(host=host, port=port)
 
     def publish(self, topic: str, payload: str, qos: int = 0, retain: bool = False):

{isar-1.22.4 → isar-1.23.1}/src/isar/services/utilities/scheduling_utilities.py

@@ -101,10 +101,9 @@ class SchedulingUtilities:
         is_capable: bool = True
         missing_capabilities: Set[str] = set()
         for task in mission.tasks:
-            for step in task.steps:
-                if not step.type in robot_capabilities:
-                    is_capable = False
-                    missing_capabilities.add(step.type)
+            if not task.type in robot_capabilities:
+                is_capable = False
+                missing_capabilities.add(task.type)
 
         if not is_capable:
             error_message = (