isar 1.32.3__py3-none-any.whl → 1.33.1__py3-none-any.whl

isar/apis/models/models.py

@@ -26,6 +26,12 @@ class ControlMissionResponse(BaseModel):
     task_status: Optional[str]
 
 
+class MissionStartResponse(BaseModel):
+    mission_id: Optional[str] = None
+    mission_started: bool
+    mission_not_started_reason: Optional[str] = None
+
+
 class RobotInfoResponse(BaseModel):
     robot_package: str
     isar_id: str

isar/apis/schedule/scheduling_controller.py

@@ -1,6 +1,5 @@
 import logging
 from http import HTTPStatus
-from threading import Lock
 
 from fastapi import Body, HTTPException, Path
 
@@ -29,7 +28,6 @@ class SchedulingController:
     ):
         self.scheduling_utilities: SchedulingUtilities = scheduling_utilities
         self.logger = logging.getLogger("api")
-        self.start_mission_lock: Lock = Lock()
 
     def start_mission_by_id(
         self,
@@ -77,67 +75,38 @@ class SchedulingController:
                 detail=error_message_no_mission_definition,
             )
 
-        if not self.start_mission_lock.acquire(blocking=False):
-            error_message_another_mission_starting: str = (
-                "Conflict - Another mission is currently being started"
-            )
-            self.logger.warning(error_message_another_mission_starting)
-            raise HTTPException(
-                status_code=HTTPStatus.CONFLICT,
-                detail=error_message_another_mission_starting,
-            )
+        state: States = self.scheduling_utilities.get_state()
+        self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(state)
 
         try:
-            state: States = self.scheduling_utilities.get_state()
-            self.scheduling_utilities.verify_state_machine_ready_to_receive_mission(
-                state
+            mission: Mission = to_isar_mission(
+                start_mission_definition=mission_definition
             )
-
-            try:
-                mission: Mission = to_isar_mission(
-                    start_mission_definition=mission_definition
-                )
-            except MissionPlannerError as e:
-                error_message = f"Bad Request - Cannot create ISAR mission: {e}"
-                self.logger.warning(error_message)
-                raise HTTPException(
-                    status_code=HTTPStatus.BAD_REQUEST,
-                    detail=error_message,
-                )
-
-            self.scheduling_utilities.verify_robot_capable_of_mission(
-                mission=mission, robot_capabilities=robot_settings.CAPABILITIES
+        except MissionPlannerError as e:
+            error_message = f"Bad Request - Cannot create ISAR mission: {e}"
+            self.logger.warning(error_message)
+            raise HTTPException(
+                status_code=HTTPStatus.BAD_REQUEST,
+                detail=error_message,
             )
 
-            self.logger.info("Starting mission: %s", mission.id)
-            self.scheduling_utilities.start_mission(mission=mission)
-            return self._api_response(mission)
+        self.scheduling_utilities.verify_robot_capable_of_mission(
+            mission=mission, robot_capabilities=robot_settings.CAPABILITIES
+        )
 
-        finally:
-            self.start_mission_lock.release()
+        self.logger.info("Starting mission: %s", mission.id)
+        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")
 
-        if not self.start_mission_lock.acquire(blocking=False):
-            error_message_another_mission_starting: str = (
-                "Conflict - Another mission is currently being started"
-            )
-            self.logger.warning(error_message_another_mission_starting)
-            raise HTTPException(
-                status_code=HTTPStatus.CONFLICT,
-                detail=error_message_another_mission_starting,
-            )
-
-        try:
-            state: States = self.scheduling_utilities.get_state()
-            self.scheduling_utilities.verify_state_machine_ready_to_receive_return_home_mission(
-                state
-            )
+        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()
-        finally:
-            self.start_mission_lock.release()
+        self.scheduling_utilities.return_home()
 
     def pause_mission(self) -> ControlMissionResponse:
         self.logger.info("Received request to pause current mission")

isar/config/open_telemetry.py

@@ -1,4 +1,5 @@
 import logging
+from urllib.parse import urljoin
 
 from azure.monitor.opentelemetry.exporter import (
     AzureMonitorLogExporter,
@@ -7,6 +8,12 @@ from azure.monitor.opentelemetry.exporter import (
 from fastapi import FastAPI
 from opentelemetry import trace
 from opentelemetry._logs import set_logger_provider
+from opentelemetry.exporter.otlp.proto.http._log_exporter import (
+    OTLPLogExporter as OTLPHttpLogExporter,
+)
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+    OTLPSpanExporter as OTLPHttpSpanExporter,
+)
 from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
 from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
 from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
@@ -17,22 +24,45 @@ from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from isar.config.log import load_log_config
 from isar.config.settings import settings
 
+logging.getLogger("opentelemetry.sdk").setLevel(logging.CRITICAL)
+
 
 def setup_open_telemetry(app: FastAPI) -> None:
-    if not settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED:
-        return
-    trace_exporter, log_exporter = get_azure_monitor_exporters()
 
-    service_name = settings.OPEN_TELEMETRY_SERVICE_NAME
+    service_name = settings.ROBOT_NAME
     resource = Resource.create({SERVICE_NAME: service_name})
 
     tracer_provider = TracerProvider(resource=resource)
-    tracer_provider.add_span_processor(BatchSpanProcessor(trace_exporter))
-    trace.set_tracer_provider(tracer_provider)
-
     log_provider = LoggerProvider(resource=resource)
+
+    if settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED:
+        print("[OTEL] Azure Monitor exporters enabled")
+        azure_monitor_trace_exporter, azure_monitor_log_exporter = (
+            get_azure_monitor_exporters()
+        )
+
+        tracer_provider.add_span_processor(
+            BatchSpanProcessor(azure_monitor_trace_exporter)
+        )
+
+        log_provider.add_log_record_processor(
+            BatchLogRecordProcessor(azure_monitor_log_exporter)
+        )
+
+    otlp_exporter_endpoint = settings.OPEN_TELEMETRY_OTLP_EXPORTER_ENDPOINT
+    if otlp_exporter_endpoint:
+        print(f"[OTEL] OTLP exporters enabled, endpoint={otlp_exporter_endpoint}")
+        otlp_trace_exporter, otlp_log_exporter = get_otlp_exporters(
+            otlp_exporter_endpoint
+        )
+        tracer_provider.add_span_processor(BatchSpanProcessor(otlp_trace_exporter))
+
+        log_provider.add_log_record_processor(
+            BatchLogRecordProcessor(otlp_log_exporter)
+        )
+
     set_logger_provider(log_provider)
-    log_provider.add_log_record_processor(BatchLogRecordProcessor(log_exporter))
+    trace.set_tracer_provider(tracer_provider)
 
     handler = LoggingHandler(logger_provider=log_provider)
     attach_loggers_for_open_telemetry(handler)
@@ -51,12 +81,22 @@ def attach_loggers_for_open_telemetry(handler: LoggingHandler):
 def get_azure_monitor_exporters() -> (
     tuple[AzureMonitorTraceExporter, AzureMonitorLogExporter]
 ):
-    """
-    If connection string is defined in environment variables, then use it to create Azure Monitor Exporters.
-    Else use Azure Managed Identity to create Azure Monitor Exporters.
-    """
     connection_string = settings.APPLICATIONINSIGHTS_CONNECTION_STRING
     trace_exporter = AzureMonitorTraceExporter(connection_string=connection_string)
     log_exporter = AzureMonitorLogExporter(connection_string=connection_string)
 
     return trace_exporter, log_exporter
+
+
+def get_otlp_exporters(
+    endpoint: str,
+) -> tuple[OTLPHttpSpanExporter, OTLPHttpLogExporter]:
+    base = endpoint.rstrip("/") + "/"
+    trace_ep = urljoin(base, "v1/traces")
+    log_ep = urljoin(base, "v1/logs")
+
+    print("[OTEL] Using HTTP/Protobuf protocol for OpenTelemetry export")
+    print(f"[OTEL]  traces → {trace_ep}")
+    print(f"[OTEL]  logs   → {log_ep}")
+
+    return OTLPHttpSpanExporter(endpoint=trace_ep), OTLPHttpLogExporter(endpoint=log_ep)

isar/config/settings.py

@@ -12,8 +12,9 @@ from robot_interface.telemetry.payloads import DocumentInfo
 
 
 class Settings(BaseSettings):
-    # Name of the OpenTelemetry service
-    OPEN_TELEMETRY_SERVICE_NAME: str = Field(default="isar")
+    # Endpoint open telemetry will export telemetry in the otlp protocol to
+    OPEN_TELEMETRY_OTLP_EXPORTER_ENDPOINT: str = Field(default="http://localhost:4318")
+
     # Connection string for Azure Application Insights
     # This is optional and it will use managed identity if not set
     APPLICATIONINSIGHTS_CONNECTION_STRING: str = Field(default="")
@@ -29,7 +30,7 @@ class Settings(BaseSettings):
     REQUEST_TIMEOUT: int = Field(default=30)
 
     # Timeout in seconds for checking whether there is a message on a queue
-    QUEUE_TIMEOUT: int = Field(default=10)
+    QUEUE_TIMEOUT: int = Field(default=3)
 
     # Sleep time for while loops in the finite state machine in seconds
     # The sleep is used to throttle the system on every iteration in the loop
@@ -80,6 +81,15 @@ class Settings(BaseSettings):
     ROBOT_API_STATUS_POLL_INTERVAL: float = Field(default=5)
     THREAD_CHECK_INTERVAL: float = Field(default=0.01)
 
+    # Determines the minimum battery level the robot must have to start a mission
+    # If it drops below this level it will recharge to the value set by
+    # ROBOT_BATTERY_RECHARGE_THRESHOLD before starting new missions
+    ROBOT_MISSION_BATTERY_START_THRESHOLD: float = Field(default=25.0)
+
+    # Determines the minimum battery threshold to consider the robot recharged
+    # and ready for more missions, after having run low on charge
+    ROBOT_BATTERY_RECHARGE_THRESHOLD: float = Field(default=80.0)
+
     # FastAPI host
     API_HOST_VIEWED_EXTERNALLY: str = Field(default="0.0.0.0")
 
@@ -215,6 +225,9 @@ class Settings(BaseSettings):
     # List of MQTT Topics
     TOPIC_ISAR_STATUS: str = Field(default="status", validate_default=True)
     TOPIC_ISAR_MISSION: str = Field(default="mission", validate_default=True)
+    TOPIC_ISAR_MISSION_ABORTED: str = Field(
+        default="aborted_mission", validate_default=True
+    )
     TOPIC_ISAR_TASK: str = Field(default="task", validate_default=True)
     TOPIC_ISAR_INSPECTION_RESULT: str = Field(
         default="inspection_result", validate_default=True
@@ -282,6 +295,7 @@ class Settings(BaseSettings):
         "TOPIC_ISAR_INSPECTION_VALUE",
         "TOPIC_ISAR_STARTUP",
         "TOPIC_ISAR_INTERVENTION_NEEDED",
+        "TOPIC_ISAR_MISSION_ABORTED",
     )
     @classmethod
     def prefix_isar_topics(cls, v: Any, info: ValidationInfo):

isar/eventhandlers/eventhandler.py

@@ -58,6 +58,28 @@ class EventHandlerBase(State):
     def stop(self) -> None:
         return
 
+    def get_event_handler_by_name(
+        self, event_handler_name: str
+    ) -> Optional[EventHandlerMapping]:
+        filtered_handlers = list(
+            filter(
+                lambda mapping: mapping.name == event_handler_name,
+                self.event_handler_mappings,
+            )
+        )
+        return filtered_handlers[0] if len(filtered_handlers) > 0 else None
+
+    def get_event_timer_by_name(
+        self, event_timer_name: str
+    ) -> Optional[TimeoutHandlerMapping]:
+        filtered_timers = list(
+            filter(
+                lambda mapping: mapping.name == event_timer_name,
+                self.timers,
+            )
+        )
+        return filtered_timers[0] if len(filtered_timers) > 0 else None
+
     def _run(self) -> None:
         should_exit_state: bool = False
         timers = deepcopy(self.timers)

isar/models/events.py

@@ -4,7 +4,7 @@ from typing import Generic, Optional, TypeVar
 
 from transitions import State
 
-from isar.apis.models.models import ControlMissionResponse
+from isar.apis.models.models import ControlMissionResponse, MissionStartResponse
 from isar.config.settings import settings
 from robot_interface.models.exceptions.robot_exceptions import ErrorMessage
 from robot_interface.models.mission.mission import Mission
@@ -17,11 +17,19 @@ T2 = TypeVar("T2")
 
 
 class Event(Queue[T]):
-    def __init__(self) -> None:
+    def __init__(self, name: str) -> None:
         super().__init__(maxsize=1)
+        self.name = name
 
-    def trigger_event(self, data: T) -> None:
-        self.put(data)
+    def trigger_event(self, data: T, timeout: int = None) -> None:
+        try:
+            # We always want a timeout when blocking for results, so that
+            # the thread will never get stuck waiting for a result
+            self.put(data, block=timeout is not None, timeout=timeout)
+        except Exception:
+            if timeout is not None:
+                raise EventTimeoutError
+            return None
 
     def consume_event(self, timeout: int = None) -> Optional[T]:
         try:
@@ -74,46 +82,67 @@ class APIEvent(Generic[T1, T2]):
     api to state machine while the response is from state machine to api.
     """
 
-    def __init__(self):
-        self.request: Event[T1] = Event()
-        self.response: Event[T2] = Event()
+    def __init__(self, name: str):
+        self.request: Event[T1] = Event("api-" + name + "-request")
+        self.response: Event[T2] = Event("api-" + name + "-request")
 
 
 class APIRequests:
     def __init__(self) -> None:
-        self.start_mission: APIEvent[Mission, bool] = APIEvent()
-        self.stop_mission: APIEvent[str, ControlMissionResponse] = APIEvent()
-        self.pause_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
-        self.resume_mission: APIEvent[bool, ControlMissionResponse] = APIEvent()
-        self.return_home: APIEvent[bool, bool] = APIEvent()
-        self.release_intervention_needed: APIEvent[bool, bool] = APIEvent()
+        self.start_mission: APIEvent[Mission, MissionStartResponse] = APIEvent(
+            "start_mission"
+        )
+        self.stop_mission: APIEvent[str, ControlMissionResponse] = APIEvent(
+            "stop_mission"
+        )
+        self.pause_mission: APIEvent[bool, ControlMissionResponse] = APIEvent(
+            "pause_mission"
+        )
+        self.resume_mission: APIEvent[bool, ControlMissionResponse] = APIEvent(
+            "resume_mission"
+        )
+        self.return_home: APIEvent[bool, bool] = APIEvent("return_home")
+        self.release_intervention_needed: APIEvent[bool, bool] = APIEvent(
+            "release_intervention_needed"
+        )
 
 
 class StateMachineEvents:
     def __init__(self) -> None:
-        self.start_mission: Event[Mission] = Event()
-        self.stop_mission: Event[bool] = Event()
-        self.pause_mission: Event[bool] = Event()
-        self.task_status_request: Event[str] = Event()
+        self.start_mission: Event[Mission] = Event("start_mission")
+        self.stop_mission: Event[bool] = Event("stop_mission")
+        self.pause_mission: Event[bool] = Event("pause_mission")
+        self.task_status_request: Event[str] = Event("task_status_request")
 
 
 class RobotServiceEvents:
     def __init__(self) -> None:
-        self.task_status_updated: Event[TaskStatus] = Event()
-        self.task_status_failed: Event[ErrorMessage] = Event()
-        self.mission_started: Event[bool] = Event()
-        self.mission_failed: Event[ErrorMessage] = Event()
-        self.robot_status_changed: Event[bool] = Event()
-        self.mission_failed_to_stop: Event[ErrorMessage] = Event()
-        self.mission_successfully_stopped: Event[bool] = Event()
+        self.task_status_updated: Event[TaskStatus] = Event("task_status_updated")
+        self.task_status_failed: Event[ErrorMessage] = Event("task_status_failed")
+        self.mission_started: Event[bool] = Event("mission_started")
+        self.mission_failed: Event[ErrorMessage] = Event("mission_failed")
+        self.robot_status_changed: Event[bool] = Event("robot_status_changed")
+        self.mission_failed_to_stop: Event[ErrorMessage] = Event(
+            "mission_failed_to_stop"
+        )
+        self.mission_successfully_stopped: Event[bool] = Event(
+            "mission_successfully_stopped"
+        )
 
 
 class SharedState:
     def __init__(self) -> None:
-        self.state: Event[State] = Event()
-        self.robot_status: Event[RobotStatus] = Event()
-        self.state_machine_current_task: Event[TASKS] = Event()
+        self.state: Event[State] = Event("state")
+        self.robot_status: Event[RobotStatus] = Event("robot_status")
+        self.state_machine_current_task: Event[TASKS] = Event(
+            "state_machine_current_task"
+        )
+        self.robot_battery_level: Event[float] = Event("robot_battery_level")
 
 
 class EventTimeoutError(Exception):
     pass
+
+
+class EventConflictError(Exception):
+    pass

isar/robot/robot_status.py

@@ -48,7 +48,10 @@ class RobotStatusThread(Thread):
                 self.last_robot_status_poll_time = time.time()
 
                 robot_status = self.robot.robot_status()
+                robot_battery_level = self.robot.get_battery_level()
+
                 self.shared_state.robot_status.update(robot_status)
+                self.shared_state.robot_battery_level.update(robot_battery_level)
             except RobotException as e:
                 self.logger.error(f"Failed to retrieve robot status: {e}")
                 continue

isar/services/utilities/scheduling_utilities.py

@@ -16,6 +16,7 @@ from isar.mission_planner.mission_planner_interface import (
 from isar.models.events import (
     APIEvent,
     APIRequests,
+    EventConflictError,
     Events,
     EventTimeoutError,
     SharedState,
@@ -176,16 +177,28 @@ class SchedulingUtilities:
             If there is a timeout while communicating with the state machine
         """
         try:
-            self._send_command(
+            mission_start_response = self._send_command(
                 deepcopy(mission),
                 self.api_events.start_mission,
             )
+            if not mission_start_response.mission_started:
+                self.logger.warning(
+                    f"Mission failed to start - {mission_start_response.mission_not_started_reason}"
+                )
+                raise HTTPException(
+                    status_code=HTTPStatus.CONFLICT,
+                    detail=mission_start_response.mission_not_started_reason,
+                )
+        except EventConflictError:
+            error_message = "Previous mission request is still being processed"
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
         except EventTimeoutError:
-            error_message = "Internal Server Error - Failed to start mission in ISAR"
-            self.logger.error(error_message)
-            raise HTTPException(
-                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            error_message = (
+                "State machine has entered a state which cannot start a mission"
             )
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
         self.logger.info("OK - Mission started in ISAR")
 
     def return_home(
@@ -203,14 +216,14 @@ class SchedulingUtilities:
                 True,
                 self.api_events.return_home,
             )
+        except EventConflictError:
+            error_message = "Previous return home request is still being processed"
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
         except EventTimeoutError:
-            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
-            )
+            error_message = "State machine has entered a state which cannot start a return home mission"
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
         self.logger.info("OK - Return home mission started in ISAR")
 
     def pause_mission(self) -> ControlMissionResponse:
@@ -225,12 +238,16 @@ class SchedulingUtilities:
             response = self._send_command(True, self.api_events.pause_mission)
             self.logger.info("OK - Mission successfully paused")
             return response
+        except EventConflictError:
+            error_message = "Previous pause mission request is still being processed"
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
         except EventTimeoutError:
-            error_message = "Internal Server Error - Failed to pause mission"
-            self.logger.error(error_message)
-            raise HTTPException(
-                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            error_message = (
+                "State machine has entered a state which cannot pause a mission"
             )
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
 
     def resume_mission(self) -> ControlMissionResponse:
         """Resume mission
@@ -244,6 +261,10 @@ class SchedulingUtilities:
             response = self._send_command(True, self.api_events.resume_mission)
             self.logger.info("OK - Mission successfully resumed")
             return response
+        except EventConflictError:
+            error_message = "Previous resume mission request is still being processed"
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
         except EventTimeoutError:
             error_message = "Internal Server Error - Failed to resume mission"
             self.logger.error(error_message)
@@ -281,12 +302,16 @@ class SchedulingUtilities:
                 raise HTTPException(
                     status_code=HTTPStatus.CONFLICT, detail=error_message
                 )
+        except EventConflictError:
+            error_message = "Previous stop mission request is still being processed"
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
         except EventTimeoutError:
-            error_message = "Internal Server Error - Failed to stop mission"
-            self.logger.error(error_message)
-            raise HTTPException(
-                status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=error_message
+            error_message = (
+                "State machine has entered a state which cannot stop a mission"
             )
+            self.logger.warning(error_message)
+            raise HTTPException(status_code=HTTPStatus.CONFLICT, detail=error_message)
         self.logger.info("OK - Mission successfully stopped")
         return stop_mission_response
 
@@ -311,11 +336,17 @@ class SchedulingUtilities:
             )
 
     def _send_command(self, input: T1, api_event: APIEvent[T1, T2]) -> T2:
-        api_event.request.trigger_event(input)
+        if api_event.request.has_event() or api_event.response.has_event():
+            raise EventConflictError("API event has already been sent")
+
         try:
+            api_event.request.trigger_event(input, timeout=1)
             return api_event.response.consume_event(timeout=self.queue_timeout)
         except EventTimeoutError as e:
             self.logger.error("Queue timed out")
             api_event.request.clear_event()
             self.logger.error("No output received for command to state machine")
             raise e
+        finally:
+            api_event.request.clear_event()
+            api_event.response.clear_event()

isar/state_machine/state_machine.py

@@ -22,6 +22,7 @@ from isar.state_machine.states.intervention_needed import InterventionNeeded
 from isar.state_machine.states.monitor import Monitor
 from isar.state_machine.states.offline import Offline
 from isar.state_machine.states.paused import Paused
+from isar.state_machine.states.recharging import Recharging
 from isar.state_machine.states.returning_home import ReturningHome
 from isar.state_machine.states.robot_standing_still import RobotStandingStill
 from isar.state_machine.states.stopping import Stopping
@@ -43,6 +44,7 @@ from robot_interface.robot_interface import RobotInterface
 from robot_interface.telemetry.mqtt_client import MqttClientInterface
 from robot_interface.telemetry.payloads import (
     InterventionNeededPayload,
+    MissionAbortedPayload,
     MissionPayload,
     RobotStatusPayload,
     TaskPayload,
@@ -108,6 +110,7 @@ class StateMachine(object):
         # Status states
         self.offline_state: State = Offline(self)
         self.blocked_protective_stopping_state: State = BlockedProtectiveStop(self)
+        self.recharging_state: State = Recharging(self)
 
         # Error and special status states
         self.unknown_status_state: State = UnknownStatus(self)
@@ -124,6 +127,7 @@ class StateMachine(object):
             self.blocked_protective_stopping_state,
             self.unknown_status_state,
             self.intervention_needed_state,
+            self.recharging_state,
         ]
 
         self.machine = Machine(
@@ -189,6 +193,12 @@ class StateMachine(object):
                 self.current_task = None
             self.send_task_status()
 
+    def battery_level_is_above_mission_start_threshold(self):
+        return (
+            not self.shared_state.robot_battery_level.check()
+            < settings.ROBOT_MISSION_BATTERY_START_THRESHOLD
+        )
+
     def update_state(self):
         """Updates the current state of the state machine."""
         self.current_state = States(self.state)  # type: ignore
@@ -227,6 +237,32 @@ class StateMachine(object):
                 f"Task: {str(task.id)[:8]} was reported as task.status by the robot"
             )
 
+    def publish_mission_aborted(self, reason: str, can_be_continued: bool) -> None:
+        if not self.mqtt_publisher:
+            return
+
+        if self.current_mission is None:
+            self.logger.warning(
+                "Could not publish mission aborted message. No ongoing mission."
+            )
+            return
+
+        payload: MissionAbortedPayload = MissionAbortedPayload(
+            isar_id=settings.ISAR_ID,
+            robot_name=settings.ROBOT_NAME,
+            mission_id=self.current_mission.id,
+            reason=reason,
+            can_be_continued=can_be_continued,
+            timestamp=datetime.now(timezone.utc),
+        )
+
+        self.mqtt_publisher.publish(
+            topic=settings.TOPIC_ISAR_MISSION_ABORTED,
+            payload=json.dumps(payload, cls=EnhancedJSONEncoder),
+            qos=1,
+            retain=True,
+        )
+
     def publish_mission_status(self) -> None:
         if not self.mqtt_publisher:
             return
@@ -339,6 +375,8 @@ class StateMachine(object):
             return RobotStatus.BlockedProtectiveStop
         elif self.current_state == States.InterventionNeeded:
             return RobotStatus.InterventionNeeded
+        elif self.current_state == States.Recharging:
+            return RobotStatus.Recharging
         else:
             return RobotStatus.Busy
 
@@ -368,7 +406,7 @@ class StateMachine(object):
         )
 
     def _queue_empty_response(self) -> None:
-        self.events.api_requests.stop_mission.response.put(
+        self.events.api_requests.stop_mission.response.trigger_event(
             ControlMissionResponse(
                 mission_id="None",
                 mission_status="None",

isar/state_machine/states/await_next_mission.py

@@ -25,7 +25,9 @@ class AwaitNextMission(EventHandlerBase):
             EventHandlerMapping(
                 name="start_mission_event",
                 event=events.api_requests.start_mission.request,
-                handler=lambda event: start_mission_event_handler(state_machine, event),
+                handler=lambda event: start_mission_event_handler(
+                    state_machine, event, events.api_requests.start_mission.response
+                ),
             ),
             EventHandlerMapping(
                 name="return_home_event",