ardupilot-methodic-configurator 1.4.8__py3-none-any.whl → 2.0.0__py3-none-any.whl

ardupilot_methodic_configurator/frontend_tkinter_connection_selection.py

@@ -285,8 +285,8 @@ def main() -> None:
     )
     # pylint: enable=duplicate-code
 
-    flight_controller = FlightController(args.reboot_time)  # Initialize your FlightController instance
-    result = flight_controller.connect(device=args.device)  # Connect to the flight controller
+    flight_controller = FlightController(reboot_time=args.reboot_time, baudrate=args.baudrate)
+    result = flight_controller.connect(device=args.device)
     if result:
         logging_warning(result)
         window = ConnectionSelectionWindow(flight_controller, result)

ardupilot_methodic_configurator/frontend_tkinter_directory_selection.py

@@ -30,7 +30,7 @@ from ardupilot_methodic_configurator.frontend_tkinter_show import show_no_param_
 from ardupilot_methodic_configurator.frontend_tkinter_template_overview import TemplateOverviewWindow
 
 
-class DirectorySelectionWidgets:
+class DirectorySelectionWidgets:  # pylint: disable=too-many-instance-attributes
     """
     A class to manage directory selection widgets in the GUI.
 
@@ -49,12 +49,14 @@ class DirectorySelectionWidgets:
         dir_tooltip: str,
         button_tooltip: str,
         is_template_selection: bool,
+        connected_fc_vehicle_type: str,
     ) -> None:
         self.parent = parent
         self.directory: str = deepcopy(initialdir)
         self.label_text = label_text
         self.autoresize_width = autoresize_width
         self.is_template_selection = is_template_selection
+        self.connected_fc_vehicle_type = connected_fc_vehicle_type
 
         # Create a new frame for the directory selection label and button
         self.container_frame = ttk.Frame(parent_frame)
@@ -89,7 +91,7 @@ class DirectorySelectionWidgets:
     def on_select_directory(self) -> bool:
         if self.is_template_selection:
             if isinstance(self.parent.root, tk.Tk):  # this keeps mypy and pyright happy
-                to = TemplateOverviewWindow(self.parent.root)
+                to = TemplateOverviewWindow(self.parent.root, connected_fc_vehicle_type=self.connected_fc_vehicle_type)
                 to.run_app()
             selected_directory = ProgramSettings.get_recently_used_dirs()[0]
             logging_info(_("Selected template directory: %s"), selected_directory)
@@ -158,6 +160,7 @@ class VehicleDirectorySelectionWidgets(DirectorySelectionWidgets):
         local_filesystem: LocalFilesystem,
         initial_dir: str,
         destroy_parent_on_open: bool,
+        connected_fc_vehicle_type: str = "",
     ) -> None:
         # Call the parent constructor with the necessary arguments
         super().__init__(
@@ -177,6 +180,7 @@ class VehicleDirectorySelectionWidgets(DirectorySelectionWidgets):
             if destroy_parent_on_open
             else "",
             is_template_selection=False,
+            connected_fc_vehicle_type=connected_fc_vehicle_type,
         )
         self.local_filesystem = local_filesystem
         self.destroy_parent_on_open = destroy_parent_on_open
@@ -231,9 +235,12 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
     vehicle configuration directory.
     """
 
-    def __init__(self, local_filesystem: LocalFilesystem, fc_connected: bool = False) -> None:
+    def __init__(
+        self, local_filesystem: LocalFilesystem, fc_connected: bool = False, connected_fc_vehicle_type: str = ""
+    ) -> None:
         super().__init__()
         self.local_filesystem = local_filesystem
+        self.connected_fc_vehicle_type = connected_fc_vehicle_type
         self.root.title(
             _("Amilcar Lucas's - ArduPilot methodic configurator ")
             + __version__
@@ -244,6 +251,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
         self.infer_comp_specs_and_conn_from_fc_params = tk.BooleanVar(value=False)
         self.use_fc_params = tk.BooleanVar(value=False)
         self.blank_change_reason = tk.BooleanVar(value=False)
+        self.copy_vehicle_image = tk.BooleanVar(value=False)
         self.configuration_template: str = ""  # will be set to a string if a template was used
 
         # Explain why we are here
@@ -259,7 +267,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
         )
         introduction_label.pack(expand=False, fill=tk.X, padx=6, pady=6)
         template_dir, new_base_dir, vehicle_dir = LocalFilesystem.get_recently_used_dirs()
-        self.create_option1_widgets(template_dir, new_base_dir, _("MyVehicleName"), fc_connected)
+        self.create_option1_widgets(template_dir, new_base_dir, _("MyVehicleName"), fc_connected, connected_fc_vehicle_type)
         self.create_option2_widgets(vehicle_dir)
         self.create_option3_widgets(vehicle_dir)
 
@@ -269,8 +277,13 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
     def close_and_quit(self) -> None:
         sys_exit(0)
 
-    def create_option1_widgets(  # pylint: disable=too-many-locals
-        self, initial_template_dir: str, initial_base_dir: str, initial_new_dir: str, fc_connected: bool
+    def create_option1_widgets(  # pylint: disable=too-many-locals,too-many-arguments,too-many-positional-arguments
+        self,
+        initial_template_dir: str,
+        initial_base_dir: str,
+        initial_new_dir: str,
+        fc_connected: bool,
+        connected_fc_vehicle_type: str,
     ) -> None:
         # Option 1 - Create a new vehicle configuration directory based on an existing template
         option1_label = ttk.Label(text=_("New vehicle"), style="Bold.TLabel")
@@ -293,6 +306,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             dir_tooltip=template_dir_edit_tooltip,
             button_tooltip=template_dir_btn_tooltip,
             is_template_selection=True,
+            connected_fc_vehicle_type=connected_fc_vehicle_type,
         )
         self.template_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
         blank_component_data_checkbox = ttk.Checkbutton(
@@ -347,6 +361,19 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             blank_change_reason_checkbox,
             _("Do not use the parameters change reason from the template."),
         )
+        copy_vehicle_image_checkbox = ttk.Checkbutton(
+            option1_label_frame,
+            variable=self.copy_vehicle_image,
+            text=_("Copy vehicle image from template"),
+        )
+        copy_vehicle_image_checkbox.pack(anchor=tk.NW)
+        show_tooltip(
+            copy_vehicle_image_checkbox,
+            _(
+                "Copy the vehicle.jpg image file from the template directory to the new vehicle directory\n"
+                "if it exists. This image helps identify the vehicle configuration."
+            ),
+        )
         if not fc_connected:
             self.infer_comp_specs_and_conn_from_fc_params.set(False)
             infer_comp_specs_and_conn_from_fc_params_checkbox.config(state=tk.DISABLED)
@@ -364,6 +391,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             dir_tooltip=new_base_dir_edit_tooltip,
             button_tooltip=new_base_dir_btn_tooltip,
             is_template_selection=False,
+            connected_fc_vehicle_type="",
         )
         self.new_base_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
         new_dir_edit_tooltip = _(
@@ -404,7 +432,12 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
         )
         option2_label.pack(expand=False, fill=tk.X, padx=6)
         self.connection_selection_widgets = VehicleDirectorySelectionWidgets(
-            self, option2_label_frame, self.local_filesystem, initial_dir, destroy_parent_on_open=True
+            self,
+            option2_label_frame,
+            self.local_filesystem,
+            initial_dir,
+            destroy_parent_on_open=True,
+            connected_fc_vehicle_type=self.connected_fc_vehicle_type,
         )
         self.connection_selection_widgets.container_frame.pack(expand=True, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
 
@@ -423,6 +456,7 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             dir_tooltip=_("Last used vehicle configuration directory"),
             button_tooltip="",
             is_template_selection=False,
+            connected_fc_vehicle_type="",
         )
         last_dir.container_frame.pack(expand=False, fill=tk.X, padx=3, pady=5, anchor=tk.NW)
 
@@ -471,7 +505,10 @@ class VehicleDirectorySelectionWindow(BaseWindow):  # pylint: disable=too-many-i
             return
 
         error_msg = self.local_filesystem.copy_template_files_to_new_vehicle_dir(
-            template_dir, new_vehicle_dir, self.blank_change_reason.get()
+            template_dir,
+            new_vehicle_dir,
+            blank_change_reason=self.blank_change_reason.get(),
+            copy_vehicle_image=self.copy_vehicle_image.get(),
         )
         if error_msg:
             messagebox.showerror(_("Copying template files"), error_msg)

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

@@ -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))
+            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")
@@ -176,7 +177,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 +204,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,12 +242,13 @@ 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"))
@@ -307,11 +318,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 +334,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 +351,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 +366,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,
             _(
@@ -544,7 +559,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
@@ -593,6 +610,9 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         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)
@@ -720,7 +740,7 @@ class ParameterEditorWindow(BaseWindow):  # pylint: disable=too-many-instance-at
         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)
@@ -804,6 +824,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
@@ -953,7 +990,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: