From ac27e8f5c1e0c4372bd7ae5dfd43de6a30fb750e Mon Sep 17 00:00:00 2001
From: Mark Haslinghuis <mark@numloq.nl>
Date: Mon, 3 Jun 2024 18:24:47 +0200
Subject: [PATCH] Add web API support for flashing (#3996)

* add web API support for flashing

* Fixes per review

* Refactor some function
---
 src/js/msp/MSPConnector.js      |  112 +--
 src/js/port_handler.js          |  104 +--
 src/js/protocols/stm32.js       |  903 ------------------------
 src/js/protocols/stm32usbdfu.js | 1164 -------------------------------
 src/js/protocols/webstm32.js    |  953 +++++++++++++++++++++++++
 src/js/tabs/firmware_flasher.js |   67 +-
 src/js/usb_shim.js              |    5 -
 7 files changed, 1067 insertions(+), 2241 deletions(-)
 delete mode 100644 src/js/protocols/stm32.js
 delete mode 100644 src/js/protocols/stm32usbdfu.js
 create mode 100644 src/js/protocols/webstm32.js
 delete mode 100644 src/js/usb_shim.js

diff --git a/src/js/msp/MSPConnector.js b/src/js/msp/MSPConnector.js
index 92b65a5ab4..d69ce0d853 100644
--- a/src/js/msp/MSPConnector.js
+++ b/src/js/msp/MSPConnector.js
@@ -6,43 +6,40 @@ import MSP from "../msp";
 import FC from "../fc";
 import MSPCodes from "./MSPCodes";
 import CONFIGURATOR from "../data_storage";
-import serial from "../serial";
+import serial from "../webSerial";
 import { gui_log } from "../gui_log";
 
 /**
  * This seems to be mainly used in firmware flasher parts.
  */
-const MSPConnectorImpl = function () {
-    this.baud = undefined;
-    this.port = undefined;
-    this.onConnectCallback = undefined;
-    this.onTimeoutCallback = undefined;
-    this.onDisconnectCallback = undefined;
-};
-
-MSPConnectorImpl.prototype.connect = function (port, baud, onConnectCallback, onTimeoutCallback, onFailureCallback) {
-
-    const self = this;
-    self.port = port;
-    self.baud = baud;
-    self.onConnectCallback = onConnectCallback;
-    self.onTimeoutCallback = onTimeoutCallback;
-    self.onFailureCallback = onFailureCallback;
-
-    serial.connect(self.port, {bitrate: self.baud}, function (openInfo) {
-        if (openInfo) {
-            const disconnectAndCleanup = function() {
-                serial.disconnect(function(result) {
-                    console.log('Disconnected');
 
-                    MSP.clearListeners();
+function readSerialAdapter(e) {
+    read_serial(e.detail.buffer);
+}
 
-                    self.onTimeoutCallback();
-                });
+function disconnectAndCleanup() {
+    serial.disconnect((result) => {
+        console.log('Disconnected', result);
 
-                MSP.disconnect_cleanup();
-            };
+        MSP.clearListeners();
 
+        this.onTimeoutCallback();
+    });
+
+    MSP.disconnect_cleanup();
+}
+
+class MSPConnectorImpl {
+    constructor() {
+        this.baud = undefined;
+        this.port = undefined;
+        this.onConnectCallback = undefined;
+        this.onTimeoutCallback = undefined;
+        this.onDisconnectCallback = undefined;
+    }
+
+    handleConnect(openInfo) {
+        if (openInfo) {
             FC.resetState();
 
             // disconnect after 10 seconds with error if we don't get IDENT data
@@ -54,37 +51,68 @@ MSPConnectorImpl.prototype.connect = function (port, baud, onConnectCallback, on
                 }
             }, 10000);
 
-            serial.onReceive.addListener(read_serial);
+            serial.removeEventListener('receive', readSerialAdapter);
+            serial.addEventListener('receive', readSerialAdapter);
 
             const mspHelper = new MspHelper();
             MSP.listen(mspHelper.process_data.bind(mspHelper));
 
-            MSP.send_message(MSPCodes.MSP_API_VERSION, false, false, function () {
+            MSP.send_message(MSPCodes.MSP_API_VERSION, false, false, () => {
                 CONFIGURATOR.connectionValid = true;
 
                 GUI.timeout_remove('msp_connector');
                 console.log('Connected');
 
-                self.onConnectCallback();
+                this.onConnectCallback();
             });
         } else {
             gui_log(i18n.getMessage('serialPortOpenFail'));
-            self.onFailureCallback();
+            this.onFailureCallback();
         }
-    });
-};
+    }
+
+    handleDisconnect (detail) {
+        console.log('Disconnected', detail);
+
+        serial.removeEventListener('receive', readSerialAdapter);
 
-MSPConnectorImpl.prototype.disconnect = function(onDisconnectCallback) {
-    self.onDisconnectCallback = onDisconnectCallback;
+        // Calling in case event listeners were not removed
+        serial.removeEventListener('connect', (e) => this.handleConnect(e.detail));
+        serial.removeEventListener('disconnect', (e) => this.handleDisconnect(e));
 
-    serial.disconnect(function (result) {
         MSP.clearListeners();
-        console.log('Disconnected');
+        MSP.disconnect_cleanup();
+    }
 
-        self.onDisconnectCallback(result);
-    });
+    connect(port, baud, onConnectCallback, onTimeoutCallback, onFailureCallback) {
 
-    MSP.disconnect_cleanup();
-};
+        this.port = port;
+        this.baud = baud;
+        this.onConnectCallback = onConnectCallback;
+        this.onTimeoutCallback = onTimeoutCallback;
+        this.onFailureCallback = onFailureCallback;
+
+        serial.removeEventListener('connect', (e) => this.handleConnect(e.detail));
+        serial.addEventListener('connect', (e) => this.handleConnect(e.detail), { once: true });
+
+        serial.removeEventListener('disconnect', (e) => this.handleDisconnect(e));
+        serial.addEventListener('disconnect', (e) => this.handleDisconnect(e), { once: true });
+
+        serial.connect(this.port, { baudRate: this.baud });
+    }
+
+    disconnect(onDisconnectCallback) {
+        this.onDisconnectCallback = onDisconnectCallback;
+
+        serial.disconnect((result) => {
+            MSP.clearListeners();
+            console.log('Disconnected', result);
+
+            this.onDisconnectCallback(result);
+        });
+
+        MSP.disconnect_cleanup();
+    }
+}
 
 export default MSPConnectorImpl;
diff --git a/src/js/port_handler.js b/src/js/port_handler.js
index 7ebb3ec6a5..80233bf426 100644
--- a/src/js/port_handler.js
+++ b/src/js/port_handler.js
@@ -1,15 +1,7 @@
-import GUI from "./gui";
-import FC from "./fc";
-import { i18n } from "./localization";
 import { get as getConfig } from "./ConfigStorage";
-import { isWeb } from "./utils/isWeb";
-import { usbDevices } from "./usb_devices";
-import { serialShim } from "./serial_shim.js";
-import { usbShim } from "./usb_shim.js";
 import { EventBus } from "../components/eventBus";
-
-const serial = serialShim();
-const usb = usbShim();
+import serial from "./webSerial";
+import usb from "./protocols/webusbdfu";
 
 const DEFAULT_PORT = 'noselection';
 const DEFAULT_BAUDS = 115200;
@@ -92,22 +84,18 @@ PortHandler.onChangeSelectedPort = function(port) {
     this.portPicker.selectedPort = port;
 };
 
-PortHandler.updateCurrentSerialPortsList = function () {
-    return serial.getDevices()
-    .then((ports) => {
-        const orderedPorts = this.sortPorts(ports);
-        this.portAvailable = orderedPorts.length > 0;
-        this.currentSerialPorts = orderedPorts;
-    });
+PortHandler.updateCurrentSerialPortsList = async function () {
+    const ports = await serial.getDevices();
+    const orderedPorts = this.sortPorts(ports);
+    this.portAvailable = orderedPorts.length > 0;
+    this.currentSerialPorts = orderedPorts;
 };
 
-PortHandler.updateCurrentUsbPortsList = function () {
-    return usb.getDevices()
-    .then((ports) => {
-        const orderedPorts = this.sortPorts(ports);
-        this.dfuAvailable = orderedPorts.length > 0;
-        this.currentUsbPorts = orderedPorts;
-    });
+PortHandler.updateCurrentUsbPortsList = async function () {
+    const ports = await usb.getDevices();
+    const orderedPorts = this.sortPorts(ports);
+    this.dfuAvailable = orderedPorts.length > 0;
+    this.currentUsbPorts = orderedPorts;
 };
 
 PortHandler.sortPorts = function(ports) {
@@ -149,7 +137,7 @@ PortHandler.selectActivePort = function(suggestedDevice) {
         selectedPort = suggestedDevice.path;
     }
 
-    // Return some serial port that is recognized by the filter
+    // Return some usb port that is recognized by the filter
     if (!selectedPort) {
         selectedPort = this.currentUsbPorts.find(device => deviceFilter.some(filter => device.displayName.includes(filter)));
         if (selectedPort) {
@@ -157,7 +145,7 @@ PortHandler.selectActivePort = function(suggestedDevice) {
         }
     }
 
-    // Return some usb port that is recognized by the filter
+    // Return some serial port that is recognized by the filter
     if (!selectedPort) {
         selectedPort = this.currentSerialPorts.find(device => deviceFilter.some(filter => device.displayName.includes(filter)));
         if (selectedPort) {
@@ -186,70 +174,6 @@ PortHandler.selectActivePort = function(suggestedDevice) {
 // TODO all the methods from here need to be refactored or removed
 ************************************/
 
-PortHandler.check_usb_devices = function (callback) {
-
-    // TODO needs USB code refactor for web
-    if (isWeb()) {
-        return;
-    }
-
-    const self = this;
-
-    chrome.usb.getDevices(usbDevices, function (result) {
-
-        const dfuElement = self.portPickerElement.children("[value='DFU']");
-        if (result.length) {
-            // Found device in DFU mode, add it to the list
-            if (!dfuElement.length) {
-                self.portPickerElement.empty();
-
-                const productName = result[0].productName;
-                const usbText = productName ? `DFU - ${productName}` : 'DFU';
-
-                self.portPickerElement.append($('<option/>', {
-                    value: "DFU",
-                    text: usbText,
-                    /**
-                     * @deprecated please avoid using `isDFU` and friends for new code.
-                     */
-                    data: {isDFU: true},
-                }));
-
-                self.portPickerElement.append($('<option/>', {
-                    value: DEFAULT_PORT,
-                    text: i18n.getMessage('portsSelectManual'),
-                    /**
-                     * @deprecated please avoid using `isDFU` and friends for new code.
-                     */
-                    data: {isManual: true},
-                }));
-
-                self.portPickerElement.val('DFU').trigger('change');
-                self.setPortsInputWidth();
-                self.dfuAvailable = true;
-            }
-        } else if (dfuElement.length) {
-            dfuElement.remove();
-            self.setPortsInputWidth();
-            self.dfuAvailable = false;
-
-            if ($('option:selected', self.portPickerElement).val() !== 'DFU') {
-                if (!(GUI.connected_to || GUI.connect_lock)) {
-                    FC.resetState();
-                }
-
-                if (self.dfuAvailable) {
-                    self.portPickerElement.trigger('change');
-                }
-            }
-        }
-
-        if (callback) {
-            callback(self.dfuAvailable);
-        }
-    });
-};
-
 PortHandler.flush_callbacks = function () {
     let killed = 0;
 
diff --git a/src/js/protocols/stm32.js b/src/js/protocols/stm32.js
deleted file mode 100644
index a6d5437ac3..0000000000
--- a/src/js/protocols/stm32.js
+++ /dev/null
@@ -1,903 +0,0 @@
-/*
-    STM32 F103 serial bus seems to properly initialize with quite a huge auto-baud range
-    From 921600 down to 1200, i don't recommend getting any lower then that
-    Official "specs" are from 115200 to 1200
-
-    popular choices - 921600, 460800, 256000, 230400, 153600, 128000, 115200, 57600, 38400, 28800, 19200
-*/
-import MSPConnectorImpl from "../msp/MSPConnector";
-import GUI, { TABS } from "../gui";
-import { i18n } from "../localization";
-import MSP from "../msp";
-import FC from "../fc";
-import { bit_check } from "../bit";
-import { gui_log } from "../gui_log";
-import MSPCodes from "../msp/MSPCodes";
-import PortUsage from "../port_usage";
-import PortHandler from "../port_handler";
-import { API_VERSION_1_42 } from "../data_storage";
-import semver from "semver";
-import $ from 'jquery';
-
-import { usbDevices } from "../usb_devices";
-import { serialShim } from "../serial_shim";
-import { usbShim } from "../usb_shim";
-
-let serial = serialShim();
-let dfu = usbShim();
-
-const STM32_protocol = function () {
-    this.baud = null;
-    this.options = {};
-    this.callback = null;
-    this.hex = null;
-    this.verify_hex = [];
-
-    this.receive_buffer = [];
-
-    this.bytesToRead = 0;
-    this.read_callback = null;
-
-    this.upload_time_start = 0;
-    this.upload_process_alive = false;
-
-    this.msp_connector = new MSPConnectorImpl();
-
-    this.status = {
-        ACK:    0x79, // y
-        NACK:   0x1F,
-    };
-
-    this.command = {
-        get:                    0x00, // Gets the version and the allowed commands supported by the current version of the bootloader
-        get_ver_r_protect_s:    0x01, // Gets the bootloader version and the Read Protection status of the Flash memory
-        get_ID:                 0x02, // Gets the chip ID
-        read_memory:            0x11, // Reads up to 256 bytes of memory starting from an address specified by the application
-        go:                     0x21, // Jumps to user application code located in the internal Flash memory or in SRAM
-        write_memory:           0x31, // Writes up to 256 bytes to the RAM or Flash memory starting from an address specified by the application
-        erase:                  0x43, // Erases from one to all the Flash memory pages
-        extended_erase:         0x44, // Erases from one to all the Flash memory pages using two byte addressing mode (v3.0+ usart).
-        write_protect:          0x63, // Enables the write protection for some sectors
-        write_unprotect:        0x73, // Disables the write protection for all Flash memory sectors
-        readout_protect:        0x82, // Enables the read protection
-        readout_unprotect:      0x92,  // Disables the read protection
-    };
-
-    // Erase (x043) and Extended Erase (0x44) are exclusive. A device may support either the Erase command or the Extended Erase command but not both.
-
-    this.available_flash_size = 0;
-    this.page_size = 0;
-    this.useExtendedErase = false;
-};
-
-// no input parameters
-STM32_protocol.prototype.connect = function (port, baud, hex, options, callback) {
-    const self = this;
-    self.hex = hex;
-    self.port = port;
-    self.baud = baud;
-    self.callback = callback;
-
-    // we will crunch the options here since doing it inside initialization routine would be too late
-    self.options = {
-        no_reboot:      false,
-        reboot_baud:    false,
-        erase_chip:     false,
-    };
-
-    if (options.no_reboot) {
-        self.options.no_reboot = true;
-    } else {
-        self.options.reboot_baud = options.reboot_baud;
-    }
-
-    if (options.erase_chip) {
-        self.options.erase_chip = true;
-    }
-
-    if (self.options.no_reboot) {
-        serial.connect(port, {bitrate: self.baud, parityBit: 'even', stopBits: 'one'}, function (openInfo) {
-            if (openInfo) {
-                // we are connected, disabling connect button in the UI
-                GUI.connect_lock = true;
-
-                self.initialize();
-            } else {
-                gui_log(i18n.getMessage('serialPortOpenFail'));
-            }
-        });
-    } else {
-
-        let rebootMode = 0; // FIRMWARE
-        const startFlashing = () => {
-            if (rebootMode === 0) {
-                return;
-            }
-
-            // refresh device list
-            PortHandler.check_usb_devices(function(dfu_available) {
-                if (dfu_available) {
-                    dfu.connect(usbDevices, hex, options);
-                } else {
-                    serial.connect(self.port, {bitrate: self.baud, parityBit: 'even', stopBits: 'one'}, function (openInfo) {
-                        if (openInfo) {
-                            self.initialize();
-                        } else {
-                            GUI.connect_lock = false;
-                            gui_log(i18n.getMessage('serialPortOpenFail'));
-                        }
-                    });
-                }
-            });
-        };
-
-        const onDisconnect = disconnectionResult => {
-            if (disconnectionResult) {
-                // wait until board boots into bootloader mode
-                // MacOs may need 5 seconds delay
-                function waitForDfu() {
-                    if (PortHandler.dfuAvailable) {
-                        console.log(`DFU available after ${failedAttempts / 10} seconds`);
-                        clearInterval(dfuWaitInterval);
-                        startFlashing();
-                    } else {
-                        failedAttempts++;
-                        if (failedAttempts > 100) {
-                            clearInterval(dfuWaitInterval);
-                            console.log(`failed to get DFU connection, gave up after 10 seconds`);
-                            gui_log(i18n.getMessage('serialPortOpenFail'));
-                            GUI.connect_lock = false;
-                        }
-                    }
-                }
-
-                let failedAttempts = 0;
-                const dfuWaitInterval = setInterval(waitForDfu, 100);
-            } else {
-                GUI.connect_lock = false;
-            }
-        };
-
-        const legacyRebootAndFlash = function() {
-            serial.connect(self.port, {bitrate: self.options.reboot_baud}, function (openInfo) {
-                if (!openInfo) {
-                    GUI.connect_lock = false;
-                    gui_log(i18n.getMessage('serialPortOpenFail'));
-                    return;
-                }
-
-                console.log('Using legacy reboot method');
-
-                console.log('Sending ascii "R" to reboot');
-                const bufferOut = new ArrayBuffer(1);
-                const bufferView = new Uint8Array(bufferOut);
-
-                bufferView[0] = 0x52;
-
-                serial.send(bufferOut, function () {
-                    serial.disconnect(disconnectionResult => onDisconnect(disconnectionResult));
-                });
-            });
-        };
-
-        const onConnectHandler = function () {
-
-            gui_log(i18n.getMessage('apiVersionReceived', [FC.CONFIG.apiVersion]));
-
-            if (semver.lt(FC.CONFIG.apiVersion, API_VERSION_1_42)) {
-                self.msp_connector.disconnect(function (disconnectionResult) {
-
-                    // need some time for the port to be closed, serial port does not open if tried immediately
-                    setTimeout(legacyRebootAndFlash, 500);
-                });
-            } else {
-                console.log('Looking for capabilities via MSP');
-
-                MSP.send_message(MSPCodes.MSP_BOARD_INFO, false, false, () => {
-                    if (bit_check(FC.CONFIG.targetCapabilities, FC.TARGET_CAPABILITIES_FLAGS.HAS_FLASH_BOOTLOADER)) {
-                        // Board has flash bootloader
-                        gui_log(i18n.getMessage('deviceRebooting_flashBootloader'));
-                        console.log('flash bootloader detected');
-                        rebootMode = 4; // MSP_REBOOT_BOOTLOADER_FLASH
-                    } else {
-                        gui_log(i18n.getMessage('deviceRebooting_romBootloader'));
-                        console.log('no flash bootloader detected');
-                        rebootMode = 1; // MSP_REBOOT_BOOTLOADER_ROM;
-                    }
-
-                    const selectedBoard = TABS.firmware_flasher.selectedBoard !== '0' ? TABS.firmware_flasher.selectedBoard : 'NONE';
-                    const connectedBoard = FC.CONFIG.boardName ? FC.CONFIG.boardName : 'UNKNOWN';
-
-                    function reboot() {
-                        const buffer = [];
-                        buffer.push8(rebootMode);
-                        setTimeout(() => {
-                            MSP.send_message(MSPCodes.MSP_SET_REBOOT, buffer, () => {
-                                // if firmware doesn't flush MSP/serial send buffers and gracefully shutdown VCP connections we won't get a reply, so don't wait for it.
-                                self.msp_connector.disconnect(disconnectionResult => onDisconnect(disconnectionResult));
-                                console.log('Reboot request received by device');
-                            });
-                        }, 100);
-                    }
-
-                    function onAbort() {
-                        GUI.connect_lock = false;
-                        rebootMode = 0;
-                        console.log('User cancelled because selected target does not match verified board');
-                        reboot();
-                        TABS.firmware_flasher.refresh();
-                    }
-
-                    if (selectedBoard !== connectedBoard && !TABS.firmware_flasher.localFirmwareLoaded) {
-                        TABS.firmware_flasher.showDialogVerifyBoard(selectedBoard, connectedBoard, onAbort, reboot);
-                    } else {
-                        reboot();
-                    }
-                });
-            }
-        };
-
-        const onTimeoutHandler = function() {
-            GUI.connect_lock = false;
-            console.log('Looking for capabilities via MSP failed');
-
-            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32RebootingToBootloaderFailed'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
-        };
-
-        const onFailureHandler = function() {
-            GUI.connect_lock = false;
-            TABS.firmware_flasher.refresh();
-        };
-
-        GUI.connect_lock = true;
-        TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32RebootingToBootloader'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
-
-        self.msp_connector.connect(self.port, self.options.reboot_baud, onConnectHandler, onTimeoutHandler, onFailureHandler);
-    }
-};
-
-// initialize certain variables and start timers that oversee the communication
-STM32_protocol.prototype.initialize = function () {
-    const self = this;
-
-    // reset and set some variables before we start
-    self.receive_buffer = [];
-    self.verify_hex = [];
-
-    self.upload_time_start = new Date().getTime();
-    self.upload_process_alive = false;
-
-    // reset progress bar to initial state
-    TABS.firmware_flasher.flashingMessage(null, TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL)
-                         .flashProgress(0);
-
-    // lock some UI elements TODO needs rework
-    $('select[name="release"]').prop('disabled', true);
-
-    serial.onReceive.addListener(function (info) {
-        self.read(info);
-    });
-
-    GUI.interval_add('STM32_timeout', function () {
-        if (self.upload_process_alive) { // process is running
-            self.upload_process_alive = false;
-        } else {
-            console.log('STM32 - timed out, programming failed ...');
-
-            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32TimedOut'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
-
-            // protocol got stuck, clear timer and disconnect
-            GUI.interval_remove('STM32_timeout');
-
-            // exit
-            self.upload_procedure(99);
-        }
-    }, 2000);
-
-    self.upload_procedure(1);
-};
-
-// no input parameters
-// this method should be executed every 1 ms via interval timer
-STM32_protocol.prototype.read = function (readInfo) {
-    // routine that fills the buffer
-    const data = new Uint8Array(readInfo.data);
-
-    for (const instance of data) {
-        this.receive_buffer.push(instance);
-    }
-
-    // routine that fetches data from buffer if statement is true
-    if (this.receive_buffer.length >= this.bytesToRead && this.bytesToRead != 0) {
-        const fetched = this.receive_buffer.slice(0, this.bytesToRead); // bytes requested
-        this.receive_buffer.splice(0, this.bytesToRead); // remove read bytes
-
-        this.bytesToRead = 0; // reset trigger
-
-        this.read_callback(fetched);
-    }
-};
-
-// we should always try to consume all "proper" available data while using retrieve
-STM32_protocol.prototype.retrieve = function (nBytes, callback) {
-    if (this.receive_buffer.length >= nBytes) {
-        // data that we need are there, process immediately
-        const data = this.receive_buffer.slice(0, nBytes);
-        this.receive_buffer.splice(0, nBytes); // remove read bytes
-
-        callback(data);
-    } else {
-        // still waiting for data, add callback
-        this.bytesToRead = nBytes;
-        this.read_callback = callback;
-    }
-};
-
-// bytes_to_send = array of bytes that will be send over serial
-// bytesToRead = received bytes necessary to trigger read_callback
-// callback = function that will be executed after received bytes = bytesToRead
-STM32_protocol.prototype.send = function (bytes_to_send, bytesToRead, callback) {
-    // flip flag
-    this.upload_process_alive = true;
-
-    const bufferOut = new ArrayBuffer(bytes_to_send.length);
-    const bufferView = new Uint8Array(bufferOut);
-
-    // set bytes_to_send values inside bufferView (alternative to for loop)
-    bufferView.set(bytes_to_send);
-
-    // update references
-    this.bytesToRead = bytesToRead;
-    this.read_callback = callback;
-
-    // empty receive buffer before next command is out
-    this.receive_buffer = [];
-
-    // send over the actual data
-    serial.send(bufferOut);
-};
-
-// val = single byte to be verified
-// data = response of n bytes from mcu (array)
-// result = true/false
-STM32_protocol.prototype.verify_response = function (val, data) {
-
-    if (val !== data[0]) {
-        const message = `STM32 Communication failed, wrong response, expected: ${val} (0x${val.toString(16)}) received: ${data[0]} (0x${data[0].toString(16)})`;
-        console.error(message);
-        TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32WrongResponse',[val, val.toString(16), data[0], data[0].toString(16)]), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
-
-        // disconnect
-        this.upload_procedure(99);
-
-        return false;
-    }
-
-    return true;
-};
-
-// input = 16 bit value
-// result = true/false
-STM32_protocol.prototype.verify_chip_signature = function (signature) {
-    switch (signature) {
-        case 0x412: // not tested
-            console.log('Chip recognized as F1 Low-density');
-            break;
-        case 0x410:
-            console.log('Chip recognized as F1 Medium-density');
-            this.available_flash_size = 131072;
-            this.page_size = 1024;
-            break;
-        case 0x414:
-            this.available_flash_size =  0x40000;
-            this.page_size = 2048;
-            console.log('Chip recognized as F1 High-density');
-            break;
-        case 0x418: // not tested
-            console.log('Chip recognized as F1 Connectivity line');
-            break;
-        case 0x420:  // not tested
-            console.log('Chip recognized as F1 Medium-density value line');
-            break;
-        case 0x428: // not tested
-            console.log('Chip recognized as F1 High-density value line');
-            break;
-        case 0x430: // not tested
-            console.log('Chip recognized as F1 XL-density value line');
-            break;
-        case 0x416: // not tested
-            console.log('Chip recognized as L1 Medium-density ultralow power');
-            break;
-        case 0x436: // not tested
-            console.log('Chip recognized as L1 High-density ultralow power');
-            break;
-        case 0x427: // not tested
-            console.log('Chip recognized as L1 Medium-density plus ultralow power');
-            break;
-        case 0x411: // not tested
-            console.log('Chip recognized as F2 STM32F2xxxx');
-            break;
-        case 0x440: // not tested
-            console.log('Chip recognized as F0 STM32F051xx');
-            break;
-        case 0x444: // not tested
-            console.log('Chip recognized as F0 STM32F050xx');
-            break;
-        case 0x413: // not tested
-            console.log('Chip recognized as F4 STM32F40xxx/41xxx');
-            break;
-        case 0x419: // not tested
-            console.log('Chip recognized as F4 STM32F427xx/437xx, STM32F429xx/439xx');
-            break;
-        case 0x432: // not tested
-            console.log('Chip recognized as F3 STM32F37xxx, STM32F38xxx');
-            break;
-        case 0x422:
-            console.log('Chip recognized as F3 STM32F30xxx, STM32F31xxx');
-            this.available_flash_size =  0x40000;
-            this.page_size = 2048;
-            break;
-    }
-
-    if (this.available_flash_size > 0) {
-        if (this.hex.bytes_total < this.available_flash_size) {
-            return true;
-        } else {
-            console.log(`Supplied hex is bigger then flash available on the chip, HEX: ${this.hex.bytes_total} bytes, limit = ${this.available_flash_size} bytes`);
-            return false;
-        }
-    }
-
-    console.log(`Chip NOT recognized: ${signature}`);
-
-    return false;
-};
-
-// firstArray = usually hex_to_flash array
-// secondArray = usually verify_hex array
-// result = true/false
-STM32_protocol.prototype.verify_flash = function (firstArray, secondArray) {
-    for (let i = 0; i < firstArray.length; i++) {
-        if (firstArray[i] !== secondArray[i]) {
-            console.log(`Verification failed on byte: ${i} expected: 0x${firstArray[i].toString(16)} received: 0x${secondArray[i].toString(16)}`);
-            return false;
-        }
-    }
-
-    console.log(`Verification successful, matching: ${firstArray.length} bytes`);
-
-    return true;
-};
-
-// step = value depending on current state of upload_procedure
-STM32_protocol.prototype.upload_procedure = function (step) {
-    const self = this;
-
-    switch (step) {
-        case 1:
-            // initialize serial interface on the MCU side, auto baud rate settings
-            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ContactingBootloader'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
-
-            let sendCounter = 0;
-            GUI.interval_add('stm32_initialize_mcu', function () { // 200 ms interval (just in case mcu was already initialized), we need to break the 2 bytes command requirement
-                self.send([0x7F], 1, function (reply) {
-                    if (reply[0] === 0x7F || reply[0] === self.status.ACK || reply[0] === self.status.NACK) {
-                        GUI.interval_remove('stm32_initialize_mcu');
-                        console.log('STM32 - Serial interface initialized on the MCU side');
-
-                        // proceed to next step
-                        self.upload_procedure(2);
-                    } else {
-                        TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ContactingBootloaderFailed'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
-
-                        GUI.interval_remove('stm32_initialize_mcu');
-
-                        // disconnect
-                        self.upload_procedure(99);
-                    }
-                });
-
-                if (sendCounter++ > 3) {
-                    // stop retrying, its too late to get any response from MCU
-                    console.log('STM32 - no response from bootloader, disconnecting');
-
-                    TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ResponseBootloaderFailed'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
-
-                    GUI.interval_remove('stm32_initialize_mcu');
-                    GUI.interval_remove('STM32_timeout');
-
-                    // exit
-                    self.upload_procedure(99);
-                }
-            }, 250, true);
-
-            break;
-        case 2:
-            // get version of the bootloader and supported commands
-            self.send([self.command.get, 0xFF], 2, function (data) { // 0x00 ^ 0xFF
-                if (self.verify_response(self.status.ACK, data)) {
-                    self.retrieve(data[1] + 1 + 1, function (data) { // data[1] = number of bytes that will follow [– 1 except current and ACKs]
-                        console.log(`STM32 - Bootloader version: ${(parseInt(data[0].toString(16)) / 10).toFixed(1)}`); // convert dec to hex, hex to dec and add floating point
-
-                        self.useExtendedErase = (data[7] === self.command.extended_erase);
-
-                        // proceed to next step
-                        self.upload_procedure(3);
-                    });
-                }
-            });
-
-            break;
-        case 3:
-            // get ID (device signature)
-            self.send([self.command.get_ID, 0xFD], 2, function (data) { // 0x01 ^ 0xFF
-                if (self.verify_response(self.status.ACK, data)) {
-                    self.retrieve(data[1] + 1 + 1, function (data) { // data[1] = number of bytes that will follow [– 1 (N = 1 for STM32), except for current byte and ACKs]
-                        const signature = (data[0] << 8) | data[1];
-                        console.log(`STM32 - Signature: 0x${signature.toString(16)}`); // signature in hex representation
-
-                        if (self.verify_chip_signature(signature)) {
-                            // proceed to next step
-                            self.upload_procedure(4);
-                        } else {
-                            // disconnect
-                            self.upload_procedure(99);
-                        }
-                    });
-                }
-            });
-
-            break;
-        case 4:
-            // erase memory
-
-            if (self.useExtendedErase) {
-                if (self.options.erase_chip) {
-
-                    const message = 'Executing global chip erase (via extended erase)';
-                    console.log(message);
-                    TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32GlobalEraseExtended'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
-
-                    self.send([self.command.extended_erase, 0xBB], 1, function (reply) {
-                        if (self.verify_response(self.status.ACK, reply)) {
-                            self.send( [0xFF, 0xFF, 0x00], 1, function (reply) {
-                                if (self.verify_response(self.status.ACK, reply)) {
-                                    console.log('Executing global chip extended erase: done');
-                                    self.upload_procedure(5);
-                                }
-                            });
-                        }
-                    });
-
-                } else {
-                    const message = 'Executing local erase (via extended erase)';
-                    console.log(message);
-                    TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32LocalEraseExtended'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
-
-                    self.send([self.command.extended_erase, 0xBB], 1, function (reply) {
-                        if (self.verify_response(self.status.ACK, reply)) {
-
-                            // For reference: https://code.google.com/p/stm32flash/source/browse/stm32.c#723
-
-                            const maxAddress = self.hex.data[self.hex.data.length - 1].address + self.hex.data[self.hex.data.length - 1].bytes - 0x8000000;
-                            const erasePagesN = Math.ceil(maxAddress / self.page_size);
-                            const buff = [];
-                            let checksum = 0;
-
-                            let pgByte;
-
-                            pgByte = (erasePagesN - 1) >> 8;
-                            buff.push(pgByte);
-                            checksum ^= pgByte;
-                            pgByte = (erasePagesN - 1) & 0xFF;
-                            buff.push(pgByte);
-                            checksum ^= pgByte;
-
-
-                            for (let i = 0; i < erasePagesN; i++) {
-                                pgByte = i >> 8;
-                                buff.push(pgByte);
-                                checksum ^= pgByte;
-                                pgByte = i & 0xFF;
-                                buff.push(pgByte);
-                                checksum ^= pgByte;
-                            }
-
-                            buff.push(checksum);
-                            console.log(`Erasing. pages: 0x00 - 0x${erasePagesN.toString(16)}, checksum: 0x${checksum.toString(16)}`);
-
-                            self.send(buff, 1, function (_reply) {
-                                if (self.verify_response(self.status.ACK, _reply)) {
-                                    console.log('Erasing: done');
-                                    // proceed to next step
-                                    self.upload_procedure(5);
-                                }
-                            });
-                        }
-                    });
-
-
-                }
-                break;
-            }
-
-            if (self.options.erase_chip) {
-                const message = 'Executing global chip erase' ;
-                console.log(message);
-                TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32GlobalErase'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
-
-                self.send([self.command.erase, 0xBC], 1, function (reply) { // 0x43 ^ 0xFF
-                    if (self.verify_response(self.status.ACK, reply)) {
-                        self.send([0xFF, 0x00], 1, function (reply) {
-                            if (self.verify_response(self.status.ACK, reply)) {
-                                console.log('Erasing: done');
-                                // proceed to next step
-                                self.upload_procedure(5);
-                            }
-                        });
-                    }
-                });
-            } else {
-                const message = 'Executing local erase';
-                console.log(message);
-                TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32LocalErase'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
-
-                self.send([self.command.erase, 0xBC], 1, function (reply) { // 0x43 ^ 0xFF
-                    if (self.verify_response(self.status.ACK, reply)) {
-                        // the bootloader receives one byte that contains N, the number of pages to be erased – 1
-                        const maxAddress = self.hex.data[self.hex.data.length - 1].address + self.hex.data[self.hex.data.length - 1].bytes - 0x8000000;
-                        const erasePagesN = Math.ceil(maxAddress / self.page_size);
-                        const buff = [];
-                        let checksum = erasePagesN - 1;
-
-                        buff.push(erasePagesN - 1);
-
-                        for (let ii = 0; ii < erasePagesN; ii++) {
-                            buff.push(ii);
-                            checksum ^= ii;
-                        }
-
-                        buff.push(checksum);
-
-                        self.send(buff, 1, function (reply) {
-                            if (self.verify_response(self.status.ACK, reply)) {
-                                console.log('Erasing: done');
-                                // proceed to next step
-                                self.upload_procedure(5);
-                            }
-                        });
-                    }
-                });
-            }
-
-            break;
-        case 5:
-            // upload
-            console.log('Writing data ...');
-            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32Flashing'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
-
-            let blocks = self.hex.data.length - 1,
-                flashing_block = 0,
-                address = self.hex.data[flashing_block].address,
-                bytes_flashed = 0,
-                bytes_flashed_total = 0; // used for progress bar
-
-            const write = function () {
-                if (bytes_flashed < self.hex.data[flashing_block].bytes) {
-                    const bytesToWrite = ((bytes_flashed + 256) <= self.hex.data[flashing_block].bytes) ? 256 : (self.hex.data[flashing_block].bytes - bytes_flashed);
-
-                    // console.log('STM32 - Writing to: 0x' + address.toString(16) + ', ' + bytesToWrite + ' bytes');
-
-                    self.send([self.command.write_memory, 0xCE], 1, function (reply) { // 0x31 ^ 0xFF
-                        if (self.verify_response(self.status.ACK, reply)) {
-                            // address needs to be transmitted as 32 bit integer, we need to bit shift each byte out and then calculate address checksum
-                            const addressArray = [(address >> 24), (address >> 16), (address >> 8), address];
-                            const addressChecksum = addressArray[0] ^ addressArray[1] ^ addressArray[2] ^ addressArray[3];
-                            // write start address + checksum
-                            self.send([addressArray[0], addressArray[1], addressArray[2], addressArray[3], addressChecksum], 1, function (_reply) {
-                                if (self.verify_response(self.status.ACK, _reply)) {
-                                    const arrayOut = Array.from(bytesToWrite + 2); // 2 byte overhead [N, ...., checksum]
-                                    arrayOut[0] = bytesToWrite - 1; // number of bytes to be written (to write 128 bytes, N must be 127, to write 256 bytes, N must be 255)
-
-                                    let checksum = arrayOut[0];
-                                    for (let ii = 0; ii < bytesToWrite; ii++) {
-                                        arrayOut[ii + 1] = self.hex.data[flashing_block].data[bytes_flashed]; // + 1 because of the first byte offset
-                                        checksum ^= self.hex.data[flashing_block].data[bytes_flashed];
-
-                                        bytes_flashed++;
-                                    }
-                                    arrayOut[arrayOut.length - 1] = checksum; // checksum (last byte in the arrayOut array)
-
-                                    address += bytesToWrite;
-                                    bytes_flashed_total += bytesToWrite;
-
-                                    self.send(arrayOut, 1, function (response) {
-                                        if (self.verify_response(self.status.ACK, response)) {
-                                            // flash another page
-                                            write();
-                                        }
-                                    });
-
-                                    // update progress bar
-                                    TABS.firmware_flasher.flashProgress(Math.round(bytes_flashed_total / (self.hex.bytes_total * 2) * 100));
-                                }
-                            });
-                        }
-                    });
-                } else {
-                    // move to another block
-                    if (flashing_block < blocks) {
-                        flashing_block++;
-
-                        address = self.hex.data[flashing_block].address;
-                        bytes_flashed = 0;
-
-                        write();
-                    } else {
-                        // all blocks flashed
-                        console.log('Writing: done');
-
-                        // proceed to next step
-                        self.upload_procedure(6);
-                    }
-                }
-            };
-
-            // start writing
-            write();
-
-            break;
-        case 6:
-            // verify
-            console.log('Verifying data ...');
-            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32Verifying'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
-
-            blocks = self.hex.data.length - 1;
-            let readingBlock = 0;
-            address = self.hex.data[readingBlock].address;
-            let bytesVerified = 0;
-            let bytesVerifiedTotal = 0; // used for progress bar
-
-            // initialize arrays
-            for (let i = 0; i <= blocks; i++) {
-                self.verify_hex.push([]);
-            }
-
-            const reading = function () {
-                if (bytesVerified < self.hex.data[readingBlock].bytes) {
-                    const bytesToRead = ((bytesVerified + 256) <= self.hex.data[readingBlock].bytes) ? 256 : (self.hex.data[readingBlock].bytes - bytesVerified);
-
-                    // console.log('STM32 - Reading from: 0x' + address.toString(16) + ', ' + bytesToRead + ' bytes');
-
-                    self.send([self.command.read_memory, 0xEE], 1, function (reply) { // 0x11 ^ 0xFF
-                        if (self.verify_response(self.status.ACK, reply)) {
-                            const addressArray = [(address >> 24), (address >> 16), (address >> 8), address];
-                            const addressChecksum = addressArray[0] ^ addressArray[1] ^ addressArray[2] ^ addressArray[3];
-
-                            self.send([addressArray[0], addressArray[1], addressArray[2], addressArray[3], addressChecksum], 1, function (_reply) { // read start address + checksum
-                                if (self.verify_response(self.status.ACK, _reply)) {
-                                    const bytesToReadN = bytesToRead - 1;
-                                    // bytes to be read + checksum XOR(complement of bytesToReadN)
-                                    self.send([bytesToReadN, (~bytesToReadN) & 0xFF], 1, function (response) {
-                                        if (self.verify_response(self.status.ACK, response)) {
-                                            self.retrieve(bytesToRead, function (data) {
-                                                for (const instance of data) {
-                                                    self.verify_hex[readingBlock].push(instance);
-                                                }
-
-                                                address += bytesToRead;
-                                                bytesVerified += bytesToRead;
-                                                bytesVerifiedTotal += bytesToRead;
-
-                                                // verify another page
-                                                reading();
-                                            });
-                                        }
-                                    });
-
-                                    // update progress bar
-                                    TABS.firmware_flasher.flashProgress(Math.round((self.hex.bytes_total + bytesVerifiedTotal) / (self.hex.bytes_total * 2) * 100));
-                                }
-                            });
-                        }
-                    });
-                } else {
-                    // move to another block
-                    if (readingBlock < blocks) {
-                        readingBlock++;
-
-                        address = self.hex.data[readingBlock].address;
-                        bytesVerified = 0;
-
-                        reading();
-                    } else {
-                        // all blocks read, verify
-
-                        let verify = true;
-                        for (let i = 0; i <= blocks; i++) {
-                            verify = self.verify_flash(self.hex.data[i].data, self.verify_hex[i]);
-
-                            if (!verify) break;
-                        }
-
-                        if (verify) {
-                            console.log('Programming: SUCCESSFUL');
-                            // update progress bar
-                            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ProgrammingSuccessful'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.VALID);
-
-                            // proceed to next step
-                            self.upload_procedure(7);
-                        } else {
-                            console.log('Programming: FAILED');
-                            // update progress bar
-                            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ProgrammingFailed'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
-
-                            // disconnect
-                            self.upload_procedure(99);
-                        }
-                    }
-                }
-            };
-
-            // start reading
-            reading();
-
-            break;
-        case 7:
-            // go
-            // memory address = 4 bytes, 1st high byte, 4th low byte, 5th byte = checksum XOR(byte 1, byte 2, byte 3, byte 4)
-            console.log('Sending GO command: 0x8000000');
-
-            self.send([self.command.go, 0xDE], 1, function (reply) { // 0x21 ^ 0xFF
-                if (self.verify_response(self.status.ACK, reply)) {
-                    const gtAddress = 0x8000000;
-                    address = [(gtAddress >> 24), (gtAddress >> 16), (gtAddress >> 8), gtAddress];
-                    const addressChecksum = address[0] ^ address[1] ^ address[2] ^ address[3];
-
-                    self.send([address[0], address[1], address[2], address[3], addressChecksum], 1, function (response) {
-                        if (self.verify_response(self.status.ACK, response)) {
-                            // disconnect
-                            self.upload_procedure(99);
-                        }
-                    });
-                }
-            });
-
-            break;
-        case 99:
-            // disconnect
-            GUI.interval_remove('STM32_timeout'); // stop STM32 timeout timer (everything is finished now)
-
-            // close connection
-            if (serial.connectionId) {
-                serial.disconnect(self.cleanup);
-            } else {
-                self.cleanup();
-            }
-
-            break;
-    }
-};
-
-STM32_protocol.prototype.cleanup = function () {
-    PortUsage.reset();
-
-    // unlocking connect button
-    GUI.connect_lock = false;
-
-    // unlock some UI elements TODO needs rework
-    $('select[name="release"]').prop('disabled', false);
-
-    // handle timing
-    const timeSpent = new Date().getTime() - self.upload_time_start;
-
-    console.log(`Script finished after: ${(timeSpent / 1000)} seconds`);
-
-    if (self.callback) {
-        self.callback();
-    }
-};
-
-// initialize object
-const STM32 = new STM32_protocol();
-export default STM32;
diff --git a/src/js/protocols/stm32usbdfu.js b/src/js/protocols/stm32usbdfu.js
deleted file mode 100644
index c245aaccb7..0000000000
--- a/src/js/protocols/stm32usbdfu.js
+++ /dev/null
@@ -1,1164 +0,0 @@
-/*
-    USB DFU uses:
-    control transfers for communicating
-    recipient is interface
-    request type is class
-
-    Descriptors seems to be broken in current chrome.usb API implementation (writing this while using canary 37.0.2040.0
-
-    General rule to remember is that DFU doesn't like running specific operations while the device isn't in idle state
-    that being said, it seems that certain level of CLRSTATUS is required before running another type of operation for
-    example switching from DNLOAD to UPLOAD, etc, clearning the state so device is in dfuIDLE is highly recommended.
-*/
-import GUI, { TABS } from "../gui";
-import { i18n } from "../localization";
-import { gui_log } from "../gui_log";
-import { checkChromeRuntimeError } from "../utils/common";
-
-// Task for the brave ones. There are quite a few shadow variables which clash when
-// const or let are used. So need to run thorough tests when chaning `var`
-/* eslint-disable no-var */
-const STM32DFU_protocol = function () {
-    this.callback = null;
-    this.hex = null;
-    this.verify_hex = [];
-
-    this.handle = null; // connection handle
-
-    this.request = {
-        DETACH:     0x00, // OUT, Requests the device to leave DFU mode and enter the application.
-        DNLOAD:     0x01, // OUT, Requests data transfer from Host to the device in order to load them into device internal Flash. Includes also erase commands
-        UPLOAD:     0x02, // IN,  Requests data transfer from device to Host in order to load content of device internal Flash into a Host file.
-        GETSTATUS:  0x03, // IN,  Requests device to send status report to the Host (including status resulting from the last request execution and the state the device will enter immediately after this request).
-        CLRSTATUS:  0x04, // OUT, Requests device to clear error status and move to next step
-        GETSTATE:   0x05, // IN,  Requests the device to send only the state it will enter immediately after this request.
-        ABORT:      0x06,  // OUT, Requests device to exit the current state/operation and enter idle state immediately.
-    };
-
-    this.status = {
-        OK:                 0x00, // No error condition is present.
-        errTARGET:          0x01, // File is not targeted for use by this device.
-        errFILE:            0x02, // File is for this device but fails some vendor-specific verification test
-        errWRITE:           0x03, // Device is unable to write memory.
-        errERASE:           0x04, // Memory erase function failed.
-        errCHECK_ERASED:    0x05, // Memory erase check failed.
-        errPROG:            0x06, // Program memory function failed.
-        errVERIFY:          0x07, // Programmed memory failed verification.
-        errADDRESS:         0x08, // Cannot program memory due to received address that is out of range.
-        errNOTDONE:         0x09, // Received DFU_DNLOAD with wLength = 0, but device does not think it has all of the data yet.
-        errFIRMWARE:        0x0A, // Device's firmware is corrupt. It cannot return to run-time (non-DFU) operations.
-        errVENDOR:          0x0B, // iString indicates a vendor-specific error.
-        errUSBR:            0x0C, // Device detected unexpected USB reset signaling.
-        errPOR:             0x0D, // Device detected unexpected power on reset.
-        errUNKNOWN:         0x0E, // Something went wrong, but the device does not know what it was.
-        errSTALLEDPKT:      0x0F,  // Device stalled an unexpected request.
-    };
-
-    this.state = {
-        appIDLE:                0, // Device is running its normal application.
-        appDETACH:              1, // Device is running its normal application, has received the DFU_DETACH request, and is waiting for a USB reset.
-        dfuIDLE:                2, // Device is operating in the DFU mode and is waiting for requests.
-        dfuDNLOAD_SYNC:         3, // Device has received a block and is waiting for the host to solicit the status via DFU_GETSTATUS.
-        dfuDNBUSY:              4, // Device is programming a control-write block into its nonvolatile memories.
-        dfuDNLOAD_IDLE:         5, // Device is processing a download operation. Expecting DFU_DNLOAD requests.
-        dfuMANIFEST_SYNC:       6, // Device has received the final block of firmware from the host and is waiting for receipt of DFU_GETSTATUS to begin the Manifestation phase; or device has completed the Manifestation phase and is waiting for receipt of DFU_GETSTATUS.
-        dfuMANIFEST:            7, // Device is in the Manifestation phase. (Not all devices will be able to respond to DFU_GETSTATUS when in this state.)
-        dfuMANIFEST_WAIT_RESET: 8, // Device has programmed its memories and is waiting for a USB reset or a power on reset. (Devices that must enter this state clear bitManifestationTolerant to 0.)
-        dfuUPLOAD_IDLE:         9, // The device is processing an upload operation. Expecting DFU_UPLOAD requests.
-        dfuERROR:               10, // An error has occurred. Awaiting the DFU_CLRSTATUS request.
-    };
-
-    this.chipInfo = null; // information about chip's memory
-    this.flash_layout = { 'start_address': 0, 'total_size': 0, 'sectors': []};
-    this.transferSize = 2048; // Default USB DFU transfer size for F3,F4 and F7
-};
-
-STM32DFU_protocol.prototype.connect = function (device, hex, options, callback) {
-    const self = this;
-
-    self.hex = hex;
-    self.callback = callback;
-
-    self.options = {
-        erase_chip: false,
-        exitDfu: false,
-    };
-
-    if (options.exitDfu) {
-        self.options.exitDfu = true;
-    } else if (options.erase_chip) {
-        self.options.erase_chip = true;
-    }
-
-    // reset and set some variables before we start
-    self.upload_time_start = new Date().getTime();
-    self.verify_hex = [];
-
-    // reset progress bar to initial state
-    TABS.firmware_flasher.flashingMessage(null, TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL).flashProgress(0);
-
-    chrome.usb.getDevices(device, function (result) {
-        if (result.length) {
-            console.log(`USB DFU detected with ID: ${result[0].device}`);
-
-            self.openDevice(result[0]);
-        } else {
-            console.log('USB DFU not found');
-            gui_log(i18n.getMessage('stm32UsbDfuNotFound'));
-        }
-    });
-};
-
-STM32DFU_protocol.prototype.openDevice = function (device) {
-    const self = this;
-
-    chrome.usb.openDevice(device, function (handle) {
-        if (checkChromeRuntimeError()) {
-            console.log('Failed to open USB device!');
-            gui_log(i18n.getMessage('usbDeviceOpenFail'));
-            if (GUI.operating_system === 'Linux') {
-                gui_log(i18n.getMessage('usbDeviceUdevNotice'));
-            }
-            return;
-        }
-
-        self.handle = handle;
-
-        gui_log(i18n.getMessage('usbDeviceOpened', handle.handle.toString()));
-        console.log(`Device opened with Handle ID: ${handle.handle}`);
-        self.claimInterface(0);
-    });
-};
-
-STM32DFU_protocol.prototype.closeDevice = function () {
-    const self = this;
-
-    chrome.usb.closeDevice(self.handle, function closed() {
-        if (checkChromeRuntimeError()) {
-            console.log('Failed to close USB device!');
-            gui_log(i18n.getMessage('usbDeviceCloseFail'));
-        } else {
-            gui_log(i18n.getMessage('usbDeviceClosed'));
-            console.log(`Device closed with Handle ID: ${self.handle.handle}`);
-        }
-
-        self.handle = null;
-    });
-};
-
-STM32DFU_protocol.prototype.claimInterface = function (interfaceNumber) {
-    const self = this;
-
-    chrome.usb.claimInterface(self.handle, interfaceNumber, function claimed() {
-        if (checkChromeRuntimeError()) {
-            console.log('Failed to claim USB device!');
-            self.cleanup();
-        } else {
-            console.log(`Claimed interface: ${interfaceNumber}`);
-
-            if (self.options.exitDfu) {
-                self.leave();
-            } else {
-                self.upload_procedure(0);
-            }
-        }
-    });
-};
-
-STM32DFU_protocol.prototype.releaseInterface = function (interfaceNumber) {
-    const self = this;
-
-    chrome.usb.releaseInterface(self.handle, interfaceNumber, function released() {
-        if (checkChromeRuntimeError()) {
-            console.log(`Could not release interface: ${interfaceNumber}`);
-        } else {
-            console.log(`Released interface: ${interfaceNumber}`);
-        }
-
-        self.closeDevice();
-    });
-};
-
-STM32DFU_protocol.prototype.resetDevice = function (callback) {
-    chrome.usb.resetDevice(this.handle, function (result) {
-        if (checkChromeRuntimeError()) {
-            console.log(`Could not reset device: ${result}`);
-        } else {
-            console.log(`Reset Device: ${result}`);
-        }
-
-        callback?.();
-    });
-};
-
-STM32DFU_protocol.prototype.getString = function (index, callback) {
-    const self = this;
-
-    chrome.usb.controlTransfer(self.handle, {
-        'direction':    'in',
-        'recipient':    'device',
-        'requestType':  'standard',
-        'request':      6,
-        'value':        0x300 | index,
-        'index':        0,  // specifies language
-        'length':       255, // max length to retreive
-    }, function (result) {
-        if (checkChromeRuntimeError()) {
-            console.log(`USB getString failed! ${result.resultCode}`);
-            callback("", result.resultCode);
-            return;
-        }
-        const view = new DataView(result.data);
-        const length = view.getUint8(0);
-        let descriptor = "";
-
-        for (let i = 2; i < length; i += 2) {
-            const charCode = view.getUint16(i, true);
-            descriptor += String.fromCharCode(charCode);
-        }
-        callback(descriptor, result.resultCode);
-    });
-};
-
-STM32DFU_protocol.prototype.getInterfaceDescriptors = function (interfaceNum, callback) {
-    const self = this;
-
-    chrome.usb.getConfiguration(self.handle, function (config) {
-        if (checkChromeRuntimeError()) {
-            console.log('USB getConfiguration failed!');
-            callback([], -200);
-            return;
-        }
-
-        let interfaceID = 0;
-        const descriptorStringArray = [];
-        const getDescriptorString = function () {
-            if (interfaceID < config.interfaces.length) {
-                self.getInterfaceDescriptor(interfaceID, function (descriptor, resultCode) {
-                    if (resultCode) {
-                        callback([], resultCode);
-                        return;
-                    }
-                    interfaceID++;
-                    self.getString(descriptor.iInterface, function (descriptorString, resultCode) {
-                        if (resultCode) {
-                            callback([], resultCode);
-                            return;
-                        }
-                        if (descriptor.bInterfaceNumber === interfaceNum) {
-                            descriptorStringArray.push(descriptorString);
-                        }
-                        getDescriptorString();
-                    });
-                });
-            } else {
-                //console.log(descriptorStringArray);
-                callback(descriptorStringArray, 0);
-                return;
-            }
-        };
-        getDescriptorString();
-    });
-};
-
-
-STM32DFU_protocol.prototype.getInterfaceDescriptor = function (_interface, callback) {
-    chrome.usb.controlTransfer(this.handle, {
-        'direction':    'in',
-        'recipient':    'device',
-        'requestType':  'standard',
-        'request':      6,
-        'value':        0x200,
-        'index':        0,
-        'length':       18 + _interface * 9,
-    }, function (result) {
-        if (checkChromeRuntimeError()) {
-            console.log(`USB getInterfaceDescriptor failed! ${result.resultCode}`);
-            callback({}, result.resultCode);
-            return;
-        }
-
-        const buf = new Uint8Array(result.data, 9 + _interface * 9);
-        const descriptor = {
-            'bLength':            buf[0],
-            'bDescriptorType':    buf[1],
-            'bInterfaceNumber':   buf[2],
-            'bAlternateSetting':  buf[3],
-            'bNumEndpoints':      buf[4],
-            'bInterfaceClass':    buf[5],
-            'bInterfaceSubclass': buf[6],
-            'bInterfaceProtocol': buf[7],
-            'iInterface':         buf[8],
-        };
-
-        callback(descriptor, result.resultCode);
-    });
-};
-
-STM32DFU_protocol.prototype.getFunctionalDescriptor = function (_interface, callback) {
-    chrome.usb.controlTransfer(this.handle, {
-        'direction':    'in',
-        'recipient':    'interface',
-        'requestType':  'standard',
-        'request':      6,
-        'value':        0x2100,
-        'index':        0,
-        'length':       255,
-    }, function (result) {
-        if (checkChromeRuntimeError()) {
-            console.log(`USB getFunctionalDescriptor failed! ${result.resultCode}`);
-            callback({}, result.resultCode);
-            return;
-        }
-
-        const buf = new Uint8Array(result.data);
-
-        const descriptor = {
-            'bLength':            buf[0],
-            'bDescriptorType':    buf[1],
-            'bmAttributes':       buf[2],
-            'wDetachTimeOut':     (buf[4] << 8)|buf[3],
-            'wTransferSize':      (buf[6] << 8)|buf[5],
-            'bcdDFUVersion':      buf[7],
-        };
-
-        callback(descriptor, result.resultCode);
-    });
-};
-
-STM32DFU_protocol.prototype.getChipInfo = function (_interface, callback) {
-    const self = this;
-
-    self.getInterfaceDescriptors(0, function (descriptors, resultCode) {
-        if (resultCode) {
-            callback({}, resultCode);
-            return;
-        }
-
-        // Keep this for new MCU debugging
-        // console.log('Descriptors: ' + descriptors);
-
-        const parseDescriptor = function(str) {
-            // F303: "@Internal Flash  /0x08000000/128*0002Kg"
-            // F40x: "@Internal Flash  /0x08000000/04*016Kg,01*064Kg,07*128Kg"
-            // F72x: "@Internal Flash  /0x08000000/04*016Kg,01*64Kg,03*128Kg"
-            // F74x: "@Internal Flash  /0x08000000/04*032Kg,01*128Kg,03*256Kg"
-
-            // H750 SPRacing H7 EXST: "@External Flash /0x90000000/998*128Kg,1*128Kg,4*128Kg,21*128Ka"
-            // H750 SPRacing H7 EXST: "@External Flash /0x90000000/1001*128Kg,3*128Kg,20*128Ka" - Early BL firmware with incorrect string, treat as above.
-
-            // H750 Partitions: Flash, Config, Firmware, 1x BB Management block + x BB Replacement blocks)
-            // AT32 F437 "@Internal Flash   /0x08000000/08*04Ka,1000*04Kg"
-            if (str === "@External Flash /0x90000000/1001*128Kg,3*128Kg,20*128Ka") {
-                str = "@External Flash /0x90000000/998*128Kg,1*128Kg,4*128Kg,21*128Ka";
-            }
-            //AT32F43xxM
-            if (str === "@Option byte   /0x1FFFC000/01*4096 g"){
-                str = "@Option bytes   /0x1FFFC000/01*4096 g";
-            }
-            //AT32F43xxG
-            if (str === "@Option byte   /0x1FFFC000/01*512 g"){
-                str = "@Option bytes   /0x1FFFC000/01*512 g";
-            }
-            // split main into [location, start_addr, sectors]
-
-            const tmp0 = str.replace(/[^\x20-\x7E]+/g, "");
-            const tmp1 = tmp0.split('/');
-
-            // G474 (and may be other G4 variants) returns
-            // "@Option Bytes   /0x1FFF7800/01*048 e/0x1FFFF800/01*048 e"
-            // for two banks of options bytes which may be fine in terms of descriptor syntax,
-            // but as this splits into an array of size 5 instead of 3, it induces an length error.
-            // Here, we blindly trim the array length to 3. While doing so may fail to
-            // capture errornous patterns, but it is good to avoid this known and immediate
-            // error.
-            // May need to preserve the second bank if the configurator starts to really
-            // support option bytes.
-
-            if (tmp1.length > 3) {
-                console.log(`parseDescriptor: shrinking long descriptor "${str}"`);
-                tmp1.length = 3;
-            }
-
-            if (!tmp1[0].startsWith("@")) {
-                return null;
-            }
-
-            const type = tmp1[0].trim().replace('@', '');
-            const start_address = parseInt(tmp1[1]);
-
-            // split sectors into array
-            const sectors = [];
-            let total_size = 0;
-            const tmp2 = tmp1[2].split(',');
-
-            if (tmp2.length < 1) {
-                return null;
-            }
-
-            for (const tmp2Index of tmp2) {
-                // split into [num_pages, page_size]
-                const tmp3 = tmp2Index.split('*');
-                if (tmp3.length !== 2) {
-                    return null;
-                }
-
-                const num_pages = parseInt(tmp3[0]);
-                let page_size = parseInt(tmp3[1]);
-
-                if (!page_size) {
-                    return null;
-                }
-                const unit = tmp3[1].slice(-2, -1);
-
-                switch (unit) {
-                    case 'M':
-                        page_size *= 1024; //  fall through to K as well
-                    case 'K':
-                        page_size *= 1024;
-                        break;
-                }
-
-                sectors.push({
-                    'num_pages'    : num_pages,
-                    'start_address': start_address + total_size,
-                    'page_size'    : page_size,
-                    'total_size'   : num_pages * page_size,
-                });
-
-                total_size += num_pages * page_size;
-            }
-
-            const memory = {
-                'type'         : type,
-                'start_address': start_address,
-                'sectors'      : sectors,
-                'total_size'   : total_size,
-            };
-        return memory;
-    };
-    const chipInfo = descriptors.map(parseDescriptor).reduce(function(o, v, i) {
-        o[v.type.toLowerCase().replace(' ', '_')] = v;
-        return o;
-    }, {});
-        callback(chipInfo, resultCode);
-    });
-};
-
-STM32DFU_protocol.prototype.controlTransfer = function (direction, request, value, _interface, length, data, callback, _timeout) {
-    const self = this;
-
-    // timeout support was added in chrome v43
-    let timeout;
-    if (typeof _timeout === "undefined") {
-        timeout = 0; // default is 0 (according to chrome.usb API)
-    } else {
-        timeout = _timeout;
-    }
-
-    if (direction === 'in') {
-        // data is ignored
-        chrome.usb.controlTransfer(self.handle, {
-            'direction':    'in',
-            'recipient':    'interface',
-            'requestType':  'class',
-            'request':      request,
-            'value':        value,
-            'index':        _interface,
-            'length':       length,
-            'timeout':      timeout,
-        }, function (result) {
-            if (checkChromeRuntimeError()) {
-                console.log(`USB controlTransfer IN failed for request ${request}!`);
-            }
-            if (result.resultCode) console.log(`USB transfer result code: ${result.resultCode}`);
-
-            const buf = new Uint8Array(result.data);
-            callback(buf, result.resultCode);
-        });
-    } else {
-        // length is ignored
-        let arrayBuf;
-
-        if (data) {
-            arrayBuf = new ArrayBuffer(data.length);
-            const arrayBufView = new Uint8Array(arrayBuf);
-            arrayBufView.set(data);
-        } else {
-            arrayBuf = new ArrayBuffer(0);
-        }
-
-        chrome.usb.controlTransfer(self.handle, {
-            'direction':    'out',
-            'recipient':    'interface',
-            'requestType':  'class',
-            'request':      request,
-            'value':        value,
-            'index':        _interface,
-            'data':         arrayBuf,
-            'timeout':      timeout,
-        }, function (result) {
-            if (checkChromeRuntimeError()) {
-                console.log(`USB controlTransfer OUT failed for request ${request}!`);
-            }
-            if (result.resultCode) console.log(`USB transfer result code: ${result.resultCode}`);
-
-            callback(result);
-        });
-    }
-};
-
-// routine calling DFU_CLRSTATUS until device is in dfuIDLE state
-STM32DFU_protocol.prototype.clearStatus = function (callback) {
-    const self = this;
-
-    function check_status() {
-        self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-            let delay = 0;
-
-            if (data[4] === self.state.dfuIDLE) {
-                callback(data);
-            } else {
-                if (data.length) {
-                    delay = data[1] | (data[2] << 8) | (data[3] << 16);
-                }
-                setTimeout(clear_status, delay);
-            }
-        });
-    }
-
-    function clear_status() {
-        self.controlTransfer('out', self.request.CLRSTATUS, 0, 0, 0, 0, check_status);
-    }
-
-    check_status();
-};
-
-STM32DFU_protocol.prototype.loadAddress = function (address, callback, abort) {
-    const self = this;
-
-    self.controlTransfer('out', self.request.DNLOAD, 0, 0, 0, [0x21, address & 0xff, (address >> 8) & 0xff, (address >> 16) & 0xff, (address >> 24) & 0xff], function () {
-        self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-            if (data[4] === self.state.dfuDNBUSY) {
-                const delay = data[1] | (data[2] << 8) | (data[3] << 16);
-
-                setTimeout(function () {
-                    self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-                        if (data[4] === self.state.dfuDNLOAD_IDLE) {
-                            callback(data);
-                        } else {
-                            console.log('Failed to execute address load');
-                            if (typeof abort === "undefined" || abort) {
-                                self.cleanup();
-                            } else {
-                                callback(data);
-                            }
-                        }
-                    });
-                }, delay);
-            } else {
-                console.log('Failed to request address load');
-                self.cleanup();
-            }
-        });
-    });
-};
-
-// first_array = usually hex_to_flash array
-// second_array = usually verify_hex array
-// result = true/false
-STM32DFU_protocol.prototype.verify_flash = function (first_array, second_array) {
-    for (let i = 0; i < first_array.length; i++) {
-        if (first_array[i] !== second_array[i]) {
-            console.log(`Verification failed on byte: ${i} expected: 0x${first_array[i].toString(16)} received: 0x${second_array[i].toString(16)}`);
-            return false;
-        }
-    }
-
-    console.log(`Verification successful, matching: ${first_array.length} bytes`);
-
-    return true;
-};
-
-STM32DFU_protocol.prototype.isBlockUsable = function(startAddress, length) {
-    const self = this;
-
-    let result = false;
-
-    let searchAddress = startAddress;
-    let remainingLength = length;
-
-    let restart;
-
-    do {
-        restart = false;
-
-        for (const sector of self.flash_layout.sectors) {
-            const sectorStart = sector.start_address;
-            const sectorLength = sector.num_pages * sector.page_size;
-            const sectorEnd = sectorStart + sectorLength - 1; // - 1 for inclusive
-
-            const addressInSector = (searchAddress >= sectorStart) && (searchAddress <= sectorEnd);
-
-            if (addressInSector) {
-                const endAddress = searchAddress + remainingLength - 1; // - 1 for inclusive
-
-                const endAddressInSector = (endAddress <= sectorEnd);
-                if (endAddressInSector) {
-                    result = true;
-                    restart = false;
-                    break;
-                }
-
-                // some of the block is in this sector, search for the another sector that contains the next part of the block
-                searchAddress = sectorEnd + 1;
-                remainingLength -= sectorLength;
-                restart = true;
-                break;
-            }
-        }
-    } while (restart);
-
-    return result;
-};
-
-STM32DFU_protocol.prototype.upload_procedure = function (step) {
-    const self = this;
-
-    let blocks;
-    let address;
-    let wBlockNum;
-
-    switch (step) {
-        case 0:
-            self.getChipInfo(0, function (chipInfo, resultCode) {
-                if (resultCode !== 0 || typeof chipInfo === "undefined") {
-                    console.log(`Failed to detect chip info, resultCode: ${resultCode}`);
-                    self.cleanup();
-                } else {
-                    let nextAction;
-
-                    if (typeof chipInfo.internal_flash !== "undefined") {
-                        // internal flash
-                        nextAction = 1;
-
-                        self.chipInfo = chipInfo;
-                        self.flash_layout = chipInfo.internal_flash;
-
-                        if (TABS.firmware_flasher.parsed_hex.bytes_total > chipInfo.internal_flash.total_size) {
-                            const firmwareSize = TABS.firmware_flasher.parsed_hex.bytes_total;
-                            const boardSize = chipInfo.internal_flash.total_size;
-                            const bareBoard = TABS.firmware_flasher.bareBoard;
-                            console.log(`Firmware size ${firmwareSize} exceeds board memory size ${boardSize} (${bareBoard})`);
-                        }
-
-                    } else if (typeof chipInfo.external_flash !== "undefined") {
-                        // external flash
-                        nextAction = 2; // no option bytes
-
-                        self.chipInfo = chipInfo;
-                        self.flash_layout = chipInfo.external_flash;
-                    } else {
-                        console.log('Failed to detect internal or external flash');
-                        self.cleanup();
-                    }
-
-                    if (typeof nextAction !== "undefined") {
-                        gui_log(i18n.getMessage('dfu_device_flash_info', (self.flash_layout.total_size / 1024).toString()));
-
-                        // verify all addresses in the hex are writable.
-
-                        const unusableBlocks = [];
-
-                        for (const block of self.hex.data) {
-                            const usable = self.isBlockUsable(block.address, block.bytes);
-                            if (!usable) {
-                                unusableBlocks.push(block);
-                            }
-                        }
-
-                        if (unusableBlocks.length > 0) {
-                            gui_log(i18n.getMessage('dfu_hex_address_errors'));
-                            TABS.firmware_flasher.flashingMessage(i18n.getMessage('dfu_hex_address_errors'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
-                            self.leave();
-                        } else {
-                            self.getFunctionalDescriptor(0, function (descriptor, resultCode) {
-                                self.transferSize = resultCode ? 2048 : descriptor.wTransferSize;
-                                console.log(`Using transfer size: ${self.transferSize}`);
-                                self.clearStatus(function () {
-                                    self.upload_procedure(nextAction);
-                                });
-                            });
-                        }
-                    }
-                }
-            });
-            break;
-        case 1: {
-            if (typeof self.chipInfo.option_bytes === "undefined") {
-                console.log('Failed to detect option bytes');
-                self.cleanup();
-            }
-
-            const unprotect = function() {
-                console.log('Initiate read unprotect');
-                const messageReadProtected = i18n.getMessage('stm32ReadProtected');
-                gui_log(messageReadProtected);
-                TABS.firmware_flasher.flashingMessage(messageReadProtected, TABS.firmware_flasher.FLASH_MESSAGE_TYPES.ACTION);
-
-                self.controlTransfer('out', self.request.DNLOAD, 0, 0, 0, [0x92], function () { // 0x92 initiates read unprotect
-                    self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-                        if (data[4] === self.state.dfuDNBUSY) { // completely normal
-                            const delay = data[1] | (data[2] << 8) | (data[3] << 16);
-                            const total_delay = delay + 20000; // wait at least 20 seconds to make sure the user does not disconnect the board while erasing the memory
-                            let timeSpentWaiting = 0;
-                            const incr = 1000; // one sec increments
-                            const waitForErase = setInterval(function () {
-
-                                TABS.firmware_flasher.flashProgress(Math.min(timeSpentWaiting / total_delay, 1) * 100);
-
-                                if (timeSpentWaiting < total_delay) {
-                                    timeSpentWaiting += incr;
-                                    return;
-                                }
-                                clearInterval(waitForErase);
-                                self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data, error) { // should stall/disconnect
-                                    if (error) { // we encounter an error, but this is expected. should be a stall.
-                                        console.log('Unprotect memory command ran successfully. Unplug flight controller. Connect again in DFU mode and try flashing again.');
-                                        gui_log(i18n.getMessage('stm32UnprotectSuccessful'));
-
-                                        const messageUnprotectUnplug = i18n.getMessage('stm32UnprotectUnplug');
-                                        gui_log(messageUnprotectUnplug);
-
-                                        TABS.firmware_flasher.flashingMessage(messageUnprotectUnplug, TABS.firmware_flasher.FLASH_MESSAGE_TYPES.ACTION)
-                                                             .flashProgress(0);
-
-                                    } else { // unprotecting the flight controller did not work. It did not reboot.
-                                        console.log('Failed to execute unprotect memory command');
-
-                                        gui_log(i18n.getMessage('stm32UnprotectFailed'));
-                                        TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32UnprotectFailed'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
-                                        console.log(data);
-                                        self.cleanup();
-                                    }
-                                }, 2000); // this should stall/disconnect anyways. so we only wait 2 sec max.
-                            }, incr);
-                        } else {
-                                console.log('Failed to initiate unprotect memory command');
-                                let messageUnprotectInitFailed = i18n.getMessage('stm32UnprotectInitFailed');
-                                gui_log(messageUnprotectInitFailed);
-                                TABS.firmware_flasher.flashingMessage(messageUnprotectInitFailed, TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
-                                self.cleanup();
-                        }
-                    });
-                });
-            };
-
-            const tryReadOB = function() {
-                // the following should fail if read protection is active
-                self.controlTransfer('in', self.request.UPLOAD, 2, 0, self.chipInfo.option_bytes.total_size, 0, function (ob_data, errcode) {
-                    if (errcode) {
-                        // TODO: this was undefined, guessing with how it usually works it should be 1
-                        const errcode1 = 1;
-                        console.log(`USB transfer error while reading option bytes: ${errcode1}`);
-                        self.cleanup();
-                        return;
-                    }
-
-                    self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-                        if (data[4] === self.state.dfuUPLOAD_IDLE && ob_data.length === self.chipInfo.option_bytes.total_size) {
-                            console.log('Option bytes read successfully');
-                            console.log('Chip does not appear read protected');
-                            gui_log(i18n.getMessage('stm32NotReadProtected'));
-                            // it is pretty safe to continue to erase flash
-                            self.clearStatus(function() {
-                                self.upload_procedure(2);
-                            });
-                            /* // this snippet is to protect the flash memory (only for the brave)
-                            ob_data[1] = 0x0;
-                            var writeOB = function() {
-                                self.controlTransfer('out', self.request.DNLOAD, 2, 0, 0, ob_data, function () {
-                                    self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-                                        if (data[4] == self.state.dfuDNBUSY) {
-                                        var delay = data[1] | (data[2] << 8) | (data[3] << 16);
-
-                                        setTimeout(function () {
-                                            self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-                                            if (data[4] == self.state.dfuDNLOAD_IDLE) {
-                                                console.log('Failed to write ob');
-                                                self.cleanup();
-                                            } else {
-                                                console.log('Success writing ob');
-                                                self.cleanup();
-                                            }
-                                            });
-                                        }, delay);
-                                        } else {
-                                        console.log('Failed to initiate write ob');
-                                        self.cleanup();
-                                        }
-                                    });
-                                });
-                            }
-                            self.clearStatus(function () {
-                                self.loadAddress(self.chipInfo.option_bytes.start_address, function () {
-                                    self.clearStatus(writeOB);
-                                });
-                            }); // */
-                        } else {
-                            console.log('Option bytes could not be read. Quite possibly read protected.');
-                            self.clearStatus(unprotect);
-                        }
-                    });
-                });
-            };
-
-            const initReadOB = function (loadAddressResponse) {
-                // contrary to what is in the docs. Address load should in theory work even if read protection is active
-                // if address load fails with this specific error though, it is very likely bc of read protection
-                if (loadAddressResponse[4] === self.state.dfuERROR && loadAddressResponse[0] === self.status.errVENDOR) {
-                    // read protected
-                    gui_log(i18n.getMessage('stm32AddressLoadFailed'));
-                    self.clearStatus(unprotect);
-                    return;
-                } else if (loadAddressResponse[4] === self.state.dfuDNLOAD_IDLE) {
-                    console.log('Address load for option bytes sector succeeded.');
-                    self.clearStatus(tryReadOB);
-                } else {
-                    gui_log(i18n.getMessage('stm32AddressLoadUnknown'));
-                    self.cleanup();
-                }
-            };
-
-            self.clearStatus(function () {
-            // load address fails if read protection is active unlike as stated in the docs
-            self.loadAddress(self.chipInfo.option_bytes.start_address, initReadOB, false);
-            });
-            break;
-        }
-        case 2: {
-            // erase
-                // find out which pages to erase
-                const erase_pages = [];
-                for (let i = 0; i < self.flash_layout.sectors.length; i++) {
-                    for (let j = 0; j < self.flash_layout.sectors[i].num_pages; j++) {
-                        if (self.options.erase_chip) {
-                            // full chip erase
-                            erase_pages.push({'sector': i, 'page': j});
-                        } else {
-                            // local erase
-                            const page_start = self.flash_layout.sectors[i].start_address + j * self.flash_layout.sectors[i].page_size;
-                            const page_end = page_start + self.flash_layout.sectors[i].page_size - 1;
-                            for (const hexData of self.hex.data) {
-                                const starts_in_page = hexData.address >= page_start && hexData.address <= page_end;
-                                const end_address = hexData.address + hexData.bytes - 1;
-                                const ends_in_page = end_address >= page_start && end_address <= page_end;
-                                const spans_page = hexData.address < page_start && end_address > page_end;
-
-                                if (starts_in_page || ends_in_page || spans_page) {
-                                    const idx = erase_pages.findIndex(function (element, index, array) {
-                                        return element.sector === i && element.page === j;
-                                    });
-                                    if (idx === -1)
-                                        erase_pages.push({'sector': i, 'page': j});
-                                }
-                            }
-                        }
-                    }
-                }
-
-                if (erase_pages.length === 0) {
-                    console.log('Aborting, No flash pages to erase');
-                    TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32InvalidHex'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
-                    self.cleanup();
-                    break;
-                }
-
-
-                TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32Erase'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
-                console.log('Executing local chip erase', erase_pages);
-
-                let page = 0;
-                let total_erased = 0; // bytes
-
-                const erase_page_next = function() {
-                    TABS.firmware_flasher.flashProgress((page + 1) / erase_pages.length * 100);
-                    page++;
-
-                    if (page === erase_pages.length) {
-                        console.log("Erase: complete");
-                        gui_log(i18n.getMessage('dfu_erased_kilobytes', (total_erased / 1024).toString()));
-                        self.upload_procedure(4);
-                    } else {
-                        erase_page();
-                    }
-                };
-
-                const erase_page = function() {
-                    const page_addr = erase_pages[page].page * self.flash_layout.sectors[erase_pages[page].sector].page_size
-                            + self.flash_layout.sectors[erase_pages[page].sector].start_address;
-                    const cmd = [0x41, page_addr & 0xff, (page_addr >> 8) & 0xff, (page_addr >> 16) & 0xff, (page_addr >> 24) & 0xff];
-                    total_erased += self.flash_layout.sectors[erase_pages[page].sector].page_size;
-                    console.log(`Erasing. sector ${erase_pages[page].sector}, page ${erase_pages[page].page} @ 0x${page_addr.toString(16)}`);
-
-                    self.controlTransfer('out', self.request.DNLOAD, 0, 0, 0, cmd, function () {
-                        self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-                            if (data[4] === self.state.dfuDNBUSY) { // completely normal
-                                const delay = data[1] | (data[2] << 8) | (data[3] << 16);
-
-                                setTimeout(function () {
-                                    self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-
-                                        if (data[4] === self.state.dfuDNBUSY) {
-
-                                            //
-                                            // H743 Rev.V (probably other H7 Rev.Vs also) remains in dfuDNBUSY state after the specified delay time.
-                                            // STM32CubeProgrammer deals with behavior with an undocumented procedure as follows.
-                                            //     1. Issue DFU_CLRSTATUS, which ends up with (14,10) = (errUNKNOWN, dfuERROR)
-                                            //     2. Issue another DFU_CLRSTATUS which delivers (0,2) = (OK, dfuIDLE)
-                                            //     3. Treat the current erase successfully finished.
-                                            // Here, we call clarStatus to get to the dfuIDLE state.
-                                            //
-
-                                            console.log('erase_page: dfuDNBUSY after timeout, clearing');
-
-                                            self.clearStatus(function() {
-                                                self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-                                                    if (data[4] === self.state.dfuIDLE) {
-                                                        erase_page_next();
-                                                    } else {
-                                                        console.log(`Failed to erase page 0x${page_addr.toString(16)} (did not reach dfuIDLE after clearing`);
-                                                        self.cleanup();
-                                                    }
-                                                });
-                                            });
-                                        } else if (data[4] === self.state.dfuDNLOAD_IDLE) {
-                                            erase_page_next();
-                                        } else {
-                                            console.log(`Failed to erase page 0x${page_addr.toString(16)}`);
-                                            self.cleanup();
-                                        }
-                                    });
-                                }, delay);
-                            } else {
-                                console.log(`Failed to initiate page erase, page 0x${page_addr.toString(16)}`);
-                                self.cleanup();
-                            }
-                        });
-                    });
-                };
-
-                // start
-                erase_page();
-            break;
-        }
-        case 4: {
-            // upload
-            // we dont need to clear the state as we are already using DFU_DNLOAD
-            console.log('Writing data ...');
-            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32Flashing'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
-
-            blocks = self.hex.data.length - 1;
-            let flashing_block = 0;
-            address = self.hex.data[flashing_block].address;
-
-            let bytes_flashed = 0;
-            let bytes_flashed_total = 0; // used for progress bar
-            wBlockNum = 2; // required by DFU
-
-            const write = function () {
-                if (bytes_flashed < self.hex.data[flashing_block].bytes) {
-                    const bytes_to_write = ((bytes_flashed + self.transferSize) <= self.hex.data[flashing_block].bytes) ? self.transferSize : (self.hex.data[flashing_block].bytes - bytes_flashed);
-
-                    const data_to_flash = self.hex.data[flashing_block].data.slice(bytes_flashed, bytes_flashed + bytes_to_write);
-
-                    address += bytes_to_write;
-                    bytes_flashed += bytes_to_write;
-                    bytes_flashed_total += bytes_to_write;
-
-                    self.controlTransfer('out', self.request.DNLOAD, wBlockNum++, 0, 0, data_to_flash, function () {
-                        self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-                            if (data[4] === self.state.dfuDNBUSY) {
-                                const delay = data[1] | (data[2] << 8) | (data[3] << 16);
-
-                                setTimeout(function () {
-                                    self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-                                        if (data[4] === self.state.dfuDNLOAD_IDLE) {
-                                            // update progress bar
-                                            TABS.firmware_flasher.flashProgress(bytes_flashed_total / (self.hex.bytes_total * 2) * 100);
-
-                                            // flash another page
-                                            write();
-                                        } else {
-                                            console.log(`Failed to write ${bytes_to_write}bytes to 0x${address.toString(16)}`);
-                                            self.cleanup();
-                                        }
-                                    });
-                                }, delay);
-                            } else {
-                                console.log(`Failed to initiate write ${bytes_to_write}bytes to 0x${address.toString(16)}`);
-                                self.cleanup();
-                            }
-                        });
-                    });
-                } else {
-                    if (flashing_block < blocks) {
-                        // move to another block
-                        flashing_block++;
-
-                        address = self.hex.data[flashing_block].address;
-                        bytes_flashed = 0;
-                        wBlockNum = 2;
-
-                        self.loadAddress(address, write);
-                    } else {
-                        // all blocks flashed
-                        console.log('Writing: done');
-
-                        // proceed to next step
-                        self.upload_procedure(5);
-                    }
-                }
-            };
-
-            // start
-            self.loadAddress(address, write);
-
-            break;
-        }
-        case 5: {
-            // verify
-            console.log('Verifying data ...');
-            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32Verifying'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
-
-            blocks = self.hex.data.length - 1;
-            let reading_block = 0;
-            address = self.hex.data[reading_block].address;
-
-            let bytes_verified = 0;
-            let bytes_verified_total = 0; // used for progress bar
-            wBlockNum = 2; // required by DFU
-
-            // initialize arrays
-            for (let i = 0; i <= blocks; i++) {
-                self.verify_hex.push([]);
-            }
-
-            // start
-            self.clearStatus(function () {
-                self.loadAddress(address, function () {
-                    self.clearStatus(read);
-                });
-            });
-
-            const read = function () {
-                if (bytes_verified < self.hex.data[reading_block].bytes) {
-                    const bytes_to_read = ((bytes_verified + self.transferSize) <= self.hex.data[reading_block].bytes) ? self.transferSize : (self.hex.data[reading_block].bytes - bytes_verified);
-
-                    self.controlTransfer('in', self.request.UPLOAD, wBlockNum++, 0, bytes_to_read, 0, function (data, code) {
-                        for (const piece of data) {
-                            self.verify_hex[reading_block].push(piece);
-                        }
-
-                        address += bytes_to_read;
-                        bytes_verified += bytes_to_read;
-                        bytes_verified_total += bytes_to_read;
-
-                        // update progress bar
-                        TABS.firmware_flasher.flashProgress((self.hex.bytes_total + bytes_verified_total) / (self.hex.bytes_total * 2) * 100);
-
-                        // verify another page
-                        read();
-                    });
-                } else {
-                    if (reading_block < blocks) {
-                        // move to another block
-                        reading_block++;
-
-                        address = self.hex.data[reading_block].address;
-                        bytes_verified = 0;
-                        wBlockNum = 2;
-
-                        self.clearStatus(function () {
-                            self.loadAddress(address, function () {
-                                self.clearStatus(read);
-                            });
-                        });
-                    } else {
-                        // all blocks read, verify
-
-                        let verify = true;
-                        for (let i = 0; i <= blocks; i++) {
-                            verify = self.verify_flash(self.hex.data[i].data, self.verify_hex[i]);
-
-                            if (!verify) break;
-                        }
-
-                        if (verify) {
-                            console.log('Programming: SUCCESSFUL');
-                            // update progress bar
-                            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ProgrammingSuccessful'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.VALID);
-
-                            // proceed to next step
-                            self.leave();
-                        } else {
-                            console.log('Programming: FAILED');
-                            // update progress bar
-                            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ProgrammingFailed'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
-
-                            // disconnect
-                            self.cleanup();
-                        }
-                    }
-                }
-            };
-            break;
-        }
-    }
-};
-
-STM32DFU_protocol.prototype.leave = function () {
-    // leave DFU
-
-    const self = this;
-
-    let address;
-    if (self.hex) {
-        address = self.hex.data[0].address;
-    } else {
-        // Assuming we're running off internal flash
-        address =  0x08000000;
-    }
-
-    self.clearStatus(function () {
-        self.loadAddress(address, function () {
-            // 'downloading' 0 bytes to the program start address followed by a GETSTATUS is used to trigger DFU exit on STM32
-            self.controlTransfer('out', self.request.DNLOAD, 0, 0, 0, 0, function () {
-                self.controlTransfer('in', self.request.GETSTATUS, 0, 0, 6, 0, function (data) {
-                    self.cleanup();
-                });
-            });
-        });
-    });
-};
-
-STM32DFU_protocol.prototype.cleanup = function () {
-    const self = this;
-
-    self.releaseInterface(0);
-
-    GUI.connect_lock = false;
-
-    const timeSpent = new Date().getTime() - self.upload_time_start;
-
-    console.log(`Script finished after: ${timeSpent / 1000} seconds`);
-
-    if (self.callback) {
-        self.callback();
-    }
-};
-
-// initialize object
-const STM32DFU = new STM32DFU_protocol();
-
-export default STM32DFU;
diff --git a/src/js/protocols/webstm32.js b/src/js/protocols/webstm32.js
new file mode 100644
index 0000000000..c75f44ff09
--- /dev/null
+++ b/src/js/protocols/webstm32.js
@@ -0,0 +1,953 @@
+/*
+    STM32 F103 serial bus seems to properly initialize with quite a huge auto-baud range
+    From 921600 down to 1200, i don't recommend getting any lower then that
+    Official "specs" are from 115200 to 1200
+
+    popular choices - 921600, 460800, 256000, 230400, 153600, 128000, 115200, 57600, 38400, 28800, 19200
+*/
+import MSPConnectorImpl from "../msp/MSPConnector";
+import GUI, { TABS } from "../gui";
+import { i18n } from "../localization";
+import MSP from "../msp";
+import FC from "../fc";
+import { bit_check } from "../bit";
+import { gui_log } from "../gui_log";
+import MSPCodes from "../msp/MSPCodes";
+import PortUsage from "../port_usage";
+import PortHandler from "../port_handler";
+import { API_VERSION_1_42 } from "../data_storage";
+import semver from "semver";
+import $ from 'jquery';
+import serial from "../webSerial";
+import DFU from "../protocols/webusbdfu";
+import { read_serial } from "../serial_backend";
+
+function readSerialAdapter(event) {
+    read_serial(event.detail.buffer);
+}
+
+function onTimeoutHandler() {
+    GUI.connect_lock = false;
+    console.log('Looking for capabilities via MSP failed');
+
+    TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32RebootingToBootloaderFailed'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
+}
+
+function onFailureHandler() {
+    GUI.connect_lock = false;
+    TABS.firmware_flasher.refresh();
+}
+
+class STM32Protocol {
+    constructor() {
+        this.baud = null;
+        this.options = {};
+        this.callback = null;
+        this.hex = null;
+        this.verify_hex = [];
+
+        this.receive_buffer = [];
+
+        this.bytesToRead = 0;
+        this.read_callback = null;
+
+        this.upload_time_start = 0;
+        this.upload_process_alive = false;
+
+        this.mspConnector = new MSPConnectorImpl();
+
+        this.status = {
+            ACK: 0x79, // y
+            NACK: 0x1F,
+        };
+
+        this.command = {
+            get: 0x00, // Gets the version and the allowed commands supported by the current version of the bootloader
+            get_ver_r_protect_s: 0x01, // Gets the bootloader version and the Read Protection status of the Flash memory
+            get_ID: 0x02, // Gets the chip ID
+            read_memory: 0x11, // Reads up to 256 bytes of memory starting from an address specified by the application
+            go: 0x21, // Jumps to user application code located in the internal Flash memory or in SRAM
+            write_memory: 0x31, // Writes up to 256 bytes to the RAM or Flash memory starting from an address specified by the application
+            erase: 0x43, // Erases from one to all the Flash memory pages
+            extended_erase: 0x44, // Erases from one to all the Flash memory pages using two byte addressing mode (v3.0+ usart).
+            write_protect: 0x63, // Enables the write protection for some sectors
+            write_unprotect: 0x73, // Disables the write protection for all Flash memory sectors
+            readout_protect: 0x82, // Enables the read protection
+            readout_unprotect: 0x92, // Disables the read protection
+        };
+
+        // Erase (x043) and Extended Erase (0x44) are exclusive. A device may support either the Erase command or the Extended Erase command but not both.
+        this.available_flash_size = 0;
+        this.page_size = 0;
+        this.useExtendedErase = false;
+        this.rebootMode = 0;
+        this.handleMSPConnect = this.handleMSPConnect.bind(this);
+    }
+
+    startFlashing() {
+        if (this.rebootMode === 0) {
+            return;
+        }
+
+        // refresh device list
+        if (PortHandler.dfuAvailable) {
+            DFU.connect(this.hex, this.serialOptions);
+        } else {
+            // TODO: update to use web serial / USB API
+            this.prepareSerialPort();
+            console.log('Connecting to serial port', this.port, this.baud);
+            serial.connect(this.port, { bitrate: this.baud, parityBit: 'even', stopBits: 'one' }, (openInfo) => {
+                if (openInfo) {
+                    this.initialize();
+                } else {
+                    GUI.connect_lock = false;
+                    gui_log(i18n.getMessage('serialPortOpenFail'));
+                }
+            });
+        }
+    }
+
+    handleConnect(event) {
+        console.log('Connected to serial port', event.detail, event);
+        if (event) {
+            // we are connected, disabling connect button in the UI
+            GUI.connect_lock = true;
+
+            this.initialize();
+        } else {
+            gui_log(i18n.getMessage('serialPortOpenFail'));
+        }
+    }
+
+    handleDisconnect(disconnectionResult) {
+        console.log('Waiting for DFU connection', disconnectionResult);
+
+        serial.removeEventListener('connect', (event) => this.handleConnect(event.detail));
+        serial.removeEventListener('disconnect', (event) => this.handleDisconnect(event.detail));
+
+        if (disconnectionResult) {
+            // wait until board boots into bootloader mode
+            // MacOs may need 5 seconds delay
+            let failedAttempts = 0;
+            let dfuWaitInterval = null;
+
+            function waitForDfu() {
+                if (PortHandler.dfuAvailable) {
+                    console.log(`DFU available after ${failedAttempts} seconds`);
+                    clearInterval(dfuWaitInterval);
+                    this.startFlashing();
+                } else {
+                    failedAttempts++;
+                    if (failedAttempts > 10) {
+                        clearInterval(dfuWaitInterval);
+                        console.log(`failed to get DFU connection, gave up after 10 seconds`);
+                        gui_log(i18n.getMessage('serialPortOpenFail'));
+                        GUI.connect_lock = false;
+                    }
+                }
+            }
+
+            if (PortHandler.dfuAvailable) {
+                console.log('DFU device found');
+                this.startFlashing();
+            } else {
+                DFU.requestPermission().then(port => {
+                    if (port) {
+                        console.log('DFU device found on port', port);
+                        this.startFlashing();
+                    } else {
+                        console.log('No DFU device found');
+                        dfuWaitInterval = setInterval(() => {
+                            console.log('Checking for DFU connection');
+                            waitForDfu();
+                        }, 1000);
+                    }
+                });
+            }
+        } else {
+            GUI.connect_lock = false;
+        }
+    }
+
+    prepareSerialPort() {
+        serial.removeEventListener('connect', (event) => this.handleConnect(event.detail));
+        serial.addEventListener('connect', (event) => this.handleConnect(event.detail), { once: true });
+
+        serial.removeEventListener('disconnect', (event) => this.handleDisconnect(event.detail));
+        serial.addEventListener('disconnect', (event) => this.handleDisconnect(event.detail) , { once: true });
+    }
+
+    // TODO: remove this method once all devices are updated to use the new method
+    legacyRebootAndFlash() {
+        this.prepareSerialPort();
+        serial.connect(this.port, { bitrate: this.options.reboot_baud }, (openInfo) => {
+            if (!openInfo) {
+                GUI.connect_lock = false;
+                gui_log(i18n.getMessage('serialPortOpenFail'));
+                return;
+            }
+
+            console.log('Using legacy reboot method');
+
+            console.log('Sending ascii "R" to reboot');
+            const bufferOut = new ArrayBuffer(1);
+            const bufferView = new Uint8Array(bufferOut);
+
+            bufferView[0] = 0x52;
+
+            serial.send(bufferOut, () => {
+                serial.disconnect(disconnectionResult => this.handleDisconnect(disconnectionResult));
+            });
+        });
+    }
+
+    reboot() {
+        const buffer = [];
+        buffer.push8(this.rebootMode);
+        setTimeout(() => {
+            MSP.promise(MSPCodes.MSP_SET_REBOOT, buffer)
+            .then(() => {
+                // if firmware doesn't flush MSP/serial send buffers and gracefully shutdown VCP connections we won't get a reply, so don't wait for it.
+                this.mspConnector.disconnect(disconnectionResult => {
+                    console.log('Disconnecting from MSP', disconnectionResult);
+                    this.handleDisconnect(disconnectionResult);
+                });
+            });
+            console.log('Reboot request received by device');
+        }, 100);
+    }
+
+    onAbort() {
+        GUI.connect_lock = false;
+        this.rebootMode = 0;
+        console.log('User cancelled because selected target does not match verified board');
+        this.reboot();
+        TABS.firmware_flasher.refresh();
+    }
+
+    lookingForCapabilitiesViaMSP() {
+        console.log('Looking for capabilities via MSP');
+
+        MSP.promise(MSPCodes.MSP_BOARD_INFO)
+        .then(() => {
+            if (bit_check(FC.CONFIG.targetCapabilities, FC.TARGET_CAPABILITIES_FLAGS.HAS_FLASH_BOOTLOADER)) {
+                // Board has flash bootloader
+                gui_log(i18n.getMessage('deviceRebooting_flashBootloader'));
+                console.log('flash bootloader detected');
+                this.rebootMode = 4; // MSP_REBOOT_BOOTLOADER_FLASH
+            } else {
+                gui_log(i18n.getMessage('deviceRebooting_romBootloader'));
+                console.log('no flash bootloader detected');
+                this.rebootMode = 1; // MSP_REBOOT_BOOTLOADER_ROM;
+            }
+
+            const selectedBoard = TABS.firmware_flasher.selectedBoard !== '0' ? TABS.firmware_flasher.selectedBoard : 'NONE';
+            const connectedBoard = FC.CONFIG.boardName ? FC.CONFIG.boardName : 'UNKNOWN';
+
+            try {
+                if (selectedBoard !== connectedBoard && !TABS.firmware_flasher.localFirmwareLoaded) {
+                    TABS.firmware_flasher.showDialogVerifyBoard(selectedBoard, connectedBoard, this.onAbort, this.reboot);
+                } else {
+                    this.reboot();
+                }
+            } catch (e) {
+                console.error(e);
+                this.reboot();
+            }
+        });
+    }
+
+    handleMSPConnect() {
+        gui_log(i18n.getMessage('apiVersionReceived', [FC.CONFIG.apiVersion]));
+
+        if (semver.lt(FC.CONFIG.apiVersion, API_VERSION_1_42)) {
+            this.mspConnector.disconnect((disconnectionResult) => {
+                // need some time for the port to be closed, serial port does not open if tried immediately
+                setTimeout(this.legacyRebootAndFlash, 500);
+            });
+        } else {
+            this.lookingForCapabilitiesViaMSP();
+        }
+    }
+
+    // no input parameters
+    connect(port, baud, hex, options, callback) {
+        this.hex = hex;
+        this.port = port;
+        this.baud = baud;
+        this.callback = callback;
+        this.serialOptions = options;
+
+        // we will crunch the options here since doing it inside initialization routine would be too late
+        this.mspOptions = {
+            no_reboot: false,
+            reboot_baud: false,
+            erase_chip: false,
+        };
+
+        if (options.no_reboot) {
+            this.mspOptions.no_reboot = true;
+        } else {
+            this.mspOptions.reboot_baud = options.reboot_baud;
+        }
+
+        if (options.erase_chip) {
+            this.mspOptions.erase_chip = true;
+        }
+
+        if (this.options.no_reboot) {
+            // TODO: update to use web serial / USB API
+            this.prepareSerialPort();
+            serial.connect(port, { baudRate: this.baud, parityBit: 'even', stopBits: 'one' });
+        } else {
+            this.rebootMode = 0; // FIRMWARE
+
+            GUI.connect_lock = true;
+            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32RebootingToBootloader'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
+
+            serial.addEventListener('disconnect', (event) => this.handleDisconnect(event.detail), { once: true });
+
+            this.mspConnector.connect(this.port, this.mspOptions.reboot_baud, this.handleMSPConnect, onTimeoutHandler, onFailureHandler);
+        }
+    }
+
+    // initialize certain variables and start timers that oversee the communication
+    initialize() {
+
+        console.log(":exploding_head:");
+
+        // reset and set some variables before we start
+        this.receive_buffer = [];
+        this.verify_hex = [];
+
+        this.upload_time_start = new Date().getTime();
+        this.upload_process_alive = false;
+
+        // reset progress bar to initial state
+        TABS.firmware_flasher.flashingMessage(null, TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL)
+            .flashProgress(0);
+
+        // lock some UI elements TODO needs rework
+        $('select[name="release"]').prop('disabled', true);
+
+        serial.removeEventListener('receive', readSerialAdapter);
+        serial.addEventListener('receive', readSerialAdapter);
+
+        GUI.interval_add('STM32_timeout', () => {
+            if (this.upload_process_alive) { // process is running
+                this.upload_process_alive = false;
+            } else {
+                console.log('STM32 - timed out, programming failed ...');
+
+                TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32TimedOut'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
+
+                // protocol got stuck, clear timer and disconnect
+                GUI.interval_remove('STM32_timeout');
+
+                // exit
+                this.upload_procedure(99);
+            }
+        }, 2000);
+
+        console.log('STM32 - Initialization done, starting upload procedure');
+
+        this.upload_procedure(1);
+    }
+    // no input parameters
+    // this method should be executed every 1 ms via interval timer
+    read(readInfo) {
+        // routine that fills the buffer
+        const data = new Uint8Array(readInfo.data);
+
+        for (const instance of data) {
+            this.receive_buffer.push(instance);
+        }
+
+        // routine that fetches data from buffer if statement is true
+        if (this.receive_buffer.length >= this.bytesToRead && this.bytesToRead != 0) {
+            const fetched = this.receive_buffer.slice(0, this.bytesToRead); // bytes requested
+            this.receive_buffer.splice(0, this.bytesToRead); // remove read bytes
+
+            this.bytesToRead = 0; // reset trigger
+
+            this.read_callback(fetched);
+        }
+    }
+    // we should always try to consume all "proper" available data while using retrieve
+    retrieve(nBytes, callback) {
+        if (this.receive_buffer.length >= nBytes) {
+            // data that we need are there, process immediately
+            const data = this.receive_buffer.slice(0, nBytes);
+            this.receive_buffer.splice(0, nBytes); // remove read bytes
+
+            callback(data);
+        } else {
+            // still waiting for data, add callback
+            this.bytesToRead = nBytes;
+            this.read_callback = callback;
+        }
+    }
+    // bytes_to_send = array of bytes that will be send over serial
+    // bytesToRead = received bytes necessary to trigger read_callback
+    // callback = function that will be executed after received bytes = bytesToRead
+    send(bytes_to_send, bytesToRead, callback) {
+        // flip flag
+        this.upload_process_alive = true;
+
+        const bufferOut = new ArrayBuffer(bytes_to_send.length);
+        const bufferView = new Uint8Array(bufferOut);
+
+        // set bytes_to_send values inside bufferView (alternative to for loop)
+        bufferView.set(bytes_to_send);
+
+        // update references
+        this.bytesToRead = bytesToRead;
+        this.read_callback = callback;
+
+        // empty receive buffer before next command is out
+        this.receive_buffer = [];
+
+        // send over the actual data
+        serial.send(bufferOut);
+    }
+    // val = single byte to be verified
+    // data = response of n bytes from mcu (array)
+    // result = true/false
+    verify_response(val, data) {
+
+        if (val !== data[0]) {
+            const message = `STM32 Communication failed, wrong response, expected: ${val} (0x${val.toString(16)}) received: ${data[0]} (0x${data[0].toString(16)})`;
+            console.error(message);
+            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32WrongResponse', [val, val.toString(16), data[0], data[0].toString(16)]), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
+
+            // disconnect
+            this.upload_procedure(99);
+
+            return false;
+        }
+
+        return true;
+    }
+    // input = 16 bit value
+    // result = true/false
+    verify_chip_signature(signature) {
+        switch (signature) {
+            case 0x412: // not tested
+                console.log('Chip recognized as F1 Low-density');
+                break;
+            case 0x410:
+                console.log('Chip recognized as F1 Medium-density');
+                this.available_flash_size = 131072;
+                this.page_size = 1024;
+                break;
+            case 0x414:
+                this.available_flash_size = 0x40000;
+                this.page_size = 2048;
+                console.log('Chip recognized as F1 High-density');
+                break;
+            case 0x418: // not tested
+                console.log('Chip recognized as F1 Connectivity line');
+                break;
+            case 0x420: // not tested
+                console.log('Chip recognized as F1 Medium-density value line');
+                break;
+            case 0x428: // not tested
+                console.log('Chip recognized as F1 High-density value line');
+                break;
+            case 0x430: // not tested
+                console.log('Chip recognized as F1 XL-density value line');
+                break;
+            case 0x416: // not tested
+                console.log('Chip recognized as L1 Medium-density ultralow power');
+                break;
+            case 0x436: // not tested
+                console.log('Chip recognized as L1 High-density ultralow power');
+                break;
+            case 0x427: // not tested
+                console.log('Chip recognized as L1 Medium-density plus ultralow power');
+                break;
+            case 0x411: // not tested
+                console.log('Chip recognized as F2 STM32F2xxxx');
+                break;
+            case 0x440: // not tested
+                console.log('Chip recognized as F0 STM32F051xx');
+                break;
+            case 0x444: // not tested
+                console.log('Chip recognized as F0 STM32F050xx');
+                break;
+            case 0x413: // not tested
+                console.log('Chip recognized as F4 STM32F40xxx/41xxx');
+                break;
+            case 0x419: // not tested
+                console.log('Chip recognized as F4 STM32F427xx/437xx, STM32F429xx/439xx');
+                break;
+            case 0x432: // not tested
+                console.log('Chip recognized as F3 STM32F37xxx, STM32F38xxx');
+                break;
+            case 0x422:
+                console.log('Chip recognized as F3 STM32F30xxx, STM32F31xxx');
+                this.available_flash_size = 0x40000;
+                this.page_size = 2048;
+                break;
+            default:
+                console.log(`Chip NOT recognized: ${signature}`);
+                break;
+        }
+
+        if (this.available_flash_size > 0) {
+            if (this.hex.bytes_total < this.available_flash_size) {
+                return true;
+            } else {
+                console.log(`Supplied hex is bigger then flash available on the chip, HEX: ${this.hex.bytes_total} bytes, limit = ${this.available_flash_size} bytes`);
+                return false;
+            }
+        }
+
+        console.log(`Chip NOT recognized: ${signature}`);
+
+        return false;
+    }
+    // firstArray = usually hex_to_flash array
+    // secondArray = usually verify_hex array
+    // result = true/false
+    verify_flash(firstArray, secondArray) {
+        for (let i = 0; i < firstArray.length; i++) {
+            if (firstArray[i] !== secondArray[i]) {
+                console.log(`Verification failed on byte: ${i} expected: 0x${firstArray[i].toString(16)} received: 0x${secondArray[i].toString(16)}`);
+                return false;
+            }
+        }
+
+        console.log(`Verification successful, matching: ${firstArray.length} bytes`);
+
+        return true;
+    }
+    // step = value depending on current state of upload_procedure
+    upload_procedure(step) {
+
+        switch (step) {
+            case 1: {
+                // initialize serial interface on the MCU side, auto baud rate settings
+                TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ContactingBootloader'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
+
+                let sendCounter = 0;
+                GUI.interval_add('stm32_initialize_mcu', () => {
+                    this.send([0x7F], 1, (reply) => {
+                        if (reply[0] === 0x7F || reply[0] === this.status.ACK || reply[0] === this.status.NACK) {
+                            GUI.interval_remove('stm32_initialize_mcu');
+                            console.log('STM32 - Serial interface initialized on the MCU side');
+
+                            // proceed to next step
+                            this.upload_procedure(2);
+                        } else {
+                            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ContactingBootloaderFailed'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
+
+                            GUI.interval_remove('stm32_initialize_mcu');
+
+                            // disconnect
+                            this.upload_procedure(99);
+                        }
+                    });
+
+                    if (sendCounter++ > 3) {
+                        // stop retrying, its too late to get any response from MCU
+                        console.log('STM32 - no response from bootloader, disconnecting');
+
+                        TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ResponseBootloaderFailed'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
+
+                        GUI.interval_remove('stm32_initialize_mcu');
+                        GUI.interval_remove('STM32_timeout');
+
+                        // exit
+                        this.upload_procedure(99);
+                    }
+                }, 250, true);
+
+                break;
+            }
+            case 2: {
+                // get version of the bootloader and supported commands
+                this.send([this.command.get, 0xFF], 2, (data) => {
+                    if (this.verify_response(this.status.ACK, data)) {
+                        this.retrieve(data[1] + 1 + 1, (data) => {
+                            console.log(`STM32 - Bootloader version: ${(parseInt(data[0].toString(16)) / 10).toFixed(1)}`); // convert dec to hex, hex to dec and add floating point
+
+                            this.useExtendedErase = (data[7] === this.command.extended_erase);
+
+                            // proceed to next step
+                            this.upload_procedure(3);
+                        });
+                    }
+                });
+
+                break;
+            }
+            case 3:
+                // get ID (device signature)
+                this.send([this.command.get_ID, 0xFD], 2, (data) => {
+                    if (this.verify_response(this.status.ACK, data)) {
+                        this.retrieve(data[1] + 1 + 1, (data) => {
+                            const signature = (data[0] << 8) | data[1];
+                            console.log(`STM32 - Signature: 0x${signature.toString(16)}`); // signature in hex representation
+
+                            if (this.verify_chip_signature(signature)) {
+                                // proceed to next step
+                                this.upload_procedure(4);
+                            } else {
+                                // disconnect
+                                this.upload_procedure(99);
+                            }
+                        });
+                    }
+                });
+
+                break;
+            case 4: {
+                // erase memory
+                if (this.useExtendedErase) {
+                    if (this.options.erase_chip) {
+
+                        const message = 'Executing global chip erase (via extended erase)';
+                        console.log(message);
+                        TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32GlobalEraseExtended'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
+
+                        this.send([this.command.extended_erase, 0xBB], 1, (reply) => {
+                            if (this.verify_response(this.status.ACK, reply)) {
+                                this.send([0xFF, 0xFF, 0x00], 1, (reply) => {
+                                    if (this.verify_response(this.status.ACK, reply)) {
+                                        console.log('Executing global chip extended erase: done');
+                                        this.upload_procedure(5);
+                                    }
+                                });
+                            }
+                        });
+
+                    } else {
+                        const message = 'Executing local erase (via extended erase)';
+                        console.log(message);
+                        TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32LocalEraseExtended'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
+
+                        this.send([this.command.extended_erase, 0xBB], 1, (reply) => {
+                            if (this.verify_response(this.status.ACK, reply)) {
+
+                                // For reference: https://code.google.com/p/stm32flash/source/browse/stm32.c#723
+                                const maxAddress = this.hex.data[this.hex.data.length - 1].address + this.hex.data[this.hex.data.length - 1].bytes - 0x8000000;
+                                const erasePagesN = Math.ceil(maxAddress / this.page_size);
+                                const buff = [];
+                                let checksum = 0;
+
+                                let pgByte;
+
+                                pgByte = (erasePagesN - 1) >> 8;
+                                buff.push(pgByte);
+                                checksum ^= pgByte;
+                                pgByte = (erasePagesN - 1) & 0xFF;
+                                buff.push(pgByte);
+                                checksum ^= pgByte;
+
+
+                                for (let i = 0; i < erasePagesN; i++) {
+                                    pgByte = i >> 8;
+                                    buff.push(pgByte);
+                                    checksum ^= pgByte;
+                                    pgByte = i & 0xFF;
+                                    buff.push(pgByte);
+                                    checksum ^= pgByte;
+                                }
+
+                                buff.push(checksum);
+                                console.log(`Erasing. pages: 0x00 - 0x${erasePagesN.toString(16)}, checksum: 0x${checksum.toString(16)}`);
+
+                                this.send(buff, 1, (_reply) => {
+                                    if (this.verify_response(this.status.ACK, _reply)) {
+                                        console.log('Erasing: done');
+                                        // proceed to next step
+                                        this.upload_procedure(5);
+                                    }
+                                });
+                            }
+                        });
+
+
+                    }
+                    break;
+                }
+
+                if (this.options.erase_chip) {
+                    const message = 'Executing global chip erase';
+                    console.log(message);
+                    TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32GlobalErase'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
+
+                    this.send([this.command.erase, 0xBC], 1, (reply) => {
+                        if (this.verify_response(this.status.ACK, reply)) {
+                            this.send([0xFF, 0x00], 1, (reply) => {
+                                if (this.verify_response(this.status.ACK, reply)) {
+                                    console.log('Erasing: done');
+                                    // proceed to next step
+                                    this.upload_procedure(5);
+                                }
+                            });
+                        }
+                    });
+                } else {
+                    const message = 'Executing local erase';
+                    console.log(message);
+                    TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32LocalErase'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
+
+                    this.send([this.command.erase, 0xBC], 1, (reply) => {
+                        if (this.verify_response(this.status.ACK, reply)) {
+                            // the bootloader receives one byte that contains N, the number of pages to be erased – 1
+                            const maxAddress = this.hex.data[this.hex.data.length - 1].address + this.hex.data[this.hex.data.length - 1].bytes - 0x8000000;
+                            const erasePagesN = Math.ceil(maxAddress / this.page_size);
+                            const buff = [];
+                            let checksum = erasePagesN - 1;
+
+                            buff.push(erasePagesN - 1);
+
+                            for (let ii = 0; ii < erasePagesN; ii++) {
+                                buff.push(ii);
+                                checksum ^= ii;
+                            }
+
+                            buff.push(checksum);
+
+                            this.send(buff, 1, (reply) => {
+                                if (this.verify_response(this.status.ACK, reply)) {
+                                    console.log('Erasing: done');
+                                    // proceed to next step
+                                    this.upload_procedure(5);
+                                }
+                            });
+                        }
+                    });
+                }
+
+                break;
+            }
+            case 5: {
+                // upload
+                console.log('Writing data ...');
+                TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32Flashing'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
+
+                let blocks = this.hex.data.length - 1, flashing_block = 0, address = this.hex.data[flashing_block].address, bytes_flashed = 0, bytes_flashed_total = 0; // used for progress bar
+
+                const write = () => {
+                    if (bytes_flashed < this.hex.data[flashing_block].bytes) {
+                        const bytesToWrite = ((bytes_flashed + 256) <= this.hex.data[flashing_block].bytes) ? 256 : (this.hex.data[flashing_block].bytes - bytes_flashed);
+
+                        // DEBUG - console.log('STM32 - Writing to: 0x' + address.toString(16) + ', ' + bytesToWrite + ' bytes');
+                        this.send([this.command.write_memory, 0xCE], 1, (reply) => {
+                            if (this.verify_response(this.status.ACK, reply)) {
+                                // address needs to be transmitted as 32 bit integer, we need to bit shift each byte out and then calculate address checksum
+                                const addressArray = [(address >> 24), (address >> 16), (address >> 8), address];
+                                const addressChecksum = addressArray[0] ^ addressArray[1] ^ addressArray[2] ^ addressArray[3];
+                                // write start address + checksum
+                                this.send([addressArray[0], addressArray[1], addressArray[2], addressArray[3], addressChecksum], 1, (_reply) => {
+                                    if (this.verify_response(this.status.ACK, _reply)) {
+                                        const arrayOut = Array.from(bytesToWrite + 2); // 2 byte overhead [N, ...., checksum]
+                                        arrayOut[0] = bytesToWrite - 1; // number of bytes to be written (to write 128 bytes, N must be 127, to write 256 bytes, N must be 255)
+
+                                        let checksum = arrayOut[0];
+                                        for (let ii = 0; ii < bytesToWrite; ii++) {
+                                            arrayOut[ii + 1] = this.hex.data[flashing_block].data[bytes_flashed]; // + 1 because of the first byte offset
+                                            checksum ^= this.hex.data[flashing_block].data[bytes_flashed];
+
+                                            bytes_flashed++;
+                                        }
+                                        arrayOut[arrayOut.length - 1] = checksum; // checksum (last byte in the arrayOut array)
+
+                                        address += bytesToWrite;
+                                        bytes_flashed_total += bytesToWrite;
+
+                                        this.send(arrayOut, 1, (response) => {
+                                            if (this.verify_response(this.status.ACK, response)) {
+                                                // flash another page
+                                                write();
+                                            }
+                                        });
+
+                                        // update progress bar
+                                        TABS.firmware_flasher.flashProgress(Math.round(bytes_flashed_total / (this.hex.bytes_total * 2) * 100));
+                                    }
+                                });
+                            }
+                        });
+                    } else if (flashing_block < blocks) {
+                        // move to another block
+                        flashing_block++;
+
+                        address = this.hex.data[flashing_block].address;
+                        bytes_flashed = 0;
+
+                        write();
+                    } else {
+                        // all blocks flashed
+                        console.log('Writing: done');
+
+                        // proceed to next step
+                        this.upload_procedure(6);
+                    }
+                };
+
+                // start writing
+                write();
+
+                break;
+            }
+            case 6: {
+                // verify
+                console.log('Verifying data ...');
+                TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32Verifying'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.NEUTRAL);
+
+                const blocks = this.hex.data.length - 1;
+                let readingBlock = 0;
+                let address = this.hex.data[readingBlock].address;
+                let bytesVerified = 0;
+                let bytesVerifiedTotal = 0; // used for progress bar
+
+
+                // initialize arrays
+                for (let i = 0; i <= blocks; i++) {
+                    this.verify_hex.push([]);
+                }
+
+                const reading = () => {
+                    if (bytesVerified < this.hex.data[readingBlock].bytes) {
+                        const bytesToRead = ((bytesVerified + 256) <= this.hex.data[readingBlock].bytes) ? 256 : (this.hex.data[readingBlock].bytes - bytesVerified);
+
+                        // DEBUG console.log('STM32 - Reading from: 0x' + address.toString(16) + ', ' + bytesToRead + ' bytes');
+                        this.send([this.command.read_memory, 0xEE], 1, (reply) => {
+                            if (this.verify_response(this.status.ACK, reply)) {
+                                const addressArray = [(address >> 24), (address >> 16), (address >> 8), address];
+                                const addressChecksum = addressArray[0] ^ addressArray[1] ^ addressArray[2] ^ addressArray[3];
+
+                                this.send([addressArray[0], addressArray[1], addressArray[2], addressArray[3], addressChecksum], 1, (_reply) => {
+                                    if (this.verify_response(this.status.ACK, _reply)) {
+                                        const bytesToReadN = bytesToRead - 1;
+                                        // bytes to be read + checksum XOR(complement of bytesToReadN)
+                                        this.send([bytesToReadN, (~bytesToReadN) & 0xFF], 1, (response) => {
+                                            if (this.verify_response(this.status.ACK, response)) {
+                                                this.retrieve(bytesToRead, (data) => {
+                                                    for (const instance of data) {
+                                                        this.verify_hex[readingBlock].push(instance);
+                                                    }
+
+                                                    address += bytesToRead;
+                                                    bytesVerified += bytesToRead;
+                                                    bytesVerifiedTotal += bytesToRead;
+
+                                                    // verify another page
+                                                    reading();
+                                                });
+                                            }
+                                        });
+
+                                        // update progress bar
+                                        TABS.firmware_flasher.flashProgress(Math.round((this.hex.bytes_total + bytesVerifiedTotal) / (this.hex.bytes_total * 2) * 100));
+                                    }
+                                });
+                            }
+                        });
+                    } else if (readingBlock < blocks) {
+                        // move to another block
+                        readingBlock++;
+
+                        address = this.hex.data[readingBlock].address;
+                        bytesVerified = 0;
+
+                        reading();
+                    } else {
+                        // all blocks read, verify
+                        let verify = true;
+                        for (let i = 0; i <= blocks; i++) {
+                            verify = this.verify_flash(this.hex.data[i].data, this.verify_hex[i]);
+
+                            if (!verify) {
+                                break;
+                            }
+                        }
+
+                        if (verify) {
+                            console.log('Programming: SUCCESSFUL');
+                            // update progress bar
+                            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ProgrammingSuccessful'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.VALID);
+
+                            // proceed to next step
+                            this.upload_procedure(7);
+                        } else {
+                            console.log('Programming: FAILED');
+                            // update progress bar
+                            TABS.firmware_flasher.flashingMessage(i18n.getMessage('stm32ProgrammingFailed'), TABS.firmware_flasher.FLASH_MESSAGE_TYPES.INVALID);
+
+                            // disconnect
+                            this.upload_procedure(99);
+                        }
+                    }
+                };
+
+                // start reading
+                reading();
+
+                break;
+            }
+            case 7: {
+                // go
+                // memory address = 4 bytes, 1st high byte, 4th low byte, 5th byte = checksum XOR(byte 1, byte 2, byte 3, byte 4)
+                console.log('Sending GO command: 0x8000000');
+
+                this.send([this.command.go, 0xDE], 1, (reply) => {
+                    if (this.verify_response(this.status.ACK, reply)) {
+                        const gtAddress = 0x8000000;
+                        const address = [(gtAddress >> 24), (gtAddress >> 16), (gtAddress >> 8), gtAddress];
+                        const addressChecksum = address[0] ^ address[1] ^ address[2] ^ address[3];
+
+                        this.send([address[0], address[1], address[2], address[3], addressChecksum], 1, (response) => {
+                            if (this.verify_response(this.status.ACK, response)) {
+                                // disconnect
+                                this.upload_procedure(99);
+                            }
+                        });
+                    }
+                });
+
+                break;
+            }
+            case 99: {
+                // disconnect
+                GUI.interval_remove('STM32_timeout'); // stop STM32 timeout timer (everything is finished now)
+
+
+                // close connection
+                if (serial.connectionId) {
+                    serial.disconnect(this.cleanup);
+                } else {
+                    this.cleanup();
+                }
+
+                break;
+            }
+        }
+    }
+    cleanup() {
+        PortUsage.reset();
+
+        // unlocking connect button
+        GUI.connect_lock = false;
+
+        // unlock some UI elements TODO needs rework
+        $('select[name="release"]').prop('disabled', false);
+
+        // handle timing
+        const timeSpent = new Date().getTime() - this.upload_time_start;
+
+        console.log(`Script finished after: ${(timeSpent / 1000)} seconds`);
+
+        if (this.callback) {
+            this.callback();
+        }
+    }
+}
+
+// initialize object
+const STM32 = new STM32Protocol();
+export default STM32;
diff --git a/src/js/tabs/firmware_flasher.js b/src/js/tabs/firmware_flasher.js
index 6e9c00a0fa..f2924c9636 100644
--- a/src/js/tabs/firmware_flasher.js
+++ b/src/js/tabs/firmware_flasher.js
@@ -16,17 +16,12 @@ import { gui_log } from '../gui_log';
 import semver from 'semver';
 import { urlExists } from '../utils/common';
 import { generateFilename } from '../utils/generate_filename';
+import read_hex_file from '../workers/hex_parser.js';
 import Sponsor from '../Sponsor';
 import FileSystem from '../FileSystem';
-import { usbDevices } from '../usb_devices.js';
-import { serialShim } from "../serial_shim.js";
-import { usbShim } from "../usb_shim.js";
-import STM32 from '../protocols/stm32';
-import { isWeb } from '../utils/isWeb.js';
-import read_hex_file from '../workers/hex_parser.js';
-
-let serial = serialShim();
-let dfu = usbShim();
+import STM32 from '../protocols/webstm32';
+import DFU from '../protocols/webusbdfu';
+import serial from '../webSerial';
 
 const firmware_flasher = {
     targets: null,
@@ -570,8 +565,6 @@ firmware_flasher.initialize = function (callback) {
             return output.join('').split('\n');
         }
 
-        const portPickerElement = $('div#port-picker #port');
-
         function flashFirmware(firmware) {
             const options = {};
 
@@ -582,37 +575,33 @@ firmware_flasher.initialize = function (callback) {
                 eraseAll = true;
             }
 
-            if (isWeb()) {
-                // TODO: Currently only web dfu is supported - add support for web serial
-                self.isFlashing = false;
-                return dfu.connect(firmware, options);
-            }
+            const port = PortHandler.portPicker.selectedPort;
+            const isSerial = port.startsWith('serial_');
+            const isDFU = port.startsWith('usb_');
 
-            if (!$('option:selected', portPickerElement).data().isDFU) {
-                if (String(portPickerElement.val()) !== '0') {
-                    const port = String(portPickerElement.val());
+            console.log('Selected port:', port);
 
-                    if ($('input.updating').is(':checked')) {
-                        options.no_reboot = true;
-                    } else {
-                        options.reboot_baud = parseInt($('div#port-picker #baud').val());
-                    }
+            if (isDFU) {
+                tracking.sendEvent(tracking.EVENT_CATEGORIES.FLASHING, 'DFU Flashing', { filename: self.filename || null });
+                DFU.connect(firmware, options);
+            } else if (isSerial) {
+                if ($('input.updating').is(':checked')) {
+                    options.no_reboot = true;
+                } else {
+                    options.reboot_baud = PortHandler.portPicker.selectedBauds;
+                }
 
-                    let baud = 115200;
-                    if ($('input.flash_manual_baud').is(':checked')) {
-                        baud = parseInt($('#flash_manual_baud_rate').val());
-                    }
+                let baud = 115200;
+                if ($('input.flash_manual_baud').is(':checked')) {
+                    baud = parseInt($('#flash_manual_baud_rate').val()) || 115200;
+                }
 
-                    tracking.sendEvent(tracking.EVENT_CATEGORIES.FLASHING, 'Flashing', { filename: self.filename || null });
+                tracking.sendEvent(tracking.EVENT_CATEGORIES.FLASHING, 'Flashing', { filename: self.filename || null });
 
-                    STM32.connect(port, baud, firmware, options);
-                } else {
-                    console.log('Please select valid serial port');
-                    gui_log(i18n.getMessage('firmwareFlasherNoValidPort'));
-                }
+                STM32.connect(port, baud, firmware, options);
             } else {
-                tracking.sendEvent(tracking.EVENT_CATEGORIES.FLASHING, 'DFU Flashing', { filename: self.filename || null });
-                dfu.connect(firmware, options);
+                console.log('Please select valid serial port');
+                gui_log(i18n.getMessage('firmwareFlasherNoValidPort'));
             }
 
             self.isFlashing = false;
@@ -939,7 +928,7 @@ firmware_flasher.initialize = function (callback) {
                 tracking.sendEvent(tracking.EVENT_CATEGORIES.FLASHING, 'ExitDfu', null);
                 try {
                     console.log('Closing DFU');
-                    dfu.connect(usbDevices, self.parsed_hex, { exitDfu: true });
+                    DFU.connect(self.parsed_hex, { exitDfu: true });
                 } catch (e) {
                     console.log(`Exiting DFU failed: ${e.message}`);
                 }
@@ -1138,6 +1127,10 @@ firmware_flasher.initialize = function (callback) {
 
         self.flashingMessage(i18n.getMessage('firmwareFlasherLoadFirmwareFile'), self.FLASH_MESSAGE_TYPES.NEUTRAL);
 
+        if (PortHandler.dfuAvailable) {
+            $('a.exit_dfu').removeClass('disabled');
+        }
+
         GUI.content_ready(callback);
     }
 
diff --git a/src/js/usb_shim.js b/src/js/usb_shim.js
deleted file mode 100644
index ba11f0537d..0000000000
--- a/src/js/usb_shim.js
+++ /dev/null
@@ -1,5 +0,0 @@
-import stm32usbdfu from "./protocols/stm32usbdfu.js";
-import webusbdfu from "./protocols/webusbdfu.js";
-import { isWeb } from "./utils/isWeb";
-
-export let usbShim = () => isWeb() ? webusbdfu : stm32usbdfu;