diff --git a/images/icons/cf_icon_dronecan_grey.svg b/images/icons/cf_icon_dronecan_grey.svg
new file mode 100644
index 000000000..7083b22fe
--- /dev/null
+++ b/images/icons/cf_icon_dronecan_grey.svg
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 141.7 141.7">
+  <circle cx="28" cy="40" r="16" fill="#818181"/>
+  <circle cx="70.85" cy="40" r="16" fill="#818181"/>
+  <circle cx="113.7" cy="40" r="16" fill="#818181"/>
+  <rect x="22" y="56" width="12" height="24" fill="#818181"/>
+  <rect x="64.85" y="56" width="12" height="24" fill="#818181"/>
+  <rect x="107.7" y="56" width="12" height="24" fill="#818181"/>
+  <rect x="10" y="78" width="121.7" height="10" rx="3" fill="#818181"/>
+</svg>
diff --git a/images/icons/cf_icon_dronecan_white.svg b/images/icons/cf_icon_dronecan_white.svg
new file mode 100644
index 000000000..2f38ad71e
--- /dev/null
+++ b/images/icons/cf_icon_dronecan_white.svg
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 141.7 141.7">
+  <circle cx="28" cy="40" r="16" fill="#ffffff"/>
+  <circle cx="70.85" cy="40" r="16" fill="#ffffff"/>
+  <circle cx="113.7" cy="40" r="16" fill="#ffffff"/>
+  <rect x="22" y="56" width="12" height="24" fill="#ffffff"/>
+  <rect x="64.85" y="56" width="12" height="24" fill="#ffffff"/>
+  <rect x="107.7" y="56" width="12" height="24" fill="#ffffff"/>
+  <rect x="10" y="78" width="121.7" height="10" rx="3" fill="#ffffff"/>
+</svg>
diff --git a/index.html b/index.html
index d95578b9f..2682e4b4c 100644
--- a/index.html
+++ b/index.html
@@ -347,9 +347,13 @@ <h2 class="groundstation-telemetry__header" data-i18n="gsTelemetry"></h2>
                             <li class="tab_led_strip">
                                 <a href="#" data-i18n="tabLedStrip" class="tabicon ic_led" title="LED Strip"></a>
                             </li>
+                             <li class="tab_dronecan">
+                                <a href="#" data-i18n="tabDroneCAN" class="tabicon ic_dronecan" title="DroneCAN"></a>
+                            </li>
+
                         </ul>
                     </li>
-
+                    
                     <!-- Data Logging -->
                     <li class="nav-group">
                         <div class="group-header" role="button" tabindex="0" aria-expanded="false">
diff --git a/js/configurator_main.js b/js/configurator_main.js
index c2516d5c0..4bce05602 100644
--- a/js/configurator_main.js
+++ b/js/configurator_main.js
@@ -36,6 +36,7 @@ import configurationTab from './../tabs/configuration';
 import pidTuningTab from './../tabs/pid_tuning';
 import receiverTab from './../tabs/receiver';
 import gpsTab from './../tabs/gps';
+import dronecanTab from './../tabs/dronecan';
 import magnetometerTab from './../tabs/magnetometer';
 import missionControlTab from './../tabs/mission_control';
 import mixerTab from './../tabs/mixer';
@@ -116,7 +117,7 @@ $(function() {
         var ui_tabs = $('#tabs > ul');
         $('a', ui_tabs).on('click', function() {
 
-            if ($(this).parent().hasClass("tab_help")) {
+            if ($(this).parent().hasClass("tab_help") || $(this).parent().hasClass("nav-toggle-all")) {
                 return;
             }
 
@@ -231,6 +232,9 @@ $(function() {
                         case 'gps':
                             gpsTab.initialize(content_ready);
                             break;
+                         case 'dronecan':
+                              dronecanTab.initialize(content_ready);
+                              break;
                         case 'magnetometer':
                             magnetometerTab.initialize(content_ready);
                             break;
@@ -360,84 +364,6 @@ $(function() {
         // Update button state on initialization
         updateToggleAllButton();
 
-
-        // Accordion Navigation Groups
-        $('.group-header').on('click', function(e) {
-            e.stopPropagation(); // Prevent triggering tab click
-            const header = $(this);
-            const items = header.next('.group-items');
-
-            // Toggle this group
-            header.toggleClass('active');
-            items.toggleClass('expanded');
-
-            // Update aria-expanded for accessibility
-            header.attr('aria-expanded', header.hasClass('active'));
-
-            // Update the expand/collapse all button state
-            updateToggleAllButton();
-        });
-
-        // Keyboard accessibility for accordion headers
-        $('.group-header').on('keydown', function(e) {
-            if (e.key === 'Enter' || e.key === ' ') {
-                e.preventDefault();
-                $(this).trigger('click');
-            }
-        });
-
-        function updateToggleAllButton() {
-            const allExpanded = $('.nav-group .group-header.active').length === $('.nav-group .group-header').length;
-            const $expandIcon = $('#toggleAllGroups .expand-icon');
-            const $collapseIcon = $('#toggleAllGroups .collapse-icon');
-            const $toggleText = $('#toggleAllGroups .toggle-text');
-
-            if (allExpanded) {
-                $expandIcon.hide();
-                $collapseIcon.show();
-                $toggleText.attr('data-i18n', 'navCollapseAll');
-                $toggleText.text(i18n.getMessage('navCollapseAll'));
-            } else {
-                $expandIcon.show();
-                $collapseIcon.hide();
-                $toggleText.attr('data-i18n', 'navExpandAll');
-                $toggleText.text(i18n.getMessage('navExpandAll'));
-            }
-        }
-
-        // Expand/Collapse All Toggle
-        $('#toggleAllGroups').on('click', function(e) {
-            e.preventDefault();
-            const allExpanded = $('.nav-group .group-header.active').length === $('.nav-group .group-header').length;
-
-            if (allExpanded) {
-                // Collapse all except first
-                $('.nav-group .group-header').removeClass('active').attr('aria-expanded', 'false');
-                $('.nav-group .group-items').removeClass('expanded');
-                $('#tabs ul.mode-connected .nav-group:first-child .group-header').addClass('active').attr('aria-expanded', 'true');
-                $('#tabs ul.mode-connected .nav-group:first-child .group-items').addClass('expanded');
-                store.set('expand_all_groups', false);
-            } else {
-                // Expand all
-                $('.nav-group .group-header').addClass('active').attr('aria-expanded', 'true');
-                $('.nav-group .group-items').addClass('expanded');
-                store.set('expand_all_groups', true);
-            }
-
-            updateToggleAllButton();
-        });
-
-        // Initialize: apply saved expand all preference or expand first group by default
-        if (store.get('expand_all_groups', false)) {
-            $('.nav-group .group-header').addClass('active').attr('aria-expanded', 'true');
-            $('.nav-group .group-items').addClass('expanded');
-        } else {
-            $('#tabs ul.mode-connected .nav-group:first-child .group-header').addClass('active').attr('aria-expanded', 'true');
-            $('#tabs ul.mode-connected .nav-group:first-child .group-items').addClass('expanded');
-        }
-
-        updateToggleAllButton();
-
         // options
         $('#options').on('click', function() {
             var el = $(this);
@@ -477,15 +403,6 @@ $(function() {
                         store.set('disable_3d_acceleration', check);
                     });
 
-                    if (store.get('disable_3d_acceleration', false)) {
-                        $('div.disable_3d_acceleration input').prop('checked', true);
-                    }
-
-                    $('div.disable_3d_acceleration input').on('change', function () {
-                        var check = $(this).is(':checked');
-                        store.set('disable_3d_acceleration', check);
-                    });
-
                     $('div.statistics input').on('change', function () {
                         var check = $(this).is(':checked');
                     });
diff --git a/js/fc.js b/js/fc.js
index fdbd9c83f..3e8f9cd53 100644
--- a/js/fc.js
+++ b/js/fc.js
@@ -88,6 +88,9 @@ var FC = {
     EZ_TUNE: null,
     FLIGHT_MODES: null,
     GEOZONES: null,
+    DRONECAN_NODES: [],
+    DRONECAN_ASYNC_REQUEST: null,
+    DRONECAN_ASYNC_RESULT: null,
 
     restartRequired: false,
     MAX_SERVO_RATE: 125,
@@ -611,6 +614,10 @@ var FC = {
            items: [],
         };
 
+        this.DRONECAN_NODES = [];
+        this.DRONECAN_ASYNC_REQUEST = null;
+        this.DRONECAN_ASYNC_RESULT = null;
+
     },
     getOutputUsages: function() {
         return {
@@ -666,7 +673,9 @@ var FC = {
         return [
             'UBLOX',
             'MSP',
-            'FAKE'
+            'CRSF',
+            'FAKE',
+            'DRONECAN'
         ];
     },
     getGpsBaudRates: function () {
diff --git a/js/gui.js b/js/gui.js
index 2531b12b5..0166533f8 100644
--- a/js/gui.js
+++ b/js/gui.js
@@ -28,6 +28,7 @@ var GUI_control = function () {
         'cli',
         'configuration',
         'gps',
+        'dronecan',
         'magnetometer',
         'led_strip',
         'logging',
diff --git a/js/msp/MSPCodes.js b/js/msp/MSPCodes.js
index 07b56eab7..4bd6c5c28 100644
--- a/js/msp/MSPCodes.js
+++ b/js/msp/MSPCodes.js
@@ -222,6 +222,10 @@ var MSPCodes = {
     MSP2_INAV_LOGIC_CONDITIONS_SINGLE:      0x203B,
     MSP2_INAV_LOGIC_CONDITIONS_CONFIGURED:  0x203C,
 
+    MSP2_INAV_DRONECAN_NODES:           0x2042,
+    MSP2_INAV_DRONECAN_ASYNC_REQUEST:   0x2043,
+    MSP2_INAV_DRONECAN_ASYNC_RESULT:    0x2044,
+    
     MSP2_INAV_LED_STRIP_CONFIG_EX:      0x2048,
     MSP2_INAV_SET_LED_STRIP_CONFIG_EX:  0x2049,
 
diff --git a/js/msp/MSPHelper.js b/js/msp/MSPHelper.js
index dc709ac91..0095d8c11 100644
--- a/js/msp/MSPHelper.js
+++ b/js/msp/MSPHelper.js
@@ -26,6 +26,16 @@ import {Geozone, GeozoneVertex, GeozoneShapes } from './../geozone';
 var mspHelper = (function () {
     var self = {};
 
+    const PARAM_TYPE_INT    = 1;
+    const PARAM_TYPE_FLOAT  = 2;
+    const PARAM_TYPE_BOOL   = 3;
+    const PARAM_TYPE_STRING = 4;
+    const DRONECAN_SERVICE_GETNODEINFO    = 1;
+    const DRONECAN_SERVICE_RESTART_NODE   = 5;
+    const DRONECAN_SERVICE_EXECUTE_OPCODE = 10;
+    const DRONECAN_SERVICE_PARAM_GETSET   = 11;
+    const DRONECAN_ASYNC_STATE_READY      = 2;
+
     self.sensorStatusEx = null;
 
     self.setSensorStatusEx = function (cb)  {
@@ -1557,6 +1567,128 @@ var mspHelper = (function () {
                 console.log('Safehome points saved');
                 break;
 
+            case MSPCodes.MSP2_INAV_DRONECAN_NODES:
+                FC.DRONECAN_NODES = [];
+                if (data.byteLength > 0) {
+                    const count = data.getUint8(0);
+                    for (let i = 0; i < count; i++) {
+                        const offset = 1 + i * 13;
+                        if (offset + 13 > data.byteLength) break;
+                        FC.DRONECAN_NODES.push({
+                            nodeID:              data.getUint8(offset),
+                            health:              data.getUint8(offset + 1),
+                            mode:                data.getUint8(offset + 2),
+                            last_seen_ms:        data.getUint32(offset + 3, true),
+                            uptime_sec:          data.getUint32(offset + 7, true),
+                            vendor_status_code:  data.getUint16(offset + 11, true),
+                        });
+                    }
+                }
+                break;
+            
+            case MSPCodes.MSP2_INAV_DRONECAN_ASYNC_REQUEST:
+                if (data.byteLength >= 2) {
+                    FC.DRONECAN_ASYNC_REQUEST = {
+                        status: data.getUint8(0),
+                        seq:    data.getUint8(1),
+                    };  
+                }   
+                break;
+                  
+            case MSPCodes.MSP2_INAV_DRONECAN_ASYNC_RESULT:
+                if (data.byteLength >= 5) {
+                    const state      = data.getUint8(0);
+                    const seq        = data.getUint8(1);
+                    const service_id = data.getUint16(2, true);
+                    const node_id    = data.getUint8(4); 
+                    const result = { state, seq, service_id, node_id };
+                      
+                    if (state === DRONECAN_ASYNC_STATE_READY) {
+                        try {
+                        let offset = 5;
+                        if (service_id === DRONECAN_SERVICE_RESTART_NODE || service_id === DRONECAN_SERVICE_EXECUTE_OPCODE) {
+                            result.ok = data.getUint8(offset) !== 0;
+                        } else {
+                            const name_len = data.getUint8(offset++);
+                            result.name = String.fromCodePoint(
+                                ...new Uint8Array(data.buffer, data.byteOffset + offset, name_len));
+                            offset += name_len;
+
+                            if (service_id === DRONECAN_SERVICE_GETNODEINFO) {
+                                result.sw_major                = data.getUint8(offset++);
+                                result.sw_minor                = data.getUint8(offset++);
+                                result.sw_optional_field_flags = data.getUint8(offset++);
+                                result.sw_vcs_commit           = data.getUint32(offset, true); offset += 4;
+                                result.hw_major                = data.getUint8(offset++);
+                                result.hw_minor                = data.getUint8(offset++);
+                                result.hw_unique_id            = new Uint8Array(
+                                    data.buffer, data.byteOffset + offset, 16).slice(); // copy; don't hold a live view into the MSP buffer
+                            } else if (service_id === DRONECAN_SERVICE_PARAM_GETSET) {
+                                result.value_type = data.getUint8(offset++);
+                                switch (result.value_type) {
+                                    case PARAM_TYPE_INT: { // 8 bytes, little-endian lo/hi
+                                        const lo = data.getUint32(offset, true);
+                                        const hi = data.getUint32(offset + 4, true);
+                                        const big = BigInt(hi) * BigInt(0x100000000) + BigInt(lo);
+                                        const signed = big >= (1n << 63n) ? big - (1n << 64n) : big;
+                                        result.value = (signed >= BigInt(Number.MIN_SAFE_INTEGER) &&
+                                                        signed <= BigInt(Number.MAX_SAFE_INTEGER))
+                                                        ? Number(signed) : signed;
+                                        offset += 8;
+                                        break;
+                                    }
+                                    case PARAM_TYPE_FLOAT: // 4 bytes
+                                        result.value = data.getFloat32(offset, true);
+                                        offset += 4;
+                                        break;
+                                    case PARAM_TYPE_BOOL: // 1 byte
+                                        result.value = data.getUint8(offset) !== 0;
+                                        offset += 1;
+                                        break;
+                                    case PARAM_TYPE_STRING: { // 1-byte length prefix + data
+                                        const slen = data.getUint8(offset++);
+                                        result.value = String.fromCodePoint(
+                                            ...new Uint8Array(data.buffer, data.byteOffset + offset, slen));
+                                        offset += slen;
+                                        break;
+                                    }
+                                    default:
+                                        result.value = null;
+                                }
+                                // min/max are NumericValue (EMPTY, INT, or FLOAT); only present for INT and FLOAT params
+                                if (result.value_type === PARAM_TYPE_INT || result.value_type === PARAM_TYPE_FLOAT) {
+                                    const decodeNumeric = () => {
+                                        const type = data.getUint8(offset++);
+                                        let value; // EMPTY — no range provided
+                                        if (type === PARAM_TYPE_INT) {
+                                            const lo = data.getUint32(offset, true);
+                                            const hi = data.getUint32(offset + 4, true);
+                                            offset += 8;
+                                            const big = BigInt(hi) * BigInt(0x100000000) + BigInt(lo);
+                                            const signed = big >= (1n << 63n) ? big - (1n << 64n) : big;
+                                            value = (signed >= BigInt(Number.MIN_SAFE_INTEGER) &&
+                                                     signed <= BigInt(Number.MAX_SAFE_INTEGER))
+                                                    ? Number(signed) : signed;
+                                        } else if (type === PARAM_TYPE_FLOAT) {
+                                            value = data.getFloat32(offset, true);
+                                            offset += 4;
+                                        }
+                                        return value;
+                                    };
+                                    result.min = decodeNumeric();
+                                    result.max = decodeNumeric();
+                                }
+                            }
+                        }
+                        } catch (e) {
+                            console.warn('MSP2_INAV_DRONECAN_ASYNC_RESULT: truncated or malformed response, result fields may be partial (' + e.message + ')');
+                        }
+                    }
+
+                    FC.DRONECAN_ASYNC_RESULT = result;
+                }
+                break;
+
             case MSPCodes.MSP2_INAV_FW_APPROACH:
                 FC.FW_APPROACH.put(new FwApproach(
                     data.getUint8(0),
diff --git a/locale/en/messages.json b/locale/en/messages.json
index 4f20b2365..cf48cbe21 100644
--- a/locale/en/messages.json
+++ b/locale/en/messages.json
@@ -185,6 +185,72 @@
     "tabGPS": {
         "message": "GPS"
     },
+    "tabDroneCAN": {
+        "message": "DroneCAN"
+    },
+    "dronecanColHealth": {
+        "message": "Health"
+    },
+    "dronecanColLastSeen": {
+        "message": "Last Seen"
+    },
+    "dronecanColMode": {
+        "message": "Mode"
+    },
+    "dronecanColName": {
+        "message": "Name"
+    },
+    "dronecanColNodeID": {
+        "message": "Node ID"
+    },
+    "dronecanColUptime": {
+        "message": "Uptime"
+    },
+    "dronecanNodesTitle": {
+        "message": "DroneCAN Nodes"
+    },
+    "dronecanNodeDetail": {
+        "message": "Node Detail"
+    },
+    "dronecanNoNodes": {
+        "message": "No DroneCAN nodes detected."
+    },
+    "dronecanBusConfig": {
+        "message": "Bus Configuration"
+    },
+    "dronecanBitrate": {
+        "message": "CAN Baud Rate"
+    },
+    "dronecanNodeId": {
+        "message": "FC Node ID"
+    },
+    "dronecanSave": {
+        "message": "Save & Reboot"
+    },
+    "dronecanNodeIdReservedWarning": {
+        "message": "Node IDs 126 and 127 are reserved for diagnostic tools. Are you sure?"
+    },
+    "dronecanDetailColProperty": {
+        "message": "Property"
+    },
+    "dronecanDetailColValue": {
+        "message": "Value"
+    },
+    "dronecanParamColIndex": {
+        "message": "#"
+    },
+    "dronecanParamColName": {
+        "message": "Name"
+    },
+    "dronecanParamColType": {
+        "message": "Type"
+    },
+    "dronecanParamColValue": {
+        "message": "Value"
+    },
+    "dronecanParamColRange": {
+        "message": "Range"
+    },
     "tabOutputs": {
         "message": "Outputs"
     },
@@ -1277,6 +1343,9 @@
     "configurationGPSProtocol": {
         "message": "Protocol"
     },
+    "gpsDroneCANInfo": {
+        "message": "GPS is provided via DroneCAN. Configure bus settings on the DroneCAN tab. Serial port and baud rate do not apply."
+    },
     "configurationGPSUseGalileo": {
         "message": "Gps use Galileo Satellites (EU)"
     },
@@ -6541,5 +6610,44 @@
     },
     "migrationMissingProfileWarning": {
         "message": "No migration profile available for version $1 → $2. Settings will be restored without conversion — some may fail or be ignored by the firmware."
+    },
+    "dronecanParamsLoading": {
+        "message": "Loading parameters..."
+    },
+    "dronecanNoParams": {
+        "message": "No parameters."
+    },
+    "dronecanParamWrite": {
+        "message": "Write"
+    },
+    "dronecanParamError": {
+        "message": "ERR"
+    },
+    "dronecanParamOutOfRange": {
+        "message": "Out of range"
+    },
+    "dronecanParamRangeMustBeBetween": {
+        "message": "Must be between $1 and $2"
+    },
+    "dronecanSaveToEeprom": {
+        "message": "Save to EEPROM"
+    },
+    "dronecanSaved": {
+        "message": "Saved!"
+    },
+    "dronecanFailed": {
+        "message": "Failed"
+    },
+    "dronecanRestartNode": {
+        "message": "Restart Node"
+    },
+    "dronecanRestarting": {
+        "message": "Restarting..."
+    },
+    "dronecanSecondsAgo": {
+        "message": "$1s ago"
+    },
+    "dronecanNameError": {
+        "message": "Error"
     }
 }
diff --git a/src/css/main.css b/src/css/main.css
index 7df84b518..315936dbf 100644
--- a/src/css/main.css
+++ b/src/css/main.css
@@ -1141,6 +1141,18 @@ li.active .ic_mag {
     background-image: url("./../../images/icons/cf_icon_mag_white.svg");
 }
 
+.ic_dronecan {
+    background-image: url("./../../images/icons/cf_icon_dronecan_grey.svg");
+}
+
+.ic_dronecan:hover {
+    background-image: url("./../../images/icons/cf_icon_dronecan_white.svg");
+}
+
+li.active .ic_dronecan {
+    background-image: url("./../../images/icons/cf_icon_dronecan_white.svg");
+}
+
 .ic_search {
     background-image: url("./../../images/icons/search-white.svg");
 }
@@ -1825,7 +1837,7 @@ dialog {
 /* fixing padding for all Tabs*/
 .tab-setup, .tab-landing, .tab-adjustments, .tab-auxiliary, .tab-cli, .tab-configuration, .tab-failsafe, .tab-onboard_logging,
 .tab-firmware_flasher, .tab-gps, .tab-magnetometer, .tab-help, .tab-led-strip, .tab-logging, .tab-modes, .tab-motors, .tab-pid_tuning,
-.tab-ports, .tab-receiver, .tab-sensors, .tab-servos, .tab-osd, .tab-calibration, .tab-ez_tune {
+.tab-ports, .tab-receiver, .tab-sensors, .tab-servos, .tab-osd, .tab-calibration, .tab-ez_tune, .tab-dronecan {
     height: 100%;
     position: relative;
 }
diff --git a/src/css/styles.css b/src/css/styles.css
index 7be0b5d2e..65baa44b2 100644
--- a/src/css/styles.css
+++ b/src/css/styles.css
@@ -38,3 +38,5 @@
 @import 'tabs/setup.css';
 @import 'tabs/sitl.css';
 @import 'groundstation.css';
+@import 'tabs/dronecan.css';
+
diff --git a/src/css/tabs/dronecan.css b/src/css/tabs/dronecan.css
new file mode 100644
index 000000000..8fb2af935
--- /dev/null
+++ b/src/css/tabs/dronecan.css
@@ -0,0 +1,131 @@
+.dronecan-detail .sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border: 0;
+}
+
+#dronecan-node-table .health-badge {
+    display: inline-block;
+    padding: 0.15em 0.5em;
+    border-radius: 3px;
+    font-weight: bold;
+    color: #fff;
+}
+
+#dronecan-node-table .health-ok       { background-color: #388e3c; }
+#dronecan-node-table .health-warning  { background-color: #f57f17; }
+#dronecan-node-table .health-error    { background-color: #cc0000; }
+#dronecan-node-table .health-critical { background-color: #7b0000; }
+
+#dronecan-node-table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+#dronecan-node-table th,
+#dronecan-node-table td {
+    padding: 0.4em 0.6em;
+    border-bottom: 1px solid #444;
+    text-align: left;
+}
+
+#dronecan-node-table tbody tr:hover {
+    background-color: rgba(255,255,255,0.05);
+    cursor: pointer;
+}
+
+#dronecan-node-detail {
+    margin-top: 1.5em;
+}
+
+#dronecan-detail-table th {
+    padding-right: 1em;
+    text-align: left;
+    color: #aaa;
+}
+
+#dronecan-params {
+    padding: 1em 0 2.5em 0;
+}
+
+#dronecan-params table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+#dronecan-params th,
+#dronecan-params td {
+    padding: 0.4em 0.6em;
+    border-bottom: 1px solid #444;
+    text-align: left;
+}
+
+#dronecan-params input.param-input {
+    border: 1px solid #555;
+    padding: 0.2em 0.4em;
+    border-radius: 3px;
+    width: 100%;
+    box-sizing: border-box;
+}
+
+#dronecan-params button.param-write {
+    padding: 0.2em 0.7em;
+    background-color: #fff;
+    border: 1px solid #156a8c;
+    border-radius: 4px;
+    color: #156a8c;
+    font-size: 1em;
+    cursor: pointer;
+    transition: all ease 0.2s;
+    white-space: nowrap;
+}
+
+#dronecan-params button.param-write:hover {
+    background-color: #156a8c;
+    color: #fff;
+}
+
+#dronecan-params button.param-write:disabled {
+    border-color: #555;
+    color: #555;
+    cursor: default;
+}
+
+#dronecan-params .param-actions {
+    margin-top: 1em;
+    display: flex;
+    gap: 0.5em;
+    align-items: center;
+}
+
+#dronecan-params button.param-save-eeprom {
+    min-width: 9em;
+}
+
+#dronecan-params button.param-action-btn {
+    padding: 0.35em 1em;
+    background-color: #156a8c;
+    border: 1px solid #156a8c;
+    border-radius: 4px;
+    color: #fff;
+    font-size: 1em;
+    cursor: pointer;
+    transition: all ease 0.2s;
+}
+
+#dronecan-params button.param-action-btn:hover {
+    background-color: #10536e;
+    border-color: #10536e;
+}
+
+#dronecan-params button.param-action-btn:disabled {
+    background-color: #555;
+    border-color: #555;
+    cursor: default;
+}
diff --git a/src/css/tabs/gps.css b/src/css/tabs/gps.css
index ad1c9a935..d2c2c5520 100644
--- a/src/css/tabs/gps.css
+++ b/src/css/tabs/gps.css
@@ -113,6 +113,12 @@
     border-top-right-radius: 0;
 }
 
+.tab-gps .gps-dronecan-info {
+    font-size: 0.9em;
+    font-style: italic;
+    margin: 2px 0 4px;
+}
+
 .tab-gps .config-section .checkbox .switchery {
     margin-right: 68px;
 }
diff --git a/tabs/dronecan.html b/tabs/dronecan.html
new file mode 100644
index 000000000..d226f068d
--- /dev/null
+++ b/tabs/dronecan.html
@@ -0,0 +1,78 @@
+<div class="tab-dronecan toolbar_fixed_bottom">
+    <div class="content_wrapper">
+        <div class="tab_title" data-i18n="tabDroneCAN"></div>
+
+        <div class="gui_box grey">
+            <div class="gui_box_titlebar">
+                <div class="spacer_box_title" data-i18n="dronecanBusConfig"></div>
+            </div>
+            <div class="spacer_box">
+                <div class="dronecan-config-row">
+                    <label for="dronecan-bitrate" data-i18n="dronecanBitrate">CAN Baud Rate</label>
+                    <select id="dronecan-bitrate">
+                        <option value="125">125 kbps</option>
+                        <option value="250">250 kbps</option>
+                        <option value="500">500 kbps</option>
+                        <option value="1000">1000 kbps</option>
+                    </select>
+                </div>
+                <div class="dronecan-config-row">
+                    <label for="dronecan-node-id" data-i18n="dronecanNodeId">FC Node ID</label>
+                    <input id="dronecan-node-id" type="number" min="1" max="127" value="1">
+                </div>
+            </div>
+        </div>
+
+        <div id="dronecan-status" class="note">
+            <div class="note_spacer">
+                <p data-i18n="dronecanNoNodes"></p>
+            </div>
+        </div>
+
+        <div id="dronecan-node-wrapper" style="display:none">
+            <div class="gui_box grey">
+                <div class="gui_box_titlebar">
+                    <div class="spacer_box_title" data-i18n="dronecanNodesTitle"></div>
+                </div>
+                <div class="spacer_box">
+                    <table id="dronecan-node-table" class="dronecan-nodes">
+                        <thead>
+                            <tr>
+                                <th data-i18n="dronecanColNodeID"></th>
+                                <th data-i18n="dronecanColName"></th>
+                                <th data-i18n="dronecanColHealth"></th>
+                                <th data-i18n="dronecanColMode"></th>
+                                <th data-i18n="dronecanColLastSeen"></th>
+                            </tr>
+                        </thead>
+                        <tbody id="dronecan-node-tbody"></tbody>
+                    </table>
+                </div>
+            </div>
+
+            <div id="dronecan-node-detail" class="gui_box grey" style="display:none">
+                <div class="gui_box_titlebar">
+                    <div class="spacer_box_title" data-i18n="dronecanNodeDetail"></div>
+                </div>
+                <div class="spacer_box">
+                    <table class="dronecan-detail">
+                        <thead>
+                            <tr>
+                                <th class="sr-only" data-i18n="dronecanDetailColProperty"></th>
+                                <th class="sr-only" data-i18n="dronecanDetailColValue"></th>
+                            </tr>
+                        </thead>
+                        <tbody id="dronecan-detail-tbody"></tbody>
+                    </table>
+                </div>
+                <div id="dronecan-params"></div>
+            </div>
+        </div>
+
+    </div>
+    <div class="content_toolbar supported hide">
+        <div class="btn save_btn">
+            <a id="dronecan-save" class="save" href="#" data-i18n="dronecanSave">Save &amp; Reboot</a>
+        </div>
+    </div>
+</div>
diff --git a/tabs/dronecan.js b/tabs/dronecan.js
new file mode 100644
index 000000000..2cd567964
--- /dev/null
+++ b/tabs/dronecan.js
@@ -0,0 +1,465 @@
+'use strict';
+
+import MSPCodes from './../js/msp/MSPCodes';
+import MSP from './../js/msp';
+import mspHelper from './../js/msp/MSPHelper';
+import GUI from './../js/gui';
+import FC from './../js/fc';
+import i18n from './../js/localization';
+import interval from './../js/intervals';
+
+const HEALTH_LABELS = ['OK', 'WARNING', 'ERROR', 'CRITICAL'];
+const HEALTH_CLASSES = ['health-ok', 'health-warning', 'health-error', 'health-critical'];
+const esc = s => String(s).replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
+const POLL_INTERVAL_MS  = 75;
+const POLL_MAX_ATTEMPTS = 34; // 34 polls × 75 ms ≈ 2.5 s total window
+const MODE_LABELS = ['OPERATIONAL', 'INITIALIZATION', 'MAINTENANCE', 'SOFTWARE_UPDATE', 'UNKNOWN_4', 'UNKNOWN_5', 'UNKNOWN_6', 'OFFLINE']; // modes 0-3 per DroneCAN NodeStatus; 4-6 reserved by spec
+const PARAM_TYPE_INT    = 1;
+const PARAM_TYPE_FLOAT  = 2;
+const PARAM_TYPE_BOOL   = 3;
+const PARAM_TYPE_STRING = 4;
+const DRONECAN_SERVICE_GETNODEINFO    = 1;
+const DRONECAN_SERVICE_RESTART_NODE   = 5;
+const DRONECAN_SERVICE_EXECUTE_OPCODE = 10;
+const DRONECAN_SERVICE_PARAM_GETSET   = 11;
+const DRONECAN_ASYNC_STATE_READY         = 2;
+const DRONECAN_ASYNC_STATE_ERROR         = 3;
+const DRONECAN_ASYNC_REQUEST_STATUS_OK   = 0;
+const DRONECAN_ASYNC_REQUEST_STATUS_BUSY = 1;
+const DRONECAN_EXECUTE_OPCODE_SAVE       = 0;
+
+function getModeLabel(mode) {
+    return (mode < MODE_LABELS.length && MODE_LABELS[mode]) ? MODE_LABELS[mode] : `MODE_${mode}`;
+}
+
+const dronecanTab = {};
+let nameCache = {};
+let currentDetailNodeId = null;
+
+function encodeParamValueBytes(value_type, value) {
+    switch (value_type) {
+        case PARAM_TYPE_INT: {
+            const v = typeof value === 'bigint' ? value : BigInt(Math.trunc(value));
+            const bytes = [];
+            for (let i = 0; i < 8; i++) bytes.push(Number((v >> BigInt(i * 8)) & 0xFFn));
+            return bytes;
+        }
+        case PARAM_TYPE_FLOAT:
+            return Array.from(new Uint8Array(new Float32Array([value]).buffer));
+        case PARAM_TYPE_BOOL:
+            return [value ? 1 : 0];
+        case PARAM_TYPE_STRING: {
+            const enc = new TextEncoder().encode(String(value).slice(0, 63));
+            return [enc.length, ...enc];
+        }
+        default:
+            return [];
+    }
+}
+
+function buildParamGetSetPayload(params) {
+    const payload = [params.index & 0xFF, (params.index >> 8) & 0xFF, params.is_write ? 1 : 0];
+    if (!params.is_write) return payload;
+
+    payload.push(params.value_type, ...encodeParamValueBytes(params.value_type, params.value));
+    const nameEnc = new TextEncoder().encode(String(params.name || '').slice(0, 92));
+    payload.push(nameEnc.length, ...nameEnc);
+    return payload;
+}
+
+function buildAsyncRequestPayload(service_id, node_id, params) {
+    const payload = [service_id & 0xFF, (service_id >> 8) & 0xFF, node_id];
+    if (service_id === DRONECAN_SERVICE_PARAM_GETSET && params) {
+        payload.push(...buildParamGetSetPayload(params));
+    } else if (service_id === DRONECAN_SERVICE_EXECUTE_OPCODE && params) {
+        payload.push(params.opcode);
+    }
+    return payload;
+}
+
+function dronecanAsyncPoll(service_id, node_id, params, onDone) {
+    const reqPayload = buildAsyncRequestPayload(service_id, node_id, params);
+
+    MSP.send_message(MSPCodes.MSP2_INAV_DRONECAN_ASYNC_REQUEST, reqPayload, false, () => {
+        const req = FC.DRONECAN_ASYNC_REQUEST;
+        if (req?.status !== DRONECAN_ASYNC_REQUEST_STATUS_OK) {
+            onDone(req?.status === DRONECAN_ASYNC_REQUEST_STATUS_BUSY ? new Error('busy') : new Error('not_ready'), null);
+            return;
+        }
+        const expectedSeq = req.seq;
+        let attempts = 0;
+        const poll = () => {
+            MSP.send_message(MSPCodes.MSP2_INAV_DRONECAN_ASYNC_RESULT, false, false, () => {
+                const r = FC.DRONECAN_ASYNC_RESULT;
+                if (!r || r.seq !== expectedSeq ||
+                    r.service_id !== service_id || r.node_id !== node_id) {
+                    onDone(new Error('stale'), null); return;
+                }
+                if (r.state === DRONECAN_ASYNC_STATE_READY) { onDone(null, r); }
+                else if (r.state === DRONECAN_ASYNC_STATE_ERROR) { onDone(new Error('error'), null); }
+                else if (++attempts < POLL_MAX_ATTEMPTS) { setTimeout(poll, POLL_INTERVAL_MS); }
+                else { onDone(new Error('timeout'), null); }
+            });
+        };
+        setTimeout(poll, POLL_INTERVAL_MS);
+    });
+}
+
+function fetchNamesSequentially(nodes, index, tbody) {
+    if (index >= nodes.length) return; 
+    const node = nodes[index]; 
+    dronecanAsyncPoll(DRONECAN_SERVICE_GETNODEINFO, node.nodeID, null, (err, result) => {
+        if (!err && result) {
+            nameCache[node.nodeID] = result.name;
+            const r = tbody.querySelector(`tr[data-node-id="${node.nodeID}"]`);
+            if (r) r.cells[1].textContent = result.name;
+        }
+        fetchNamesSequentially(nodes, index + 1, tbody);
+    });
+}
+
+dronecanTab.initialize = function (callback) {
+    GUI.active_tab = this;
+
+    import('./dronecan.html?raw').then(({default: html}) => {
+        GUI.load(html, () => {
+            i18n.localize();
+            mspHelper.getSetting('dronecan_bitrate_kbps').then(data => {
+                if (data) {
+                    const val = data.setting.table ? data.setting.table.values[data.value] : data.value;
+                    $('#dronecan-bitrate').val(val);
+                }
+                return mspHelper.getSetting('dronecan_node_id');
+            }).then(data => {
+                if (data) $('#dronecan-node-id').val(data.value);
+            });
+            $('#dronecan-save').on('click', dronecanTab.saveConfig);
+            dronecanTab.refresh();
+            interval.add('dronecan_refresh', () => dronecanTab.refresh(), 2000);
+            GUI.content_ready(callback);
+        });
+    });
+};
+
+dronecanTab.refresh = function () {
+    MSP.send_message(MSPCodes.MSP2_INAV_DRONECAN_NODES, false, false, () => {
+        dronecanTab.render();
+    });
+};
+
+dronecanTab.render = function () {
+    const nodes = FC.DRONECAN_NODES;
+    const status = document.getElementById('dronecan-status');
+    const table = document.getElementById('dronecan-node-wrapper');
+    const tbody = document.getElementById('dronecan-node-tbody');
+
+    if (!nodes || nodes.length === 0) {
+        status.style.display = '';
+        table.style.display = 'none';
+        document.getElementById('dronecan-node-detail').style.display = 'none';
+        currentDetailNodeId = null;
+
+        return;
+    }
+
+    status.style.display = 'none';
+    table.style.display = '';
+    tbody.innerHTML = '';
+
+    const nodesToFetch = [];
+    nodes.forEach(node => {
+        const health = node.health < HEALTH_LABELS.length ? node.health : 3;
+        const modeLabel = getModeLabel(node.mode);
+        const lastSeen = i18n.getMessage('dronecanSecondsAgo', [(node.last_seen_ms / 1000).toFixed(1)]);
+
+        const row = document.createElement('tr');
+        row.dataset.nodeId = node.nodeID;
+        row.innerHTML = `
+            <td>${esc(node.nodeID)}</td>
+            <td>—</td>
+            <td><span class="health-badge ${HEALTH_CLASSES[health]}">${HEALTH_LABELS[health]}</span></td>
+            <td>${esc(modeLabel)}</td>
+            <td>${lastSeen}</td>
+        `;
+        if (nameCache[node.nodeID] !== undefined) {
+            row.cells[1].textContent = nameCache[node.nodeID];
+        } else {
+            nodesToFetch.push(node);
+        }
+
+        row.addEventListener('click', () => dronecanTab.showDetail(node.nodeID));
+        tbody.appendChild(row);
+    });
+
+    fetchNamesSequentially(nodesToFetch, 0, tbody);
+    if (currentDetailNodeId !== null) {
+        const liveNode = nodes.find(n => n.nodeID === currentDetailNodeId);
+        if (liveNode) {
+            const detail = document.getElementById('dronecan-node-detail');
+            const health = liveNode.health < HEALTH_LABELS.length ? liveNode.health : 3;
+            const uptime = `${Math.floor(liveNode.uptime_sec / 3600)}h ${Math.floor((liveNode.uptime_sec % 3600) / 60)}m ${liveNode.uptime_sec % 60}s`;
+            const modeLabel = getModeLabel(liveNode.mode);
+            const set = (attr, val) => { const el = detail.querySelector(`[data-detail="${attr}"]`); if (el) el.textContent = val; };
+            set('health', HEALTH_LABELS[health]);
+            set('mode', modeLabel);
+            set('last-seen', i18n.getMessage('dronecanSecondsAgo', [(liveNode.last_seen_ms / 1000).toFixed(1)]));
+            set('uptime', uptime);
+            set('vendor-status', liveNode.vendor_status_code);
+        } else {
+            document.getElementById('dronecan-node-detail').style.display = 'none';
+            currentDetailNodeId = null;
+        }
+    }
+};
+
+dronecanTab.showDetail = function (nodeId) {
+    currentDetailNodeId = nodeId;
+    const node = FC.DRONECAN_NODES.find(n => n.nodeID === nodeId);
+    if (!node) return;
+    
+    dronecanAsyncPoll(DRONECAN_SERVICE_GETNODEINFO, nodeId, null, (err, result) => {
+        if (nodeId !== currentDetailNodeId) return;
+        const detail = document.getElementById('dronecan-node-detail');
+        const tbody  = document.getElementById('dronecan-detail-tbody');
+        const health   = node.health < HEALTH_LABELS.length ? node.health : 3;
+        const uptime   = result ? `${Math.floor(node.uptime_sec / 3600)}h ${Math.floor((node.uptime_sec % 3600) / 60)}m ${node.uptime_sec % 60}s` : '—';
+        const modeLabel = getModeLabel(node.mode);
+
+        let nameCell = '—';
+        if (result) {
+            nameCell = esc(result.name);
+        } else if (err) {
+            nameCell = i18n.getMessage('dronecanNameError');
+        }
+
+        let versionRows = '';
+        if (result) {
+            const swCommitSuffix = (result.sw_optional_field_flags & 1)
+                ? ` (${result.sw_vcs_commit.toString(16).padStart(8, '0')})`
+                : '';
+            versionRows = `
+                <tr><th>SW Version</th><td>${esc(result.sw_major)}.${esc(result.sw_minor)}${swCommitSuffix}</td></tr>
+                <tr><th>HW Version</th><td>${esc(result.hw_major)}.${esc(result.hw_minor)}</td></tr>
+                <tr><th>Unique ID</th><td>${Array.from(result.hw_unique_id).map(b => b.toString(16).padStart(2, '0')).join(':')}</td></tr>
+            `;
+        }
+
+        tbody.innerHTML = `
+            <tr><th>Node ID</th><td>${esc(nodeId)}</td></tr>
+            <tr><th>Name</th><td class="dronecan-detail-name">${nameCell}</td></tr>
+            <tr><th>Health</th><td data-detail="health">${HEALTH_LABELS[health]}</td></tr>
+            <tr><th>Mode</th><td data-detail="mode">${esc(modeLabel)}</td></tr>
+            <tr><th>Last Seen</th><td data-detail="last-seen">${i18n.getMessage('dronecanSecondsAgo', [(node.last_seen_ms / 1000).toFixed(1)])}</td></tr>
+            <tr><th>Uptime</th><td data-detail="uptime">${uptime}</td></tr>
+            <tr><th>Vendor Status</th><td data-detail="vendor-status">${esc(node.vendor_status_code)}</td></tr>
+            ${versionRows}
+        `;
+        detail.style.display = '';
+        dronecanTab.showParams(nodeId);
+    });
+};
+
+function paramValueToString(value_type, value) {
+    if (value_type === PARAM_TYPE_BOOL) {
+        return value ? 'true' : 'false';
+    }
+    return String(value);
+}
+
+function convertParamValue(value_type, writeValue) {
+    switch (value_type) {
+        case PARAM_TYPE_INT:
+            try { return BigInt(writeValue); } catch { return Number.NaN; }
+        case PARAM_TYPE_FLOAT:  return Number.parseFloat(writeValue);
+        case PARAM_TYPE_BOOL:   return writeValue === 'true' || writeValue === '1';
+        case PARAM_TYPE_STRING:
+        default:                return writeValue;
+    }
+}
+
+function validateNumericParam(param, value) {
+    const isInt = param.value_type === PARAM_TYPE_INT;
+    if (isInt ? typeof value !== 'bigint' : Number.isNaN(value)) {
+        return { ok: false, message: i18n.getMessage('dronecanParamOutOfRange') };
+    }
+    const toBig = b => typeof b === 'bigint' ? b : BigInt(Math.round(b));
+    const tooLow  = param.min !== undefined && (isInt ? value < toBig(param.min) : value < Number(param.min));
+    const tooHigh = param.max !== undefined && (isInt ? value > toBig(param.max) : value > Number(param.max));
+    if (tooLow || tooHigh) {
+        const lo = param.min !== undefined ? param.min : '—';
+        const hi = param.max !== undefined ? param.max : '—';
+        return { ok: false, message: i18n.getMessage('dronecanParamRangeMustBeBetween', [lo, hi]) };
+    }
+    return { ok: true };
+}
+
+function flagParamInputError(input, btn, message) {
+    input.style.outline = '2px solid #cc0000';
+    input.title = message;
+    btn.textContent = i18n.getMessage('dronecanParamOutOfRange');
+    setTimeout(() => { btn.textContent = i18n.getMessage('dronecanParamWrite'); }, 2000);
+}
+
+function submitParamWrite(btn, nodeId, payload, param, input) {
+    btn.disabled = true;
+    btn.textContent = '...';
+    dronecanAsyncPoll(DRONECAN_SERVICE_PARAM_GETSET, nodeId, payload, (err, result) => {
+        if (!err && result) {
+            param.value = result.value;
+            input.value = paramValueToString(param.value_type, result.value);
+            btn.textContent = i18n.getMessage('OK');
+        } else {
+            btn.textContent = i18n.getMessage('dronecanParamError');
+        }
+        btn.disabled = false;
+        setTimeout(() => { btn.textContent = i18n.getMessage('dronecanParamWrite'); }, 2000);
+    });
+}
+
+function handleParamWriteClick(btn, container, params, nodeId) {
+    const idx = Number.parseInt(btn.dataset.index, 10);
+    const input = container.querySelector(`.param-input[data-index="${idx}"]`);
+    const param = params.find(p => p.index === idx);
+    if (!input || !param) return;
+
+    const payload = {
+        index: idx, is_write: true, value_type: param.value_type, name: param.name,
+        value: convertParamValue(param.value_type, input.value),
+    };
+
+    if (param.value_type === PARAM_TYPE_INT || param.value_type === PARAM_TYPE_FLOAT) {
+        const validation = validateNumericParam(param, payload.value);
+        if (!validation.ok) {
+            flagParamInputError(input, btn, validation.message);
+            return;
+        }
+    }
+
+    input.style.outline = '';
+    input.title = '';
+    submitParamWrite(btn, nodeId, payload, param, input);
+}
+
+function handleSaveToEeprom(btn, nodeId) {
+    btn.disabled = true;
+    btn.textContent = '...';
+    dronecanAsyncPoll(DRONECAN_SERVICE_EXECUTE_OPCODE, nodeId, { opcode: DRONECAN_EXECUTE_OPCODE_SAVE }, (err, result) => {
+        btn.textContent = (!err && result?.ok) ? i18n.getMessage('dronecanSaved') : i18n.getMessage('dronecanFailed');
+        btn.disabled = false;
+        setTimeout(() => { btn.textContent = i18n.getMessage('dronecanSaveToEeprom'); }, 2000);
+    });
+}
+
+function handleRestartNode(btn, nodeId) {
+    btn.disabled = true;
+    btn.textContent = '...';
+    dronecanAsyncPoll(DRONECAN_SERVICE_RESTART_NODE, nodeId, null, (err, result) => {
+        btn.textContent = (!err && result?.ok) ? i18n.getMessage('dronecanRestarting') : i18n.getMessage('dronecanFailed');
+        btn.disabled = false;
+        setTimeout(() => { btn.textContent = i18n.getMessage('dronecanRestartNode'); }, 3000);
+    });
+}
+
+dronecanTab.showParams = function (nodeId) {
+    const container = document.getElementById('dronecan-params');
+    if (!container) return;
+    container.innerHTML = `<p>${i18n.getMessage('dronecanParamsLoading')}</p>`;
+
+    const params = [];
+
+    function fetchParam(index) {
+        if (index > 8191) { renderParams(); return; } // UAVCAN v0 GetSet.Request uses a uint13 index (max 8191); firmware reads uint16
+        if (nodeId !== currentDetailNodeId) return;
+        dronecanAsyncPoll(DRONECAN_SERVICE_PARAM_GETSET, nodeId, { index, is_write: false }, (err, result) => {
+            if (nodeId !== currentDetailNodeId) return;
+            if (err || !result?.name) {
+                renderParams();
+                return;
+            }
+            params.push({ index, name: result.name, value_type: result.value_type, value: result.value,
+                min: result.min, max: result.max });
+            fetchParam(index + 1);
+        });
+    }
+
+    function renderParams() {
+        if (params.length === 0) {
+            container.innerHTML = `<p>${i18n.getMessage('dronecanNoParams')}</p>`;
+            return;
+        }
+        const TYPE_LABELS = ['', 'INT', 'FLOAT', 'BOOL', 'STRING'];
+        const fmtNumeric = (v, type) => {
+            if (v === undefined) return '—';
+            return type === PARAM_TYPE_FLOAT ? Number(v).toFixed(3) : String(v);
+        };
+        const lblWrite       = i18n.getMessage('dronecanParamWrite');
+        const lblSaveEeprom  = i18n.getMessage('dronecanSaveToEeprom');
+        const lblRestartNode = i18n.getMessage('dronecanRestartNode');
+        const thIndex = i18n.getMessage('dronecanParamColIndex');
+        const thName  = i18n.getMessage('dronecanParamColName');
+        const thType  = i18n.getMessage('dronecanParamColType');
+        const thValue = i18n.getMessage('dronecanParamColValue');
+        const thRange = i18n.getMessage('dronecanParamColRange');
+        let html = `<table><thead><tr><th>${thIndex}</th><th>${thName}</th><th>${thType}</th><th>${thValue}</th><th>${thRange}</th><th></th></tr></thead><tbody>`;
+        params.forEach(p => {
+            const valStr = paramValueToString(p.value_type, p.value);
+            const hasRange = (p.value_type === PARAM_TYPE_INT || p.value_type === PARAM_TYPE_FLOAT) && (p.min !== undefined || p.max !== undefined);
+            const rangeStr = hasRange
+                ? `${fmtNumeric(p.min, p.value_type)} … ${fmtNumeric(p.max, p.value_type)}`
+                : '—';
+            html += `<tr>
+                <td>${p.index}</td>
+                <td>${esc(p.name)}</td>
+                <td>${TYPE_LABELS[p.value_type] || esc(String(p.value_type))}</td>
+                <td><input class="param-input" data-index="${p.index}" data-type="${p.value_type}" value="${esc(valStr)}"></td>
+                <td class="param-range">${esc(rangeStr)}</td>
+                <td><button class="param-write" data-index="${p.index}">${lblWrite}</button></td>
+            </tr>`;
+        });
+        html += '</tbody></table>';
+        html += `<div class="param-actions"><button class="param-action-btn param-save-eeprom">${lblSaveEeprom}</button> <button class="param-action-btn param-restart-node">${lblRestartNode}</button></div>`;
+        container.innerHTML = html;
+
+        const saveBtn = container.querySelector('.param-save-eeprom');
+        saveBtn.addEventListener('click', () => handleSaveToEeprom(saveBtn, nodeId));
+
+        const restartBtn = container.querySelector('.param-restart-node');
+        restartBtn.addEventListener('click', () => handleRestartNode(restartBtn, nodeId));
+
+        container.querySelectorAll('.param-write').forEach(btn => {
+            btn.addEventListener('click', () => handleParamWriteClick(btn, container, params, nodeId));
+        });
+    }
+
+    fetchParam(0);
+};
+
+function finishSaveConfigAndReboot() {
+    GUI.log(i18n.getMessage('configurationEepromSaved'));
+    MSP.send_message(MSPCodes.MSP_SET_REBOOT, false, false, () => {
+        GUI.log(i18n.getMessage('deviceRebooting'));
+        GUI.handleReconnect($('.tab_dronecan a'));
+    });
+}
+
+function saveNodeIdAndReboot(nodeId) {
+    mspHelper.setSetting('dronecan_node_id', nodeId, () => {
+        mspHelper.saveToEeprom(finishSaveConfigAndReboot);
+    });
+}
+
+dronecanTab.saveConfig = function () {
+    const bitrate = $('#dronecan-bitrate').val();
+    const nodeId = Number.parseInt($('#dronecan-node-id').val(), 10);
+    if (nodeId >= 126 && !confirm(i18n.getMessage('dronecanNodeIdReservedWarning'))) return;
+    mspHelper.setSetting('dronecan_bitrate_kbps', bitrate, () => saveNodeIdAndReboot(nodeId));
+};
+
+dronecanTab.cleanup = function (callback) {
+    interval.remove('dronecan_refresh');
+    currentDetailNodeId = null;
+    nameCache = {}; // prevent stale names from a previous vehicle appearing on reconnect
+    if (callback) callback();
+};
+
+export default dronecanTab;
diff --git a/tabs/gps.html b/tabs/gps.html
index a81c76e78..72003de20 100644
--- a/tabs/gps.html
+++ b/tabs/gps.html
@@ -14,6 +14,15 @@
                             <label for="feature-7"><span data-i18n="featureGPS"></span></label>
                             <div for="feature-7" class="helpicon cf_tip" data-i18n_title="featureGPSTip"></div>
                         </div>
+                        <div class="select">
+                            <select id="gps_protocol" class="gps_protocol">
+                                <!-- list generated here -->
+                            </select>
+                            <label for="gps_protocol"><span data-i18n="configurationGPSProtocol"></span></label>
+                            <div id="gps_dronecan_info" class="gps-dronecan-info" style="display: none;">
+                                <span data-i18n="gpsDroneCANInfo"></span>
+                            </div>
+                        </div>
                         <div class="select">
                             <select id="gps_port" class="gps_port"></select>
                             <label for="gps_port"><span data-i18n="gpsPort"></span></label>
@@ -22,12 +31,6 @@
                             <select id="gps_baud" class="gps_baud"></select>
                             <label for="gps_baud"><span data-i18n="gpsBaud"></span></label>
                         </div>
-                        <div class="select">
-                            <select id="gps_protocol" class="gps_protocol">
-                                <!-- list generated here -->
-                            </select>
-                            <label for="gps_protocol"><span data-i18n="configurationGPSProtocol"></span></label>
-                        </div>
                         <div class="select">
                             <select id="gps_ubx_sbas" class="gps_ubx_sbas">
                                 <!-- list generated here -->
diff --git a/tabs/gps.js b/tabs/gps.js
index 266ddd606..5ff6343c2 100644
--- a/tabs/gps.js
+++ b/tabs/gps.js
@@ -190,6 +190,13 @@ gpsTab.initialize = function (callback) {
 
         gps_protocol_e.on('change', function () {
             FC.MISC.gps_type = parseInt($(this).val());
+            const isDroneCAN = FC.MISC.gps_type === 4;
+            $('#gps_port').closest('.select').toggle(!isDroneCAN);
+            $('#gps_baud').closest('.select').toggle(!isDroneCAN);
+            $('#gps_dronecan_info').toggle(isDroneCAN);
+            if (isDroneCAN) {
+                $port.val(-1);
+            }
         });
 
         gps_protocol_e.val(FC.MISC.gps_type);
diff --git a/test_dronecan_async_result.mjs b/test_dronecan_async_result.mjs
new file mode 100644
index 000000000..d29a33b3e
--- /dev/null
+++ b/test_dronecan_async_result.mjs
@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+/**
+ * Test: MSP2_INAV_DRONECAN_ASYNC_RESULT decoder
+ *
+ * Mirrors the parsing logic in MSPHelper.js case MSP2_INAV_DRONECAN_ASYNC_RESULT
+ * (string decoding here uses String.fromCodePoint instead of fromCharCode per
+ * lint preference; both are equivalent for the single-byte values decoded here).
+ * Run with: node test_dronecan_async_result.mjs
+ *
+ * Wire format (state, seq, service_id, node_id always present):
+ *   [0]     state       uint8  (0=IDLE, 1=PENDING, 2=READY, 3=ERROR)
+ *   [1]     seq         uint8
+ *   [2..3]  service_id  uint16 LE
+ *   [4]     node_id     uint8
+ *
+ * When state == READY (2), followed by:
+ *   [5]     name_len    uint8
+ *   [6..]   name        name_len bytes
+ *
+ * Then for service_id == 1 (GETNODEINFO):
+ *   sw_major(1) sw_minor(1) sw_optional_field_flags(1) sw_vcs_commit(4 LE)
+ *   hw_major(1) hw_minor(1) hw_unique_id(16)
+ *
+ * Then for service_id == 11 (PARAM_GETSET):
+ *   value_type(1) followed by:
+ *     type 1 (INT):    lo(4 LE) hi(4 LE)
+ *     type 2 (FLOAT):  float32(4 LE)
+ *     type 3 (BOOL):   uint8(1)
+ *     type 4 (STRING): slen(1) str[slen]
+ */
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition, message) {
+    if (condition) {
+        console.log(`  ✓ ${message}`);
+        passed++;
+    } else {
+        console.log(`  ✗ ${message}`);
+        failed++;
+    }
+}
+
+function assertEqual(actual, expected, message) {
+    const ok = actual === expected ||
+               (typeof actual === 'bigint' && actual === BigInt(expected)) ||
+               (typeof expected === 'bigint' && BigInt(actual) === expected);
+    if (ok) {
+        console.log(`  ✓ ${message}`);
+        passed++;
+    } else {
+        console.log(`  ✗ ${message} — expected ${expected}, got ${actual}`);
+        failed++;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Parser — mirrors MSPHelper.js case MSP2_INAV_DRONECAN_ASYNC_RESULT exactly
+// ---------------------------------------------------------------------------
+function parseAsyncResult(data) {
+    if (data.byteLength < 5) return null;
+
+    const state      = data.getUint8(0);
+    const seq        = data.getUint8(1);
+    const service_id = data.getUint16(2, true);
+    const node_id    = data.getUint8(4);
+    const result     = { state, seq, service_id, node_id };
+
+    if (state === 2) { // READY
+        let offset = 5;
+        const name_len = data.getUint8(offset++);
+        result.name = String.fromCodePoint(
+            ...new Uint8Array(data.buffer, data.byteOffset + offset, name_len));
+        offset += name_len;
+
+        if (service_id === 1) { // GETNODEINFO
+            result.sw_major                = data.getUint8(offset++);
+            result.sw_minor                = data.getUint8(offset++);
+            result.sw_optional_field_flags = data.getUint8(offset++);
+            result.sw_vcs_commit           = data.getUint32(offset, true); offset += 4;
+            result.hw_major                = data.getUint8(offset++);
+            result.hw_minor                = data.getUint8(offset++);
+            result.hw_unique_id            = new Uint8Array(data.buffer, data.byteOffset + offset, 16);
+        } else if (service_id === 11) { // PARAM_GETSET
+            result.value_type = data.getUint8(offset++);
+            switch (result.value_type) {
+                case 1: { // INT
+                    const lo  = data.getUint32(offset, true);
+                    const hi  = data.getUint32(offset + 4, true);
+                    const big = BigInt(hi) * BigInt(0x100000000) + BigInt(lo);
+                    result.value = (big >= BigInt(Number.MIN_SAFE_INTEGER) &&
+                                    big <= BigInt(Number.MAX_SAFE_INTEGER))
+                                   ? Number(big) : big;
+                    break;
+                }
+                case 2: // FLOAT
+                    result.value = data.getFloat32(offset, true);
+                    break;
+                case 3: // BOOL
+                    result.value = data.getUint8(offset) !== 0;
+                    break;
+                case 4: { // STRING
+                    const slen = data.getUint8(offset++);
+                    result.value = String.fromCodePoint(
+                        ...new Uint8Array(data.buffer, data.byteOffset + offset, slen));
+                    break;
+                }
+                default:
+                    result.value = null;
+            }
+        }
+    }
+
+    return result;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makePrefix(state, seq, service_id, node_id) {
+    const buf  = new ArrayBuffer(5);
+    const view = new DataView(buf);
+    view.setUint8(0,  state);
+    view.setUint8(1,  seq);
+    view.setUint16(2, service_id, true);
+    view.setUint8(4,  node_id);
+    return new Uint8Array(buf);
+}
+
+function appendName(arr, name) {
+    const enc = new TextEncoder().encode(name);
+    return new Uint8Array([...arr, enc.length, ...enc]);
+}
+
+function concat(...arrays) {
+    const total = arrays.reduce((n, a) => n + a.length, 0);
+    const out   = new Uint8Array(total);
+    let offset  = 0;
+    for (const a of arrays) { out.set(a, offset); offset += a.length; }
+    return out;
+}
+
+function u8(...bytes)       { return new Uint8Array(bytes); }
+function u32le(v)           { const b = new ArrayBuffer(4); new DataView(b).setUint32(0, v, true); return new Uint8Array(b); }
+function f32le(v)           { const b = new ArrayBuffer(4); new DataView(b).setFloat32(0, v, true); return new Uint8Array(b); }
+function i64le(lo, hi)      { return new Uint8Array([...u32le(lo), ...u32le(hi)]); }
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+console.log('\nTest: payload too short (< 5 bytes) → null');
+{
+    const r = parseAsyncResult(new DataView(new ArrayBuffer(4)));
+    assert(r === null, 'returns null for < 5 bytes');
+}
+
+console.log('\nTest: PENDING state — prefix only, no name or value');
+{
+    const raw = makePrefix(1 /*PENDING*/, 7, 1, 42);
+    const r   = parseAsyncResult(new DataView(raw.buffer));
+    assert(r !== null,          'parses without error');
+    assertEqual(r.state,      1, 'state = PENDING');
+    assertEqual(r.seq,        7, 'seq');
+    assertEqual(r.service_id, 1, 'service_id');
+    assertEqual(r.node_id,   42, 'node_id');
+    assert(r.name === undefined, 'name absent for non-READY state');
+}
+
+console.log('\nTest: ERROR state — prefix only');
+{
+    const raw = makePrefix(3 /*ERROR*/, 2, 11, 10);
+    const r   = parseAsyncResult(new DataView(raw.buffer));
+    assert(r !== null,           'parses without error');
+    assertEqual(r.state,      3, 'state = ERROR');
+    assertEqual(r.service_id, 11, 'service_id');
+    assert(r.name === undefined,  'name absent for ERROR state');
+}
+
+console.log('\nTest: READY GetNodeInfo — name and version fields');
+{
+    const name = 'com.example.gps';
+    const uid  = new Uint8Array(Array.from({ length: 16 }, (_, i) => 0xA0 + i));
+    const raw  = concat(
+        makePrefix(2 /*READY*/, 3, 1 /*GETNODEINFO*/, 74),
+        appendName(new Uint8Array(0), name),
+        u8(1, 7, 1),            // sw_major, sw_minor, sw_optional_field_flags
+        u32le(0xDEADBEEF),      // sw_vcs_commit
+        u8(2, 0),               // hw_major, hw_minor
+        uid,
+    );
+    const r = parseAsyncResult(new DataView(raw.buffer));
+    assert(r !== null,                       'parses without error');
+    assertEqual(r.state,                  2, 'state = READY');
+    assertEqual(r.name,            name,     'name');
+    assertEqual(r.sw_major,           1,     'sw_major');
+    assertEqual(r.sw_minor,           7,     'sw_minor');
+    assertEqual(r.sw_optional_field_flags, 1, 'sw_optional_field_flags');
+    assertEqual(r.sw_vcs_commit, 0xDEADBEEF, 'sw_vcs_commit');
+    assertEqual(r.hw_major,           2,     'hw_major');
+    assertEqual(r.hw_minor,           0,     'hw_minor');
+    assert(r.hw_unique_id instanceof Uint8Array, 'hw_unique_id is Uint8Array');
+    assertEqual(r.hw_unique_id.length,    16, 'hw_unique_id length');
+    for (let i = 0; i < 16; i++) {
+        assertEqual(r.hw_unique_id[i], 0xA0 + i, `hw_unique_id[${i}]`);
+    }
+}
+
+console.log('\nTest: READY GetNodeInfo — empty name');
+{
+    const raw = concat(
+        makePrefix(2, 1, 1, 5),
+        u8(0),                  // name_len = 0
+        u8(1, 0, 0),            // sw version
+        u32le(0),
+        u8(1, 0),               // hw version
+        new Uint8Array(16),
+    );
+    const r = parseAsyncResult(new DataView(raw.buffer));
+    assert(r !== null,         'parses without error');
+    assertEqual(r.name,    '', 'empty name');
+    assertEqual(r.sw_major, 1, 'sw_major still present');
+}
+
+console.log('\nTest: READY Param GetSet — INT (small, fits Number)');
+{
+    const raw = concat(
+        makePrefix(2, 5, 11 /*PARAM_GETSET*/, 10),
+        appendName(new Uint8Array(0), 'BATT_N_CELLS'),
+        u8(1),                  // value_type = INT
+        i64le(6, 0),            // value = 6
+    );
+    const r = parseAsyncResult(new DataView(raw.buffer));
+    assert(r !== null,               'parses without error');
+    assertEqual(r.name, 'BATT_N_CELLS', 'name');
+    assertEqual(r.value_type,     1,   'value_type = INT');
+    assertEqual(r.value,          6,   'value = 6');
+    assert(typeof r.value === 'number', 'value is Number (fits safe integer range)');
+}
+
+console.log('\nTest: READY Param GetSet — INT (large, returned as BigInt)');
+{
+    // 2^53 + 1 exceeds Number.MAX_SAFE_INTEGER
+    const big = BigInt(Number.MAX_SAFE_INTEGER) + 1n;
+    const lo  = Number(big & 0xFFFFFFFFn);
+    const hi  = Number((big >> 32n) & 0xFFFFFFFFn);
+    const raw = concat(
+        makePrefix(2, 6, 11, 10),
+        appendName(new Uint8Array(0), 'LARGE'),
+        u8(1),
+        i64le(lo, hi),
+    );
+    const r = parseAsyncResult(new DataView(raw.buffer));
+    assert(r !== null,                    'parses without error');
+    assert(typeof r.value === 'bigint',   'value is BigInt for large integers');
+    assertEqual(r.value, big,             'value matches expected BigInt');
+}
+
+console.log('\nTest: READY Param GetSet — FLOAT');
+{
+    const raw = concat(
+        makePrefix(2, 7, 11, 10),
+        appendName(new Uint8Array(0), 'NAV_FW_CRUISE_THR'),
+        u8(2),                  // value_type = FLOAT
+        f32le(1450),
+    );
+    const r = parseAsyncResult(new DataView(raw.buffer));
+    assert(r !== null,                          'parses without error');
+    assertEqual(r.value_type,             2,    'value_type = FLOAT');
+    assert(Math.abs(r.value - 1450) < 0.1,   'value ≈ 1450');
+}
+
+console.log('\nTest: READY Param GetSet — BOOL true');
+{
+    const raw = concat(
+        makePrefix(2, 8, 11, 10),
+        appendName(new Uint8Array(0), 'GPS_ENABLED'),
+        u8(3, 1),               // value_type = BOOL, value = 1
+    );
+    const r = parseAsyncResult(new DataView(raw.buffer));
+    assert(r !== null,              'parses without error');
+    assertEqual(r.value_type,  3,   'value_type = BOOL');
+    assertEqual(r.value,    true,   'value = true');
+    assert(typeof r.value === 'boolean', 'value is boolean type');
+}
+
+console.log('\nTest: READY Param GetSet — BOOL false');
+{
+    const raw = concat(
+        makePrefix(2, 9, 11, 10),
+        appendName(new Uint8Array(0), 'GPS_ENABLED'),
+        u8(3, 0),               // value_type = BOOL, value = 0
+    );
+    const r = parseAsyncResult(new DataView(raw.buffer));
+    assert(r !== null,             'parses without error');
+    assertEqual(r.value,   false,  'value = false');
+}
+
+console.log('\nTest: READY Param GetSet — STRING');
+{
+    const str = 'FIXED_WING';
+    const enc = new TextEncoder().encode(str);
+    const raw = concat(
+        makePrefix(2, 10, 11, 10),
+        appendName(new Uint8Array(0), 'CRAFT_NAME'),
+        u8(4),                  // value_type = STRING
+        u8(enc.length),
+        enc,
+    );
+    const r = parseAsyncResult(new DataView(raw.buffer));
+    assert(r !== null,                'parses without error');
+    assertEqual(r.value_type,    4,   'value_type = STRING');
+    assertEqual(r.value,        str,  'value string');
+}
+
+console.log('\nTest: READY Param GetSet — EMPTY type (unknown)');
+{
+    const raw = concat(
+        makePrefix(2, 11, 11, 10),
+        appendName(new Uint8Array(0), 'UNKNOWN'),
+        u8(0),                  // value_type = EMPTY
+    );
+    const r = parseAsyncResult(new DataView(raw.buffer));
+    assert(r !== null,              'parses without error');
+    assertEqual(r.value_type,  0,   'value_type = EMPTY');
+    assert(r.value === null,        'value is null for EMPTY type');
+}
+
+console.log('\nTest: seq field preserved correctly across states');
+for (const [state, seq] of [[0, 0], [1, 128], [2, 255], [3, 1]]) {
+    const prefix = makePrefix(state, seq, 1, 5);
+    const raw    = state === 2
+        ? concat(prefix, u8(0), u8(0, 0, 0), u32le(0), u8(0, 0), new Uint8Array(16))
+        : prefix;
+    const r = parseAsyncResult(new DataView(raw.buffer));
+    assertEqual(r?.seq, seq, `seq=${seq} preserved for state=${state}`);
+}
+
+// ---------------------------------------------------------------------------
+// Summary
+// ---------------------------------------------------------------------------
+console.log(`\n${passed + failed} tests: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);