ardupilot-methodic-configurator 1.5.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

ardupilot_methodic_configurator/frontend_tkinter_flightcontroller_info.py

@@ -8,11 +8,10 @@ SPDX-FileCopyrightText: 2024-2025 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
 SPDX-License-Identifier: GPL-3.0-or-later
 """
 
+import logging
 import tkinter as tk
-
-# from logging import debug as logging_debug
-from logging import info as logging_info
-from tkinter import ttk
+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
@@ -21,6 +20,46 @@ from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWin
 from ardupilot_methodic_configurator.frontend_tkinter_progress_window import ProgressWindow
 
 
+class FlightControllerInfoPresenter:
+    """
+    Business logic for flight controller information presentation.
+
+    Separated from UI for better testability.
+    """
+
+    def __init__(self, flight_controller: FlightController) -> None:
+        self.flight_controller = flight_controller
+        self.param_default_values: dict[str, Par] = {}
+
+    def get_info_data(self) -> dict[str, Union[str, dict[str, str]]]:
+        """Get formatted flight controller information for display."""
+        return self.flight_controller.info.get_info()
+
+    def log_flight_controller_info(self) -> None:
+        """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]:
+        """
+        Download flight controller parameters.
+
+        Args:
+            progress_callback: Optional callback function for progress updates
+
+        Returns:
+            Dictionary of parameter default values
+
+        """
+        fc_parameters, param_default_values = self.flight_controller.download_params(progress_callback)
+        self.flight_controller.fc_parameters = fc_parameters
+        self.param_default_values = param_default_values
+        return param_default_values
+
+    def get_param_default_values(self) -> dict[str, Par]:
+        """Get parameter default values."""
+        return self.param_default_values
+
+
 class FlightControllerInfoWindow(BaseWindow):
     """Display flight controller hardware, firmware and parameter information."""
 
@@ -28,57 +67,59 @@ class FlightControllerInfoWindow(BaseWindow):
         super().__init__()
         self.root.title(_("ArduPilot methodic configurator ") + __version__ + _(" - Flight Controller Info"))
         self.root.geometry("500x350")  # Adjust the window size as needed
-        self.flight_controller = flight_controller
-        self.param_default_values: dict[str, Par] = {}
 
+        self.presenter = FlightControllerInfoPresenter(flight_controller)
+
+        self._create_info_display()
+        self.presenter.log_flight_controller_info()
+
+        # Schedule parameter download after UI is ready
+        self.root.after(50, self._download_flight_controller_parameters)
+        self.root.mainloop()
+
+    def _create_info_display(self) -> None:
+        """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)
 
         # Dynamically create labels and text fields for each attribute
-        for row_nr, (description, attr_value) in enumerate(flight_controller.info.get_info().items()):
-            label = ttk.Label(self.info_frame, text=f"{description}:")
-            label.grid(row=row_nr, column=0, sticky="w")
-
-            text_field = ttk.Entry(self.info_frame)
-            text_field.grid(row=row_nr, column=1, sticky="ew", columnspan=1)
-
-            # Check if the attribute exists and has a non-empty value before inserting
-            if attr_value:
-                if isinstance(attr_value, dict):
-                    text_field.insert(tk.END, (", ").join(attr_value.keys()))
-                else:
-                    text_field.insert(tk.END, attr_value)
-            else:
-                text_field.insert(tk.END, _("N/A"))  # Insert "Not Available" if the attribute is missing or empty
-            text_field.configure(state="readonly")
+        info_data = self.presenter.get_info_data()
+        for row_nr, (description, attr_value) in enumerate(info_data.items()):
+            self._create_info_row(row_nr, description, attr_value)
 
         self.info_frame.columnconfigure(1, weight=1)
 
-        logging_info(_("Firmware Version: %s"), flight_controller.info.flight_sw_version_and_type)
-        logging_info(_("Firmware first 8 hex bytes of the FC git hash: %s"), flight_controller.info.flight_custom_version)
-        logging_info(_("Firmware first 8 hex bytes of the ChibiOS git hash: %s"), flight_controller.info.os_custom_version)
-        logging_info(
-            _("Flight Controller firmware type: %s (%s)"),
-            flight_controller.info.firmware_type,
-            flight_controller.info.apj_board_id,
-        )
-        logging_info(_("Flight Controller HW / board version: %s"), flight_controller.info.board_version)
-        logging_info(_("Flight Controller USB vendor ID: %s"), flight_controller.info.vendor)
-        logging_info(_("Flight Controller USB product ID: %s"), flight_controller.info.product)
+    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}:")
+        label.grid(row=row_nr, column=0, sticky="w")
 
-        self.root.after(50, self.download_flight_controller_parameters())  # type: ignore[func-returns-value]
-        self.root.mainloop()
+        text_field = ttk.Entry(self.info_frame)
+        text_field.grid(row=row_nr, column=1, sticky="ew", columnspan=1)
+
+        # Format the value for display using the backend logic
+        display_value = self.presenter.flight_controller.info.format_display_value(attr_value)
+        text_field.insert(tk.END, display_value)
+        text_field.configure(state="readonly")
 
-    def download_flight_controller_parameters(self) -> None:
+    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")
         )
-        self.flight_controller.fc_parameters, self.param_default_values = self.flight_controller.download_params(
-            param_download_progress_window.update_progress_bar
-        )
-        param_download_progress_window.destroy()  # for the case that '--device test' and there is no real FC connected
-        self.root.destroy()
+
+        try:
+            self.presenter.download_parameters(param_download_progress_window.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}")
+        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]:
-        return self.param_default_values
+        """Get parameter default values from the presenter."""
+        return self.presenter.get_param_default_values()

ardupilot_methodic_configurator/frontend_tkinter_pair_tuple_combobox.py

@@ -106,7 +106,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:
+        if len(style.lookup(current_combo_style, "postoffset")) > 0:  # type: ignore[no-untyped-call]
             return
         combo_values = combo.cget("values")
         if len(combo_values) == 0:
@@ -123,8 +123,9 @@ class PairTupleCombobox(ttk.Combobox):  # pylint: disable=too-many-ancestors
         # the new style must inherit from current widget style (unless it's our custom style!)
         style_name = current_combo_style if unique_name in current_combo_style else f"{unique_name}.{current_combo_style}"
 
-        style.configure(style_name, postoffset=(0, 0, width, 0))
-        combo.configure(style=style_name)
+        if isinstance(combo, ttk.Combobox):
+            style.configure(style_name, postoffset=(0, 0, width, 0))  # type: ignore[no-untyped-call]
+            combo.configure(style=style_name)
 
 
 class PairTupleComboboxTooltip(PairTupleCombobox):  # pylint: disable=too-many-ancestors
@@ -249,8 +250,8 @@ def main() -> None:
     root.geometry("400x100")  # Set a size for the window
 
     # Generate 20 random strings between 4 and 70 characters
-    import random  # pylint: disable=import-outside-toplevel
-    import string  # pylint: disable=import-outside-toplevel
+    import random  # pylint: disable=import-outside-toplevel # noqa: PLC0415
+    import string  # pylint: disable=import-outside-toplevel # noqa: PLC0415
 
     random_strings = [
         "".join(random.choices(string.ascii_letters + string.digits, k=random.randint(4, 70)))  # noqa: S311

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -150,6 +150,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         self.tempcal_imu_progress_window: ProgressWindow
         self.file_upload_progress_window: ProgressWindow
         self.last_time_asked_to_save: float = 0
+        self.gui_complexity = str(ProgramSettings.get_setting("gui_complexity"))
 
         self.root.title(
             _("Amilcar Lucas's - ArduPilot methodic configurator ") + __version__ + _(" - Parameter file editor and uploader")
@@ -160,13 +161,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")])
-        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.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]
 
         self.__create_conf_widgets(__version__)
 
@@ -176,7 +179,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             last_step_nr = int(last_step_filename[:2]) + 1 if len(last_step_filename) >= 2 else 1
 
             self.stage_progress_bar = StageProgressBar(
-                self.main_frame, self.local_filesystem.configuration_phases, last_step_nr
+                self.main_frame, self.local_filesystem.configuration_phases, last_step_nr, self.gui_complexity
             )
             self.stage_progress_bar.pack(side=tk.TOP, fill="x", expand=False, pady=(2, 2), padx=(4, 4))
 
@@ -203,18 +206,27 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
 
         # Create a new frame inside the config_subframe for the intermediate parameter file directory selection labels
         # and directory selection button
+        connected_vehicle_type = self.flight_controller.info.vehicle_type if self.flight_controller.info.vehicle_type else ""
         directory_selection_frame = VehicleDirectorySelectionWidgets(
-            self, config_subframe, self.local_filesystem, self.local_filesystem.vehicle_dir, destroy_parent_on_open=False
+            self,
+            config_subframe,
+            self.local_filesystem,
+            self.local_filesystem.vehicle_dir,
+            destroy_parent_on_open=False,
+            connected_fc_vehicle_type=connected_vehicle_type,
         )
-        directory_selection_frame.container_frame.pack(side=tk.LEFT, fill="x", expand=False, padx=(4, 6))
+        if self.gui_complexity != "simple":
+            directory_selection_frame.container_frame.pack(side=tk.LEFT, fill="x", expand=False, padx=(4, 6))
 
         # Create a new frame inside the config_subframe for the intermediate parameter file selection label and combobox
         file_selection_frame = ttk.Frame(config_subframe)
-        file_selection_frame.pack(side=tk.LEFT, fill="x", expand=False, padx=(6, 6))
+        if self.gui_complexity != "simple":
+            file_selection_frame.pack(side=tk.LEFT, fill="x", expand=False, padx=(6, 6))
 
         # Create a label for the Combobox
         file_selection_label = ttk.Label(file_selection_frame, text=_("Current intermediate parameter file:"))
-        file_selection_label.pack(side=tk.TOP, anchor=tk.NW)  # Add the label to the top of the file_selection_frame
+        if self.gui_complexity != "simple":
+            file_selection_label.pack(side=tk.TOP, anchor=tk.NW)  # Add the label to the top of the file_selection_frame
 
         # Create Combobox for intermediate parameter file selection
         self.file_selection_combobox = AutoResizeCombobox(
@@ -232,19 +244,20 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             style="readonly.TCombobox",
         )
         self.file_selection_combobox.bind("<<ComboboxSelected>>", self.on_param_file_combobox_change)
-        self.file_selection_combobox.pack(side=tk.TOP, anchor=tk.NW, pady=(4, 0))
+        if self.gui_complexity != "simple":  # only display the combobox when not simple
+            self.file_selection_combobox.pack(side=tk.TOP, anchor=tk.NW, pady=(4, 0))
 
         font_family, _font_size = get_widget_font_family_and_size(file_selection_label)
         self.legend_frame(config_subframe, font_family)
 
-        image_label = BaseWindow.put_image_in_label(config_frame, LocalFilesystem.application_logo_filepath())
+        image_label = self.put_image_in_label(config_frame, LocalFilesystem.application_logo_filepath())
         image_label.pack(side=tk.RIGHT, anchor=tk.NE, padx=(4, 4), pady=(4, 0))
         image_label.bind("<Button-1>", lambda event: show_about_window(self.main_frame, version))  # noqa: ARG005
         show_tooltip(image_label, _("User Manual, Support Forum, Report a Bug, Licenses, Source Code"))
 
     def legend_frame(self, config_subframe: ttk.Frame, font_family: str) -> None:
         style = ttk.Style()
-        style.configure("Legend.TLabelframe", font=(font_family, 9))
+        style.configure("Legend.TLabelframe", font=(font_family, 9))  # type: ignore[no-untyped-call]
         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)
@@ -258,9 +271,12 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         cal_label = ttk.Label(legend_left, text=_("Calibration param"), background="yellow", font=font)
         show_tooltip(cal_label, _("Calibration parameter - not-reusable, even in similar vehicles"))
         cal_label.pack(side=tk.TOP, anchor=tk.NW)
-        readonly_label = ttk.Label(legend_left, text=_("Read-only param"), background="red", font=font)
+        readonly_label = ttk.Label(legend_left, text=_("Read-only param"), background="purple1", font=font)
         show_tooltip(readonly_label, _("Read-only parameter - not writable nor changeable"))
         readonly_label.pack(side=tk.TOP, anchor=tk.NW)
+        toolow_label = ttk.Label(legend_left, text=_("Below limit"), background="orangered", font=font)
+        show_tooltip(toolow_label, _("Parameter value below the minimum recommended value"))
+        toolow_label.pack(side=tk.TOP, anchor=tk.NW)
         legend_right = ttk.Frame(legend_frame)
         legend_right.pack(side=tk.RIGHT, anchor=tk.NE)
         default_label = ttk.Label(legend_right, text=_("Default value"), background="lightblue", font=font)
@@ -279,6 +295,9 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         )
         ne_label.configure(state="disabled")
         ne_label.pack(side=tk.TOP, anchor=tk.NW)
+        toohigh_label = ttk.Label(legend_right, text=_("Above limit"), background="red3", font=font)
+        show_tooltip(toohigh_label, _("Parameter value above the maximum recommended value"))
+        toohigh_label.pack(side=tk.TOP, anchor=tk.NW)
         legend_frame.pack(side=tk.LEFT, fill="x", expand=False, padx=(2, 2))
 
     def __create_parameter_area_widgets(self) -> None:
@@ -307,11 +326,12 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             variable=self.show_only_differences,
             command=self.on_show_only_changed_checkbox_change,
         )
-        only_changed_checkbox.pack(side=tk.TOP, anchor=tk.NW)
-        show_tooltip(
-            only_changed_checkbox,
-            _("Toggle to show only parameters that will change if/when uploaded to the flight controller"),
-        )
+        if self.gui_complexity != "simple":
+            only_changed_checkbox.pack(side=tk.TOP, anchor=tk.NW)
+            show_tooltip(
+                only_changed_checkbox,
+                _("Toggle to show only parameters that will change if/when uploaded to the flight controller"),
+            )
 
         annotate_params_checkbox = ttk.Checkbutton(
             checkboxes_frame,
@@ -322,14 +342,15 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
                 "annotate_docs_into_param_files", self.annotate_params_into_files.get()
             ),
         )
-        annotate_params_checkbox.pack(side=tk.TOP, anchor=tk.NW)
-        show_tooltip(
-            annotate_params_checkbox,
-            _(
-                "Annotate ArduPilot parameter documentation metadata into the intermediate parameter files\n"
-                "The files will be bigger, but all the existing parameter documentation will be included inside"
-            ),
-        )
+        if self.gui_complexity != "simple":
+            annotate_params_checkbox.pack(side=tk.TOP, anchor=tk.NW)
+            show_tooltip(
+                annotate_params_checkbox,
+                _(
+                    "Annotate ArduPilot parameter documentation metadata into the intermediate parameter files\n"
+                    "The files will be bigger, but all the existing parameter documentation will be included inside"
+                ),
+            )
 
         # Create upload button
         upload_selected_button = ttk.Button(
@@ -338,7 +359,8 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             command=self.on_upload_selected_click,
         )
         upload_selected_button.configure(state="normal" if self.flight_controller.master else "disabled")
-        upload_selected_button.pack(side=tk.LEFT, padx=(8, 8))  # Add padding on both sides of the upload selected button
+        if self.gui_complexity != "simple" or self.flight_controller.master:
+            upload_selected_button.pack(side=tk.LEFT, padx=(8, 8))  # Add padding on both sides of the upload selected button
         show_tooltip(
             upload_selected_button,
             _(
@@ -352,7 +374,8 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
 
         # Create skip button
         skip_button = ttk.Button(buttons_frame, text=_("Skip parameter file"), command=self.on_skip_click)
-        skip_button.pack(side=tk.RIGHT, padx=(8, 8))  # Add right padding to the skip button
+        if self.gui_complexity != "simple" or not self.flight_controller.master:
+            skip_button.pack(side=tk.RIGHT, padx=(8, 8))  # Add right padding to the skip button
         show_tooltip(
             skip_button,
             _(
@@ -367,7 +390,11 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         style = ttk.Style()
 
         instructions_text = RichText(
-            usage_popup_window.main_frame, wrap=tk.WORD, height=10, bd=0, background=style.lookup("TLabel", "background")
+            usage_popup_window.main_frame,
+            wrap=tk.WORD,
+            height=10,
+            bd=0,
+            background=style.lookup("TLabel", "background"),  # type: ignore[no-untyped-call]
         )
         instructions_text.insert(tk.END, _("1. Read "))
         instructions_text.insert(tk.END, _("all"), "bold")
@@ -544,7 +571,9 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
     def __should_jump_to_file(self, selected_file: str) -> str:
         jump_possible = self.local_filesystem.jump_possible(selected_file)
         for dest_file, msg in jump_possible.items():
-            if messagebox.askyesno(_("Skip some steps?"), _(msg) if msg else _("Skip to {dest_file}?").format(**locals())):
+            if self.gui_complexity == "simple" or messagebox.askyesno(
+                _("Skip some steps?"), _(msg) if msg else _("Skip to {dest_file}?").format(**locals())
+            ):
                 self.file_selection_combobox.set(dest_file)
                 return dest_file
         return selected_file
@@ -587,12 +616,14 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
     def on_param_file_combobox_change(self, _event: Union[None, tk.Event], forced: bool = False) -> None:
         if not self.file_selection_combobox["values"]:
             return
-        self.parameter_editor_table.generate_edit_widgets_focus_out()
         selected_file = self.file_selection_combobox.get()
         self._update_progress_bar_from_file(selected_file)
         if self.current_file != selected_file or forced:
             self.write_changes_to_intermediate_parameter_file()
             self.__do_tempcal_imu(selected_file)
+            # open the documentation of the next step in the browser,
+            # before giving the user the option to close the SW in the __should_copy_fc_values_to_file method
+            self.documentation_frame.open_documentation_in_browser(selected_file)
             self.__should_copy_fc_values_to_file(selected_file)
             selected_file = self.__should_jump_to_file(selected_file)
             self.__should_download_file_from_url(selected_file)
@@ -637,7 +668,9 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         else:
             fc_parameters = {}
         # Re-populate the table with the new parameters
-        self.parameter_editor_table.repopulate(selected_file, fc_parameters, self.show_only_differences.get())
+        self.parameter_editor_table.repopulate(
+            selected_file, fc_parameters, self.show_only_differences.get(), self.gui_complexity
+        )
 
     def on_show_only_changed_checkbox_change(self) -> None:
         self.repopulate_parameter_table(self.current_file)
@@ -717,10 +750,8 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             self.reset_progress_window.destroy()  # for the case that we are doing a test and there is no real FC connected
 
     def on_upload_selected_click(self) -> None:
-        self.parameter_editor_table.generate_edit_widgets_focus_out()
-
         self.write_changes_to_intermediate_parameter_file()
-        selected_params = self.parameter_editor_table.get_upload_selected_params(self.current_file)
+        selected_params = self.parameter_editor_table.get_upload_selected_params(self.current_file, str(self.gui_complexity))
         if selected_params:
             if hasattr(self.flight_controller, "fc_parameters") and self.flight_controller.fc_parameters:
                 self.upload_selected_params(selected_params)
@@ -733,7 +764,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             logging_warning(_("No parameter was selected for upload, will not upload any parameter"))
             messagebox.showwarning(_("Will not upload any parameter"), _("No parameter was selected for upload"))
         # Delete the parameter table and create a new one with the next file if available
-        self.on_skip_click(force_focus_out_event=False)
+        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:
@@ -794,9 +825,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
                 logging_info(_("All parameters uploaded to the flight controller successfully"))
         self.local_filesystem.write_last_uploaded_filename(self.current_file)
 
-    def on_skip_click(self, _event: Union[None, tk.Event] = None, force_focus_out_event: bool = True) -> None:
-        if force_focus_out_event:
-            self.parameter_editor_table.generate_edit_widgets_focus_out()
+    def on_skip_click(self, _event: Union[None, tk.Event] = None) -> None:
         self.write_changes_to_intermediate_parameter_file()
         # Find the next filename in the file_parameters dictionary
         files = list(self.local_filesystem.file_parameters.keys())
@@ -804,6 +833,23 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
             return
         try:
             next_file_index = files.index(self.current_file) + 1
+            # Skip files with mandatory_level == 0
+            while next_file_index < len(files):
+                next_file = files[next_file_index]
+                mandatory_text, _mandatory_url = self.local_filesystem.get_documentation_text_and_url(next_file, "mandatory")
+                # Extract percentage from mandatory_text like "80% mandatory (20% optional)"
+                percentage = 0
+                if mandatory_text:
+                    try:
+                        percentage = int(mandatory_text.split("%")[0])
+                    except (ValueError, IndexError):
+                        percentage = 0
+
+                # If the file has mandatory_level > 0, use it
+                if percentage > 0:
+                    break
+
+                next_file_index += 1
             if next_file_index >= len(files):
                 self.write_summary_files()
                 # Close the application and the connection
@@ -917,7 +963,9 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         return should_write_file
 
     def close_connection_and_quit(self) -> None:
-        self.parameter_editor_table.generate_edit_widgets_focus_out()
+        focused_widget = self.parameter_editor_table.view_port.focus_get()
+        if focused_widget is not None:
+            focused_widget.event_generate("<FocusOut>", when="now")  # trigger a sync between GUI and data-model values
         self.write_changes_to_intermediate_parameter_file()
         self.root.quit()  # Then stop the Tkinter event loop
 
@@ -953,7 +1001,7 @@ if __name__ == "__main__":
 
     logging_basicConfig(level=logging_getLevelName(args.loglevel), format="%(asctime)s - %(levelname)s - %(message)s")
 
-    fc = FlightController(args.reboot_time)
+    fc = FlightController(reboot_time=args.reboot_time, baudrate=args.baudrate)
     filesystem = LocalFilesystem(
         args.vehicle_dir, args.vehicle_type, "", args.allow_editing_template_files, args.save_component_to_system_templates
     )

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_documentation_frame.py

@@ -45,14 +45,13 @@ class DocumentationFrame:
     def __init__(self, root: tk.Widget, local_filesystem: LocalFilesystem, current_file: str) -> None:
         self.root = root
         self.local_filesystem = local_filesystem
-        self.current_file = current_file
         self.documentation_frame: ttk.LabelFrame
         self.documentation_labels: dict[str, ttk.Label] = {}
         self.mandatory_level: ttk.Progressbar
         self.auto_open_var = tk.BooleanVar(value=bool(ProgramSettings.get_setting("auto_open_doc_in_browser")))
-        self._create_documentation_frame()
+        self._create_documentation_frame(current_file)
 
-    def _create_documentation_frame(self) -> None:
+    def _create_documentation_frame(self, current_file: str) -> None:
         self.documentation_frame = ttk.LabelFrame(self.root, text=_("Documentation"))
 
         # Create a grid structure within the documentation_frame
@@ -60,6 +59,11 @@ class DocumentationFrame:
         documentation_grid.pack(fill="both", expand=True)
 
         for row, (text, tooltip) in enumerate(self.DOCUMENTATION_SECTIONS):
+            if row == 3 and ProgramSettings.get_setting("gui_complexity") == "simple":
+                # Skip the mandatory level row in simple mode
+                self.mandatory_level = ttk.Progressbar(documentation_grid, length=100, mode="determinate")
+                continue
+
             # Create labels for the first column with static descriptive text
             label = ttk.Label(documentation_grid, text=text)
             label.grid(row=row, column=0, sticky="w")
@@ -75,8 +79,8 @@ class DocumentationFrame:
         documentation_grid.columnconfigure(1, weight=1)
 
         # Dynamically update the documentation text and URL links
-        self.refresh_documentation_labels(self.current_file)
-        self.update_why_why_now_tooltip(self.current_file)
+        self.refresh_documentation_labels(current_file)
+        self.update_why_why_now_tooltip(current_file)
 
     def _create_bottom_row(self, documentation_grid: ttk.Frame, row: int) -> None:
         bottom_frame = ttk.Frame(documentation_grid)
@@ -111,8 +115,22 @@ class DocumentationFrame:
         if tooltip_text:
             show_tooltip(self.documentation_frame, tooltip_text, position_below=False)
 
+    def open_documentation_in_browser(self, current_file: str) -> None:
+        _blog_text, blog_url = self.local_filesystem.get_documentation_text_and_url(current_file, "blog")
+        _wiki_text, wiki_url = self.local_filesystem.get_documentation_text_and_url(current_file, "wiki")
+        _external_tool_text, external_tool_url = self.local_filesystem.get_documentation_text_and_url(
+            current_file, "external_tool"
+        )
+
+        if self.auto_open_var.get() or ProgramSettings.get_setting("gui_complexity") == "simple":
+            if wiki_url:
+                webbrowser_open(url=wiki_url, new=0, autoraise=False)
+            if external_tool_url:
+                webbrowser_open(url=external_tool_url, new=0, autoraise=False)
+            if blog_url:
+                webbrowser_open(url=blog_url, new=0, autoraise=True)
+
     def refresh_documentation_labels(self, current_file: str) -> None:
-        self.current_file = current_file
         if current_file:
             title = _("{current_file} Documentation")
             frame_title = title.format(**locals())
@@ -133,14 +151,6 @@ class DocumentationFrame:
         mandatory_text, _mandatory_url = self.local_filesystem.get_documentation_text_and_url(current_file, "mandatory")
         self._refresh_mandatory_level(current_file, mandatory_text)
 
-        if self.auto_open_var.get():
-            if wiki_url:
-                webbrowser_open(url=wiki_url, new=0, autoraise=False)
-            if external_tool_url:
-                webbrowser_open(url=external_tool_url, new=0, autoraise=False)
-            if blog_url:
-                webbrowser_open(url=blog_url, new=0, autoraise=True)
-
     def _refresh_documentation_label(self, label_key: str, text: str, url: str, url_expected: bool = True) -> None:
         label = self.documentation_labels[label_key]
         if url: