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

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.4.0"

ardupilot_methodic_configurator/__main__.py

@@ -36,14 +36,15 @@ 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
 from ardupilot_methodic_configurator.frontend_tkinter_component_editor import ComponentEditorWindow
 from ardupilot_methodic_configurator.frontend_tkinter_connection_selection import ConnectionSelectionWindow
-from ardupilot_methodic_configurator.frontend_tkinter_directory_selection import VehicleDirectorySelectionWindow
 from ardupilot_methodic_configurator.frontend_tkinter_flightcontroller_info import FlightControllerInfoWindow
 from ardupilot_methodic_configurator.frontend_tkinter_parameter_editor import ParameterEditorWindow
+from ardupilot_methodic_configurator.frontend_tkinter_project_opener import VehicleProjectOpenerWindow
 from ardupilot_methodic_configurator.frontend_tkinter_show import show_error_message
 
 
@@ -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:
@@ -189,19 +189,18 @@ def initialize_flight_controller_and_filesystem(state: ApplicationState) -> None
         state.param_default_values_dirty = state.local_filesystem.write_param_default_values(state.param_default_values)
 
 
-def vehicle_directory_selection(state: ApplicationState) -> Union[VehicleDirectorySelectionWindow, None]:
+def vehicle_directory_selection(state: ApplicationState) -> Union[VehicleProjectOpenerWindow, 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
 
     Returns:
-        VehicleDirectorySelectionWindow if selection was needed, None otherwise
+        VehicleProjectOpenerWindow if selection was needed, None otherwise
 
     """
     state.vehicle_project_manager = VehicleProjectManager(state.local_filesystem, state.flight_controller)
-    fc_connected = len(state.flight_controller.fc_parameters) > 0
     if not state.vehicle_type:
         logging_debug(
             _(
@@ -209,7 +208,7 @@ def vehicle_directory_selection(state: ApplicationState) -> Union[VehicleDirecto
                 "FC connected and no explicit vehicle type set on the command line"
             )
         )
-    vehicle_dir_window = VehicleDirectorySelectionWindow(state.vehicle_project_manager, fc_connected, state.vehicle_type)
+    vehicle_dir_window = VehicleProjectOpenerWindow(state.vehicle_project_manager)
     vehicle_dir_window.root.mainloop()
 
     if state.vehicle_project_manager.reset_fc_parameters_to_their_defaults:
@@ -485,7 +484,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/backend_filesystem_program_settings.py

@@ -68,8 +68,10 @@ class ProgramSettings:
             "annotate_docs_into_param_files": False,
             "gui_complexity": "simple",  # simple or normal
             # Motor test settings
-            "motor_test_duration": 2.5,  # Default test duration in seconds
-            "motor_test_throttle_pct": 10,  # Default throttle percentage (10%)
+            "motor_test": {
+                "duration": 2.5,  # Default test duration in seconds
+                "throttle_pct": 10,  # Default throttle percentage (10%)
+            },
         }
 
     @staticmethod
@@ -341,14 +343,14 @@ class ProgramSettings:
     @staticmethod
     def motor_diagram_filepath(frame_class: int, frame_type: int) -> tuple[str, str]:
         """
-        Get the filepath for the motor diagram SVG file.
+        Get the filepath for the motor diagram PNG file.
 
         Args:
             frame_class: ArduPilot frame class (1=QUAD, 2=HEXA, etc.)
             frame_type: ArduPilot frame type (0=PLUS, 1=X, etc.)
 
         Returns:
-            str: Absolute path to the motor diagram SVG file
+            str: Absolute path to the motor diagram PNG file
             str: Error message if multiple or no files found, empty string if no error
 
         """
@@ -361,12 +363,12 @@ class ProgramSettings:
             # Running as script
             application_path = os_path.dirname(os_path.dirname(os_path.abspath(__file__)))
 
-        images_dir = os_path.join(application_path, "ardupilot_methodic_configurator", "images")
+        images_dir = os_path.join(application_path, "ardupilot_methodic_configurator", "images", "motor_diagrams_png")
 
-        # Generate SVG filename based on frame configuration
-        filename = f"m_{frame_class:02d}_{frame_type:02d}_*.svg"
+        # Generate PNG filename based on frame configuration
+        filename = f"m_{frame_class:02d}_{frame_type:02d}_*.png"
 
-        # Search for matching SVG file (since exact naming varies)
+        # Search for matching PNG file (since exact naming varies)
         matching_files = glob.glob(os_path.join(images_dir, filename))
 
         err_msg = (

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,too-many-instance-attributes
     """
     A class to manage the connection and parameters of a flight controller.
 
@@ -113,6 +114,10 @@ class FlightController:
         self.fc_parameters: dict[str, float] = {}
         self.info = BackendFlightcontrollerInfo()
 
+        # Battery status tracking
+        self._last_battery_message_time: float = 0.0
+        self._last_battery_status: Union[tuple[float, float], None] = None
+
     def discover_connections(self) -> None:
         comports = FlightController.__list_serial_ports()
         netports = FlightController.__list_network_ports()
@@ -684,7 +689,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()
 
@@ -713,6 +718,43 @@ class FlightController:
             return
         self.master.param_set_send(param_name, param_value)
 
+    def fetch_param(self, param_name: str, timeout: int = 5) -> Optional[float]:
+        """
+        Fetch a parameter from the flight controller using MAVLink PARAM_REQUEST_READ message.
+
+        Args:
+            param_name (str): The name of the parameter to fetch.
+            timeout (int): Timeout in seconds to wait for the response. Default is 5.
+
+        Returns:
+            float: The value of the parameter, or None if not found or timeout occurred.
+
+        """
+        if self.master is None:  # FIXME for testing only pylint: disable=fixme
+            return None
+
+        # Send PARAM_REQUEST_READ message
+        self.master.mav.param_request_read_send(
+            self.master.target_system,
+            self.master.target_component,
+            param_name.encode("utf-8"),
+            -1,  # param_index: -1 means use param_id instead
+        )
+
+        # Wait for PARAM_VALUE response
+        start_time = time_time()
+        while time_time() - start_time < timeout:
+            msg = self.master.recv_match(type="PARAM_VALUE", blocking=False)
+            if msg is not None:
+                # Check if this is the parameter we requested
+                received_param_name = msg.param_id.rstrip("\x00")
+                if received_param_name == param_name:
+                    logging_debug(_("Received parameter: %s = %s"), param_name, msg.param_value)
+                    return float(msg.param_value)
+            time_sleep(0.01)  # Small sleep to prevent busy waiting
+
+        raise TimeoutError(_("Timeout waiting for parameter %s") % param_name)
+
     def reset_all_parameters_to_default(self) -> tuple[bool, str]:
         """
         Reset all parameters to their factory default values.
@@ -816,12 +858,16 @@ class FlightController:
 
     # Motor Test Functionality
 
-    def test_motor(self, motor_number: int, throttle_percent: int, timeout_seconds: int) -> tuple[bool, str]:
+    def test_motor(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self, test_sequence_nr: int, motor_letters: str, motor_output_nr: int, throttle_percent: int, timeout_seconds: int
+    ) -> tuple[bool, str]:
         """
         Test a specific motor.
 
         Args:
-            motor_number: Motor number (1-based, as used by ArduPilot)
+            test_sequence_nr: Motor test number, this is not the same as the output number!
+            motor_letters: Motor letters (for logging purposes only)
+            motor_output_nr: Motor output number (for logging purposes only)
             throttle_percent: Throttle percentage (0-100)
             timeout_seconds: Test duration in seconds
 
@@ -839,20 +885,24 @@ class FlightController:
         # https://mavlink.io/en/messages/common.html#MAV_CMD_DO_MOTOR_TEST
         success, error_msg = self._send_command_and_wait_ack(
             mavutil.mavlink.MAV_CMD_DO_MOTOR_TEST,
-            param1=motor_number,  # motor number
+            param1=test_sequence_nr + 1,  # motor test number, this is not the same as the output number!
             param2=mavutil.mavlink.MOTOR_TEST_THROTTLE_PERCENT,  # throttle type
             param3=throttle_percent,  # throttle value
             param4=timeout_seconds,  # timeout
-            param5=motor_number,  # motor count (same as motor number for single motor test)
-            param6=mavutil.mavlink.MOTOR_TEST_ORDER_BOARD,  # test order
+            param5=0,  # motor count (0=test just the motor specified in param1)
+            param6=0,  # test order (0=default/board order)
             param7=0,  # unused
         )
 
         if success:
             logging_info(
-                _("Motor test command confirmed: Motor %(motor)d at %(throttle)d%% for %(duration)d seconds"),
+                _(
+                    "Motor test command acknowledged: Motor %(seq)s on output %(output)d at %(throttle)d%% thrust"
+                    " for %(duration)d seconds"
+                ),
                 {
-                    "motor": motor_number,
+                    "seq": motor_letters,
+                    "output": motor_output_nr,
                     "throttle": throttle_percent,
                     "duration": timeout_seconds,
                 },
@@ -863,11 +913,12 @@ class FlightController:
 
         return success, error_msg
 
-    def test_all_motors(self, throttle_percent: int, timeout_seconds: int) -> tuple[bool, str]:
+    def test_all_motors(self, nr_of_motors: int, throttle_percent: int, timeout_seconds: int) -> tuple[bool, str]:
         """
         Test all motors simultaneously.
 
         Args:
+            nr_of_motors: Number of motors to test
             throttle_percent: Throttle percentage (0-100)
             timeout_seconds: Test duration in seconds
 
@@ -881,38 +932,34 @@ class FlightController:
             logging_error(error_msg)
             return False, error_msg
 
-        # MAV_CMD_DO_MOTOR_TEST command for all motors
-        success, error_msg = self._send_command_and_wait_ack(
-            mavutil.mavlink.MAV_CMD_DO_MOTOR_TEST,
-            param1=0,  # motor count (all motors)
-            param2=mavutil.mavlink.MOTOR_TEST_THROTTLE_PERCENT,  # throttle type
-            param3=throttle_percent,  # throttle value
-            param4=timeout_seconds,  # timeout
-            param5=0,  # motor count
-            param6=mavutil.mavlink.MOTOR_TEST_ORDER_BOARD,  # test order
-            param7=0,  # unused
-        )
-
-        if success:
-            logging_info(
-                _("All motors test command confirmed at %(throttle)d%% for %(duration)d seconds"),
-                {
-                    "throttle": throttle_percent,
-                    "duration": timeout_seconds,
-                },
+        for i in range(nr_of_motors):
+            # MAV_CMD_DO_MOTOR_TEST command for all motors
+            self.master.mav.command_long_send(
+                self.master.target_system,
+                self.master.target_component,
+                mavutil.mavlink.MAV_CMD_DO_MOTOR_TEST,
+                0,  # confirmation
+                param1=i + 1,  # motor number (1-based)
+                param2=mavutil.mavlink.MOTOR_TEST_THROTTLE_PERCENT,  # throttle type
+                param3=throttle_percent,  # throttle value
+                param4=timeout_seconds,  # timeout
+                param5=0,  # motor count (0=all motors when param1=0)
+                param6=0,  # test order (0=default/board order)
+                param7=0,  # unused
             )
-        else:
-            error_msg = _("All motors test command failed: %(error)s") % {"error": error_msg}
-            logging_error(error_msg)
+            time_sleep(0.01)  # to let the FC parse each command individually
 
-        return success, error_msg
+        return True, ""
 
-    def test_motors_in_sequence(self, motor_number: int, throttle_percent: int, timeout_seconds: int) -> tuple[bool, str]:
+    def test_motors_in_sequence(
+        self, start_motor: int, motor_count: int, throttle_percent: int, timeout_seconds: int
+    ) -> tuple[bool, str]:
         """
         Test motors in sequence (A, B, C, D, etc.).
 
         Args:
-            motor_number: The motor number to test (1-based index)
+            start_motor: The first motor to test (1-based index)
+            motor_count: Number of motors to test in sequence
             throttle_percent: Throttle percentage (1-100)
             timeout_seconds: Test duration per motor in seconds
 
@@ -929,11 +976,11 @@ class FlightController:
         # MAV_CMD_DO_MOTOR_TEST command for sequence test
         success, error_msg = self._send_command_and_wait_ack(
             mavutil.mavlink.MAV_CMD_DO_MOTOR_TEST,
-            param1=motor_number,  # motor count
+            param1=start_motor,  # starting motor number (1-based)
             param2=mavutil.mavlink.MOTOR_TEST_THROTTLE_PERCENT,  # throttle type
             param3=throttle_percent,  # throttle value
             param4=timeout_seconds,  # timeout per motor
-            param5=motor_number,  # motor count
+            param5=motor_count,  # number of motors to test in sequence
             param6=mavutil.mavlink.MOTOR_TEST_ORDER_SEQUENCE,  # test order (sequence)
             param7=0,  # unused
         )
@@ -973,8 +1020,8 @@ class FlightController:
             param2=mavutil.mavlink.MOTOR_TEST_THROTTLE_PERCENT,  # throttle type
             param3=0,  # throttle value (0% = stop)
             param4=0,  # timeout (0 = immediate stop)
-            param5=0,  # motor count
-            param6=mavutil.mavlink.MOTOR_TEST_ORDER_BOARD,  # test order
+            param5=0,  # motor count (0 = all motors when param1=0)
+            param6=0,  # test order (0 = default/board order)
             param7=0,  # unused
         )
 
@@ -1014,6 +1061,7 @@ class FlightController:
             param5=0,  # unused
             param6=0,  # unused
             param7=0,  # unused
+            timeout=0.8,  # shorter timeout for battery status requests
         )
 
         if success:
@@ -1048,15 +1096,21 @@ class FlightController:
 
         try:
             # Try to get real telemetry data
-            battery_status = self.master.recv_match(type="BATTERY_STATUS", blocking=True, timeout=2)
+            battery_status = self.master.recv_match(type="BATTERY_STATUS", blocking=False, timeout=0.3)
             if battery_status:
                 # Convert from millivolts to volts, and centiamps to amps
                 voltage = battery_status.voltages[0] / 1000.0 if battery_status.voltages[0] != -1 else 0.0
                 current = battery_status.current_battery / 100.0 if battery_status.current_battery != -1 else 0.0
+                self._last_battery_status = (voltage, current)
+                self._last_battery_message_time = time_time()
                 return (voltage, current), ""
         except Exception as e:  # pylint: disable=broad-exception-caught
             logging_debug(_("Failed to get battery status from telemetry: %(error)s"), {"error": str(e)})
 
+        if self._last_battery_message_time and (time_time() - self._last_battery_message_time) < 3:
+            # If we received a battery message recently, don't log an error
+            return self._last_battery_status, ""
+        self._last_battery_status = None
         error_msg = _("Battery status not available from telemetry")
         return None, error_msg
 
@@ -1163,6 +1217,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(
@@ -1192,3 +1420,10 @@ class FlightController:
             help=_("Flight controller reboot time. Default is %(default)s"),
         )
         return parser
+
+    @property
+    def comport_device(self) -> str:
+        """Get the current self.comport.device string."""
+        if self.comport is not None:
+            return str(getattr(self.comport, "device", ""))
+        return ""

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."""