ardupilot-methodic-configurator 2.1.2__py3-none-any.whl → 2.2.0__py3-none-any.whl

ardupilot_methodic_configurator/backend_flightcontroller.py

@@ -16,6 +16,7 @@ from logging import warning as logging_warning
 from os import name as os_name
 from os import path as os_path
 from os import readlink as os_readlink
+from pathlib import Path
 from time import sleep as time_sleep
 from time import time as time_time
 from typing import Callable, NoReturn, Optional, Union
@@ -27,10 +28,10 @@ from pymavlink.dialects.v20.ardupilotmega import MAVLink_autopilot_version_messa
 from serial.serialutil import SerialException
 
 from ardupilot_methodic_configurator import _
-from ardupilot_methodic_configurator.annotate_params import Par
 from ardupilot_methodic_configurator.argparse_check_range import CheckRange
 from ardupilot_methodic_configurator.backend_flightcontroller_info import BackendFlightcontrollerInfo
 from ardupilot_methodic_configurator.backend_mavftp import MAVFTP
+from ardupilot_methodic_configurator.data_model_par_dict import ParDict
 
 # pylint: disable=too-many-lines
 
@@ -64,16 +65,36 @@ class FakeSerialForTests:
 
 DEFAULT_BAUDRATE: int = 115200
 DEFAULT_REBOOT_TIME: int = 7
-
-
-class FlightController:  # pylint: disable=too-many-public-methods
+# https://github.com/ArduPilot/ardupilot/blob/master/libraries/AP_SerialManager/AP_SerialManager.cpp#L741C1-L757C32
+SUPPORTED_BAUDRATES: list[str] = [
+    "1200",
+    "2400",
+    "4800",
+    "9600",
+    "19200",
+    "38400",
+    "57600",
+    "100000",
+    "111100",
+    "115200",
+    "230400",
+    "256000",
+    "460800",
+    "500000",
+    "921600",
+    "1500000",
+    "2000000",
+]
+
+
+class FlightController:
     """
     A class to manage the connection and parameters of a flight controller.
 
     Attributes:
         device (str): The connection string to the flight controller.
         master (mavutil.mavlink_connection): The MAVLink connection object.
-        fc_parameters (Dict[str, float]): A dictionary of flight controller parameters.
+        fc_parameters (dict[str, float]): A dictionary of flight controller parameters.
 
     """
 
@@ -145,11 +166,15 @@ class FlightController:  # pylint: disable=too-many-public-methods
             self.__connection_tuples.insert(-1, (self.comport.device, getattr(self.comport, "description", "")))
         # Try to connect
         return self.__create_connection_with_retry(
-            progress_callback=progress_callback, baudrate=baudrate, log_errors=log_errors
+            progress_callback=progress_callback, baudrate=baudrate, log_errors=log_errors, timeout=2
         )
 
     def connect(
-        self, device: str, progress_callback: Union[None, Callable[[int, int], None]] = None, log_errors: bool = True
+        self,
+        device: str,
+        progress_callback: Union[None, Callable[[int, int], None]] = None,
+        log_errors: bool = True,
+        baudrate: Optional[int] = None,
     ) -> str:
         """
         Establishes a connection to the FlightController using a specified device.
@@ -166,19 +191,25 @@ class FlightController:  # pylint: disable=too-many-public-methods
             progress_callback (callable, optional): A callback function to report the progress
                                                     of the connection attempt. Default is None.
             log_errors: log errors
+            baudrate (int, optional): The baudrate to use for the connection. If None,
+                                    uses the default baudrate from initialization.
 
         Returns:
             str: An error message if the connection fails, otherwise an empty string indicating
                 a successful connection.
 
         """
+        connection_baudrate = baudrate
+        if connection_baudrate is None:
+            connection_baudrate = self.__baudrate
+
         if device:
             if device == "none":
                 return ""
             self.add_connection(device)
             self.comport = mavutil.SerialPort(device=device, description=device)
             return self.__create_connection_with_retry(
-                progress_callback=progress_callback, baudrate=self.__baudrate, log_errors=log_errors
+                progress_callback=progress_callback, baudrate=connection_baudrate, log_errors=log_errors
             )
 
         # Try to autodetect serial ports
@@ -200,7 +231,7 @@ class FlightController:  # pylint: disable=too-many-public-methods
             err = self._register_and_try_connect(
                 comport=autodetect_serial[0],
                 progress_callback=progress_callback,
-                baudrate=self.__baudrate,
+                baudrate=connection_baudrate,
                 log_errors=False,
             )
             if err == "":
@@ -403,7 +434,10 @@ class FlightController:  # pylint: disable=too-many-public-methods
         """
         if self.comport is None or self.comport.device == "test":  # FIXME for testing only pylint: disable=fixme
             return ""
-        logging_info(_("Will connect to %s @ %u baud"), self.comport.device, baudrate)
+        if self.comport.device.startswith("udp") or self.comport.device.startswith("tcp"):
+            logging_info(_("Will connect to %s"), self.comport.device)
+        else:
+            logging_info(_("Will connect to %s @ %u baud"), self.comport.device, baudrate)
         try:
             # Create the connection
             self.master = mavutil.mavlink_connection(
@@ -524,41 +558,64 @@ class FlightController:  # pylint: disable=too-many-public-methods
         return ""
 
     def download_params(
-        self, progress_callback: Union[None, Callable[[int, int], None]] = None
-    ) -> tuple[dict[str, float], dict[str, "Par"]]:
+        self,
+        progress_callback: Union[None, Callable[[int, int], None]] = None,
+        parameter_values_filename: Optional[Path] = None,
+        parameter_defaults_filename: Optional[Path] = None,
+    ) -> tuple[dict[str, float], ParDict]:
         """
         Requests all flight controller parameters from a MAVLink connection.
 
+        Args:
+            progress_callback (Union[None, Callable[[int, int], None]]): A callback function to report download progress.
+            parameter_values_filename (Optional[Path]): The filename to save the parameter values.
+            parameter_defaults_filename (Optional[Path]): The filename to save the parameter defaults.
+
         Returns:
-            Dict[str, float]: A dictionary of flight controller parameters.
-            Dict[str, Par]: A dictionary of flight controller default parameters.
+            dict[str, float]: A dictionary of flight controller parameters.
+            ParDict: A dictionary of flight controller default parameters.
 
         """
         # FIXME this entire if statement is for testing only, remove it later pylint: disable=fixme
         if self.master is None and self.comport is not None and self.comport.device == "test":
             filename = "params.param"
             logging_warning(_("Testing active, will load all parameters from the %s file"), filename)
-            par_dict_with_comments = Par.load_param_file_into_dict(filename)
-            return {k: v.value for k, v in par_dict_with_comments.items()}, {}
+            par_dict_with_comments = ParDict.from_file(filename)
+            return {k: v.value for k, v in par_dict_with_comments.items()}, ParDict()
 
         if self.master is None:
-            return {}, {}
+            return {}, ParDict()
 
         # Check if MAVFTP is supported
         comport_device = getattr(self.comport, "device", "")
         if self.info.is_mavftp_supported:
             logging_info(_("MAVFTP is supported by the %s flight controller"), comport_device)
 
-            param_dict, default_param_dict = self.download_params_via_mavftp(progress_callback)
+            param_dict, default_param_dict = self._download_params_via_mavftp(
+                progress_callback, parameter_values_filename, parameter_defaults_filename
+            )
             if param_dict:
                 return param_dict, default_param_dict
 
         logging_info(_("MAVFTP is not supported by the %s flight controller, fallback to MAVLink"), comport_device)
-        return self.__download_params_via_mavlink(progress_callback), {}
+        return self._download_params_via_mavlink(progress_callback), ParDict()
 
-    def __download_params_via_mavlink(
+    def _download_params_via_mavlink(
         self, progress_callback: Union[None, Callable[[int, int], None]] = None
     ) -> dict[str, float]:
+        """
+        Requests all flight controller parameters from a MAVLink connection.
+
+        Gets parameters via PARAM_REQUEST_LIST and PARAM_VALUE messages
+
+        Args:
+            progress_callback (Union[None, Callable[[int, int], None]]): A callback function to report download progress.
+
+        Returns:
+            dict[str, float]: A dictionary of flight controller parameters.
+            ParDict: A dictionary of flight controller default parameters.
+
+        """
         comport_device = getattr(self.comport, "device", "")
         logging_debug(_("Will fetch all parameters from the %s flight controller"), comport_device)
 
@@ -595,33 +652,51 @@ class FlightController:  # pylint: disable=too-many-public-methods
                 break
         return parameters
 
-    def download_params_via_mavftp(
-        self, progress_callback: Union[None, Callable[[int, int], None]] = None
-    ) -> tuple[dict[str, float], dict[str, "Par"]]:
+    def _download_params_via_mavftp(
+        self,
+        progress_callback: Union[None, Callable[[int, int], None]] = None,
+        parameter_values_filename: Optional[Path] = None,
+        parameter_defaults_filename: Optional[Path] = None,
+    ) -> tuple[dict[str, float], ParDict]:
+        """
+        Requests all flight controller parameters from a MAVLink connection.
+
+        Gets parameters via MAVFTP protocol
+
+        Args:
+            progress_callback (Union[None, Callable[[int, int], None]]): A callback function to report download progress.
+            parameter_values_filename (Optional[Path]): The filename to save the parameter values.
+            parameter_defaults_filename (Optional[Path]): The filename to save the parameter defaults.
+
+        Returns:
+            dict[str, float]: A dictionary of flight controller parameters.
+            ParDict: A dictionary of flight controller default parameters.
+
+        """
         if self.master is None:
-            return {}, {}
+            return {}, ParDict()
         mavftp = MAVFTP(self.master, target_system=self.master.target_system, target_component=self.master.target_component)
 
         def get_params_progress_callback(completion: float) -> None:
             if progress_callback is not None and completion is not None:
                 progress_callback(int(completion * 100), 100)
 
-        complete_param_filename = "complete.param"
-        default_param_filename = "00_default.param"
+        complete_param_filename = str(parameter_values_filename) if parameter_values_filename else "complete.param"
+        default_param_filename = str(parameter_defaults_filename) if parameter_defaults_filename else "00_default.param"
         mavftp.cmd_getparams([complete_param_filename, default_param_filename], progress_callback=get_params_progress_callback)
         ret = mavftp.process_ftp_reply("getparams", timeout=10)
-        pdict = {}
+        pdict: dict[str, float] = {}
+        defdict: ParDict = ParDict()
+
         # add a file sync operation to ensure the file is completely written
         time_sleep(0.3)
         if ret.error_code == 0:
             # load the parameters from the file
-            par_dict = Par.load_param_file_into_dict(complete_param_filename)
-            for name, data in par_dict.items():
-                pdict[name] = data.value
-            defdict = Par.load_param_file_into_dict(default_param_filename)
+            par_dict = ParDict.from_file(complete_param_filename)
+            pdict = {name: data.value for name, data in par_dict.items()}
+            defdict = ParDict.from_file(default_param_filename)
         else:
             ret.display_message()
-            defdict = {}
 
         return pdict, defdict
 

ardupilot_methodic_configurator/data_model_ardupilot_parameter.py

@@ -12,8 +12,7 @@ from math import inf, isfinite, isnan, nan
 from typing import Any, Optional
 
 from ardupilot_methodic_configurator import _
-from ardupilot_methodic_configurator.annotate_params import Par
-from ardupilot_methodic_configurator.backend_filesystem import is_within_tolerance
+from ardupilot_methodic_configurator.data_model_par_dict import Par, is_within_tolerance
 
 
 class ParameterUnchangedError(Exception):

ardupilot_methodic_configurator/data_model_configuration_step.py

@@ -17,6 +17,7 @@ from typing import Any, Optional
 from ardupilot_methodic_configurator import _
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.data_model_ardupilot_parameter import ArduPilotParameter
+from ardupilot_methodic_configurator.data_model_par_dict import ParDict
 
 
 class ConfigurationStepProcessor:
@@ -157,8 +158,8 @@ class ConfigurationStepProcessor:
             default_par = self.local_filesystem.param_default_dict.get(param_name, None)
 
             # Check if parameter is forced or derived
-            forced_par = self.local_filesystem.forced_parameters.get(selected_file, {}).get(param_name, None)
-            derived_par = self.local_filesystem.derived_parameters.get(selected_file, {}).get(param_name, None)
+            forced_par = self.local_filesystem.forced_parameters.get(selected_file, ParDict()).get(param_name, None)
+            derived_par = self.local_filesystem.derived_parameters.get(selected_file, ParDict()).get(param_name, None)
 
             # Get FC value if available
             fc_value = fc_parameters.get(param_name)