tasmota-webserial-esptool 9.2.9 → 9.2.10

package/dist/const.js

@@ -128,7 +128,7 @@ export const ESP32S3_UARTDEV_BUF_NO_USB_OTG = 3; // The above var when USB-OTG i
 export const ESP32S3_UARTDEV_BUF_NO_USB_JTAG_SERIAL = 4; // The above var when USB-JTAG/Serial is used
 export const ESP32C2_SPI_REG_BASE = 0x60002000;
 export const ESP32C2_BASEFUSEADDR = 0x60008800;
-export const ESP32C2_MACFUSEADDR = 0x60008800 + 0x044;
+export const ESP32C2_MACFUSEADDR = ESP32C2_BASEFUSEADDR + 0x040;
 export const ESP32C2_SPI_USR_OFFS = 0x18;
 export const ESP32C2_SPI_USR1_OFFS = 0x1c;
 export const ESP32C2_SPI_USR2_OFFS = 0x20;

package/dist/esp_loader.d.ts

@@ -16,9 +16,13 @@ export declare class ESPLoader extends EventTarget {
     __inputBuffer?: number[];
     __inputBufferReadIndex?: number;
     __totalBytesRead?: number;
-    private __currentBaudRate;
+    currentBaudRate: number;
     private _maxUSBSerialBaudrate?;
     __reader?: ReadableStreamDefaultReader<Uint8Array>;
+    private SLIP_END;
+    private SLIP_ESC;
+    private SLIP_ESC_END;
+    private SLIP_ESC_ESC;
     private _isESP32S2NativeUSB;
     private _initializationSucceeded;
     private __commandLock;
@@ -381,8 +385,6 @@ export declare class ESPLoader extends EventTarget {
     private set _writer(value);
     private get _writeChain();
     private set _writeChain(value);
-    private get _currentBaudRate();
-    private set _currentBaudRate(value);
     writeToStream(data: number[]): Promise<void>;
     disconnect(): Promise<void>;
     /**
@@ -431,6 +433,29 @@ export declare class ESPLoader extends EventTarget {
      * This is needed after Improv or other operations that leave ESP in firmware mode
      */
     reconnectToBootloader(): Promise<void>;
+    /**
+     * @name exitConsoleMode
+     * Exit console mode and return to bootloader
+     * For ESP32-S2, uses reconnectToBootloader which will trigger port change
+     * @returns true if manual reconnection is needed (ESP32-S2), false otherwise
+     */
+    exitConsoleMode(): Promise<boolean>;
+    /**
+     * @name isConsoleResetSupported
+     * Check if console reset is supported for this device
+     * ESP32-S2 USB-JTAG/CDC does not support reset in console mode
+     * because any reset causes USB port to be lost (hardware limitation)
+     */
+    isConsoleResetSupported(): boolean;
+    /**
+     * @name resetInConsoleMode
+     * Reset device while in console mode (firmware mode)
+     *
+     * NOTE: For ESP32-S2 USB-JTAG/CDC, ANY reset (hardware or software) causes
+     * the USB port to be lost because the device switches USB modes during reset.
+     * This is a hardware limitation - use isConsoleResetSupported() to check first.
+     */
+    resetInConsoleMode(): Promise<void>;
     /**
      * @name drainInputBuffer
      * Actively drain the input buffer by reading data for a specified time.

package/dist/esp_loader.js

@@ -26,7 +26,11 @@ export class ESPLoader extends EventTarget {
         this.IS_STUB = false;
         this.connected = true;
         this.flashSize = null;
-        this.__currentBaudRate = ESP_ROM_BAUD;
+        this.currentBaudRate = ESP_ROM_BAUD;
+        this.SLIP_END = 0xc0;
+        this.SLIP_ESC = 0xdb;
+        this.SLIP_ESC_END = 0xdc;
+        this.SLIP_ESC_ESC = 0xdd;
         this._isESP32S2NativeUSB = false;
         this._initializationSucceeded = false;
         this.__commandLock = Promise.resolve([0, []]);
@@ -529,10 +533,7 @@ export class ESPLoader extends EventTarget {
             }
         }
         catch {
-            // Don't log error if this is an expected disconnect during console mode transition
-            if (!this._consoleMode) {
-                this.logger.error("Read loop got disconnected");
-            }
+            //      this.logger.error("Read loop got disconnected");
         }
         finally {
             // Always reset reconfiguring flag when read loop ends
@@ -1142,7 +1143,9 @@ export class ESPLoader extends EventTarget {
             }
             catch (error) {
                 lastError = error;
-                this.logger.debug(`${strategy.name} reset failed: ${error.message}`);
+                //        this.logger.debug(
+                //          `${strategy.name} reset failed: ${(error as Error).message}`,
+                //        );
                 // Set abandon flag to stop any in-flight operations
                 this._abandonCurrentOperation = true;
                 // Wait a bit for in-flight operations to abort
@@ -1721,44 +1724,44 @@ export class ESPLoader extends EventTarget {
                         const waitingFor = partialPacket === null ? "header" : "content";
                         throw new SlipReadError("Timed out waiting for packet " + waitingFor);
                     }
-                    const b = this._readByte();
+                    const byte = this._readByte();
                     if (partialPacket === null) {
                         // waiting for packet header
-                        if (b == 0xc0) {
+                        if (byte == this.SLIP_END) {
                             partialPacket = [];
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid head of packet (" + toHex(b) + ")");
+                            throw new SlipReadError("Invalid head of packet (" + toHex(byte) + ")");
                         }
                     }
                     else if (inEscape) {
                         // part-way through escape sequence
                         inEscape = false;
-                        if (b == 0xdc) {
-                            partialPacket.push(0xc0);
+                        if (byte == this.SLIP_ESC_END) {
+                            partialPacket.push(this.SLIP_END);
                         }
-                        else if (b == 0xdd) {
-                            partialPacket.push(0xdb);
+                        else if (byte == this.SLIP_ESC_ESC) {
+                            partialPacket.push(this.SLIP_ESC);
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(b) + ")");
+                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(byte) + ")");
                         }
                     }
-                    else if (b == 0xdb) {
+                    else if (byte == this.SLIP_ESC) {
                         // start of escape sequence
                         inEscape = true;
                     }
-                    else if (b == 0xc0) {
+                    else if (byte == this.SLIP_END) {
                         // end of packet
                         if (this.debug)
                             this.logger.debug("Received full packet: " + hexFormatter(partialPacket));
@@ -1768,7 +1771,7 @@ export class ESPLoader extends EventTarget {
                     }
                     else {
                         // normal byte in packet
-                        partialPacket.push(b);
+                        partialPacket.push(byte);
                     }
                 }
             }
@@ -1799,44 +1802,44 @@ export class ESPLoader extends EventTarget {
                 }
                 if (this.debug)
                     this.logger.debug("Read " + readBytes.length + " bytes: " + hexFormatter(readBytes));
-                for (const b of readBytes) {
+                for (const byte of readBytes) {
                     if (partialPacket === null) {
                         // waiting for packet header
-                        if (b == 0xc0) {
+                        if (byte == this.SLIP_END) {
                             partialPacket = [];
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid head of packet (" + toHex(b) + ")");
+                            throw new SlipReadError("Invalid head of packet (" + toHex(byte) + ")");
                         }
                     }
                     else if (inEscape) {
                         // part-way through escape sequence
                         inEscape = false;
-                        if (b == 0xdc) {
-                            partialPacket.push(0xc0);
+                        if (byte == this.SLIP_ESC_END) {
+                            partialPacket.push(this.SLIP_END);
                         }
-                        else if (b == 0xdd) {
-                            partialPacket.push(0xdb);
+                        else if (byte == this.SLIP_ESC_ESC) {
+                            partialPacket.push(this.SLIP_ESC);
                         }
                         else {
                             if (this.debug) {
-                                this.logger.debug("Read invalid data: " + toHex(b));
+                                this.logger.debug("Read invalid data: " + toHex(byte));
                                 this.logger.debug("Remaining data in serial buffer: " +
                                     hexFormatter(this._inputBuffer));
                             }
-                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(b) + ")");
+                            throw new SlipReadError("Invalid SLIP escape (0xdb, " + toHex(byte) + ")");
                         }
                     }
-                    else if (b == 0xdb) {
+                    else if (byte == this.SLIP_ESC) {
                         // start of escape sequence
                         inEscape = true;
                     }
-                    else if (b == 0xc0) {
+                    else if (byte == this.SLIP_END) {
                         // end of packet
                         if (this.debug)
                             this.logger.debug("Received full packet: " + hexFormatter(partialPacket));
@@ -1846,7 +1849,7 @@ export class ESPLoader extends EventTarget {
                     }
                     else {
                         // normal byte in packet
-                        partialPacket.push(b);
+                        partialPacket.push(byte);
                     }
                 }
             }
@@ -1911,10 +1914,10 @@ export class ESPLoader extends EventTarget {
         await sleep(SYNC_TIMEOUT);
         // Track current baudrate for reconnect
         if (this._parent) {
-            this._parent._currentBaudRate = baud;
+            this._parent.currentBaudRate = baud;
         }
         else {
-            this._currentBaudRate = baud;
+            this.currentBaudRate = baud;
         }
         // Warn if baudrate exceeds USB-Serial chip capability
         const maxBaud = this._parent
@@ -1986,8 +1989,8 @@ export class ESPLoader extends EventTarget {
             this.readLoop();
         }
         catch (e) {
-            this.logger.error(`Reconfigure port error: ${e}`);
-            throw new Error(`Unable to change the baud rate to ${baud}: ${e}`);
+            //      this.logger.error(`Reconfigure port error: ${e}`);
+            //      throw new Error(`Unable to change the baud rate to ${baud}: ${e}`);
         }
         finally {
             // Always reset flag, even on error or early return
@@ -2520,19 +2523,6 @@ export class ESPLoader extends EventTarget {
             this.__writeChain = value;
         }
     }
-    get _currentBaudRate() {
-        return this._parent
-            ? this._parent._currentBaudRate
-            : this.__currentBaudRate;
-    }
-    set _currentBaudRate(value) {
-        if (this._parent) {
-            this._parent._currentBaudRate = value;
-        }
-        else {
-            this.__currentBaudRate = value;
-        }
-    }
     async writeToStream(data) {
         if (!this.port.writable) {
             this.logger.debug("Port writable stream not available, skipping write");
@@ -2602,7 +2592,7 @@ export class ESPLoader extends EventTarget {
             return;
         }
         if (!this.port.writable) {
-            this.logger.debug("Port already closed, skipping disconnect");
+            //      this.logger.debug("Port already closed, skipping disconnect");
             return;
         }
         // Wait for pending writes to complete
@@ -2610,7 +2600,7 @@ export class ESPLoader extends EventTarget {
             await this._writeChain;
         }
         catch (err) {
-            this.logger.debug(`Pending write error during disconnect: ${err}`);
+            //      this.logger.debug(`Pending write error during disconnect: ${err}`);
         }
         // Release persistent writer before closing
         if (this._writer) {
@@ -2619,7 +2609,7 @@ export class ESPLoader extends EventTarget {
                 this._writer.releaseLock();
             }
             catch (err) {
-                this.logger.debug(`Writer close/release error: ${err}`);
+                //        this.logger.debug(`Writer close/release error: ${err}`);
             }
             this._writer = undefined;
         }
@@ -2632,7 +2622,7 @@ export class ESPLoader extends EventTarget {
                 writer.releaseLock();
             }
             catch (err) {
-                this.logger.debug(`Direct writer close error: ${err}`);
+                //        this.logger.debug(`Direct writer close error: ${err}`);
             }
         }
         await new Promise((resolve) => {
@@ -2654,7 +2644,7 @@ export class ESPLoader extends EventTarget {
                 this._reader.cancel();
             }
             catch (err) {
-                this.logger.debug(`Reader cancel error: ${err}`);
+                //        this.logger.debug(`Reader cancel error: ${err}`);
                 // Reader already released, resolve immediately
                 clearTimeout(timeout);
                 resolve(undefined);
@@ -2691,7 +2681,7 @@ export class ESPLoader extends EventTarget {
             await this._writeChain;
         }
         catch (err) {
-            this.logger.debug(`Pending write error during release: ${err}`);
+            //      this.logger.debug(`Pending write error during release: ${err}`);
         }
         // Release writer
         if (this._writer) {
@@ -2795,6 +2785,8 @@ export class ESPLoader extends EventTarget {
             this.logger.debug(`USB detection failed, using cached value: ${this.isUsbJtagOrOtg}`);
             isUsbJtag = this.isUsbJtagOrOtg;
         }
+        // Release reader/writer so console can create new ones
+        // This is needed for Desktop (Web Serial) to unlock streams
         if (isUsbJtag) {
             // USB-JTAG/OTG devices: Use watchdog reset which closes port
             const wasReset = await this._resetToFirmwareIfNeeded();
@@ -2817,6 +2809,18 @@ export class ESPLoader extends EventTarget {
             catch (err) {
                 this.logger.debug(`Could not reset device: ${err}`);
             }
+            // For WebUSB (Android), recreate streams after hardware reset
+            if (this.isWebUSB()) {
+                try {
+                    // Use the public recreateStreams() method to safely recreate streams
+                    // without closing the port (important after hardware reset)
+                    await this.port.recreateStreams();
+                    this.logger.debug("WebUSB streams recreated for console mode");
+                }
+                catch (err) {
+                    this.logger.debug(`Failed to recreate WebUSB streams: ${err}`);
+                }
+            }
             return false; // Port stays open
         }
     }
@@ -2837,7 +2841,7 @@ export class ESPLoader extends EventTarget {
                     this.chipFamily === CHIP_FAMILY_ESP32S3
                     ? "USB-JTAG/Serial or USB-OTG"
                     : "USB-JTAG/Serial";
-                this.logger.log(`Resetting ${this.chipFamily} (${resetMethod}) to boot into firmware...`);
+                this.logger.log(`Resetting ${this.chipName || "device"} (${resetMethod}) to boot into firmware...`);
                 // Set console mode flag before reset to prevent subsequent hardReset calls
                 this._consoleMode = true;
                 // For S2/S3: Clear force download boot mask before WDT reset
@@ -2896,7 +2900,7 @@ export class ESPLoader extends EventTarget {
         }
         try {
             this.logger.log("Reconnecting serial port...");
-            const savedBaudRate = this._currentBaudRate;
+            const savedBaudRate = this.currentBaudRate;
             this.connected = false;
             this.__inputBuffer = [];
             this.__inputBufferReadIndex = 0;
@@ -2942,7 +2946,7 @@ export class ESPLoader extends EventTarget {
             try {
                 await this.port.open({ baudRate: ESP_ROM_BAUD });
                 this.connected = true;
-                this._currentBaudRate = ESP_ROM_BAUD;
+                this.currentBaudRate = ESP_ROM_BAUD;
             }
             catch (err) {
                 throw new Error(`Failed to open port: ${err}`);
@@ -3062,7 +3066,7 @@ export class ESPLoader extends EventTarget {
             try {
                 await this.port.open({ baudRate: ESP_ROM_BAUD });
                 this.connected = true;
-                this._currentBaudRate = ESP_ROM_BAUD;
+                this.currentBaudRate = ESP_ROM_BAUD;
             }
             catch (err) {
                 throw new Error(`Failed to open port: ${err}`);
@@ -3100,6 +3104,98 @@ export class ESPLoader extends EventTarget {
             throw err;
         }
     }
+    /**
+     * @name exitConsoleMode
+     * Exit console mode and return to bootloader
+     * For ESP32-S2, uses reconnectToBootloader which will trigger port change
+     * @returns true if manual reconnection is needed (ESP32-S2), false otherwise
+     */
+    async exitConsoleMode() {
+        if (this._parent) {
+            return await this._parent.exitConsoleMode();
+        }
+        // Clear console mode flag
+        this._consoleMode = false;
+        // Check if this is ESP32-S2 with USB-JTAG/OTG
+        const isESP32S2 = this.chipFamily === CHIP_FAMILY_ESP32S2;
+        // For ESP32-S2: if _isUsbJtagOrOtg is undefined, try to detect it
+        // If detection fails or is undefined, assume USB-JTAG/OTG (conservative/safe path)
+        let isUsbJtagOrOtg = this._isUsbJtagOrOtg;
+        if (isESP32S2 && isUsbJtagOrOtg === undefined) {
+            try {
+                isUsbJtagOrOtg = await this.detectUsbConnectionType();
+            }
+            catch (err) {
+                this.logger.debug(`USB detection failed, assuming USB-JTAG/OTG for ESP32-S2: ${err}`);
+                isUsbJtagOrOtg = true; // Conservative fallback for ESP32-S2
+            }
+        }
+        if (isESP32S2 && isUsbJtagOrOtg) {
+            // ESP32-S2 USB: Use reconnectToBootloader which handles the mode switch
+            // This will close the port and the device will reboot to bootloader
+            this.logger.log("ESP32-S2 USB detected - reconnecting to bootloader");
+            try {
+                await this.reconnectToBootloader();
+            }
+            catch (err) {
+                this.logger.debug(`Reconnect error (expected for ESP32-S2): ${err}`);
+            }
+            // For ESP32-S2, port will change, so return true to indicate manual reconnection needed
+            return true;
+        }
+        // For other devices, use standard reconnectToBootloader
+        await this.reconnectToBootloader();
+        return false; // No manual reconnection needed
+    }
+    /**
+     * @name isConsoleResetSupported
+     * Check if console reset is supported for this device
+     * ESP32-S2 USB-JTAG/CDC does not support reset in console mode
+     * because any reset causes USB port to be lost (hardware limitation)
+     */
+    isConsoleResetSupported() {
+        if (this._parent) {
+            return this._parent.isConsoleResetSupported();
+        }
+        // For ESP32-S2: if _isUsbJtagOrOtg is undefined, assume USB-JTAG/OTG (conservative)
+        // This means console reset is NOT supported (safer default)
+        const isS2UsbJtag = this.chipFamily === CHIP_FAMILY_ESP32S2 &&
+            (this._isUsbJtagOrOtg === true || this._isUsbJtagOrOtg === undefined);
+        return !isS2UsbJtag; // Not supported for ESP32-S2 USB-JTAG/CDC
+    }
+    /**
+     * @name resetInConsoleMode
+     * Reset device while in console mode (firmware mode)
+     *
+     * NOTE: For ESP32-S2 USB-JTAG/CDC, ANY reset (hardware or software) causes
+     * the USB port to be lost because the device switches USB modes during reset.
+     * This is a hardware limitation - use isConsoleResetSupported() to check first.
+     */
+    async resetInConsoleMode() {
+        if (this._parent) {
+            return await this._parent.resetInConsoleMode();
+        }
+        if (!this.isConsoleResetSupported()) {
+            this.logger.debug("Console reset not supported for ESP32-S2 USB-JTAG/CDC");
+            return; // Do nothing
+        }
+        // For other devices: Use standard firmware reset
+        const isWebUSB = this.port.isWebUSB === true;
+        try {
+            this.logger.debug("Resetting device in console mode");
+            if (isWebUSB) {
+                await this.hardResetToFirmwareWebUSB();
+            }
+            else {
+                await this.hardResetToFirmware();
+            }
+            this.logger.debug("Device reset complete");
+        }
+        catch (err) {
+            this.logger.error(`Reset failed: ${err}`);
+            throw err;
+        }
+    }
     /**
      * @name drainInputBuffer
      * Actively drain the input buffer by reading data for a specified time.
@@ -3114,7 +3210,7 @@ export class ESPLoader extends EventTarget {
         // Wait for the buffer to fill
         await sleep(bufferingTime);
         // Unsupported command response is sent 8 times and has
-        // 14 bytes length including delimiter 0xC0 bytes.
+        // 14 bytes length including delimiter SLIP_END (0xC0) bytes.
         // At least part of it is read as a command response,
         // but to be safe, read it all.
         const bytesToDrain = 14 * 8;
@@ -3278,7 +3374,7 @@ export class ESPLoader extends EventTarget {
                                 // The stub expects 4 bytes (ACK), if we send less it will break out
                                 try {
                                     // Send SLIP frame with no data (just delimiters)
-                                    const abortFrame = [0xc0, 0xc0]; // Empty SLIP frame
+                                    const abortFrame = [this.SLIP_END, this.SLIP_END]; // Empty SLIP frame
                                     await this.writeToStream(abortFrame);
                                     this.logger.debug(`Sent abort frame to stub`);
                                     // Give stub time to process abort

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export { ESPLoader } from "./esp_loader";
 export { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, CHIP_FAMILY_ESP8266, CHIP_FAMILY_ESP32C2, CHIP_FAMILY_ESP32C3, CHIP_FAMILY_ESP32C5, CHIP_FAMILY_ESP32C6, CHIP_FAMILY_ESP32C61, CHIP_FAMILY_ESP32H2, CHIP_FAMILY_ESP32H4, CHIP_FAMILY_ESP32H21, CHIP_FAMILY_ESP32P4, CHIP_FAMILY_ESP32S31, ESP_FLASH_BEGIN, ESP_FLASH_DATA, ESP_FLASH_END, ESP_MEM_BEGIN, ESP_MEM_END, ESP_MEM_DATA, ESP_SYNC, ESP_WRITE_REG, ESP_READ_REG, ESP_ERASE_FLASH, ESP_ERASE_REGION, ESP_READ_FLASH, ESP_SPI_SET_PARAMS, ESP_SPI_ATTACH, ESP_CHANGE_BAUDRATE, ESP_SPI_FLASH_MD5, ESP_GET_SECURITY_INFO, ESP_CHECKSUM_MAGIC, ESP_FLASH_DEFL_BEGIN, ESP_FLASH_DEFL_DATA, ESP_FLASH_DEFL_END, ROM_INVALID_RECV_MSG, USB_RAM_BLOCK, ESP_RAM_BLOCK, DEFAULT_TIMEOUT, CHIP_ERASE_TIMEOUT, MAX_TIMEOUT, SYNC_TIMEOUT, ERASE_REGION_TIMEOUT_PER_MB, MEM_END_ROM_TIMEOUT, FLASH_READ_TIMEOUT, } from "./const";
 export declare const connect: (logger: Logger) => Promise<ESPLoader>;
 export declare const connectWithPort: (port: SerialPort, logger: Logger) => Promise<ESPLoader>;
+export { toHex, sleep, hexFormatter, formatMacAddr } from "./util";

package/dist/index.js

@@ -43,3 +43,5 @@ export const connectWithPort = async (port, logger) => {
     }
     return new ESPLoader(port, logger);
 };
+// Export utility functions for use in UI code
+export { toHex, sleep, hexFormatter, formatMacAddr } from "./util";

package/dist/util.d.ts

@@ -11,4 +11,8 @@ export declare const slipEncode: (buffer: number[]) => number[];
 export declare const toByteArray: (str: string) => number[];
 export declare const hexFormatter: (bytes: number[]) => string;
 export declare const toHex: (value: number, size?: number) => string;
+/**
+ * Format MAC address array to string (e.g., [0xAA, 0xBB, 0xCC] -> "AA:BB:CC:DD:EE:FF")
+ */
+export declare const formatMacAddr: (macAddr: number[]) => string;
 export declare const sleep: (ms: number) => Promise<unknown>;

package/dist/util.js

@@ -43,4 +43,12 @@ export const toHex = (value, size = 2) => {
         return "0x" + hex.padStart(size, "0");
     }
 };
+/**
+ * Format MAC address array to string (e.g., [0xAA, 0xBB, 0xCC] -> "AA:BB:CC:DD:EE:FF")
+ */
+export const formatMacAddr = (macAddr) => {
+    return macAddr
+        .map((value) => value.toString(16).toUpperCase().padStart(2, "0"))
+        .join(":");
+};
 export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));