tasmota-webserial-esptool 9.2.3 → 9.2.5

package/dist/const.d.ts

@@ -67,6 +67,10 @@ export declare const ESP32S2_SPI_MISO_DLEN_OFFS = 40;
 export declare const ESP32S2_SPI_W0_OFFS = 88;
 export declare const ESP32S2_UART_DATE_REG_ADDR = 1610612856;
 export declare const ESP32S2_BOOTLOADER_FLASH_OFFSET = 4096;
+export declare const ESP32S2_RTC_CNTL_WDTWPROTECT_REG = 1061191852;
+export declare const ESP32S2_RTC_CNTL_WDTCONFIG0_REG = 1061191828;
+export declare const ESP32S2_RTC_CNTL_WDTCONFIG1_REG = 1061191832;
+export declare const ESP32S2_RTC_CNTL_WDT_WKEY = 1356348065;
 export declare const ESP32S3_SPI_REG_BASE = 1610620928;
 export declare const ESP32S3_BASEFUSEADDR = 1610641408;
 export declare const ESP32S3_MACFUSEADDR: number;
@@ -78,6 +82,10 @@ export declare const ESP32S3_SPI_MISO_DLEN_OFFS = 40;
 export declare const ESP32S3_SPI_W0_OFFS = 88;
 export declare const ESP32S3_UART_DATE_REG_ADDR = 1610612864;
 export declare const ESP32S3_BOOTLOADER_FLASH_OFFSET = 0;
+export declare const ESP32S3_RTC_CNTL_WDTWPROTECT_REG = 1610645680;
+export declare const ESP32S3_RTC_CNTL_WDTCONFIG0_REG = 1610645656;
+export declare const ESP32S3_RTC_CNTL_WDTCONFIG1_REG = 1610645660;
+export declare const ESP32S3_RTC_CNTL_WDT_WKEY = 1356348065;
 export declare const ESP32C2_SPI_REG_BASE = 1610620928;
 export declare const ESP32C2_BASEFUSEADDR = 1610647552;
 export declare const ESP32C2_MACFUSEADDR: number;

package/dist/const.js

@@ -86,6 +86,11 @@ export const ESP32S2_SPI_MISO_DLEN_OFFS = 0x28;
 export const ESP32S2_SPI_W0_OFFS = 0x58;
 export const ESP32S2_UART_DATE_REG_ADDR = 0x60000078;
 export const ESP32S2_BOOTLOADER_FLASH_OFFSET = 0x1000;
+// ESP32-S2 RTC Watchdog Timer registers for USB-OTG reset
+export const ESP32S2_RTC_CNTL_WDTWPROTECT_REG = 0x3f4080ac;
+export const ESP32S2_RTC_CNTL_WDTCONFIG0_REG = 0x3f408094;
+export const ESP32S2_RTC_CNTL_WDTCONFIG1_REG = 0x3f408098;
+export const ESP32S2_RTC_CNTL_WDT_WKEY = 0x50d83aa1;
 export const ESP32S3_SPI_REG_BASE = 0x60002000;
 export const ESP32S3_BASEFUSEADDR = 0x60007000;
 export const ESP32S3_MACFUSEADDR = 0x60007000 + 0x044;
@@ -97,6 +102,11 @@ export const ESP32S3_SPI_MISO_DLEN_OFFS = 0x28;
 export const ESP32S3_SPI_W0_OFFS = 0x58;
 export const ESP32S3_UART_DATE_REG_ADDR = 0x60000080;
 export const ESP32S3_BOOTLOADER_FLASH_OFFSET = 0x0;
+// ESP32-S3 RTC Watchdog Timer registers for USB-OTG reset
+export const ESP32S3_RTC_CNTL_WDTWPROTECT_REG = 0x600080b0;
+export const ESP32S3_RTC_CNTL_WDTCONFIG0_REG = 0x60008098;
+export const ESP32S3_RTC_CNTL_WDTCONFIG1_REG = 0x6000809c;
+export const ESP32S3_RTC_CNTL_WDT_WKEY = 0x50d83aa1;
 export const ESP32C2_SPI_REG_BASE = 0x60002000;
 export const ESP32C2_BASEFUSEADDR = 0x60008800;
 export const ESP32C2_MACFUSEADDR = 0x60008800 + 0x044;

package/dist/esp_loader.d.ts

@@ -172,6 +172,12 @@ export declare class ESPLoader extends EventTarget {
      * Similar to esptool.py's connect() method with multiple reset strategies
      */
     connectWithResetStrategies(): Promise<void>;
+    /**
+     * @name watchdogReset
+     * Watchdog reset for ESP32-S2/S3 with USB-OTG
+     * Uses RTC watchdog timer to reset the chip - works when DTR/RTS signals are not available
+     */
+    watchdogReset(): Promise<void>;
     hardReset(bootloader?: boolean): Promise<void>;
     /**
      * @name macAddr
@@ -321,6 +327,12 @@ export declare class ESPLoader extends EventTarget {
      * Reconnect the serial port to flush browser buffers and reload stub
      */
     reconnect(): Promise<void>;
+    /**
+     * @name reconnectToBootloader
+     * Close and reopen the port, then reset ESP to bootloader mode
+     * This is needed after Improv or other operations that leave ESP in firmware mode
+     */
+    reconnectToBootloader(): Promise<void>;
     /**
      * @name drainInputBuffer
      * Actively drain the input buffer by reading data for a specified time.

package/dist/esp_loader.js

@@ -1,5 +1,5 @@
 /// <reference types="@types/w3c-web-serial" />
-import { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, 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, CHIP_FAMILY_ESP8266, MAX_TIMEOUT, DEFAULT_TIMEOUT, ERASE_REGION_TIMEOUT_PER_MB, ESP_CHANGE_BAUDRATE, ESP_CHECKSUM_MAGIC, ESP_FLASH_BEGIN, ESP_FLASH_DATA, ESP_FLASH_END, ESP_MEM_BEGIN, ESP_MEM_DATA, ESP_MEM_END, ESP_READ_REG, ESP_WRITE_REG, ESP_SPI_ATTACH, ESP_SYNC, ESP_GET_SECURITY_INFO, FLASH_SECTOR_SIZE, FLASH_WRITE_SIZE, STUB_FLASH_WRITE_SIZE, MEM_END_ROM_TIMEOUT, ROM_INVALID_RECV_MSG, SYNC_PACKET, SYNC_TIMEOUT, USB_RAM_BLOCK, ESP_ERASE_FLASH, ESP_ERASE_REGION, ESP_READ_FLASH, CHIP_ERASE_TIMEOUT, FLASH_READ_TIMEOUT, timeoutPerMb, ESP_ROM_BAUD, USB_JTAG_SERIAL_PID, ESP_FLASH_DEFL_BEGIN, ESP_FLASH_DEFL_DATA, ESP_FLASH_DEFL_END, getSpiFlashAddresses, DETECTED_FLASH_SIZES, CHIP_DETECT_MAGIC_REG_ADDR, CHIP_DETECT_MAGIC_VALUES, CHIP_ID_TO_INFO, ESP32P4_EFUSE_BLOCK1_ADDR, SlipReadError, } from "./const";
+import { CHIP_FAMILY_ESP32, CHIP_FAMILY_ESP32S2, CHIP_FAMILY_ESP32S3, 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, CHIP_FAMILY_ESP8266, MAX_TIMEOUT, DEFAULT_TIMEOUT, ERASE_REGION_TIMEOUT_PER_MB, ESP_CHANGE_BAUDRATE, ESP_CHECKSUM_MAGIC, ESP_FLASH_BEGIN, ESP_FLASH_DATA, ESP_FLASH_END, ESP_MEM_BEGIN, ESP_MEM_DATA, ESP_MEM_END, ESP_READ_REG, ESP_WRITE_REG, ESP_SPI_ATTACH, ESP_SYNC, ESP_GET_SECURITY_INFO, FLASH_SECTOR_SIZE, FLASH_WRITE_SIZE, STUB_FLASH_WRITE_SIZE, MEM_END_ROM_TIMEOUT, ROM_INVALID_RECV_MSG, SYNC_PACKET, SYNC_TIMEOUT, USB_RAM_BLOCK, ESP_ERASE_FLASH, ESP_ERASE_REGION, ESP_READ_FLASH, CHIP_ERASE_TIMEOUT, FLASH_READ_TIMEOUT, timeoutPerMb, ESP_ROM_BAUD, USB_JTAG_SERIAL_PID, ESP_FLASH_DEFL_BEGIN, ESP_FLASH_DEFL_DATA, ESP_FLASH_DEFL_END, getSpiFlashAddresses, DETECTED_FLASH_SIZES, CHIP_DETECT_MAGIC_REG_ADDR, CHIP_DETECT_MAGIC_VALUES, CHIP_ID_TO_INFO, ESP32P4_EFUSE_BLOCK1_ADDR, SlipReadError, ESP32S2_RTC_CNTL_WDTWPROTECT_REG, ESP32S2_RTC_CNTL_WDTCONFIG0_REG, ESP32S2_RTC_CNTL_WDTCONFIG1_REG, ESP32S2_RTC_CNTL_WDT_WKEY, ESP32S3_RTC_CNTL_WDTWPROTECT_REG, ESP32S3_RTC_CNTL_WDTCONFIG0_REG, ESP32S3_RTC_CNTL_WDTCONFIG1_REG, ESP32S3_RTC_CNTL_WDT_WKEY, } from "./const";
 import { getStubCode } from "./stubs";
 import { hexFormatter, sleep, slipEncode, toHex } from "./util";
 import { deflate } from "pako";
@@ -1075,6 +1075,45 @@ export class ESPLoader extends EventTarget {
         this._abandonCurrentOperation = false;
         throw new Error(`Couldn't sync to ESP. Try resetting manually. Last error: ${lastError === null || lastError === void 0 ? void 0 : lastError.message}`);
     }
+    /**
+     * @name watchdogReset
+     * Watchdog reset for ESP32-S2/S3 with USB-OTG
+     * Uses RTC watchdog timer to reset the chip - works when DTR/RTS signals are not available
+     */
+    async watchdogReset() {
+        this.logger.log("Hard resetting with watchdog timer...");
+        // Select correct register addresses based on chip family
+        let WDTWPROTECT_REG;
+        let WDTCONFIG0_REG;
+        let WDTCONFIG1_REG;
+        let WDT_WKEY;
+        if (this.chipFamily === CHIP_FAMILY_ESP32S2) {
+            WDTWPROTECT_REG = ESP32S2_RTC_CNTL_WDTWPROTECT_REG;
+            WDTCONFIG0_REG = ESP32S2_RTC_CNTL_WDTCONFIG0_REG;
+            WDTCONFIG1_REG = ESP32S2_RTC_CNTL_WDTCONFIG1_REG;
+            WDT_WKEY = ESP32S2_RTC_CNTL_WDT_WKEY;
+        }
+        else if (this.chipFamily === CHIP_FAMILY_ESP32S3) {
+            WDTWPROTECT_REG = ESP32S3_RTC_CNTL_WDTWPROTECT_REG;
+            WDTCONFIG0_REG = ESP32S3_RTC_CNTL_WDTCONFIG0_REG;
+            WDTCONFIG1_REG = ESP32S3_RTC_CNTL_WDTCONFIG1_REG;
+            WDT_WKEY = ESP32S3_RTC_CNTL_WDT_WKEY;
+        }
+        else {
+            throw new Error(`watchdogReset() is only supported for ESP32-S2 and ESP32-S3, not ${this.chipFamily}`);
+        }
+        // Unlock watchdog registers
+        await this.writeRegister(WDTWPROTECT_REG, WDT_WKEY, undefined, 0);
+        // Set WDT timeout to 2000ms
+        await this.writeRegister(WDTCONFIG1_REG, 2000, undefined, 0);
+        // Enable WDT: bit 31 = enable, bits 28-30 = stage, bit 8 = sys reset, bits 0-2 = prescaler
+        const wdtConfig = (1 << 31) | (5 << 28) | (1 << 8) | 2;
+        await this.writeRegister(WDTCONFIG0_REG, wdtConfig, undefined, 0);
+        // Lock watchdog registers
+        await this.writeRegister(WDTWPROTECT_REG, 0, undefined, 0);
+        // Wait for reset to take effect
+        await this.sleep(500);
+    }
     async hardReset(bootloader = false) {
         if (bootloader) {
             // enter flash mode
@@ -1096,7 +1135,14 @@ export class ESPLoader extends EventTarget {
         }
         else {
             // just reset (no bootloader mode)
-            if (this.isWebUSB()) {
+            // For ESP32-S2/S3 with USB-OTG, use watchdog reset instead of DTR/RTS
+            if (this.port.getInfo().usbProductId === USB_JTAG_SERIAL_PID &&
+                (this.chipFamily === CHIP_FAMILY_ESP32S2 ||
+                    this.chipFamily === CHIP_FAMILY_ESP32S3)) {
+                await this.watchdogReset();
+                this.logger.log("Watchdog reset (USB-OTG).");
+            }
+            else if (this.isWebUSB()) {
                 // WebUSB: Use longer delays for better compatibility
                 await this.setRTSWebUSB(true); // EN->LOW
                 await this.sleep(200);
@@ -2128,7 +2174,9 @@ export class ESPLoader extends EventTarget {
         }
     }
     get _currentBaudRate() {
-        return this._parent ? this._parent._currentBaudRate : this.__currentBaudRate;
+        return this._parent
+            ? this._parent._currentBaudRate
+            : this.__currentBaudRate;
     }
     set _currentBaudRate(value) {
         if (this._parent) {
@@ -2393,6 +2441,98 @@ export class ESPLoader extends EventTarget {
             throw err;
         }
     }
+    /**
+     * @name reconnectToBootloader
+     * Close and reopen the port, then reset ESP to bootloader mode
+     * This is needed after Improv or other operations that leave ESP in firmware mode
+     */
+    async reconnectToBootloader() {
+        if (this._parent) {
+            await this._parent.reconnectToBootloader();
+            return;
+        }
+        try {
+            this.logger.log("Reconnecting to bootloader mode...");
+            this.connected = false;
+            this.__inputBuffer = [];
+            this.__inputBufferReadIndex = 0;
+            // Wait for pending writes to complete
+            try {
+                await this._writeChain;
+            }
+            catch (err) {
+                this.logger.debug(`Pending write error during reconnect: ${err}`);
+            }
+            // Block new writes during port close/open
+            this._isReconfiguring = true;
+            // Release persistent writer
+            if (this._writer) {
+                try {
+                    this._writer.releaseLock();
+                }
+                catch (err) {
+                    this.logger.debug(`Writer release error during reconnect: ${err}`);
+                }
+                this._writer = undefined;
+            }
+            // Cancel reader
+            if (this._reader) {
+                try {
+                    await this._reader.cancel();
+                }
+                catch (err) {
+                    this.logger.debug(`Reader cancel error: ${err}`);
+                }
+                this._reader = undefined;
+            }
+            // Close port
+            try {
+                await this.port.close();
+                this.logger.log("Port closed");
+            }
+            catch (err) {
+                this.logger.debug(`Port close error: ${err}`);
+            }
+            // Open the port
+            this.logger.debug("Opening port...");
+            try {
+                await this.port.open({ baudRate: ESP_ROM_BAUD });
+                this.connected = true;
+            }
+            catch (err) {
+                throw new Error(`Failed to open port: ${err}`);
+            }
+            // Verify port streams are available
+            if (!this.port.readable || !this.port.writable) {
+                throw new Error(`Port streams not available after open (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`);
+            }
+            // Port is now open and ready - allow writes for initialization
+            this._isReconfiguring = false;
+            // Reset chip info and stub state
+            this.__chipFamily = undefined;
+            this.chipName = "Unknown Chip";
+            this.IS_STUB = false;
+            // Start read loop
+            if (!this._parent) {
+                this.__inputBuffer = [];
+                this.__inputBufferReadIndex = 0;
+                this.__totalBytesRead = 0;
+                this.readLoop();
+            }
+            // Wait for readLoop to start
+            await sleep(100);
+            // Reset to bootloader mode using multiple strategies
+            await this.connectWithResetStrategies();
+            // Detect chip type
+            await this.detectChip();
+            this.logger.log(`Reconnected to bootloader: ${this.chipName}`);
+        }
+        catch (err) {
+            // Ensure flag is reset on error
+            this._isReconfiguring = false;
+            throw err;
+        }
+    }
     /**
      * @name drainInputBuffer
      * Actively drain the input buffer by reading data for a specified time.