isar 1.17.0__tar.gz → 1.19.0__tar.gz

{isar-1.17.0 → isar-1.19.0}/.github/workflows/stale.yml

@@ -20,7 +20,7 @@ jobs:
 
     steps:
     - name: Close Stale Issues
-      uses: actions/stale@v4.1.0
+      uses: actions/stale@v9.0.0
       with:
         repo-token: ${{ secrets.STALE_ISSUE_TOKEN }}
         stale-issue-message: 'This issue has automatically been marked as stale as there has been no activity for 60 days.'

{isar-1.17.0 → isar-1.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: isar
-Version: 1.17.0
+Version: 1.19.0
 Summary: Integration and Supervisory control of Autonomous Robots
 Home-page: https://github.com/equinor/isar
 Author: Equinor ASA
@@ -415,6 +415,17 @@ ISAR_MQTT_PASSWORD
 
 If not specified the password will default to an empty string.
 
+## Running several ISAR instances locally
+
+To run several ISAR instances in parallel locally:
+1. Generate a guid: https://www.guidgenerator.com/
+2. Open a new terminal in the isar folder
+3. Run the following command before running main.py:
+
+```
+export ISAR_API_PORT=port_name_higher_than_1024 ISAR_ISAR_ID=guid ISAR_ROBOT_NAME=random_robot_name
+```
+
 # Contributions
 
 Equinor welcomes all kinds of contributions, including code, bug reports, issues, feature requests, and documentation

{isar-1.17.0 → isar-1.19.0}/README.md

@@ -361,6 +361,17 @@ ISAR_MQTT_PASSWORD
 
 If not specified the password will default to an empty string.
 
+## Running several ISAR instances locally
+
+To run several ISAR instances in parallel locally:
+1. Generate a guid: https://www.guidgenerator.com/
+2. Open a new terminal in the isar folder
+3. Run the following command before running main.py:
+
+```
+export ISAR_API_PORT=port_name_higher_than_1024 ISAR_ISAR_ID=guid ISAR_ROBOT_NAME=random_robot_name
+```
+
 # Contributions
 
 Equinor welcomes all kinds of contributions, including code, bug reports, issues, feature requests, and documentation

{isar-1.17.0 → isar-1.19.0}/main.py

@@ -19,9 +19,6 @@ from isar.services.service_connections.mqtt.robot_heartbeat_publisher import (
 from isar.services.service_connections.mqtt.robot_info_publisher import (
     RobotInfoPublisher,
 )
-from isar.services.service_connections.mqtt.robot_status_publisher import (
-    RobotStatusPublisher,
-)
 from isar.state_machine.state_machine import StateMachine, main
 from isar.storage.uploader import Uploader
 from robot_interface.robot_interface import RobotInterface
@@ -56,15 +53,6 @@ if __name__ == "__main__":
             target=mqtt_client.run, name="ISAR MQTT Client", daemon=True
         )
         threads.append(mqtt_thread)
-        robot_status_publisher: RobotStatusPublisher = RobotStatusPublisher(
-            mqtt_queue=queues.mqtt_queue, robot=robot, state_machine=state_machine
-        )
-        robot_status_thread: Thread = Thread(
-            target=robot_status_publisher.run,
-            name="ISAR Robot Status Publisher",
-            daemon=True,
-        )
-        threads.append(robot_status_thread)
 
         robot_info_publisher: RobotInfoPublisher = RobotInfoPublisher(
             mqtt_queue=queues.mqtt_queue

{isar-1.17.0 → isar-1.19.0}/src/isar/config/settings.py

@@ -56,6 +56,9 @@ class Settings(BaseSettings):
     # Number of attempts to initiate a step or mission before cancelling
     INITIATE_FAILURE_COUNTER_LIMIT: int = Field(default=10)
 
+    # Number of attempts to request a step status in monitor before cancelling
+    REQUEST_STATUS_FAILURE_COUNTER_LIMIT: int = Field(default=3)
+
     # Number of attempts to stop the robot before giving up
     STOP_ROBOT_ATTEMPTS_LIMIT: int = Field(default=10)
 
@@ -226,14 +229,13 @@ class Settings(BaseSettings):
     DATA_CLASSIFICATION: str = Field(default="internal")
 
     # List of MQTT Topics
-    TOPIC_ISAR_STATE: str = Field(default="state", validate_default=True)
+    TOPIC_ISAR_STATUS: str = Field(default="status", validate_default=True)
     TOPIC_ISAR_MISSION: str = Field(default="mission", validate_default=True)
     TOPIC_ISAR_TASK: str = Field(default="task", validate_default=True)
     TOPIC_ISAR_STEP: str = Field(default="step", validate_default=True)
     TOPIC_ISAR_INSPECTION_RESULT: str = Field(
         default="inspection_result", validate_default=True
     )
-    TOPIC_ISAR_ROBOT_STATUS: str = Field(default="robot_status", validate_default=True)
     TOPIC_ISAR_ROBOT_INFO: str = Field(default="robot_info", validate_default=True)
     TOPIC_ISAR_ROBOT_HEARTBEAT: str = Field(
         default="robot_heartbeat", validate_default=True
@@ -281,11 +283,10 @@ class Settings(BaseSettings):
         }
 
     @field_validator(
-        "TOPIC_ISAR_STATE",
+        "TOPIC_ISAR_STATUS",
         "TOPIC_ISAR_MISSION",
         "TOPIC_ISAR_TASK",
         "TOPIC_ISAR_STEP",
-        "TOPIC_ISAR_ROBOT_STATUS",
         "TOPIC_ISAR_ROBOT_INFO",
         "TOPIC_ISAR_ROBOT_HEARTBEAT",
         "TOPIC_ISAR_INSPECTION_RESULT",

{isar-1.17.0 → isar-1.19.0}/src/isar/state_machine/state_machine.py

@@ -24,6 +24,7 @@ from isar.state_machine.states import (
     Initiate,
     Monitor,
     Off,
+    Offline,
     Paused,
     Stop,
 )
@@ -31,7 +32,12 @@ from isar.state_machine.states_enum import States
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
 from robot_interface.models.initialize.initialize_params import InitializeParams
 from robot_interface.models.mission.mission import Mission
-from robot_interface.models.mission.status import MissionStatus, StepStatus, TaskStatus
+from robot_interface.models.mission.status import (
+    MissionStatus,
+    RobotStatus,
+    StepStatus,
+    TaskStatus,
+)
 from robot_interface.models.mission.step import Step
 from robot_interface.models.mission.task import Task
 from robot_interface.robot_interface import RobotInterface
@@ -88,6 +94,7 @@ class StateMachine(object):
         self.monitor_state: State = Monitor(self)
         self.initiate_state: State = Initiate(self)
         self.off_state: State = Off(self)
+        self.offline_state: State = Offline(self)
 
         self.states: List[State] = [
             self.off_state,
@@ -97,6 +104,7 @@ class StateMachine(object):
             self.monitor_state,
             self.stop_state,
             self.paused_state,
+            self.offline_state,
         ]
 
         self.machine = Machine(self, states=self.states, initial="off", queued=True)
@@ -194,6 +202,18 @@ class StateMachine(object):
                     "dest": self.idle_state,
                     "before": self._mission_stopped,
                 },
+                {
+                    "trigger": "robot_turned_offline",
+                    "source": [self.idle_state],
+                    "dest": self.offline_state,
+                    "before": self._offline,
+                },
+                {
+                    "trigger": "robot_turned_online",
+                    "source": self.offline_state,
+                    "dest": self.idle_state,
+                    "before": self._online,
+                },
             ]
         )
 
@@ -239,6 +259,12 @@ class StateMachine(object):
     def _off(self) -> None:
         return
 
+    def _offline(self) -> None:
+        return
+
+    def _online(self) -> None:
+        return
+
     def _resume(self) -> None:
         self.logger.info(f"Resuming mission: {self.current_mission.id}")
         self.current_mission.status = MissionStatus.InProgress
@@ -417,7 +443,7 @@ class StateMachine(object):
         self.send_state_status()
         self._log_state_transition(self.current_state)
         self.logger.info(f"State: {self.current_state}")
-        self.publish_state()
+        self.publish_status()
 
     def reset_state_machine(self) -> None:
         self.logger.info("Resetting state machine")
@@ -559,25 +585,33 @@ class StateMachine(object):
             retain=False,
         )
 
-    def publish_state(self) -> None:
+    def publish_status(self) -> None:
         if not self.mqtt_publisher:
             return
         payload: str = json.dumps(
             {
                 "isar_id": settings.ISAR_ID,
                 "robot_name": settings.ROBOT_NAME,
-                "state": self.current_state,
+                "status": self._current_status(),
                 "timestamp": datetime.utcnow(),
             },
             cls=EnhancedJSONEncoder,
         )
 
         self.mqtt_publisher.publish(
-            topic=settings.TOPIC_ISAR_STATE,
+            topic=settings.TOPIC_ISAR_STATUS,
             payload=payload,
             retain=False,
         )
 
+    def _current_status(self) -> RobotStatus:
+        if self.current_state == States.Idle:
+            return RobotStatus.Available
+        elif self.current_state == States.Offline:
+            return RobotStatus.Offline
+        else:
+            return RobotStatus.Busy
+
     def _log_state_transition(self, next_state):
         """Logs all state transitions that are not self-transitions."""
         self.transitions_list.append(next_state)

{isar-1.17.0 → isar-1.19.0}/src/isar/state_machine/states/__init__.py

@@ -3,5 +3,6 @@ from .initialize import Initialize
 from .initiate import Initiate
 from .monitor import Monitor
 from .off import Off
+from .offline import Offline
 from .paused import Paused
 from .stop import Stop

isar-1.19.0/src/isar/state_machine/states/idle.py

@@ -0,0 +1,85 @@
+import logging
+import time
+from typing import TYPE_CHECKING, Optional
+
+from transitions import State
+
+from isar.config.settings import settings
+from isar.models.communication.message import StartMissionMessage
+from isar.services.utilities.threaded_request import (
+    ThreadedRequest,
+    ThreadedRequestNotFinishedError,
+)
+from robot_interface.models.exceptions.robot_exceptions import RobotException
+from robot_interface.models.mission.status import RobotStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Idle(State):
+    def __init__(self, state_machine: "StateMachine") -> None:
+        super().__init__(name="idle", on_enter=self.start, on_exit=self.stop)
+        self.state_machine: "StateMachine" = state_machine
+        self.logger = logging.getLogger("state_machine")
+        self.robot_status_thread: Optional[ThreadedRequest] = None
+        self.last_robot_status_poll_time: float = time.time()
+
+    def start(self) -> None:
+        self.state_machine.update_state()
+        self._run()
+
+    def stop(self) -> None:
+        if self.robot_status_thread:
+            self.robot_status_thread.wait_for_thread()
+        self.robot_status_thread = None
+
+    def _run(self) -> None:
+        while True:
+            start_mission: Optional[StartMissionMessage] = (
+                self.state_machine.should_start_mission()
+            )
+            if start_mission:
+                self.state_machine.start_mission(
+                    mission=start_mission.mission,
+                    initial_pose=start_mission.initial_pose,
+                )
+                transition = self.state_machine.mission_started  # type: ignore
+                break
+            time.sleep(self.state_machine.sleep_time)
+
+            time_from_last_robot_status_poll = (
+                time.time() - self.last_robot_status_poll_time
+            )
+            if (
+                time_from_last_robot_status_poll
+                < settings.ROBOT_API_STATUS_POLL_INTERVAL
+            ):
+                continue
+
+            if not self.robot_status_thread:
+                self.robot_status_thread = ThreadedRequest(
+                    request_func=self.state_machine.robot.robot_status
+                )
+                self.robot_status_thread.start_thread(
+                    name="State Machine Offline Get Robot Status"
+                )
+
+            try:
+                robot_status: RobotStatus = self.robot_status_thread.get_output()
+            except ThreadedRequestNotFinishedError:
+                time.sleep(self.state_machine.sleep_time)
+                continue
+
+            except (RobotException,) as e:
+                self.logger.error(
+                    f"Failed to get robot status because: {e.error_description}"
+                )
+
+            self.last_robot_status_poll_time = time.time()
+
+            if robot_status == RobotStatus.Offline:
+                transition = self.state_machine.robot_turned_offline  # type: ignore
+                break
+
+        transition()

{isar-1.17.0 → isar-1.19.0}/src/isar/state_machine/states/monitor.py

@@ -1,18 +1,20 @@
 import logging
 import time
 from copy import deepcopy
-from typing import Callable, Optional, Sequence, TYPE_CHECKING, Tuple, Union
+from typing import TYPE_CHECKING, Callable, Optional, Sequence, Tuple, Union
 
 from injector import inject
 from transitions import State
 
 from isar.mission_planner.task_selector_interface import TaskSelectorStop
+from isar.config.settings import settings
 from isar.services.utilities.threaded_request import (
     ThreadedRequest,
     ThreadedRequestNotFinishedError,
 )
 from robot_interface.models.exceptions.robot_exceptions import (
     ErrorMessage,
+    RobotCommunicationTimeoutException,
     RobotException,
     RobotMissionStatusException,
     RobotRetrieveInspectionException,
@@ -32,6 +34,10 @@ class Monitor(State):
     def __init__(self, state_machine: "StateMachine") -> None:
         super().__init__(name="monitor", on_enter=self.start, on_exit=self.stop)
         self.state_machine: "StateMachine" = state_machine
+        self.request_status_failure_counter: int = 0
+        self.request_status_failure_counter_limit: int = (
+            settings.REQUEST_STATUS_FAILURE_COUNTER_LIMIT
+        )
 
         self.logger = logging.getLogger("state_machine")
         self.step_status_thread: Optional[ThreadedRequest] = None
@@ -61,7 +67,6 @@ class Monitor(State):
                     status_function=self.state_machine.robot.step_status,
                     thread_name="State Machine Monitor Get Step Status",
                 )
-
             try:
                 status: Union[StepStatus, MissionStatus] = (
                     self.step_status_thread.get_output()
@@ -70,6 +75,34 @@ class Monitor(State):
                 time.sleep(self.state_machine.sleep_time)
                 continue
 
+            except RobotCommunicationTimeoutException as e:
+                self.state_machine.current_mission.error_message = ErrorMessage(
+                    error_reason=e.error_reason, error_description=e.error_description
+                )
+                self.step_status_thread = None
+                self.request_status_failure_counter += 1
+                self.logger.warning(
+                    f"Monitoring step {self.state_machine.current_step.id} failed #: "
+                    f"{self.request_status_failure_counter} failed because: {e.error_description}"
+                )
+
+                if (
+                    self.request_status_failure_counter
+                    >= self.request_status_failure_counter_limit
+                ):
+                    self.state_machine.current_step.error_message = ErrorMessage(
+                        error_reason=e.error_reason,
+                        error_description=e.error_description,
+                    )
+                    self.logger.error(
+                        f"Step will be cancelled after failing to get step status "
+                        f"{self.request_status_failure_counter} times because: "
+                        f"{e.error_description}"
+                    )
+                    status = StepStatus.Failed
+                else:
+                    continue
+
             except RobotStepStatusException as e:
                 self.state_machine.current_step.error_message = ErrorMessage(
                     error_reason=e.error_reason, error_description=e.error_description
@@ -123,6 +156,7 @@ class Monitor(State):
             else:
                 if isinstance(status, StepStatus):
                     if self._step_finished(self.state_machine.current_step):
+                        self.state_machine.update_current_step()
                         self.state_machine.current_task.update_task_status()
                     else:  # If not all steps are done
                         self.state_machine.current_task.status = TaskStatus.InProgress
@@ -131,7 +165,6 @@ class Monitor(State):
                         self.state_machine.current_task
                     )
                     if self.state_machine.current_task.status == TaskStatus.Successful:
-                        self.state_machine.update_remaining_steps()
                         try:
                             self.state_machine.current_task = (
                                 self.state_machine.task_selector.next_task()

isar-1.19.0/src/isar/state_machine/states/offline.py

@@ -0,0 +1,62 @@
+import logging
+import time
+from typing import TYPE_CHECKING, Optional
+
+from transitions import State
+
+from isar.config.settings import settings
+from isar.services.utilities.threaded_request import (
+    ThreadedRequest,
+    ThreadedRequestNotFinishedError,
+)
+from robot_interface.models.exceptions.robot_exceptions import RobotException
+from robot_interface.models.mission.status import RobotStatus
+
+if TYPE_CHECKING:
+    from isar.state_machine.state_machine import StateMachine
+
+
+class Offline(State):
+    def __init__(self, state_machine: "StateMachine") -> None:
+        super().__init__(name="offline", on_enter=self.start, on_exit=self.stop)
+        self.state_machine: "StateMachine" = state_machine
+        self.logger = logging.getLogger("state_machine")
+        self.robot_status_thread: Optional[ThreadedRequest] = None
+
+    def start(self) -> None:
+        self.state_machine.update_state()
+        self._run()
+
+    def stop(self) -> None:
+        if self.robot_status_thread:
+            self.robot_status_thread.wait_for_thread()
+        self.robot_status_thread = None
+
+    def _run(self) -> None:
+        while True:
+            if not self.robot_status_thread:
+                self.robot_status_thread = ThreadedRequest(
+                    request_func=self.state_machine.robot.robot_status
+                )
+                self.robot_status_thread.start_thread(
+                    name="State Machine Offline Get Robot Status"
+                )
+
+            try:
+                robot_status: RobotStatus = self.robot_status_thread.get_output()
+            except ThreadedRequestNotFinishedError:
+                time.sleep(self.state_machine.sleep_time)
+                continue
+
+            except (RobotException,) as e:
+                self.logger.error(
+                    f"Failed to get robot status because: {e.error_description}"
+                )
+
+            if robot_status != RobotStatus.Offline:
+                transition = self.state_machine.robot_turned_online  # type: ignore
+                break
+
+            time.sleep(settings.ROBOT_API_STATUS_POLL_INTERVAL)
+
+        transition()

{isar-1.17.0 → isar-1.19.0}/src/isar/state_machine/states_enum.py

@@ -9,6 +9,7 @@ class States(str, Enum):
     Monitor = "monitor"
     Paused = "paused"
     Stop = "stop"
+    Offline = "offline"
 
     def __repr__(self):
         return self.value

{isar-1.17.0 → isar-1.19.0}/src/isar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: isar
-Version: 1.17.0
+Version: 1.19.0
 Summary: Integration and Supervisory control of Autonomous Robots
 Home-page: https://github.com/equinor/isar
 Author: Equinor ASA
@@ -415,6 +415,17 @@ ISAR_MQTT_PASSWORD
 
 If not specified the password will default to an empty string.
 
+## Running several ISAR instances locally
+
+To run several ISAR instances in parallel locally:
+1. Generate a guid: https://www.guidgenerator.com/
+2. Open a new terminal in the isar folder
+3. Run the following command before running main.py:
+
+```
+export ISAR_API_PORT=port_name_higher_than_1024 ISAR_ISAR_ID=guid ISAR_ROBOT_NAME=random_robot_name
+```
+
 # Contributions
 
 Equinor welcomes all kinds of contributions, including code, bug reports, issues, feature requests, and documentation

{isar-1.17.0 → isar-1.19.0}/src/isar.egg-info/SOURCES.txt

@@ -20,7 +20,6 @@ setup.py
 .github/workflows/publish_isar_base_image.yml
 .github/workflows/pythonpackage.yml
 .github/workflows/pythonpublish.yml
-.github/workflows/repository_dispatch_on_merge.yml
 .github/workflows/stale.yml
 docs/Makefile
 docs/make.bat
@@ -96,7 +95,6 @@ src/isar/services/service_connections/mqtt/__init__.py
 src/isar/services/service_connections/mqtt/mqtt_client.py
 src/isar/services/service_connections/mqtt/robot_heartbeat_publisher.py
 src/isar/services/service_connections/mqtt/robot_info_publisher.py
-src/isar/services/service_connections/mqtt/robot_status_publisher.py
 src/isar/services/service_connections/stid/__init__.py
 src/isar/services/utilities/__init__.py
 src/isar/services/utilities/queue_utilities.py
@@ -111,6 +109,7 @@ src/isar/state_machine/states/initialize.py
 src/isar/state_machine/states/initiate.py
 src/isar/state_machine/states/monitor.py
 src/isar/state_machine/states/off.py
+src/isar/state_machine/states/offline.py
 src/isar/state_machine/states/paused.py
 src/isar/state_machine/states/stop.py
 src/isar/storage/__init__.py

{isar-1.17.0 → isar-1.19.0}/src/robot_interface/models/exceptions/robot_exceptions.py

@@ -5,6 +5,7 @@ from typing import Optional
 
 class ErrorReason(str, Enum):
     RobotCommunicationException: str = "robot_communication_exception"
+    RobotCommunicationTimeoutException: str = "robot_communication_timeout_exception"
     RobotInfeasibleStepException: str = "robot_infeasible_step_exception"
     RobotInfeasibleMissionException: str = "robot_infeasible_mission_exception"
     RobotMissionStatusException: str = "robot_mission_status_exception"
@@ -49,6 +50,18 @@ class RobotCommunicationException(RobotException):
     pass
 
 
+# An exception which should be thrown by the robot package if the communication has timed
+# out and ISAR should retry the request.
+class RobotCommunicationTimeoutException(RobotException):
+    def __init__(self, error_description: str) -> None:
+        super().__init__(
+            error_reason=ErrorReason.RobotCommunicationTimeoutException,
+            error_description=error_description,
+        )
+
+    pass
+
+
 # An exception which should be thrown by the robot package if it is unable to start the
 # current step.
 class RobotInfeasibleStepException(RobotException):

{isar-1.17.0 → isar-1.19.0}/tests/isar/state_machine/test_state_machine.py

@@ -25,7 +25,7 @@ from robot_interface.models.mission.step import DriveToPose, Step, TakeImage
 from robot_interface.models.mission.task import Task
 from robot_interface.telemetry.mqtt_client import MqttClientInterface
 from tests.mocks.pose import MockPose
-from tests.mocks.robot_interface import MockRobot
+from tests.mocks.robot_interface import MockRobot, MockRobotIdleToOfflineToIdleTest
 from tests.mocks.step import MockStep
 
 
@@ -35,6 +35,8 @@ class StateMachineThread(object):
         self.state_machine: StateMachine = injector.get(StateMachine)
         self._thread: Thread = Thread(target=main, args=[self.state_machine])
         self._thread.daemon = True
+
+    def start(self):
         self._thread.start()
 
 
@@ -105,6 +107,7 @@ def test_state_machine_transitions(
     mission: Mission = Mission(tasks=[Task(steps=[step_1, step_2])])  # type: ignore
 
     state_machine_thread.state_machine.stepwise_mission = should_run_stepwise
+    state_machine_thread.start()
 
     scheduling_utilities: SchedulingUtilities = injector.get(SchedulingUtilities)
     scheduling_utilities.start_mission(mission=mission, initial_pose=None)
@@ -143,6 +146,7 @@ def test_state_machine_transitions_when_running_full_mission(
     injector, state_machine_thread
 ) -> None:
     state_machine_thread.state_machine.stepwise_mission = False
+    state_machine_thread.start()
 
     step_1: Step = DriveToPose(pose=MockPose.default_pose())
     step_2: Step = TakeImage(target=MockPose.default_pose().position)
@@ -176,6 +180,8 @@ def test_state_machine_failed_dependency(
 
     mocker.patch.object(MockRobot, "step_status", return_value=StepStatus.Failed)
 
+    state_machine_thread.start()
+
     scheduling_utilities: SchedulingUtilities = injector.get(SchedulingUtilities)
     scheduling_utilities.start_mission(mission=mission, initial_pose=None)
 
@@ -198,6 +204,8 @@ def test_state_machine_failed_dependency(
 def test_state_machine_with_successful_collection(
     injector, state_machine_thread, uploader_thread
 ) -> None:
+    state_machine_thread.start()
+
     storage_mock: StorageInterface = injector.get(List[StorageInterface])[0]
 
     step: TakeImage = MockStep.take_image_in_coordinate_direction()
@@ -230,6 +238,8 @@ def test_state_machine_with_unsuccessful_collection(
 
     mocker.patch.object(MockRobot, "get_inspections", return_value=[])
 
+    state_machine_thread.start()
+
     step: TakeImage = MockStep.take_image_in_coordinate_direction()
     mission: Mission = Mission(tasks=[Task(steps=[step])])
     scheduling_utilities: SchedulingUtilities = injector.get(SchedulingUtilities)
@@ -259,6 +269,8 @@ def test_state_machine_with_successful_mission_stop(
     state_machine_thread: StateMachineThread,
     caplog: pytest.LogCaptureFixture,
 ) -> None:
+    state_machine_thread.start()
+
     step: TakeImage = MockStep.take_image_in_coordinate_direction()
     mission: Mission = Mission(tasks=[Task(steps=[step])])
 
@@ -298,6 +310,8 @@ def test_state_machine_with_unsuccessful_mission_stop(
         MockRobot, "stop", side_effect=_mock_robot_exception_with_message
     )
 
+    state_machine_thread.start()
+
     scheduling_utilities.start_mission(mission=mission, initial_pose=None)
 
     scheduling_utilities.stop_mission()
@@ -320,6 +334,19 @@ def test_state_machine_with_unsuccessful_mission_stop(
     assert expected == actual
 
 
+def test_state_machine_idle_to_offline_to_idle(state_machine_thread) -> None:
+    state_machine_thread.state_machine.robot = MockRobotIdleToOfflineToIdleTest()
+
+    state_machine_thread.start()
+    # Robot status check happens every 5 seconds by default
+    time.sleep(13)  # Ensure that robot_status have been called again in Idle
+
+    expected_transitions_list = deque([States.Idle, States.Offline, States.Idle])
+    assert (
+        state_machine_thread.state_machine.transitions_list == expected_transitions_list
+    )
+
+
 def _mock_robot_exception_with_message() -> RobotException:
     raise RobotException(
         error_reason=ErrorReason.RobotUnknownErrorException,

{isar-1.17.0 → isar-1.19.0}/tests/mocks/robot_interface.py

@@ -78,3 +78,15 @@ def mock_image_metadata() -> ImageMetadata:
         ),
         file_type="jpg",
     )
+
+
+class MockRobotIdleToOfflineToIdleTest(MockRobot):
+    def __init__(self):
+        self.first = True
+
+    def robot_status(self) -> RobotStatus:
+        if self.first:
+            self.first = False
+            return RobotStatus.Offline
+
+        return RobotStatus.Available