WIP

Author: amilcarlucas

ardupilot_methodic_configurator/ardupilot_parameter.py

@@ -0,0 +1,204 @@
+"""
+ArduPilot parameter domain model.
+
+This file is part of Ardupilot methodic configurator. https://github.com/ArduPilot/MethodicConfigurator
+
+SPDX-FileCopyrightText: 2024-2025 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
+
+SPDX-License-Identifier: GPL-3.0-or-later
+"""
+
+from typing import Any, Optional
+
+from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.annotate_params import Par
+from ardupilot_methodic_configurator.backend_filesystem import is_within_tolerance
+
+
+class ArduPilotParameter:
+    """Domain model representing an ArduPilot parameter with all its attributes."""
+
+    def __init__(
+        self,
+        name: str,
+        par_obj: Par,
+        metadata: Optional[dict[str, Any]] = None,
+        default_par: Optional[Par] = None,
+        fc_value: Optional[float] = None,
+        is_forced: bool = False,
+        is_derived: bool = False,
+    ) -> None:
+        """
+        Initialize the parameter with all its attributes.
+
+        Args:
+            name: Name of the parameter
+            par_obj: Par object containing value and comment
+            metadata: Dictionary of parameter metadata (from pdef.xml files)
+            default_par: Default parameter object for comparison
+            fc_value: Value from the flight controller, if connected
+            is_forced: Whether this parameter is forced (cannot be edited)
+            is_derived: Whether this parameter is derived (calculated automatically)
+
+        """
+        self.name = name
+        self.value = par_obj.value
+        self.comment = par_obj.comment
+        self.metadata = metadata or {}
+        self.default_value = default_par.value if default_par else None
+        self.fc_value = fc_value
+        self.is_forced = is_forced
+        self.is_derived = is_derived
+
+    @property
+    def is_calibration(self) -> bool:
+        """Return True if this is a calibration parameter."""
+        return self.metadata.get("Calibration", False)
+
+    @property
+    def is_readonly(self) -> bool:
+        """Return True if this is a readonly parameter."""
+        return self.metadata.get("ReadOnly", False)
+
+    @property
+    def is_bitmask(self) -> bool:
+        """Return True if this parameter uses a bitmask representation."""
+        return "Bitmask" in self.metadata
+
+    @property
+    def has_default_value(self) -> bool:
+        """Return True if the current value equals the default value."""
+        return self.default_value is not None and is_within_tolerance(self.value, self.default_value)
+
+    @property
+    def has_fc_value(self) -> bool:
+        """Return True if there is a flight controller value for this parameter."""
+        return self.fc_value is not None
+
+    @property
+    def is_different_from_fc(self) -> bool:
+        """Return True if the parameter value is different from the flight controller value."""
+        return self.fc_value is not None and not is_within_tolerance(self.value, self.fc_value)
+
+    @property
+    def doc_tooltip(self) -> str:
+        """Return the documentation tooltip for this parameter."""
+        return self.metadata.get("doc_tooltip", _("No documentation available in apm.pdef.xml for this parameter"))
+
+    @property
+    def unit(self) -> str:
+        """Return the unit of this parameter."""
+        return self.metadata.get("unit", "")
+
+    @property
+    def unit_tooltip(self) -> str:
+        """Return the unit tooltip for this parameter."""
+        return str(self.metadata.get("unit_tooltip", _("No documentation available in apm.pdef.xml for this parameter")))
+
+    @property
+    def values_dict(self) -> dict:
+        """Return the values dictionary for this parameter if it exists."""
+        return self.metadata.get("values", {}) or {}
+
+    @property
+    def bitmask_dict(self) -> dict:
+        """Return the bitmask dictionary for this parameter if it exists."""
+        return self.metadata.get("Bitmask", {}) or {}
+
+    @property
+    def min_value(self) -> Optional[float]:
+        """Return the minimum allowed value for this parameter."""
+        return self.metadata.get("min", None)
+
+    @property
+    def max_value(self) -> Optional[float]:
+        """Return the maximum allowed value for this parameter."""
+        return self.metadata.get("max", None)
+
+    @property
+    def value_as_string(self) -> str:
+        """Return the parameter value formatted as a string."""
+        return format(self.value, ".6f").rstrip("0").rstrip(".")
+
+    @property
+    def fc_value_as_string(self) -> str:
+        """Return the flight controller value formatted as a string."""
+        if self.fc_value is not None:
+            return format(self.fc_value, ".6f").rstrip("0").rstrip(".")
+        return _("N/A")
+
+    def is_in_values_dict(self) -> bool:
+        """Return True if the current value is in the values dictionary."""
+        return bool(self.values_dict and self.value_as_string in self.values_dict)
+
+    def get_selected_value_from_dict(self) -> Optional[str]:
+        """Return the string representation from the values dictionary for the current value."""
+        if self.is_in_values_dict():
+            return self.values_dict.get(self.value_as_string, None)
+        return None
+
+    def set_value(self, value: float) -> bool:
+        """
+        Set the parameter value and return whether it changed.
+
+        Args:
+            value: The new value to set
+
+        Returns:
+            True if the value was changed, False otherwise
+
+        """
+        if self.is_forced or self.is_derived:
+            return False
+
+        if is_within_tolerance(self.value, value):
+            return False
+
+        self.value = value
+        return True
+
+    def set_comment(self, comment: str) -> bool:
+        """
+        Set the parameter comment and return whether it changed.
+
+        Args:
+            comment: The new comment to set
+
+        Returns:
+            True if the comment was changed, False otherwise
+
+        """
+        if self.is_forced or self.is_derived:
+            return False
+
+        if comment == self.comment or (comment == "" and self.comment is None):
+            return False
+
+        self.comment = comment
+        return True
+
+    def is_editable(self) -> bool:
+        """
+        Check if this parameter is editable.
+
+        Returns:
+            True if the parameter can be edited, False otherwise
+
+        """
+        return not (self.is_forced or self.is_derived or self.is_readonly)
+
+    def is_valid_value(self, value: float) -> bool:
+        """
+        Check if a value is valid for this parameter.
+
+        Args:
+            value: The value to check
+
+        Returns:
+            True if the value is valid, False otherwise
+
+        """
+        if self.min_value is not None and value < self.min_value:
+            return False
+
+        return not (self.max_value is not None and value > self.max_value)

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -44,6 +44,8 @@
 from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip
 from ardupilot_methodic_configurator.frontend_tkinter_stage_progress import StageProgressBar
 from ardupilot_methodic_configurator.frontend_tkinter_usage_popup_window import UsagePopupWindow
+from ardupilot_methodic_configurator.parameter_editor_model import ParameterEditorModel
+from ardupilot_methodic_configurator.parameter_repository import LocalFilesystemParameterRepository
 from ardupilot_methodic_configurator.tempcal_imu import IMUfit
 
 
@@ -140,6 +142,10 @@ def __init__(self, current_file: str, flight_controller: FlightController, local
         self.flight_controller = flight_controller
         self.local_filesystem = local_filesystem
 
+        # Initialize the parameter repository and model
+        self.parameter_repository = LocalFilesystemParameterRepository(local_filesystem)
+        self.parameter_model = ParameterEditorModel(self.parameter_repository)
+
         self.at_least_one_changed_parameter_written = False
         self.file_selection_combobox: AutoResizeCombobox
         self.show_only_differences: tk.BooleanVar
@@ -184,6 +190,9 @@ def __init__(self, current_file: str, flight_controller: FlightController, local
         self.documentation_frame = DocumentationFrame(self.main_frame, self.local_filesystem, self.current_file)
         self.documentation_frame.documentation_frame.pack(side=tk.TOP, fill="x", expand=False, pady=(2, 2), padx=(4, 4))
 
+        # Load the initial parameters into the model
+        self.parameter_model.load_parameters(self.current_file)
+
         self.__create_parameter_area_widgets()
 
         # trigger a table update to ask the user what to do in the case this file needs special actions
@@ -237,7 +246,7 @@ def __create_conf_widgets(self, version: str) -> None:
         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 = BaseWindow.put_image_in_label(config_frame, ProgramSettings.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"))
@@ -287,8 +296,20 @@ def __create_parameter_area_widgets(self) -> None:
             value=bool(ProgramSettings.get_setting("annotate_docs_into_param_files"))
         )
 
-        # Create a Scrollable parameter editor table
-        self.parameter_editor_table = ParameterEditorTable(self.main_frame, self.local_filesystem, self)
+        # Create a Scrollable parameter editor table connected to our model
+        self.parameter_editor_table = ParameterEditorTable(
+            self.main_frame,
+            self,
+            self.local_filesystem.param_default_dict,
+            self.local_filesystem.doc_dict,
+            self.local_filesystem,
+            self.current_file,
+            parameter_model=self.parameter_model,
+            parameter_upload_callback=self.flight_controller.set_param,
+            fc_parameters_dict=self.flight_controller.fc_parameters
+            if hasattr(self.flight_controller, "fc_parameters")
+            else {},
+        )
         self.repopulate_parameter_table(self.current_file)
         self.parameter_editor_table.pack(side="top", fill="both", expand=True)