ardupilot-methodic-configurator 2.2.0__tar.gz → 2.3.0__tar.gz

{ardupilot_methodic_configurator-2.2.0 → ardupilot_methodic_configurator-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ardupilot_methodic_configurator
-Version: 2.2.0
+Version: 2.3.0
 Summary: A clear configuration sequence for ArduPilot vehicles
 Author-email: Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
 Maintainer-email: Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
@@ -62,18 +62,18 @@ Requires-Dist: pymavlink==2.4.49
 Requires-Dist: pyserial==3.5
 Requires-Dist: requests==2.32.5
 Provides-Extra: dev
-Requires-Dist: coverage==7.10.6; extra == "dev"
+Requires-Dist: coverage==7.10.7; extra == "dev"
 Requires-Dist: mock==5.2.0; extra == "dev"
-Requires-Dist: mypy==1.18.1; extra == "dev"
+Requires-Dist: mypy==1.18.2; extra == "dev"
 Requires-Dist: pre-commit==4.3.0; extra == "dev"
 Requires-Dist: pylint==3.3.8; extra == "dev"
 Requires-Dist: pyright==1.1.405; extra == "dev"
 Requires-Dist: pytest==8.4.2; extra == "dev"
 Requires-Dist: pytest-cov==7.0.0; extra == "dev"
 Requires-Dist: pytest-md==0.2.0; extra == "dev"
-Requires-Dist: pytest-mock==3.15.0; extra == "dev"
+Requires-Dist: pytest-mock==3.15.1; extra == "dev"
 Requires-Dist: python-gettext==5.0; extra == "dev"
-Requires-Dist: ruff==0.13.0; extra == "dev"
+Requires-Dist: ruff==0.13.1; extra == "dev"
 Requires-Dist: types-requests==2.32.4.20250913; extra == "dev"
 Provides-Extra: scripts
 Requires-Dist: bs4; extra == "scripts"

{ardupilot_methodic_configurator-2.2.0 → ardupilot_methodic_configurator-2.3.0}/ardupilot_methodic_configurator/__init__.py

@@ -12,4 +12,4 @@ from ardupilot_methodic_configurator.internationalization import load_translatio
 
 _ = load_translation()
 
-__version__ = "2.2.0"
+__version__ = "2.3.0"

{ardupilot_methodic_configurator-2.2.0 → ardupilot_methodic_configurator-2.3.0}/ardupilot_methodic_configurator/__main__.py

@@ -36,6 +36,7 @@ from ardupilot_methodic_configurator.backend_filesystem_program_settings import
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.backend_internet import verify_and_open_url
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
+from ardupilot_methodic_configurator.configuration_manager import ConfigurationManager
 from ardupilot_methodic_configurator.data_model_par_dict import ParDict
 from ardupilot_methodic_configurator.data_model_software_updates import UpdateManager, check_for_software_updates
 from ardupilot_methodic_configurator.data_model_vehicle_project import VehicleProjectManager
@@ -168,8 +169,7 @@ def initialize_flight_controller_and_filesystem(state: ApplicationState) -> None
     # Get default parameter values from flight controller
     if state.flight_controller.master is not None or state.args.device == "test":
         fciw = FlightControllerInfoWindow(state.flight_controller)
-        default_values = fciw.get_param_default_values()
-        state.param_default_values = ParDict(default_values) if default_values else ParDict()
+        state.param_default_values = fciw.get_param_default_values()
 
     # Initialize local filesystem
     try:
@@ -191,7 +191,7 @@ def initialize_flight_controller_and_filesystem(state: ApplicationState) -> None
 
 def vehicle_directory_selection(state: ApplicationState) -> Union[VehicleDirectorySelectionWindow, None]:
     """
-    Handle vehicle directory selection if no parameter files are found.
+    Handle vehicle directory selection if no parameter files are found in the current working directory.
 
     Args:
         state: Application state containing filesystem and flight controller info
@@ -485,7 +485,8 @@ def parameter_editor_and_uploader(state: ApplicationState) -> None:
             )
 
     # Call the GUI function with the starting intermediate parameter file
-    ParameterEditorWindow(start_file, state.flight_controller, state.local_filesystem)
+    configuration_manager = ConfigurationManager(start_file, state.flight_controller, state.local_filesystem)
+    ParameterEditorWindow(configuration_manager)
 
 
 def main() -> None:

{ardupilot_methodic_configurator-2.2.0 → ardupilot_methodic_configurator-2.3.0}/ardupilot_methodic_configurator/backend_flightcontroller.py

@@ -8,6 +8,7 @@ SPDX-FileCopyrightText: 2024-2025 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
 SPDX-License-Identifier: GPL-3.0-or-later
 """
 
+import os
 from argparse import ArgumentParser
 from logging import debug as logging_debug
 from logging import error as logging_error
@@ -87,7 +88,7 @@ SUPPORTED_BAUDRATES: list[str] = [
 ]
 
 
-class FlightController:
+class FlightController:  # pylint: disable=too-many-public-methods
     """
     A class to manage the connection and parameters of a flight controller.
 
@@ -684,7 +685,7 @@ class FlightController:
         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)
+        ret = mavftp.process_ftp_reply("getparams", timeout=40)  #  on slow links it might take a long time
         pdict: dict[str, float] = {}
         defdict: ParDict = ParDict()
 
@@ -1163,6 +1164,180 @@ class FlightController:
             ret.display_message()
         return ret.error_code == 0
 
+    def download_last_flight_log(
+        self, local_filename: str, progress_callback: Union[None, Callable[[int, int], None]] = None
+    ) -> bool:
+        """Download the last flight log from the flight controller."""
+        if self.master is None:
+            error_msg = _("No flight controller connected")
+            logging_error(error_msg)
+            return False
+        if not self.info.is_mavftp_supported:
+            error_msg = _("MAVFTP is not supported by the flight controller")
+            logging_error(error_msg)
+            return False
+
+        mavftp = MAVFTP(self.master, target_system=self.master.target_system, target_component=self.master.target_component)
+
+        def get_progress_callback(completion: float) -> None:
+            if progress_callback is not None and completion is not None:
+                progress_callback(int(completion * 100), 100)
+
+        try:
+            # Try to get the last log number using different methods
+            remote_filenumber = self._get_last_log_number(mavftp)
+            if remote_filenumber is None:
+                return False
+
+            # We want the previous log, not the current one (which might be incomplete)
+            # remote_filenumber -= 1
+            # if remote_filenumber < 1:
+            #     logging_error(_("No previous flight log available"))
+            #     return False
+
+            return self._download_log_file(mavftp, remote_filenumber, local_filename, get_progress_callback)
+
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logging_error(_("Error during flight log download: %s"), str(e))
+            return False
+
+    def _get_last_log_number(self, mavftp: MAVFTP) -> Union[int, None]:
+        """Get the last log number using multiple fallback methods."""
+        # Method 1: Try to get LASTLOG.TXT
+        log_number = self._get_log_number_from_lastlog_txt(mavftp)
+        if log_number is not None:
+            return log_number
+
+        # Method 2: Try to list the logs directory and find the highest numbered log
+        log_number = self._get_log_number_from_directory_listing(mavftp)
+        if log_number is not None:
+            return log_number
+
+        # Method 3: Try common log numbers (scan backwards from a reasonable max)
+        log_number = self._get_log_number_by_scanning(mavftp)
+        if log_number is not None:
+            return log_number
+
+        logging_error(_("Could not determine the last log number using any method"))
+        return None
+
+    def _get_log_number_from_lastlog_txt(self, mavftp: MAVFTP) -> Union[int, None]:
+        """Try to get the log number from LASTLOG.TXT file."""
+        logging_info(_("Trying to get log number from LASTLOG.TXT"))
+        try:
+            temp_lastlog_file = "temp_lastlog.txt"
+            mavftp.cmd_get(["/APM/LOGS/LASTLOG.TXT", temp_lastlog_file])
+            ret = mavftp.process_ftp_reply("OpenFileRO", timeout=10)
+            if ret.error_code != 0:
+                logging_warning(_("LASTLOG.TXT not available, trying alternative methods"))
+                return None
+
+            return self._extract_log_number_from_file(temp_lastlog_file)
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logging_warning(_("Failed to get log number from LASTLOG.TXT: %s"), str(e))
+            return None
+
+    def _get_log_number_from_directory_listing(self, _mavftp: MAVFTP) -> Union[int, None]:
+        """Try to get the highest log number by listing the logs directory using MAVFTP."""
+        logging_info(_("Trying to get log number from directory listing"))
+        try:
+            result = _mavftp.cmd_list(["/APM/LOGS/"])
+            if not hasattr(result, "directory_listing") or not isinstance(result.directory_listing, dict):
+                logging_error(_("No directory listing found in MAVFTPReturn"))
+                return None
+            highest = -1
+            for name in result.directory_listing:
+                # Typical log file names: 00000036.BIN, 00000037.BIN, etc.
+                if name.endswith(".BIN") and name[:8].isdigit():
+                    try:
+                        log_num = int(name[:8])
+                        highest = max(highest, log_num)
+                    except ValueError:
+                        continue
+            if highest != -1:
+                logging_info(_("Highest log number found: %d"), highest)
+                return highest
+            logging_error(_("No log files found in directory listing"))
+            return None
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logging_warning(_("Failed to get log number from directory listing: %s"), str(e))
+            return None
+
+    def _get_log_number_by_scanning(self, mavftp: MAVFTP) -> Union[int, None]:
+        """Try to find the last log using binary search for efficiency."""
+        logging_info(_("Trying to find log number using binary search"))
+        try:
+            # Binary search to find the highest log number
+            low = 1
+            high = 9999  # Reasonable upper bound for log numbers
+            last_found = None
+
+            while low <= high:
+                mid = (low + high) // 2
+                remote_filename = f"/APM/LOGS/{mid:08}.BIN"
+
+                # Test if this log file exists
+                temp_test_file = f"temp_test_{mid}.tmp"
+                mavftp.cmd_get([remote_filename, temp_test_file])
+                ret = mavftp.process_ftp_reply("OpenFileRO", timeout=5)  # Must be > idle_detection_time (3.7s)
+
+                # Clean up the temp file if it was created
+                if os.path.exists(temp_test_file):
+                    os.remove(temp_test_file)
+
+                if ret.error_code == 0:
+                    # File exists, search in upper half
+                    last_found = mid
+                    low = mid + 1
+                    logging_debug(_("Log %d exists, searching higher"), mid)
+                else:
+                    # File doesn't exist, search in lower half
+                    high = mid - 1
+                    logging_debug(_("Log %d doesn't exist, searching lower"), mid)
+
+            if last_found is not None:
+                logging_info(_("Found highest log number using binary search: %d"), last_found)
+                return last_found
+
+            logging_warning(_("No log files found using binary search"))
+            return None
+
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logging_warning(_("Failed to scan for log numbers using binary search: %s"), str(e))
+            return None
+
+    def _download_log_file(
+        self, mavftp: MAVFTP, remote_filenumber: int, local_filename: str, get_progress_callback: Callable
+    ) -> bool:
+        """Download the actual log file from the flight controller."""
+        remote_filename = f"/APM/LOGS/{remote_filenumber:08}.BIN"
+        logging_info(_("Downloading flight log %s to %s"), remote_filename, local_filename)
+
+        # Download the actual log file
+        mavftp.cmd_get([remote_filename, local_filename], progress_callback=get_progress_callback)
+        ret = mavftp.process_ftp_reply("OpenFileRO", timeout=0)  # No timeout for large log files
+        if ret.error_code != 0:
+            logging_error(_("Failed to download flight log %s"), remote_filename)
+            ret.display_message()
+            return False
+
+        logging_info(_("Successfully downloaded flight log to %s"), local_filename)
+        return True
+
+    def _extract_log_number_from_file(self, temp_lastlog_file: str) -> Union[int, None]:
+        """Extract log number from LASTLOG.TXT file and clean up the temporary file."""
+        try:
+            with open(temp_lastlog_file, encoding="UTF-8") as file:
+                file_contents = file.readline()
+                return int(file_contents.strip())
+        except (FileNotFoundError, ValueError) as e:
+            logging_error(_("Could not extract last log file number from LASTLOG.TXT: %s"), e)
+            return None
+        finally:
+            # Clean up the temporary file
+            if os.path.exists(temp_lastlog_file):
+                os.remove(temp_lastlog_file)
+
     @staticmethod
     def add_argparse_arguments(parser: ArgumentParser) -> ArgumentParser:
         parser.add_argument(

{ardupilot_methodic_configurator-2.2.0 → ardupilot_methodic_configurator-2.3.0}/ardupilot_methodic_configurator/backend_mavftp.py

@@ -229,6 +229,7 @@ class MAVFTPReturn:
         invalid_error_code: int = 0,
         invalid_opcode: int = 0,
         invalid_payload_size: int = 0,
+        directory_listing: Union[dict[str, int], None] = None,
     ) -> None:
         self.operation_name = operation_name
         self.error_code = error_code
@@ -236,8 +237,9 @@ class MAVFTPReturn:
         self.invalid_error_code = invalid_error_code
         self.invalid_opcode = invalid_opcode
         self.invalid_payload_size = invalid_payload_size
+        self.directory_listing = directory_listing
 
-    def display_message(self) -> None:  # pylint: disable=too-many-branches
+    def display_message(self) -> None:  # pylint: disable=too-many-branches, too-many-statements # noqa: C901, PLR0912, PLR0915
         if self.error_code == ERR_None:
             logging.info("%s succeeded", self.operation_name)
         elif self.error_code == ERR_Fail:
@@ -284,6 +286,16 @@ class MAVFTPReturn:
         else:
             logging.error("%s failed, unknown error %u in display_message()", self.operation_name, self.error_code)
 
+        if self.directory_listing is not None:
+            total_size = 0
+            for name, size in self.directory_listing.items():
+                if size == -1:  # directories are defined by a size of -1
+                    logging.info("   %s/", name)
+                else:
+                    logging.info("   %s\t%u", name, size)
+                total_size += max(0, size)
+            logging.info("Total size %.2f kByte", total_size / 1024.0)
+
     @property
     def return_code(self) -> int:
         return self.error_code
@@ -357,6 +369,7 @@ class MAVFTP:  # pylint: disable=too-many-instance-attributes
         self.write_pending = 0
         self.write_last_send: Union[None, float] = None
         self.open_retries = 0
+        self.directory_listing: dict[str, int] = {}
 
         self.master = master
         self.target_system = target_system
@@ -464,6 +477,7 @@ class MAVFTP:  # pylint: disable=too-many-instance-attributes
         self.dir_offset = 0
         op = FTP_OP(self.seq, self.session, OP_ListDirectory, len(enc_dname), 0, 0, self.dir_offset, enc_dname)
         self.__send(op)
+        self.directory_listing = {}
         return self.process_ftp_reply("ListDirectory")
 
     def __handle_list_reply(self, op, _m) -> MAVFTPReturn:
@@ -477,13 +491,20 @@ class MAVFTP:  # pylint: disable=too-many-instance-attributes
                 self.dir_offset += 1
                 try:
                     d = str(d, "ascii")  # noqa: PLW2901
-                except Exception:  # noqa: S112 pylint: disable=broad-exception-caught
+                except (TypeError, UnicodeDecodeError):
                     continue
                 if d[0] == "D":
-                    logging.info(" D %s", d[1:])
+                    name = d[1:]
+                    self.directory_listing[name] = -1  # directories are defined by a size of -1
+                    logging.info(" D %s", name)
                 elif d[0] == "F":
                     (name, size) = d[1:].split("\t")
-                    size_int = int(size)
+                    try:
+                        size_int = int(size)
+                    except (ValueError, TypeError, OverflowError):
+                        logging.error("Invalid file size: %s", size)
+                        size_int = 0
+                    self.directory_listing[name] = size_int
                     self.total_size += size_int
                     logging.info("   %s\t%u", name, size_int)
                 else:
@@ -497,7 +518,7 @@ class MAVFTP:  # pylint: disable=too-many-instance-attributes
             self.total_size = 0
         else:
             return self.__decode_ftp_ack_and_nack(op)
-        return MAVFTPReturn("ListDirectory", ERR_None)
+        return MAVFTPReturn("ListDirectory", ERR_None, directory_listing=self.directory_listing)
 
     def cmd_get(self, args, callback=None, progress_callback=None) -> MAVFTPReturn:
         """Get file."""