FEATURE: Use and present board/firmware type information

Author: amilcarlucas

MethodicConfigurator/ardupilot_methodic_configurator.py

@@ -104,11 +104,19 @@ def component_editor(
     component_editor_window.populate_frames()
     component_editor_window.set_vehicle_type_and_version(vehicle_type, flight_controller.info.flight_sw_version_and_type)
     component_editor_window.set_fc_manufacturer(flight_controller.info.vendor)
-    component_editor_window.set_fc_model(flight_controller.info.product)
+    component_editor_window.set_fc_model(flight_controller.info.firmware_type)
     if vehicle_dir_window and vehicle_dir_window.configuration_template:
         component_editor_window.set_vehicle_configuration_template(vehicle_dir_window.configuration_template)
     if args.skip_component_editor:
         component_editor_window.root.after(10, component_editor_window.root.destroy)
+    elif bool(ProgramSettings.get_setting("auto_open_doc_in_browser")) and flight_controller.info.firmware_type != _(
+        "Unknown"
+    ):
+        url = (
+            "https://github.com/ArduPilot/ardupilot/blob/master/libraries/AP_HAL_ChibiOS/hwdef/"
+            f"{flight_controller.info.firmware_type}/README.md"
+        )
+        webbrowser_open(url=url, new=0, autoraise=True)
     component_editor_window.root.mainloop()
 
     if vehicle_dir_window and vehicle_dir_window.configuration_template and vehicle_dir_window.use_fc_params.get():

MethodicConfigurator/backend_flightcontroller.py

@@ -299,10 +299,10 @@ def __process_autopilot_version(self, m: MAVLink_autopilot_version_message, bann
             )
         self.info.set_capabilities(m.capabilities)
         self.info.set_flight_sw_version(m.flight_sw_version)
+        self.info.set_usb_vendor_and_product_ids(m.vendor_id, m.product_id)  # must be done before set_board_version()
         self.info.set_board_version(m.board_version)
         self.info.set_flight_custom_version(m.flight_custom_version)
         self.info.set_os_custom_version(m.os_custom_version)
-        self.info.set_vendor_id_and_product_id(m.vendor_id, m.product_id)
 
         os_custom_version = ""
         os_custom_version_index = None
@@ -320,14 +320,16 @@ def __process_autopilot_version(self, m: MAVLink_autopilot_version_message, bann
             logging_info("FC banner %s", msg)
 
         # the banner message after the ChibiOS one contains the FC type
-        fc_product = ""
+        firmware_type = ""
         if os_custom_version_index is not None and os_custom_version_index + 1 < len(banner_msgs):
-            fc_product_banner_substrings = banner_msgs[os_custom_version_index + 1].split(" ")
-            if len(fc_product_banner_substrings) >= 3:
-                fc_product = fc_product_banner_substrings[0]
-        if fc_product != self.info.product:
-            logging_warning(_("FC product mismatch: %s (BANNER) != %s (AUTOPILOT_VERSION)"), fc_product, self.info.product)
-            self.info.product = fc_product  # force the one from the banner because it is more reliable
+            firmware_type_banner_substrings = banner_msgs[os_custom_version_index + 1].split(" ")
+            if len(firmware_type_banner_substrings) >= 3:
+                firmware_type = firmware_type_banner_substrings[0]
+        if firmware_type and firmware_type != self.info.firmware_type:
+            logging_warning(
+                _("FC firmware type mismatch: %s (BANNER) != %s (AUTOPILOT_VERSION)"), firmware_type, self.info.firmware_type
+            )
+            self.info.firmware_type = firmware_type  # force the one from the banner because it is more reliable
         return ""
 
     def download_params(

MethodicConfigurator/backend_flightcontroller_info.py

@@ -14,6 +14,13 @@
 from pymavlink import mavutil
 
 # import pymavlink.dialects.v20.ardupilotmega
+from MethodicConfigurator import _
+from MethodicConfigurator.middleware_fc_ids import (
+    APJ_BOARD_ID_NAME_DICT,
+    APJ_BOARD_ID_VENDOR_DICT,
+    VID_PID_PRODUCT_DICT,
+    VID_VENDOR_DICT,
+)
 
 
 class BackendFlightcontrollerInfo:  # pylint: disable=too-many-instance-attributes
@@ -29,10 +36,12 @@ def __init__(self) -> None:
         self.component_id: str = ""
         self.autopilot: str = ""
         self.vehicle_type: str = ""
+        self.firmware_type: str = ""
         self.mav_type: str = ""
         self.flight_sw_version: str = ""
         self.flight_sw_version_and_type: str = ""
         self.board_version: str = ""
+        self.apj_board_id: str = ""
         self.flight_custom_version: str = ""
         self.os_custom_version: str = ""
         self.vendor: str = ""
@@ -48,18 +57,20 @@ def __init__(self) -> None:
 
     def get_info(self) -> dict[str, Union[str, dict[str, str]]]:
         return {
-            "Vendor": self.vendor_and_vendor_id,
-            "Product": self.product_and_product_id,
-            "Hardware Version": self.board_version,
-            "Autopilot Type": self.autopilot,
-            "ArduPilot FW Type": self.vehicle_type,
-            "MAV Type": self.mav_type,
-            "Firmware Version": self.flight_sw_version_and_type,
-            "Git Hash": self.flight_custom_version,
-            "OS Git Hash": self.os_custom_version,
-            "Capabilities": self.capabilities,
-            "System ID": self.system_id,
-            "Component ID": self.component_id,
+            _("USB Vendor"): self.vendor_and_vendor_id,
+            _("USB Product"): self.product_and_product_id,
+            _("Board Type"): self.apj_board_id,
+            _("Hardware Version"): self.board_version,
+            _("Autopilot Type"): self.autopilot,
+            _("ArduPilot Vehicle Type"): self.vehicle_type,
+            _("ArduPilot FW Type"): self.firmware_type,
+            _("MAV Type"): self.mav_type,
+            _("Firmware Version"): self.flight_sw_version_and_type,
+            _("Git Hash"): self.flight_custom_version,
+            _("OS Git Hash"): self.os_custom_version,
+            _("Capabilities"): self.capabilities,
+            _("System ID"): self.system_id,
+            _("Component ID"): self.component_id,
         }
 
     def set_system_id_and_component_id(self, system_id: str, component_id: str) -> None:
@@ -80,29 +91,28 @@ def set_flight_sw_version(self, version: int) -> None:
         self.flight_sw_version_and_type = self.flight_sw_version + " " + v_fw_type
 
     def set_board_version(self, board_version: int) -> None:
-        self.board_version = str(board_version)
+        self.board_version = str(board_version & 0x0FFFF)
+        apj_board_id = board_version >> 16
+        self.apj_board_id = str(apj_board_id)
+        self.firmware_type = str(APJ_BOARD_ID_NAME_DICT.get(apj_board_id, _("Unknown")))
+
+        vendor_derived_from_apj_board_id = str(APJ_BOARD_ID_VENDOR_DICT.get(apj_board_id, "ArduPilot"))
+        if vendor_derived_from_apj_board_id != "ArduPilot" and self.vendor in ["ArduPilot", _("Unknown")]:
+            self.vendor = vendor_derived_from_apj_board_id
 
     def set_flight_custom_version(self, flight_custom_version: Sequence[int]) -> None:
         self.flight_custom_version = "".join(chr(c) for c in flight_custom_version)
 
     def set_os_custom_version(self, os_custom_version: Sequence[int]) -> None:
         self.os_custom_version = "".join(chr(c) for c in os_custom_version)
 
-    def set_vendor_id_and_product_id(self, vendor_id: int, product_id: int) -> None:
-        pid_vid_dict = self.__list_ardupilot_supported_usb_pid_vid()
-
-        self.vendor_id = f"0x{vendor_id:04X}" if vendor_id else "Unknown"
-        if vendor_id and vendor_id in pid_vid_dict:
-            self.vendor = f"{pid_vid_dict[vendor_id]['vendor']}"
-        elif vendor_id:
-            self.vendor = "Unknown"
+    def set_usb_vendor_and_product_ids(self, vendor_id: int, product_id: int) -> None:
+        self.vendor_id = f"0x{vendor_id:04X}" if vendor_id else _("Unknown")
+        self.vendor = str(VID_VENDOR_DICT.get(vendor_id, _("Unknown")))
         self.vendor_and_vendor_id = f"{self.vendor} ({self.vendor_id})"
 
-        self.product_id = f"0x{product_id:04X}" if product_id else "Unknown"
-        if vendor_id and product_id and product_id in pid_vid_dict[vendor_id]["PID"]:
-            self.product = f"{pid_vid_dict[vendor_id]['PID'][product_id]}"
-        elif product_id:
-            self.product = "Unknown"
+        self.product_id = f"0x{product_id:04X}" if product_id else _("Unknown")
+        self.product = str(VID_PID_PRODUCT_DICT.get((vendor_id, product_id), _("Unknown")))
         self.product_and_product_id = f"{self.product} ({self.product_id})"
 
     def set_capabilities(self, capabilities: int) -> None:
@@ -234,49 +244,3 @@ def __classify_vehicle_type(mav_type_int: int) -> str:
 
         # Return the classified vehicle type based on the MAV_TYPE enum
         return mav_type_to_vehicle_type.get(mav_type_int, "")
-
-    @staticmethod
-    def __list_ardupilot_supported_usb_pid_vid() -> dict[int, dict[str, Union[str, dict[int, str]]]]:
-        """
-        List all ArduPilot supported USB vendor ID (VID) and product ID (PID).
-
-        source: https://ardupilot.org/dev/docs/USB-IDs.html
-        """
-        return {
-            0x0483: {"vendor": "ST Microelectronics", "PID": {0x5740: "ChibiOS"}},
-            0x1209: {
-                "vendor": "ArduPilot",
-                "PID": {
-                    0x5740: "MAVLink",
-                    0x5741: "Bootloader",
-                },
-            },
-            0x16D0: {"vendor": "ArduPilot", "PID": {0x0E65: "MAVLink"}},
-            0x26AC: {"vendor": "3D Robotics", "PID": {}},
-            0x2DAE: {
-                "vendor": "CubePilot",
-                "PID": {
-                    0x1001: "CubeBlack bootloader",
-                    0x1011: "CubeBlack",
-                    0x1101: "CubeBlack+",
-                    0x1002: "CubeYellow bootloader",
-                    0x1012: "CubeYellow",
-                    0x1005: "CubePurple bootloader",
-                    0x1015: "CubePurple",
-                    0x1016: "CubeOrange",
-                    0x1058: "CubeOrange+",
-                    0x1059: "CubeRed",
-                },
-            },
-            0x3162: {"vendor": "Holybro", "PID": {0x004B: "Durandal"}},
-            0x27AC: {
-                "vendor": "Laser Navigation",
-                "PID": {
-                    0x1151: "VRBrain-v51",
-                    0x1152: "VRBrain-v52",
-                    0x1154: "VRBrain-v54",
-                    0x1910: "VRCore-v10",
-                    0x1351: "VRUBrain-v51",
-                },
-            },
-        }

MethodicConfigurator/frontend_tkinter_component_editor.py

@@ -292,11 +292,11 @@ def set_vehicle_type_and_version(self, vehicle_type: str, version: str) -> None:
             self._set_component_value_and_update_ui(("Flight Controller", "Firmware", "Version"), version)
 
     def set_fc_manufacturer(self, manufacturer: str) -> None:
-        if manufacturer and manufacturer not in ("Unknown", "ArduPilot"):
+        if manufacturer and manufacturer not in (_("Unknown"), "ArduPilot"):
             self._set_component_value_and_update_ui(("Flight Controller", "Product", "Manufacturer"), manufacturer)
 
     def set_fc_model(self, model: str) -> None:
-        if model and model not in ("Unknown", "MAVLink"):
+        if model and model not in (_("Unknown"), "MAVLink"):
             self._set_component_value_and_update_ui(("Flight Controller", "Product", "Model"), model)
 
     def set_vehicle_configuration_template(self, configuration_template: str) -> None:

MethodicConfigurator/frontend_tkinter_flightcontroller_info.py

@@ -49,14 +49,19 @@ def __init__(self, flight_controller: FlightController) -> None:
                 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.insert(tk.END, _("N/A"))  # Insert "Not Available" if the attribute is missing or empty
             text_field.configure(state="readonly")
 
         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)