feat(component editor): Import FRAME_CLASS from FC parameters into Frame.Specifications.Class

use a new FRAME_CLASS_DICT lookup for validating telemetry connection types.

Author: amilcarlucas

ardupilot_methodic_configurator/data_model_vehicle_components_base.py

@@ -262,6 +262,7 @@ def update_json_structure(
                     "Specifications": {
                         "TOW min Kg": 1,
                         "TOW max Kg": 1,
+                        "Class": "Undefined",
                     }
                 },
                 "Flight Controller": {

ardupilot_methodic_configurator/data_model_vehicle_components_import.py

@@ -17,6 +17,7 @@
 from typing import Any, Optional
 
 from ardupilot_methodic_configurator import _
+from ardupilot_methodic_configurator.backend_flightcontroller_business_logic import get_frame_info
 from ardupilot_methodic_configurator.battery_cell_voltages import (
     BATTERY_CELL_VOLTAGE_TYPES,
     BATTERY_DEFAULT_CHEMISTRY,
@@ -36,6 +37,7 @@
     SERVO_FUNCTION_ESC_CONTROL,
     ComponentDataModelValidation,
     get_esc_connection_sub_dict,
+    get_frame_class_sub_dict,
 )
 
 
@@ -183,6 +185,14 @@ def process_fc_parameters(
         self._verify_dict_is_uptodate(doc, get_esc_connection_sub_dict(fw_type), "MOT_PWM_TYPE", "values")
         self._verify_dict_is_uptodate(doc, RC_PROTOCOLS_DICT, "RC_PROTOCOLS", "Bitmask")
 
+        # Process frame information if FRAME_CLASS is present in FC parameters
+        if "FRAME_CLASS" in fc_parameters:
+            frame_class, _ = get_frame_info(fc_parameters)
+            self.set_component_value(
+                ("Frame", "Specifications", "Class"),
+                get_frame_class_sub_dict(fw_type).get(frame_class, "Undefined"),
+            )
+
         # Process parameters in sequence
         self._set_gnss_type_from_fc_parameters(fc_parameters)
         esc_is_serial = self._set_serial_type_from_fc_parameters(fc_parameters)

ardupilot_methodic_configurator/data_model_vehicle_components_validation.py

@@ -316,6 +316,46 @@ def get_esc_connection_sub_dict(
     "65536": {"type": RC_PORTS + SERIAL_PORTS, "protocol": "MAVRadio"},  # Bit 16
 }
 
+FRAME_CLASS_DICT: dict[str, dict[int, str]] = {
+    "ArduCopter": {
+        0: "Undefined",
+        1: "Quad",
+        2: "Hexa",
+        3: "Octa",
+        4: "OctaQuad",
+        5: "Y6",
+        6: "Heli",
+        7: "Tri",
+        8: "SingleCopter",
+        9: "CoaxCopter",
+        10: "BiCopter",
+        11: "Heli_Dual",
+        12: "DodecaHexa",
+        13: "HeliQuad",
+        14: "Deca",
+        15: "Scripting Matrix",
+        16: "6DoF Scripting",
+        17: "Dynamic Scripting Matrix",
+    },
+    "Heli": {
+        6: "Heli",
+        11: "Heli_Dual",
+        13: "HeliQuad",
+    },
+    "Rover": {
+        0: "Undefined",
+        1: "Rover",
+        2: "Boat",
+        3: "BalanceBot",
+    },
+    "ArduPlane": {},
+}
+
+
+def get_frame_class_sub_dict(vehicle_type: str) -> dict[int, str]:
+    """Return the vehicle-type-specific frame class mapping from FRAME_CLASS_DICT."""
+    return FRAME_CLASS_DICT.get(vehicle_type, FRAME_CLASS_DICT["ArduCopter"])
+
 
 class ComponentDataModelValidation(ComponentDataModelBase):
     """

ardupilot_methodic_configurator/vehicle_components_schema.json

@@ -199,6 +199,10 @@
                 "TOW max Kg": {
                   "type": "number",
                   "description": "Maximum take-off weight in kilograms"
+                },
+                "Class": {
+                  "type": "string",
+                  "description": "Frame class/category (e.g., Quad, Hexa, Octa, etc.)"
                 }
               },
               "description": "Technical specifications of the vehicle frame"

tests/test_data_model_vehicle_components_import.py

@@ -309,6 +309,17 @@ def test_system_imports_esc_aio_configuration(self, realistic_model) -> None:
         assert esc_type == "AIO"
         assert esc_protocol == "DShot600"
 
+    def test_user_can_import_frame_class_from_fc(self, realistic_model) -> None:
+        """Given FRAME_CLASS from FC, set Frame.Specifications.Class."""
+        fc_parameters = {"FRAME_CLASS": 3, "MOT_PWM_TYPE": 6, "SERVO1_FUNCTION": 0}
+        doc = {"MOT_PWM_TYPE": {"values": {"6": "DShot600"}}}
+
+        with patch.object(realistic_model, "_verify_dict_is_uptodate", return_value=True):
+            realistic_model.process_fc_parameters(fc_parameters, doc)
+
+        frame_class = realistic_model.get_component_value(("Frame", "Specifications", "Class"))
+        assert frame_class == "Octa"
+
     def test_user_can_import_esc_connection_and_telemetry_from_serial_fc(self, realistic_model) -> None:
         """
         Import ESC serial config into FC->ESC Connection and ESC->FC Telemetry.

tests/unit_data_model_vehicle_components_validation_constants.py

@@ -21,6 +21,7 @@
     ESC_CONNECTION_DICT,
     ESC_SERIAL_SAME_PORT_PROTOCOLS,
     FC_CONNECTION_TYPE_PATHS,
+    FRAME_CLASS_DICT,
     GNSS_RECEIVER_CONNECTION,
     I2C_PORTS,
     OTHER_PORTS,
@@ -33,6 +34,7 @@
     SERIAL_PROTOCOLS_DICT,
     SPI_PORTS,
     get_connection_type_tuples_with_labels,
+    get_frame_class_sub_dict,
 )
 
 
@@ -556,3 +558,83 @@ def test_esc_serial_same_port_protocols_contents(self) -> None:
                 assert protocol in vehicle_protocols, (
                     f"Protocol '{protocol}' from ESC_SERIAL_SAME_PORT_PROTOCOLS not found in ESC_CONNECTION_DICT['{vtype}']"
                 )
+
+
+class TestFrameClassDict:
+    """Tests for FRAME_CLASS_DICT and get_frame_class_sub_dict."""
+
+    def test_frame_class_dict_structure(self) -> None:
+        """FRAME_CLASS_DICT is keyed by vehicle type with int->str sub-dicts."""
+        assert isinstance(FRAME_CLASS_DICT, dict)
+        assert len(FRAME_CLASS_DICT) > 0
+
+        for vtype, sub_dict in FRAME_CLASS_DICT.items():
+            assert isinstance(vtype, str), f"Vehicle type key '{vtype}' is not a string"
+            assert isinstance(sub_dict, dict), f"Sub-dict for '{vtype}' is not a dict"
+            for key, value in sub_dict.items():
+                assert isinstance(key, int), f"Frame class key '{key}' in '{vtype}' is not an int"
+                assert isinstance(value, str), f"Frame class value '{value}' in '{vtype}' is not a string"
+                assert value.strip(), f"Frame class name for key {key} in '{vtype}' is empty"
+
+    def test_frame_class_dict_contains_required_vehicle_types(self) -> None:
+        """FRAME_CLASS_DICT contains entries for all expected vehicle types."""
+        for required in ("ArduCopter", "Heli", "Rover", "ArduPlane"):
+            assert required in FRAME_CLASS_DICT, f"Missing vehicle type '{required}' in FRAME_CLASS_DICT"
+
+    def test_arducopter_frame_class_values(self) -> None:
+        """ArduCopter sub-dict contains the standard multirotor frame classes."""
+        sub = FRAME_CLASS_DICT["ArduCopter"]
+        assert sub[1] == "Quad"
+        assert sub[2] == "Hexa"
+        assert sub[3] == "Octa"
+        assert sub[6] == "Heli"
+        assert sub[11] == "Heli_Dual"
+        assert sub[13] == "HeliQuad"
+
+    def test_heli_frame_class_values(self) -> None:
+        """Heli sub-dict contains only helicopter-relevant frame classes."""
+        sub = FRAME_CLASS_DICT["Heli"]
+        assert sub[6] == "Heli"
+        assert sub[11] == "Heli_Dual"
+        assert sub[13] == "HeliQuad"
+        # Non-heli classes must not appear
+        assert 1 not in sub, "Quad should not be in Heli FRAME_CLASS_DICT"
+        assert 2 not in sub, "Hexa should not be in Heli FRAME_CLASS_DICT"
+
+    def test_rover_frame_class_values(self) -> None:
+        """Rover sub-dict uses Rover-specific frame class values."""
+        sub = FRAME_CLASS_DICT["Rover"]
+        assert sub[1] == "Rover"
+        assert sub[2] == "Boat"
+        assert sub[3] == "BalanceBot"
+        # Multirotor classes must not appear in Rover
+        assert 4 not in sub, "OctaQuad should not be in Rover FRAME_CLASS_DICT"
+
+    def test_arduplane_frame_class_is_empty(self) -> None:
+        """ArduPlane has no FRAME_CLASS parameter, so its sub-dict must be empty."""
+        assert FRAME_CLASS_DICT["ArduPlane"] == {}
+
+    def test_get_frame_class_sub_dict_known_vehicle_types(self) -> None:
+        """get_frame_class_sub_dict returns the correct sub-dict for known vehicle types."""
+        assert get_frame_class_sub_dict("ArduCopter") is FRAME_CLASS_DICT["ArduCopter"]
+        assert get_frame_class_sub_dict("Heli") is FRAME_CLASS_DICT["Heli"]
+        assert get_frame_class_sub_dict("Rover") is FRAME_CLASS_DICT["Rover"]
+        assert get_frame_class_sub_dict("ArduPlane") is FRAME_CLASS_DICT["ArduPlane"]
+
+    def test_get_frame_class_sub_dict_unknown_type_falls_back_to_arducopter(self) -> None:
+        """get_frame_class_sub_dict falls back to ArduCopter for unknown vehicle types."""
+        result = get_frame_class_sub_dict("UnknownVehicle")
+        assert result is FRAME_CLASS_DICT["ArduCopter"]
+
+    def test_get_frame_class_sub_dict_empty_string_falls_back_to_arducopter(self) -> None:
+        """get_frame_class_sub_dict falls back to ArduCopter when fw_type is empty."""
+        result = get_frame_class_sub_dict("")
+        assert result is FRAME_CLASS_DICT["ArduCopter"]
+
+    def test_frame_class_values_are_unique_per_vehicle_type(self) -> None:
+        """Within each vehicle type, frame class names must be unique."""
+        for vtype, sub_dict in FRAME_CLASS_DICT.items():
+            if not sub_dict:
+                continue
+            names = list(sub_dict.values())
+            assert len(names) == len(set(names)), f"Duplicate frame class names found in '{vtype}'"