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

ardupilot_methodic_configurator/frontend_tkinter_connection_selection.py

@@ -14,14 +14,15 @@ import tkinter as tk
 from argparse import ArgumentParser, Namespace
 from logging import basicConfig as logging_basicConfig
 from logging import debug as logging_debug
+from logging import error as logging_error
 from logging import getLevelName as logging_getLevelName
 from logging import warning as logging_warning
 from sys import exit as sys_exit
-from tkinter import simpledialog, ttk
+from tkinter import messagebox, simpledialog, ttk
 from typing import Union
 
 from ardupilot_methodic_configurator import _
-from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
+from ardupilot_methodic_configurator.backend_flightcontroller import SUPPORTED_BAUDRATES, FlightController
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_pair_tuple_combobox import PairTupleCombobox
@@ -44,11 +45,13 @@ class ConnectionSelectionWidgets:  # pylint: disable=too-many-instance-attribute
         flight_controller: FlightController,
         destroy_parent_on_connect: bool,
         download_params_on_connect: bool,
+        default_baudrate: int = 115200,
     ) -> None:
         self.parent = parent
         self.flight_controller = flight_controller
         self.destroy_parent_on_connect = destroy_parent_on_connect
         self.download_params_on_connect = download_params_on_connect
+        self.default_baudrate = default_baudrate
         self.previous_selection: Union[None, str] = (
             flight_controller.comport.device
             if flight_controller.comport and hasattr(flight_controller.comport, "device")
@@ -63,21 +66,49 @@ class ConnectionSelectionWidgets:  # pylint: disable=too-many-instance-attribute
         conn_selection_label = ttk.Label(self.container_frame, text=_("flight controller connection:"))
         conn_selection_label.pack(side=tk.TOP)  # Add the label to the top of the conn_selection_frame
 
+        # Create a frame for connection and baudrate selection
+        selection_frame = ttk.Frame(self.container_frame)
+        selection_frame.pack(side=tk.TOP, pady=(4, 0))
+
+        # Create a label for port
+        port_label = ttk.Label(selection_frame, text=_("Port:"))
+        port_label.pack(side=tk.LEFT, padx=(0, 5))
+
         # Create a read-only combobox for flight controller connection selection
         self.conn_selection_combobox = PairTupleCombobox(
-            self.container_frame,
+            selection_frame,
             self.flight_controller.get_connection_tuples(),
             self.previous_selection,
             "FC connection",
             state="readonly",
         )
         self.conn_selection_combobox.bind("<<ComboboxSelected>>", self.on_select_connection_combobox_change, "+")
-        self.conn_selection_combobox.pack(side=tk.TOP, pady=(4, 0))
+        self.conn_selection_combobox.pack(side=tk.LEFT, padx=(0, 5))
         show_tooltip(
             self.conn_selection_combobox,
             _("Select the flight controller connection\nYou can add a custom connection to the existing ones"),
         )
 
+        # Create a label for baudrate
+        baudrate_label = ttk.Label(selection_frame, text=_("Baudrate:"))
+        baudrate_label.pack(side=tk.LEFT, padx=(10, 5))
+
+        # Create a combobox for baudrate selection
+        self.baudrate_var = tk.StringVar(value=str(self.default_baudrate))
+        self.baudrate_combobox = ttk.Combobox(
+            selection_frame,
+            textvariable=self.baudrate_var,
+            values=SUPPORTED_BAUDRATES,
+            state="normal",
+            width=10,
+        )
+        self.baudrate_combobox.pack(side=tk.LEFT, padx=(0, 5))
+        self.baudrate_combobox.bind("<<ComboboxSelected>>", self.on_baudrate_combobox_change, "+")
+        show_tooltip(
+            self.baudrate_combobox,
+            _("Select the baudrate for the connection\nMost flight controllers use 115200"),
+        )
+
     def on_select_connection_combobox_change(self, _event: tk.Event) -> None:
         selected_connection = self.conn_selection_combobox.get_selected_key()
         error_msg = _("Connection combobox changed to: {selected_connection}")
@@ -95,6 +126,23 @@ class ConnectionSelectionWidgets:  # pylint: disable=too-many-instance-attribute
                 return
             self.reconnect(selected_connection)  # type: ignore[arg-type] # workaround for mypy issue
 
+    def on_baudrate_combobox_change(self, _event: tk.Event) -> None:
+        """Handle baudrate combobox selection changes."""
+        _selected_baudrate = self.baudrate_var.get()
+        error_msg = _("Baudrate combobox changed to: {_selected_baudrate}")
+        logging_debug(error_msg.format(**locals()))
+
+        # Get the current connection
+        current_connection = (
+            self.flight_controller.comport.device
+            if self.flight_controller.comport and hasattr(self.flight_controller.comport, "device")
+            else None
+        )
+
+        # If we have an active connection, reconnect with the new baudrate
+        if self.flight_controller.master is not None and current_connection:
+            self.reconnect(current_connection)
+
     def add_connection(self) -> str:
         # Open the connection selection dialog
         selected_connection = simpledialog.askstring(
@@ -126,8 +174,28 @@ class ConnectionSelectionWidgets:  # pylint: disable=too-many-instance-attribute
         self.connection_progress_window = ProgressWindow(
             self.parent.root, _("Connecting with the FC"), _("Connection step {} of {}")
         )
+        # Get the current baudrate from the combobox
+        selected_baudrate = "unknown"  # Initialize with default value for error handling
+        try:
+            selected_baudrate = self.baudrate_var.get()
+            current_baudrate = int(selected_baudrate)
+            if str(current_baudrate) not in SUPPORTED_BAUDRATES:
+                warning_msg = _("Unsupported baudrate selected: {current_baudrate}")
+                logging_warning(warning_msg.format(**locals()))
+            if current_baudrate < 1200:
+                raise ValueError
+        except (ValueError, AttributeError):
+            error_msg = _("Invalid baudrate selected: {selected_baudrate}, reverting to default: {self.default_baudrate}")
+            error_msg = error_msg.format(**locals())
+            # Display error popup
+            messagebox.showerror(_("Invalid Baudrate"), error_msg)
+            logging_error(error_msg)
+            # Reset the combobox to the default value
+            self.baudrate_var.set(str(self.default_baudrate))
+            current_baudrate = self.default_baudrate
+
         error_message = self.flight_controller.connect(
-            selected_connection, self.connection_progress_window.update_progress_bar
+            selected_connection, self.connection_progress_window.update_progress_bar, baudrate=current_baudrate
         )
         if error_message:
             show_no_connection_error(error_message)
@@ -152,10 +220,16 @@ class ConnectionSelectionWindow(BaseWindow):
     the UI elements related to connection selection.
     """
 
-    def __init__(self, flight_controller: FlightController, connection_result_string: str) -> None:
+    def __init__(
+        self,
+        flight_controller: FlightController,
+        connection_result_string: str,
+        default_baudrate: int = 115200,
+    ) -> None:
         super().__init__()
         self.root.title(_("Flight controller connection"))
-        self.root.geometry("460x450")  # Set the window size
+        self.root.geometry("520x462")  # Set the window size
+        self.default_baudrate = default_baudrate
 
         # Explain why we are here
         if flight_controller.comport is None:
@@ -209,9 +283,14 @@ class ConnectionSelectionWindow(BaseWindow):
         # pylint: enable=duplicate-code
         option2_label.pack(expand=False, fill=tk.X, padx=6)
         self.connection_selection_widgets = ConnectionSelectionWidgets(
-            self, option2_label_frame, flight_controller, destroy_parent_on_connect=True, download_params_on_connect=False
+            self,
+            option2_label_frame,
+            flight_controller,
+            destroy_parent_on_connect=True,
+            download_params_on_connect=False,
+            default_baudrate=self.default_baudrate,
         )
-        self.connection_selection_widgets.container_frame.pack(expand=False, fill=tk.X, padx=80, pady=6)
+        self.connection_selection_widgets.container_frame.pack(expand=False, fill=tk.X, padx=5, pady=6)
 
         # Option 3 - Skip FC connection, just edit the .param files on disk
         option3_label = ttk.Label(text=_("No connection"), style="Bold.TLabel")
@@ -289,7 +368,7 @@ def main() -> None:
     result = flight_controller.connect(device=args.device)
     if result:
         logging_warning(result)
-        window = ConnectionSelectionWindow(flight_controller, result)
+        window = ConnectionSelectionWindow(flight_controller, result, default_baudrate=args.baudrate)
         window.root.mainloop()
     flight_controller.disconnect()  # Disconnect from the flight controller
 

ardupilot_methodic_configurator/frontend_tkinter_directory_selection.py

@@ -242,7 +242,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
 
         # Set dynamic window size based on number of settings
         nr_new_project_settings = len(new_project_settings_metadata)
-        window_height = 550 + (nr_new_project_settings * 21)
+        window_height = 550 + (nr_new_project_settings * 23)
         self.root.geometry(f"800x{window_height}")  # Set the window size
 
         # Explain why we are here

ardupilot_methodic_configurator/frontend_tkinter_flightcontroller_info.py

@@ -14,10 +14,9 @@ from tkinter import messagebox, ttk
 from typing import Callable, Optional, Union
 
 from ardupilot_methodic_configurator import _, __version__
-from ardupilot_methodic_configurator.annotate_params import Par
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
+from ardupilot_methodic_configurator.data_model_par_dict import ParDict
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
-from ardupilot_methodic_configurator.frontend_tkinter_progress_window import ProgressWindow
 
 
 class FlightControllerInfoPresenter:
@@ -29,7 +28,7 @@ class FlightControllerInfoPresenter:
 
     def __init__(self, flight_controller: FlightController) -> None:
         self.flight_controller = flight_controller
-        self.param_default_values: dict[str, Par] = {}
+        self.param_default_values: ParDict = ParDict()
 
     def get_info_data(self) -> dict[str, Union[str, dict[str, str]]]:
         """Get formatted flight controller information for display."""
@@ -39,7 +38,7 @@ class FlightControllerInfoPresenter:
         """Log flight controller information."""
         self.flight_controller.info.log_flight_controller_info()
 
-    def download_parameters(self, progress_callback: Optional[Callable[[int, int], None]] = None) -> dict[str, Par]:
+    def download_parameters(self, progress_callback: Optional[Callable[[int, int], None]] = None) -> ParDict:
         """
         Download flight controller parameters.
 
@@ -55,7 +54,7 @@ class FlightControllerInfoPresenter:
         self.param_default_values = param_default_values
         return param_default_values
 
-    def get_param_default_values(self) -> dict[str, Par]:
+    def get_param_default_values(self) -> ParDict:
         """Get parameter default values."""
         return self.param_default_values
 
@@ -66,7 +65,7 @@ class FlightControllerInfoWindow(BaseWindow):
     def __init__(self, flight_controller: FlightController) -> None:
         super().__init__()
         self.root.title(_("ArduPilot methodic configurator ") + __version__ + _(" - Flight Controller Info"))
-        self.root.geometry("500x350")  # Adjust the window size as needed
+        self.root.geometry("500x420")  # Adjust the window size as needed
 
         self.presenter = FlightControllerInfoPresenter(flight_controller)
 
@@ -81,7 +80,7 @@ class FlightControllerInfoWindow(BaseWindow):
         """Create the flight controller information display."""
         # Create a frame to hold all the labels and text fields
         self.info_frame = ttk.Frame(self.main_frame)
-        self.info_frame.pack(fill=tk.BOTH, padx=20, pady=20)
+        self.info_frame.pack(fill=tk.BOTH, padx=20, pady=(20, 10))
 
         # Dynamically create labels and text fields for each attribute
         info_data = self.presenter.get_info_data()
@@ -90,6 +89,18 @@ class FlightControllerInfoWindow(BaseWindow):
 
         self.info_frame.columnconfigure(1, weight=1)
 
+        # Create progress frame at the bottom
+        self.progress_frame = ttk.Frame(self.main_frame)
+        self.progress_frame.pack(fill=tk.X, padx=20, pady=(10, 20))
+
+        # Create progress bar
+        self.progress_bar = ttk.Progressbar(self.progress_frame, length=100, mode="determinate")
+        self.progress_bar.pack(side=tk.TOP, fill=tk.X, expand=False, pady=(0, 5))
+
+        # Create progress label
+        self.progress_label = ttk.Label(self.progress_frame, text=_("Ready to download parameters..."))
+        self.progress_label.pack(side=tk.TOP, fill=tk.X, expand=False)
+
     def _create_info_row(self, row_nr: int, description: str, attr_value: Union[str, dict[str, str]]) -> None:
         """Create a single row of information display."""
         label = ttk.Label(self.info_frame, text=f"{description}:")
@@ -103,23 +114,60 @@ class FlightControllerInfoWindow(BaseWindow):
         text_field.insert(tk.END, display_value)
         text_field.configure(state="readonly")
 
+    def update_progress_bar(self, current_value: int, max_value: int) -> None:
+        """
+        Update the progress bar and the progress message with the current progress.
+
+        Args:
+            current_value (int): The current progress value.
+            max_value (int): The maximum progress value.
+
+        """
+        try:
+            # Check if progress widgets still exist
+            if not hasattr(self, "progress_bar") or self.progress_bar is None:
+                return
+
+            # Bring the main window to front (similar to original progress_window.lift())
+            self.root.lift()
+        except tk.TclError as _e:
+            msg = _("Lifting window: {_e}")
+            logging.error(msg.format(**locals()))
+            return
+
+        self.progress_bar["value"] = current_value
+        self.progress_bar["maximum"] = max_value
+
+        # Update the progress message
+        progress_message = _("Downloaded {} of {} parameters").format(current_value, max_value)
+        self.progress_label.config(text=progress_message)
+
+        # Update the display
+        self.progress_bar.update()
+        self.root.update_idletasks()
+
+        # Hide progress bar when complete
+        if current_value == max_value:
+            self.progress_frame.pack_forget()
+
     def _download_flight_controller_parameters(self) -> None:
         """Download flight controller parameters with progress feedback."""
-        param_download_progress_window = ProgressWindow(
-            self.root, _("Downloading FC parameters"), _("Downloaded {} of {} parameters")
-        )
+        # Update progress label to show we're starting
+        self.progress_label.config(text=_("Starting parameter download..."))
+        self.root.update_idletasks()
 
         try:
-            self.presenter.download_parameters(param_download_progress_window.update_progress_bar)
+            self.presenter.download_parameters(self.update_progress_bar)
         except Exception as e:  # pylint: disable=broad-exception-caught
             # Log the error
             logging.error("Failed to download parameters: %s", e)
             # Show an error message to the user
             messagebox.showerror(_("Error"), f"{_('Failed to download parameters')}: {e}")
+            # Hide progress bar on error
+            self.progress_frame.pack_forget()
         finally:
-            param_download_progress_window.destroy()  # for the case that '--device test' and there is no real FC connected
             self.root.destroy()
 
-    def get_param_default_values(self) -> dict[str, Par]:
+    def get_param_default_values(self) -> ParDict:
         """Get parameter default values from the presenter."""
         return self.presenter.get_param_default_values()

ardupilot_methodic_configurator/frontend_tkinter_pair_tuple_combobox.py

@@ -150,7 +150,7 @@ class PairTupleCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
         style = ttk.Style()
         # check if the combobox already has the "postoffset" property
         current_combo_style = combo.cget("style") or "TCombobox"
-        if len(style.lookup(current_combo_style, "postoffset")) > 0:  # type: ignore[no-untyped-call]
+        if len(style.lookup(current_combo_style, "postoffset")) > 0:
             return
         combo_values = combo.cget("values")
         if len(combo_values) == 0:
@@ -167,7 +167,7 @@ class PairTupleCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
         style_name = current_combo_style if unique_name in current_combo_style else f"{unique_name}.{current_combo_style}"
 
         if isinstance(combo, ttk.Combobox):
-            style.configure(style_name, postoffset=(0, 0, width, 0))  # type: ignore[no-untyped-call]
+            style.configure(style_name, postoffset=(0, 0, width, 0))
             combo.configure(style=style_name)
 
 

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -21,6 +21,7 @@ from logging import error as logging_error
 from logging import getLevelName as logging_getLevelName
 from logging import info as logging_info
 from logging import warning as logging_warning
+from pathlib import Path
 from tkinter import filedialog, messagebox, ttk
 from typing import Literal, Optional, Union
 
@@ -28,12 +29,12 @@ from typing import Literal, Optional, Union
 from webbrowser import open as webbrowser_open  # to open the blog post documentation
 
 from ardupilot_methodic_configurator import _, __version__
-from ardupilot_methodic_configurator.annotate_params import Par
-from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem, is_within_tolerance
+from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
 from ardupilot_methodic_configurator.backend_flightcontroller import FlightController
 from ardupilot_methodic_configurator.backend_internet import download_file_from_url
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
+from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict, is_within_tolerance
 from ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox import AutoResizeCombobox
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_directory_selection import VehicleDirectorySelectionWidgets
@@ -164,15 +165,15 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         self.root.protocol("WM_DELETE_WINDOW", self.close_connection_and_quit)
 
         style = ttk.Style()
-        style.map("readonly.TCombobox", fieldbackground=[("readonly", "white")])  # type: ignore[no-untyped-call]
-        style.map("readonly.TCombobox", selectbackground=[("readonly", "white")])  # type: ignore[no-untyped-call]
-        style.map("readonly.TCombobox", selectforeground=[("readonly", "black")])  # type: ignore[no-untyped-call]
-        style.map("default_v.TCombobox", fieldbackground=[("readonly", "light blue")])  # type: ignore[no-untyped-call]
-        style.map("default_v.TCombobox", selectbackground=[("readonly", "light blue")])  # type: ignore[no-untyped-call]
-        style.map("default_v.TCombobox", selectforeground=[("readonly", "black")])  # type: ignore[no-untyped-call]
-        style.configure("default_v.TEntry", fieldbackground="light blue")  # type: ignore[no-untyped-call]
-        style.configure("below_limit.TEntry", fieldbackground="orangered")  # type: ignore[no-untyped-call]
-        style.configure("above_limit.TEntry", fieldbackground="red3")  # type: ignore[no-untyped-call]
+        style.map("readonly.TCombobox", fieldbackground=[("readonly", "white")])
+        style.map("readonly.TCombobox", selectbackground=[("readonly", "white")])
+        style.map("readonly.TCombobox", selectforeground=[("readonly", "black")])
+        style.map("default_v.TCombobox", fieldbackground=[("readonly", "light blue")])
+        style.map("default_v.TCombobox", selectbackground=[("readonly", "light blue")])
+        style.map("default_v.TCombobox", selectforeground=[("readonly", "black")])
+        style.configure("default_v.TEntry", fieldbackground="light blue")
+        style.configure("below_limit.TEntry", fieldbackground="orangered")
+        style.configure("above_limit.TEntry", fieldbackground="red3")
 
         self.__create_conf_widgets(__version__)
 
@@ -259,7 +260,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
     def legend_frame(self, config_subframe: ttk.Frame) -> None:  # pylint: disable=too-many-locals
         font_family, font_size = get_widget_font_family_and_size(config_subframe)
         style = ttk.Style()
-        style.configure("Legend.TLabelframe", font=(font_family, font_size))  # type: ignore[no-untyped-call]
+        style.configure("Legend.TLabelframe", font=(font_family, font_size))
         legend_frame = ttk.LabelFrame(config_subframe, text=_("Legend"), style="Legend.TLabelframe")
         legend_left = ttk.Frame(legend_frame)
         legend_left.pack(side=tk.LEFT, anchor=tk.NW)
@@ -402,7 +403,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             wrap=tk.WORD,
             height=10,
             bd=0,
-            background=style.lookup("TLabel", "background"),  # type: ignore[no-untyped-call]
+            background=style.lookup("TLabel", "background"),
         )
         instructions_text.insert(tk.END, _("1. Read "))
         instructions_text.insert(tk.END, _("all"), "bold")
@@ -517,7 +518,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             message_label.pack(padx=10, pady=10)
 
             # Result variable
-            result: list[Literal[None, True, False]] = [None]
+            result: list[Optional[Literal[True, False]]] = [None]
 
             # Button frame
             button_frame = tk.Frame(dialog)
@@ -661,7 +662,9 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         )
         # Download all parameters from the flight controller
         self.flight_controller.fc_parameters, param_default_values = self.flight_controller.download_params(
-            self.param_download_progress_window.update_progress_bar
+            self.param_download_progress_window.update_progress_bar,
+            Path(self.local_filesystem.vehicle_dir) / "complete.param",
+            Path(self.local_filesystem.vehicle_dir) / "00_default.param",
         )
         if param_default_values:
             self.local_filesystem.write_param_default_values_to_file(param_default_values)
@@ -696,7 +699,6 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         # Write each selected parameter to the flight controller
         for param_name, param in selected_params.items():
             try:
-                logging_info(_("Parameter %s set to %f"), param_name, param.value)
                 if param_name not in self.flight_controller.fc_parameters or not is_within_tolerance(
                     self.flight_controller.fc_parameters[param_name], param.value
                 ):
@@ -776,25 +778,52 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         self.on_skip_click()
 
     # This function can recurse multiple times if there is an upload error
-    def upload_selected_params(self, selected_params: dict) -> None:
+    def upload_selected_params(self, selected_params: dict) -> None:  # pylint: disable=too-many-branches
         logging_info(_("Uploading %d selected %s parameters to flight controller..."), len(selected_params), self.current_file)
 
         self.upload_params_that_require_reset(selected_params)
 
         # Write each selected parameter to the flight controller
+        nr_changed = 0
+        nr_unchanged = 0
         for param_name, param in selected_params.items():
             try:
                 self.flight_controller.set_param(param_name, param.value)
-                logging_info(_("Parameter %s set to %f"), param_name, param.value)
                 if param_name not in self.flight_controller.fc_parameters or not is_within_tolerance(
                     self.flight_controller.fc_parameters[param_name], param.value
                 ):
                     self.at_least_one_changed_parameter_written = True
+                    if param_name in self.flight_controller.fc_parameters:
+                        logging_info(
+                            _("Parameter %s changed from %f to %f"),
+                            param_name,
+                            self.flight_controller.fc_parameters[param_name],
+                            param.value,
+                        )
+                    else:
+                        logging_info(
+                            _("Parameter %s changed to %f"),
+                            param_name,
+                            param.value,
+                        )
+                    nr_changed += 1
+                else:
+                    logging_info(_("Parameter %s unchanged from %f"), param_name, param.value)
+                    nr_unchanged += 1
             except ValueError as _e:  # noqa: PERF203
                 error_msg = _("Failed to set parameter {param_name}: {_e}").format(**locals())
                 logging_error(error_msg)
                 messagebox.showerror(_("ArduPilot methodic configurator"), error_msg)
 
+        changed_msg = _("%d FC parameter(s) changed value") % nr_changed if nr_changed else ""
+        unchanged_msg = (
+            _("%d FC parameter(s) already had the value defined in this configuration step") % nr_unchanged
+            if nr_unchanged
+            else ""
+        )
+        msg = changed_msg + (", " if nr_changed and nr_unchanged else "") + unchanged_msg
+        logging_info(msg)
+
         if self.at_least_one_changed_parameter_written:
             # Re-download all parameters, in case one of them changed, and validate that all uploads were successful
             self.download_flight_controller_parameters(redownload=True)
@@ -832,8 +861,80 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
                     self.upload_selected_params(selected_params)
             else:
                 logging_info(_("All parameters uploaded to the flight controller successfully"))
+
+            non_default_non_read_only_fc_params = self._non_default_non_read_only_fc_params()
+
+            last_config_step_filename = list(self.local_filesystem.file_parameters.keys())[-1]
+            # Export FC parameters that are missing or different from AMC parameter files
+            self._export_fc_params_missing_or_different_in_amc_files(non_default_non_read_only_fc_params, self.current_file)
+            self._export_fc_params_missing_or_different_in_amc_files(
+                non_default_non_read_only_fc_params, last_config_step_filename
+            )
+
         self.local_filesystem.write_last_uploaded_filename(self.current_file)
 
+    def _non_default_non_read_only_fc_params(self) -> ParDict:
+        # Create FC parameters dictionary
+        fc_parameters = ParDict.from_fc_parameters(self.flight_controller.fc_parameters)
+
+        # Early exit if no FC parameters available
+        if len(fc_parameters) == 0:
+            return fc_parameters
+
+        # Remove default parameters from FC parameters if default file exists
+        fc_parameters.remove_if_value_is_similar(self.local_filesystem.param_default_dict, is_within_tolerance)
+
+        # Filter out read-only parameters efficiently - only check params that exist in fc_parameters
+        readonly_params_to_remove = [
+            param_name
+            for param_name in fc_parameters
+            if self.local_filesystem.doc_dict.get(param_name, {}).get("ReadOnly", False)
+        ]
+        for param_name in readonly_params_to_remove:
+            del fc_parameters[param_name]
+
+        return fc_parameters
+
+    def _export_fc_params_missing_or_different_in_amc_files(self, fc_parameters: ParDict, last_filename: str) -> None:
+        """
+        Export flight controller parameters that are missing or different in AMC parameter files.
+
+        This function creates a compound state of all parameters from AMC files (excluding defaults),
+        compares them with FC parameters, and exports any parameters that are either missing from
+        AMC files or have different values to a separate parameter file.
+        """
+        if not self.flight_controller.fc_parameters:
+            return
+
+        # Create the compounded state of all parameters stored in the AMC .param files
+        compound = ParDict()
+        first_config_step_filename = None
+        for file_name, file_params in self.local_filesystem.file_parameters.items():
+            if file_name != "00_default.param":
+                if first_config_step_filename is None:
+                    first_config_step_filename = file_name
+                compound.append(file_params)
+            if file_name == last_filename:
+                break
+
+        # Calculate parameters that only exist in fc_parameters or have a different value from compound
+        params_missing_in_the_amc_param_files = fc_parameters.get_missing_or_different(compound, is_within_tolerance)
+
+        # Export to file if there are any missing/different parameters
+        if params_missing_in_the_amc_param_files:
+            # Generate filename based on the range of processed files
+            first_name_without_ext = first_config_step_filename.rsplit(".", 1)[0] if first_config_step_filename else "unknown"
+            # the last filename already has the .param extension
+            filename = f"fc_params_missing_or_different_in_the_amc_param_files_{first_name_without_ext}_to_{last_filename}"
+            self.local_filesystem.export_to_param(params_missing_in_the_amc_param_files, filename, annotate_doc=False)
+            logging_info(
+                _("Exported %d FC parameters missing or different in AMC files to %s"),
+                len(params_missing_in_the_amc_param_files),
+                filename,
+            )
+        else:
+            logging_info(_("No FC parameters are missing or different from AMC parameter files"))
+
     def _configuration_step_is_optional(self, file_name: str, threshold_pct: int = 20) -> bool:
         # Check if the configuration step for the given file is optional
         mandatory_text, _mandatory_url = self.local_filesystem.get_documentation_text_and_url(file_name, "mandatory")
@@ -959,7 +1060,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         ]
         self.write_zip_file(files_to_zip)
 
-    def write_summary_file(self, param_dict: dict, filename: str, annotate_doc: bool) -> bool:
+    def write_summary_file(self, param_dict: ParDict, filename: str, annotate_doc: bool) -> bool:
         should_write_file = True
         if param_dict:
             if self.local_filesystem.vehicle_configuration_file_exists(filename):

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_table.py

@@ -19,7 +19,6 @@ from tkinter import messagebox, ttk
 from typing import Union
 
 from ardupilot_methodic_configurator import _
-from ardupilot_methodic_configurator.annotate_params import Par
 from ardupilot_methodic_configurator.backend_filesystem import LocalFilesystem
 from ardupilot_methodic_configurator.data_model_ardupilot_parameter import (
     ArduPilotParameter,
@@ -28,6 +27,7 @@ from ardupilot_methodic_configurator.data_model_ardupilot_parameter import (
     ParameterUnchangedError,
 )
 from ardupilot_methodic_configurator.data_model_configuration_step import ConfigurationStepProcessor
+from ardupilot_methodic_configurator.data_model_par_dict import Par, ParDict
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_entry_dynamic import EntryWithDynamicalyFilteredListbox
 from ardupilot_methodic_configurator.frontend_tkinter_pair_tuple_combobox import (
@@ -65,7 +65,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
         self._last_return_values: dict[tk.Misc, str] = {}
 
         style = ttk.Style()
-        style.configure("narrow.TButton", padding=0, width=4, border=(0, 0, 0, 0))  # type: ignore[no-untyped-call]
+        style.configure("narrow.TButton", padding=0, width=4, border=(0, 0, 0, 0))
 
         # Prepare a dictionary that maps variable names to their values
         # These variables are used by the forced_parameters and derived_parameters in configuration_steps_*.json files
@@ -295,7 +295,7 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
             if param.is_readonly
             else "yellow"
             if param.is_calibration
-            else ttk.Style(self.root).lookup("TFrame", "background"),  # type: ignore[no-untyped-call]
+            else ttk.Style(self.root).lookup("TFrame", "background"),
         )
 
         tooltip_parameter_name = param.tooltip_new_value
@@ -828,14 +828,14 @@ class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors,
             )
         return False
 
-    def get_upload_selected_params(self, current_file: str, gui_complexity: str) -> dict[str, Par]:
+    def get_upload_selected_params(self, current_file: str, gui_complexity: str) -> ParDict:
         """Get the parameters selected for upload."""
         # Check if we should show upload column based on GUI complexity
         if not self._should_show_upload_column(gui_complexity):
             # all parameters are selected for upload in simple mode
             return self.local_filesystem.file_parameters[current_file]
 
-        selected_params = {}
+        selected_params = ParDict()
         for param_name, checkbutton_state in self.upload_checkbutton_var.items():
             if checkbutton_state.get():
                 selected_params[param_name] = self.local_filesystem.file_parameters[current_file][param_name]

ardupilot_methodic_configurator/frontend_tkinter_rich_text.py

@@ -75,7 +75,7 @@ def get_widget_font_family_and_size(widget: tk.Widget) -> tuple[str, int]:
     """
     style = ttk.Style()
     widget_style = widget.cget("style")  # Get the style used by the widget
-    font_name = style.lookup(widget_style, "font")  # type: ignore[no-untyped-call]
+    font_name = style.lookup(widget_style, "font")
     font_dict = tkFont.nametofont(font_name).config()
 
     default_font_family = "Segoe UI" if platform_system() == "Windows" else "Helvetica"

ardupilot_methodic_configurator/frontend_tkinter_scroll_frame.py

@@ -33,7 +33,7 @@ class ScrollFrame(ttk.Frame):  # pylint: disable=too-many-ancestors
         self.canvas = tk.Canvas(
             self,
             borderwidth=0,
-            background=ttk.Style(master).lookup("TFrame", "background"),  # type: ignore[no-untyped-call]
+            background=ttk.Style(master).lookup("TFrame", "background"),
         )
 
         # place a frame on the canvas, this frame will hold the child widgets