autopilot manager: add Unmanaged board for ethernet connections

core/services/ardupilot_manager/api/v1/routers/endpoints.py

@@ -34,3 +34,13 @@ async def remove_endpoints(endpoints: Set[Endpoint] = Body(...)) -> Any:
 @endpoints_router_v1.put("/", status_code=status.HTTP_200_OK)
 async def update_endpoints(endpoints: Set[Endpoint] = Body(...)) -> Any:
     await autopilot.update_endpoints(endpoints)
+
+
+@endpoints_router_v1.post("/unmanaged_board_master_endpoint", summary="Set the master endpoint for an unmanaged board.")
+async def set_unmanaged_board_master_endpoint(endpoint: Endpoint) -> bool:
+    return autopilot.set_unmanaged_board_master_endpoint(endpoint)
+
+
+@endpoints_router_v1.get("/unmanaged_board_master_endpoint", summary="Get the master endpoint for an unmanaged board.")
+def get_unmanaged_board_master_endpoint() -> Any:
+    return autopilot.get_unmanaged_board_master_endpoint()

core/services/ardupilot_manager/autopilot_manager.py

@@ -322,6 +322,12 @@ def load_preferred_router(self) -> Optional[str]:
     def get_available_routers(self) -> List[str]:
         return [router.name() for router in self.mavlink_manager.available_interfaces()]
 
+    async def start_unmanaged_board(self, board: FlightController) -> None:
+        self._current_board = board
+        self.master_endpoint = self.get_unmanaged_board_master_endpoint()
+        self.ardupilot_subprocess = None
+        await self.start_mavlink_manager(self.master_endpoint)
+
     async def start_sitl(self) -> None:
         self._current_board = BoardDetector.detect_sitl()
         if not self.firmware_manager.is_firmware_installed(self._current_board):
@@ -583,6 +589,8 @@ async def start_ardupilot(self) -> None:
                 await self.start_serial(flight_controller)
             elif flight_controller.platform == Platform.SITL:
                 await self.start_sitl()
+            elif flight_controller.platform == Platform.Unmanaged:
+                await self.start_unmanaged_board(flight_controller)
             else:
                 raise RuntimeError(f"Invalid board type: {flight_controller}")
         finally:
@@ -661,3 +669,23 @@ def install_firmware_from_url(
 
     def restore_default_firmware(self, board: FlightController) -> None:
         self.firmware_manager.restore_default_firmware(board)
+
+    def set_unmanaged_board_master_endpoint(self, endpoint: Endpoint) -> bool:
+        self.configuration["unmanaged_board_master_endpoint"] = endpoint.as_dict()
+        self.settings.save(self.configuration)
+        return True
+
+    def get_unmanaged_board_master_endpoint(self) -> Endpoint:
+        default_master_endpoint = Endpoint(
+            name="Unmanaged Board Master Endpoint",
+            owner=self.settings.app_name,
+            connection_type=EndpointType.UDPServer,
+            place="0.0.0.0",
+            argument=14550,
+            persistent=True,
+            enabled=True,
+        )
+        endpoint = self.configuration.get("unmanaged_board_master_endpoint", None)
+        if endpoint is None:
+            return default_master_endpoint
+        return Endpoint(**endpoint)

core/services/ardupilot_manager/flight_controller_detector/Detector.py

@@ -77,7 +77,7 @@ def detect_sitl() -> FlightController:
         return FlightController(name="SITL", manufacturer="ArduPilot Team", platform=Platform.SITL)
 
     @classmethod
-    async def detect(cls, include_sitl: bool = True) -> List[FlightController]:
+    async def detect(cls, include_sitl: bool = True, include_unmanaged: bool = True) -> List[FlightController]:
         """Return a list of available flight controllers
 
         Arguments:
@@ -99,4 +99,7 @@ async def detect(cls, include_sitl: bool = True) -> List[FlightController]:
         if include_sitl:
             available.append(Detector.detect_sitl())
 
+        if include_unmanaged:
+            available.append(FlightController(name="Unmanaged", manufacturer="Unmanaged", platform=Platform.Unmanaged))
+
         return available

core/services/ardupilot_manager/typedefs.py

@@ -97,6 +97,7 @@ class PlatformType(LowerStringEnum):
     Linux = auto()
     SITL = auto()
     Unknown = auto()
+    Unmanaged = auto()
 
 
 class Platform(str, Enum):
@@ -113,6 +114,7 @@ class Platform(str, Enum):
     Navigator64 = "navigator64"
     Argonot = "argonot"
     SITL = get_sitl_platform_name(machine())
+    Unmanaged = "Unmanaged"
 
     @property
     def type(self) -> PlatformType:
@@ -127,6 +129,7 @@ def type(self) -> PlatformType:
             Platform.Navigator64: PlatformType.Linux,
             Platform.Argonot: PlatformType.Linux,
             Platform.SITL: PlatformType.SITL,
+            Platform.Unmanaged: PlatformType.Unmanaged,
         }
         return platform_types.get(self, PlatformType.Unknown)