WIP

Author: amilcarlucas

ardupilot_methodic_configurator/ardupilot_parameter.py

@@ -0,0 +1,206 @@
+"""
+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 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."""
+        return self.metadata.get("values", {})
+
+    @property
+    def bitmask_dict(self) -> dict:
+        """Return the bitmask dictionary for this parameter."""
+        return self.metadata.get("Bitmask", {})
+
+    @property
+    def min_value(self) -> Optional[float]:
+        """Return the minimum allowed value for this parameter."""
+        min_val = self.metadata.get("min", None)
+        return float(min_val) if min_val is not None else None
+
+    @property
+    def max_value(self) -> Optional[float]:
+        """Return the maximum allowed value for this parameter."""
+        max_val = self.metadata.get("max", None)
+        return float(max_val) if max_val is not None else None
+
+    @property
+    def value_as_string(self) -> str:
+        """Return the parameter value as a formatted string."""
+        return format(self.value, ".6f").rstrip("0").rstrip(".")
+
+    @property
+    def fc_value_as_string(self) -> str:
+        """Return the flight controller value as a formatted string."""
+        if self.fc_value is None:
+            return _("N/A")
+        return format(self.fc_value, ".6f").rstrip("0").rstrip(".")
+
+    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)
+        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/bitmask_helper.py

@@ -0,0 +1,61 @@
+"""
+ArduPilot parameter bitmask utilities.
+
+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
+"""
+
+
+class BitmaskHelper:
+    """Helper class for working with ArduPilot parameter bitmasks."""
+
+    @staticmethod
+    def get_checked_keys(value: int, bitmask_dict: dict[int, str]) -> set[int]:
+        """
+        Convert a decimal value to a set of checked bit keys.
+
+        Args:
+            value: The decimal value to convert
+            bitmask_dict: Dictionary mapping bit positions to descriptions
+
+        Returns:
+            Set of keys (bit positions) that are set in the value
+
+        """
+        return {key for key in bitmask_dict if (value >> key) & 1}
+
+    @staticmethod
+    def get_value_from_keys(checked_keys: list[int]) -> int:
+        """
+        Convert a list of checked bit keys to a decimal value.
+
+        Args:
+            checked_keys: List of bit positions that are set
+
+        Returns:
+            The decimal value representing the bits set
+
+        """
+        return sum(1 << key for key in checked_keys)
+
+    @staticmethod
+    def get_description(value: int, bitmask_dict: dict[int, str]) -> str:
+        """
+        Get a human-readable description of which bits are set.
+
+        Args:
+            value: The decimal value
+            bitmask_dict: Dictionary mapping bit positions to descriptions
+
+        Returns:
+            String listing the descriptions of set bits, comma-separated
+
+        """
+        checked_keys = BitmaskHelper.get_checked_keys(value, bitmask_dict)
+        if not checked_keys:
+            return "None"
+
+        return ", ".join(bitmask_dict[key] for key in sorted(checked_keys))

ardupilot_methodic_configurator/connection_renamer.py

@@ -0,0 +1,111 @@
+"""
+ArduPilot parameter connection renaming utility.
+
+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
+
+
+class ConnectionRenamer:
+    """
+    Utility class to handle renaming parameters based on connection prefixes.
+
+    This captures the logic for renaming parameters when connection types change,
+    particularly handling special cases like CAN bus connections.
+    """
+
+    @staticmethod
+    def generate_renames(parameters: list[str], new_connection_prefix: str) -> dict[str, str]:
+        """
+        Generate a dictionary of parameter renames based on a new connection prefix.
+
+        Args:
+            parameters: List of parameter names to potentially rename
+            new_connection_prefix: The new prefix to apply (like "CAN2")
+
+        Returns:
+            Dictionary mapping old parameter names to new parameter names
+
+        """
+        renames = {}
+
+        # Extract the type and number from the new connection prefix
+        if len(new_connection_prefix) < 2:
+            return renames
+
+        new_type = new_connection_prefix[:-1]  # e.g., "CAN" from "CAN2"
+        new_number = new_connection_prefix[-1]  # e.g., "2" from "CAN2"
+
+        for param_name in parameters:
+            if new_type == "CAN" and param_name.startswith("CAN_"):
+                # Handle CAN_P1_* or CAN_D1_* pattern for CAN parameters
+                if "_P1_" in param_name:
+                    new_param_name = param_name.replace("_P1_", f"_P{new_number}_")
+                    renames[param_name] = new_param_name
+                elif "_D1_" in param_name:
+                    new_param_name = param_name.replace("_D1_", f"_D{new_number}_")
+                    renames[param_name] = new_param_name
+            elif param_name.startswith(f"{new_type}1_"):
+                # Handle standard parameters like SERIAL1_BAUD
+                new_param_name = param_name.replace(f"{new_type}1_", f"{new_type}{new_number}_")
+                renames[param_name] = new_param_name
+
+        return renames
+
+    @staticmethod
+    def apply_renames(
+        parameters: dict[str, Any], new_connection_prefix: str, variables: Optional[dict[str, Any]] = None
+    ) -> tuple[dict[str, Any], set[str], list[tuple[str, str]]]:
+        """
+        Apply connection prefix renames to a parameter dictionary.
+
+        Args:
+            parameters: Dictionary of parameter objects to rename
+            new_connection_prefix: The new prefix to apply
+            variables: Optional dictionary of variables for evaluation
+
+        Returns:
+            Tuple containing:
+            - Updated parameters dictionary
+            - Set of new parameter names
+            - List of (old_name, new_name) pairs that were renamed
+
+        """
+        if variables:
+            # If variables provided, evaluate the new_connection_prefix
+            new_connection_prefix = eval(str(new_connection_prefix), {}, variables)  # noqa: S307 pylint: disable=eval-used
+
+        # Generate the rename mapping
+        renames = ConnectionRenamer.generate_renames(list(parameters.keys()), new_connection_prefix)
+
+        # Track unique new names and actual renames performed
+        new_names = set()
+        renamed_pairs = []
+
+        # Create a new dictionary to avoid modifying during iteration
+        updated_parameters = parameters.copy()
+
+        # First identify and process duplicates
+        duplicates = []
+        for old_name, new_name in renames.items():
+            if new_name in parameters and old_name != new_name:
+                duplicates.append(old_name)
+
+        # Remove duplicates
+        for old_name in duplicates:
+            if old_name in updated_parameters:
+                updated_parameters.pop(old_name)
+
+        # Process remaining renames
+        for old_name, new_name in renames.items():
+            if old_name in updated_parameters and old_name not in duplicates:
+                renamed_pairs.append((old_name, new_name))
+                updated_parameters[new_name] = updated_parameters.pop(old_name)
+                new_names.add(new_name)
+
+        return updated_parameters, new_names, renamed_pairs

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor.py

@@ -38,7 +38,7 @@
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
 from ardupilot_methodic_configurator.frontend_tkinter_directory_selection import VehicleDirectorySelectionWidgets
 from ardupilot_methodic_configurator.frontend_tkinter_parameter_editor_documentation_frame import DocumentationFrame
-from ardupilot_methodic_configurator.frontend_tkinter_parameter_editor_table import ParameterEditorTable
+from ardupilot_methodic_configurator.frontend_tkinter_parameter_editor_table_refactored import ParameterEditorTable
 from ardupilot_methodic_configurator.frontend_tkinter_progress_window import ProgressWindow
 from ardupilot_methodic_configurator.frontend_tkinter_rich_text import RichText, get_widget_font_family_and_size
 from ardupilot_methodic_configurator.frontend_tkinter_show import show_tooltip

ardupilot_methodic_configurator/frontend_tkinter_parameter_editor_table.py

@@ -37,7 +37,7 @@
 NEW_VALUE_WIDGET_WIDTH = 9
 
 
-class ParameterEditorTable(ScrollFrame):  # pylint: disable=too-many-ancestors
+class ParameterEditorTable2(ScrollFrame):  # pylint: disable=too-many-ancestors
     """
     A class to manage and display the parameter editor table within the GUI.