Improve events

Author: haslinghuis

src/js/msp/MSPHelper.js

@@ -1779,13 +1779,17 @@ MspHelper.prototype.process_data = function (dataHandler) {
 
             // remove object from array
             dataHandler.callbacks.splice(i, 1);
-            if (!crcError) {
-                // fire callback
-                if (callback) {
+            // Always invoke callback and pass crcError flag. Previously callbacks were skipped
+            // when crcError was true; tests and callers expect the callback to still be notified.
+            if (callback) {
+                try {
                     callback({ command: code, data: data, length: data.byteLength, crcError: crcError });
+                } catch (e) {
+                    console.error(`callback for code ${code} threw:`, e);
                 }
-            } else {
-                console.warn(`code: ${code} - crc failed. No callback`);
+            }
+            if (crcError) {
+                console.warn(`code: ${code} - callback invoked despite crc failure`);
             }
         }
     }

src/js/tabs/firmware_flasher.js

@@ -40,6 +40,99 @@ const firmware_flasher = {
     // Properties to preserve firmware state during flashing
     preFlashingMessage: null,
     preFlashingMessageType: null,
+    // Minimal module-scoped handler references for cleanup to use
+    detectedUsbDevice: null,
+    detectedSerialDevice: null,
+    onPortChange: null,
+    onDeviceRemoved: null,
+    // Single debounce timer shared across instances
+    _portChangeTimer: null,
+    logHead: "[FIRMWARE_FLASHER]",
+};
+
+// Move port/device handlers to module scope for easier maintenance and testing.
+// These handlers reference the `firmware_flasher` object and shared imports (STM32, AutoDetect, GUI).
+const PORT_CHANGE_DEBOUNCE_MS = 500;
+
+function handleDetectedDevice(device, isSerial) {
+    const isFlashOnConnect = $("input.flash_on_connect").is(":checked");
+
+    console.log(`${firmware_flasher.logHead} Detected ${isSerial ? "serial" : "USB"} device:`, device);
+    console.log(`${firmware_flasher.logHead} Reboot mode: %s, flash on connect`, STM32.rebootMode, isFlashOnConnect);
+
+    // If another operation is in progress, ignore port events (unless we're resuming from a reboot)
+    if (GUI.connect_lock && !STM32.rebootMode) {
+        console.log(`${firmware_flasher.logHead} Port event ignored due to active operation (connect_lock)`);
+        return;
+    }
+
+    // Proceed if we're resuming a reboot sequence or if flash-on-connect is enabled and no operation is active
+    if (STM32.rebootMode || (isFlashOnConnect && !GUI.connect_lock)) {
+        // Remember whether we were in reboot mode before clearing it.
+        const wasReboot = Boolean(STM32.rebootMode);
+        STM32.rebootMode = 0;
+        // Only clear the global connect lock when we are resuming from a reboot sequence.
+        // If wasReboot is true, this clears connect_lock; otherwise, it leaves it unchanged.
+        GUI.connect_lock &&= !wasReboot;
+        firmware_flasher.startFlashing();
+    } else {
+        if (isSerial) {
+            // Auto-detect board when firmware flasher tab is active and no flash-on-connect
+            console.log(`${firmware_flasher.logHead} Auto-detecting board for connected serial device`);
+        }
+        AutoDetect.verifyBoard();
+    }
+}
+
+firmware_flasher.detectedUsbDevice = function (device) {
+    handleDetectedDevice(device, false);
+};
+
+firmware_flasher.detectedSerialDevice = function (device) {
+    handleDetectedDevice(device, true);
+};
+
+firmware_flasher.onPortChange = function (port) {
+    // Clear any pending debounce timer so rapid port events don't re-enter the handler.
+    if (firmware_flasher._portChangeTimer) {
+        clearTimeout(firmware_flasher._portChangeTimer);
+        firmware_flasher._portChangeTimer = null;
+    }
+
+    console.log(`${firmware_flasher.logHead} Port changed to:`, port);
+
+    if (GUI.connect_lock) {
+        console.log(`${firmware_flasher.logHead} Port change ignored during active operation (connect_lock set)`);
+        return;
+    }
+
+    // Auto-detect board when port changes and we're on firmware flasher tab
+    if (port && port !== "0" && $("input.flash_on_connect").is(":checked") === false && !STM32.rebootMode) {
+        console.log(`${firmware_flasher.logHead} Auto-detecting board for port change (debounced)`);
+
+        // Debounced verification: re-check connect lock when the timeout fires
+        firmware_flasher._portChangeTimer = setTimeout(() => {
+            firmware_flasher._portChangeTimer = null;
+            if (GUI.connect_lock) {
+                console.log(`${firmware_flasher.logHead} Skipping auto-detect due to active operation at timeout`);
+                return;
+            }
+            AutoDetect.verifyBoard();
+        }, PORT_CHANGE_DEBOUNCE_MS); // Small delay to ensure port is ready
+    } else if (!port || port === "0") {
+        if (!GUI.connect_lock) {
+            console.log(`${firmware_flasher.logHead} Clearing board selection - no port selected`);
+            $('select[name="board"]').val("0").trigger("change");
+        } else {
+            console.log(`${firmware_flasher.logHead} Not clearing board selection because operation in progress`);
+        }
+    }
+};
+
+firmware_flasher.onDeviceRemoved = function (devicePath) {
+    console.log(`${firmware_flasher.logHead} Device removed:`, devicePath);
+    $('select[name="board"]').val("0").trigger("change");
+    firmware_flasher.clearBufferedFirmware();
 };
 
 firmware_flasher.initialize = async function (callback) {
@@ -60,8 +153,6 @@ firmware_flasher.initialize = async function (callback) {
     self.intel_hex = undefined;
     self.parsed_hex = undefined;
 
-    self.logHead = "[FIRMWARE_FLASHER]";
-
     function getExtension(key) {
         if (!key) {
             return undefined;
@@ -742,20 +833,16 @@ firmware_flasher.initialize = async function (callback) {
             return output.join("").split("\n");
         }
 
-        function detectedUsbDevice(device) {
-            const isFlashOnConnect = $("input.flash_on_connect").is(":checked");
-
-            console.log(`${self.logHead} Detected USB device:`, device);
-            console.log(`${self.logHead} Reboot mode: %s, flash on connect`, STM32.rebootMode, isFlashOnConnect);
+        // Wire module-scoped handlers (defined above) into the instance once DOM is ready.
+        // Expose instance functions used by the module handlers.
+        firmware_flasher.clearBufferedFirmware = clearBufferedFirmware;
 
-            if (STM32.rebootMode || isFlashOnConnect) {
-                STM32.rebootMode = 0;
-                GUI.connect_lock = false;
-                startFlashing();
-            }
-        }
+        // startFlashing implementation will be registered after its declaration below.
 
-        EventBus.$on("port-handler:auto-select-usb-device", detectedUsbDevice);
+        EventBus.$on("port-handler:auto-select-usb-device", firmware_flasher.detectedUsbDevice);
+        EventBus.$on("port-handler:auto-select-serial-device", firmware_flasher.detectedSerialDevice);
+        EventBus.$on("ports-input:change", firmware_flasher.onPortChange);
+        EventBus.$on("port-handler:device-removed", firmware_flasher.onDeviceRemoved);
 
         async function saveFirmware() {
             const fileType = self.firmware_type;
@@ -1389,6 +1476,11 @@ firmware_flasher.initialize = async function (callback) {
             }
         }
 
+        // Register the implementation so the module-level entrypoint can call it.
+        // Assign the concrete implementation directly (bound to this instance)
+        // so callers can invoke `firmware_flasher.startFlashing()` without a trampoline.
+        firmware_flasher.startFlashing = startFlashing.bind(self);
+
         $("a.flash_firmware").on("click", async function () {
             if (GUI.connect_lock) {
                 return;
@@ -1472,6 +1564,17 @@ firmware_flasher.initialize = async function (callback) {
             $("a.exit_dfu").removeClass("disabled");
         }
 
+        // Auto-detect board if drone is already connected when tab becomes active
+        if (
+            (PortHandler.portAvailable && !$('select[name="board"]').val()) ||
+            $('select[name="board"]').val() === "0"
+        ) {
+            console.log(`${self.logHead} Auto-detecting board for already connected device`);
+            setTimeout(() => {
+                AutoDetect.verifyBoard();
+            }, 1000); // Small delay to ensure tab is fully loaded
+        }
+
         GUI.content_ready(callback);
     }
 
@@ -1490,6 +1593,24 @@ firmware_flasher.cleanup = function (callback) {
     $(document).unbind("keypress");
     $(document).off("click", "span.progressLabel a");
 
+    const cleanupHandler = (evt, property) => {
+        const handler = firmware_flasher[property];
+        if (handler) {
+            EventBus.$off(evt, handler);
+        }
+    };
+
+    cleanupHandler("port-handler:auto-select-usb-device", "detectedUsbDevice");
+    cleanupHandler("port-handler:auto-select-serial-device", "detectedSerialDevice");
+    cleanupHandler("ports-input:change", "onPortChange");
+    cleanupHandler("port-handler:device-removed", "onDeviceRemoved");
+
+    // Clear any pending debounce timer so it cannot fire after cleanup
+    if (firmware_flasher._portChangeTimer) {
+        clearTimeout(firmware_flasher._portChangeTimer);
+        firmware_flasher._portChangeTimer = null;
+    }
+
     if (callback) callback();
 };
 

test/js/msp/MSPHelper.test.js renamed to test/js/MSPHelper.test.js

@@ -1,9 +1,9 @@
 import { beforeEach, describe, expect, it } from "vitest";
-import MspHelper from "../../../src/js/msp/MSPHelper";
-import MSPCodes from "../../../src/js/msp/MSPCodes";
-import "../../../src/js/injected_methods";
-import FC from "../../../src/js/fc";
-import { API_VERSION_1_47 } from "../../../src/js/data_storage";
+import MspHelper from "../../src/js/msp/MSPHelper";
+import MSPCodes from "../../src/js/msp/MSPCodes";
+import "../../src/js/injected_methods";
+import FC from "../../src/js/fc";
+import { API_VERSION_1_47 } from "../../src/js/data_storage";
 
 describe("MspHelper", () => {
     const mspHelper = new MspHelper();
@@ -35,6 +35,61 @@ describe("MspHelper", () => {
 
             expect(callbackCalled).toEqual(true);
         });
+
+        it("passes crcError flag to callbacks when crcError is set", () => {
+            let received = null;
+
+            mspHelper.process_data({
+                code: MSPCodes.MSP_BOARD_INFO,
+                dataView: new DataView(new Uint8Array([]).buffer),
+                crcError: true,
+                callbacks: [
+                    {
+                        callback: (item) => {
+                            received = item;
+                        },
+                        code: MSPCodes.MSP_BOARD_INFO,
+                    },
+                ],
+            });
+
+            expect(received).not.toEqual(null);
+            expect(received.crcError).toEqual(true);
+            expect(received.command).toEqual(MSPCodes.MSP_BOARD_INFO);
+        });
+
+        it("passes full data and length to callbacks when crcError is set", () => {
+            let received = null;
+
+            const payload = new Uint8Array([1, 2, 3, 4]);
+            const dv = new DataView(payload.buffer);
+
+            mspHelper.process_data({
+                code: MSPCodes.MSP_BOARD_INFO,
+                dataView: dv,
+                crcError: true,
+                callbacks: [
+                    {
+                        callback: (item) => {
+                            received = item;
+                        },
+                        code: MSPCodes.MSP_BOARD_INFO,
+                    },
+                ],
+            });
+
+            expect(received).not.toEqual(null);
+            expect(received.length).toEqual(dv.byteLength);
+            expect(received.data instanceof DataView).toEqual(true);
+
+            const receivedBytes = new Uint8Array(
+                received.data.buffer,
+                received.data.byteOffset,
+                received.data.byteLength,
+            );
+            expect(Array.from(receivedBytes)).toEqual(Array.from(payload));
+        });
+
         it("handles MSP_API_VERSION correctly", () => {
             let randomValues = crypto.getRandomValues(new Uint8Array(3));
             const [mspProtocolVersion, apiVersionMajor, apiVersionMinor] = randomValues;
@@ -48,6 +103,7 @@ describe("MspHelper", () => {
             expect(FC.CONFIG.mspProtocolVersion).toEqual(mspProtocolVersion);
             expect(FC.CONFIG.apiVersion).toEqual(`${apiVersionMajor}.${apiVersionMinor}.0`);
         });
+
         it("handles MSP_PIDNAMES correctly", () => {
             let pidNamesCount = 1 + crypto.getRandomValues(new Uint8Array(1))[0];
             let expectedNames = Array.from({ length: pidNamesCount }).map((_) => generateRandomString());
@@ -64,6 +120,7 @@ describe("MspHelper", () => {
 
             expect(FC.PID_NAMES).toEqual(expectedNames);
         });
+
         it("handles MSP_MOTOR correctly", () => {
             let motorCount = crypto.getRandomValues(new Uint8Array(1))[0] % 8;
             let motorBytes = crypto.getRandomValues(new Uint16Array(motorCount));
@@ -77,6 +134,7 @@ describe("MspHelper", () => {
             expect(new Uint16Array(FC.MOTOR_DATA).slice(0, motorCount)).toEqual(motorBytes);
             expect(FC.MOTOR_DATA.slice(motorCount, 8)).toContain(undefined);
         });
+
         it("handles MSP_BOARD_INFO correctly for API version", () => {
             FC.CONFIG.apiVersion = API_VERSION_1_47;
             let infoBuffer = [];