wip

Signed-off-by: Patrick José Pereira <patrickelectric@gmail.com>

Author: patrickelectric

core/frontend/src/components/autopilot/AutopilotManagerUpdater.ts

@@ -114,6 +114,34 @@ export async function fetchFirmwareVehicleType(): Promise<void> {
   }
 }
 
+export async function fetchExtraArguments(): Promise<void> {
+  try {
+    const response = await back_axios({
+      method: 'get',
+      url: `${autopilot.API_URL}/extra_arguments`,
+      timeout: 10000,
+    })
+    autopilot.setExtraArguments(response.data)
+  } catch (error) {
+    autopilot.setExtraArguments({})
+    notifier.pushBackError('AUTOPILOT_EXTRA_ARGS_FETCH_FAIL', error)
+  }
+}
+
+export async function fetchProcessStatus(): Promise<void> {
+  try {
+    const response = await back_axios({
+      method: 'get',
+      url: `${autopilot.API_URL}/process_status`,
+      timeout: 10000,
+    })
+    autopilot.setProcessStatus(response.data)
+  } catch (error) {
+    autopilot.setProcessStatus(null)
+    notifier.pushBackError('AUTOPILOT_PROCESS_STATUS_FETCH_FAIL', error)
+  }
+}
+
 export async function availableFirmwares(vehicleType: Vehicle): Promise<Firmware[]> {
   return back_axios({
     method: 'get',

core/frontend/src/store/autopilot_manager.ts

@@ -5,8 +5,9 @@ import {
 import store from '@/store'
 import {
   AutopilotEndpoint, FirmwareInfo, FirmwareVehicleType,
-  FlightController, SerialEndpoint,
+  FlightController, ProcessStatus, SerialEndpoint,
 } from '@/types/autopilot'
+import { Dictionary } from '@/types/common'
 
 @Module({
   dynamic: true,
@@ -37,6 +38,10 @@ class AutopilotManagerStore extends VuexModule {
 
   autopilot_serials: SerialEndpoint[] = []
 
+  extra_arguments: Dictionary<string> = {}
+
+  process_status: ProcessStatus | null = null
+
   @Mutation
   setAutopilotSerialConfigurations(serials: SerialEndpoint[]): void {
     this.autopilot_serials = serials
@@ -83,6 +88,16 @@ class AutopilotManagerStore extends VuexModule {
     this.available_boards = boards
     this.updating_boards = false
   }
+
+  @Mutation
+  setExtraArguments(arguments_: Dictionary<string>): void {
+    this.extra_arguments = arguments_
+  }
+
+  @Mutation
+  setProcessStatus(process_status: ProcessStatus | null): void {
+    this.process_status = process_status
+  }
 }
 
 export { AutopilotManagerStore }

core/frontend/src/types/autopilot.ts

@@ -98,3 +98,8 @@ export interface SerialEndpoint {
   port: string
   endpoint: string
 }
+
+export interface ProcessStatus {
+  running: boolean
+  exit_code: number | null
+}

core/frontend/src/views/Autopilot.vue

@@ -74,6 +74,16 @@
             </v-expansion-panel-content>
           </v-expansion-panel>
         </v-expansion-panels>
+        <v-expansion-panels v-if="settings.is_pirate_mode && isLinuxFlightController">
+          <v-expansion-panel>
+            <v-expansion-panel-header>
+              Extra Arguments
+            </v-expansion-panel-header>
+            <v-expansion-panel-content>
+              <autopilot-extra-arguments />
+            </v-expansion-panel-content>
+          </v-expansion-panel>
+        </v-expansion-panels>
       </v-card-text>
       <v-card-actions class="d-flex justify-end align-center flex-wrap">
         <v-spacer />
@@ -131,6 +141,7 @@ import Vue from 'vue'
 import ArduPilotBanner from '@/assets/img/banners/ArduPilot.svg'
 import OpenPilotBanner from '@/assets/img/banners/OpenPilot.svg'
 import PX4Banner from '@/assets/img/banners/PX4.svg'
+import AutopilotExtraArguments from '@/components/autopilot/AutopilotExtraArguments.vue'
 import * as AutopilotManager from '@/components/autopilot/AutopilotManagerUpdater'
 import {
   fetchAvailableBoards, fetchCurrentBoard, fetchFirmwareInfo, fetchFirmwareVehicleType, fetchVehicleType,
@@ -156,6 +167,7 @@ const notifier = new Notifier(autopilot_service)
 export default Vue.extend({
   name: 'Autopilot',
   components: {
+    AutopilotExtraArguments,
     BoardChangeDialog,
     FirmwareManager,
     AutopilotSerialConfiguration,

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

@@ -3,7 +3,7 @@
 import shutil
 from functools import wraps
 from pathlib import Path
-from typing import Any, Callable, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from autopilot_manager import AutoPilotManager
 from commonwealth.mavlink_comm.exceptions import (
@@ -24,6 +24,7 @@
     FlightController,
     FlightControllerFlags,
     Parameters,
+    ProcessStatus,
     Serial,
     SITLFrame,
     Vehicle,
@@ -136,6 +137,24 @@ async def set_sitl_frame(frame: SITLFrame) -> Any:
     return autopilot.set_sitl_frame(frame)
 
 
+@index_router_v1.get("/extra_arguments", response_model=Dict[str, str], summary="Get extra ArduPilot arguments.")
+@index_to_http_exception
+def get_extra_arguments() -> Any:
+    return autopilot.get_extra_arguments()
+
+
+@index_router_v1.put("/extra_arguments", status_code=status.HTTP_200_OK, summary="Set extra ArduPilot arguments.")
+@index_to_http_exception
+def set_extra_arguments(arguments: Dict[str, str] = Body(...)) -> Any:
+    autopilot.set_extra_arguments(arguments)
+
+
+@index_router_v1.get("/process_status", response_model=ProcessStatus, summary="Get ArduPilot process status.")
+@index_to_http_exception
+def get_process_status() -> Any:
+    return autopilot.get_process_status()
+
+
 @index_router_v1.get("/firmware_vehicle_type", response_model=str, summary="Get firmware vehicle type.")
 @index_to_http_exception
 async def get_firmware_vehicle_type() -> Any:

core/services/ardupilot_manager/autopilot_manager.py

@@ -4,7 +4,7 @@
 import subprocess
 import time
 from copy import deepcopy
-from typing import Any, List, Optional, Set
+from typing import Any, Dict, List, Optional, Set
 
 import psutil
 from commonwealth.mavlink_comm.VehicleManager import VehicleManager
@@ -30,6 +30,7 @@
     Parameters,
     Platform,
     PlatformType,
+    ProcessStatus,
     Serial,
     SITLFrame,
     Vehicle,
@@ -151,6 +152,7 @@ async def setup(self) -> None:
         self.vehicle_manager = VehicleManager()
 
         self.should_be_running = False
+        self._last_exit_code: Optional[int] = None
         self.remove_old_logs()
         self.current_sitl_frame = self.load_sitl_frame()
 
@@ -189,6 +191,11 @@ def is_running(self) -> bool:
     async def auto_restart_ardupilot(self) -> None:
         """Auto-restart Ardupilot when it's not running but was supposed to."""
         while True:
+            if self.ardupilot_subprocess is not None and self.ardupilot_subprocess.poll() is not None:
+                self._last_exit_code = self.ardupilot_subprocess.returncode
+                if self._last_exit_code != 0:
+                    logger.warning(f"ArduPilot process exited with code {self._last_exit_code}")
+
             needs_restart = self.should_be_running and not self.is_running()
             if needs_restart:
                 logger.debug("Restarting ardupilot...")
@@ -315,6 +322,7 @@ async def start_linux_board(self, board: LinuxFlightController) -> None:
         #
         # The first column comes from https://ardupilot.org/dev/docs/sitl-serial-mapping.html
 
+        extra_args = self.get_extra_arguments_cmdline()
         command_line = (
             f"{firmware_path}"
             f" -A udp:{master_endpoint.place}:{master_endpoint.argument}"
@@ -323,11 +331,14 @@ async def start_linux_board(self, board: LinuxFlightController) -> None:
             f" {self.get_serial_cmdline()}"
             f" {self.get_default_params_cmdline(board.platform)}"
         )
+        if extra_args:
+            command_line += f" {extra_args}"
 
         if self.firmware_has_debug_symbols(firmware_path):
             logger.info("Debug symbols found, launching with gdb server...")
             command_line = f"gdbserver 0.0.0.0:5555 {command_line}"
 
+        self._last_exit_code = None
         logger.info(f"Using command line: '{command_line}'")
         self.ardupilot_subprocess = subprocess.Popen(
             command_line,
@@ -389,6 +400,25 @@ 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()]
 
+    def get_extra_arguments(self) -> Dict[str, str]:
+        return self.configuration.get("extra_arguments", {})
+
+    def set_extra_arguments(self, arguments: Dict[str, str]) -> None:
+        self.configuration["extra_arguments"] = arguments
+        self.settings.save(self.configuration)
+
+    def get_extra_arguments_cmdline(self) -> str:
+        parts = []
+        for name, value in self.get_extra_arguments().items():
+            if value:
+                parts.append(f"{name} {value}")
+            else:
+                parts.append(name)
+        return " ".join(parts)
+
+    def get_process_status(self) -> ProcessStatus:
+        return ProcessStatus(running=self.is_running(), exit_code=self._last_exit_code)
+
     async def start_manual_board(self, board: FlightController) -> None:
         self._current_board = board
         self.master_endpoint = self.get_manual_board_master_endpoint()
@@ -417,18 +447,23 @@ async def start_sitl(self) -> None:
             argument=5760,
             protected=True,
         )
+
+        extra_args = self.get_extra_arguments_cmdline()
+        command_line = (
+            f"{firmware_path}"
+            f" --model {self.current_sitl_frame.value}"
+            f" --base-port {master_endpoint.argument}"
+            f" --home -27.563,-48.459,0.0,270.0"
+        )
+        if extra_args:
+            command_line += f" {extra_args}"
+
         # pylint: disable=consider-using-with
+        self._last_exit_code = None
+        logger.info(f"Using command line: '{command_line}'")
         self.ardupilot_subprocess = subprocess.Popen(
-            [
-                firmware_path,
-                "--model",
-                self.current_sitl_frame.value,
-                "--base-port",
-                str(master_endpoint.argument),
-                "--home",
-                "-27.563,-48.459,0.0,270.0",
-            ],
-            shell=False,
+            command_line,
+            shell=True,
             encoding="utf-8",
             errors="ignore",
             cwd=self.settings.firmware_folder,

core/services/ardupilot_manager/typedefs.py

@@ -209,3 +209,8 @@ def valid_endpoint(cls: Any, value: str) -> str:
 
     def __hash__(self) -> int:  # make hashable BaseModel subclass
         return hash(self.port + self.endpoint)
+
+
+class ProcessStatus(BaseModel):
+    running: bool
+    exit_code: Optional[int] = None