tasmota-webserial-esptool 9.2.3 → 9.2.5

package/src/esp_loader.ts

@@ -60,6 +60,14 @@ import {
   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";
@@ -1349,6 +1357,53 @@ export class ESPLoader extends EventTarget {
     );
   }
 
+  /**
+   * @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: number;
+    let WDTCONFIG0_REG: number;
+    let WDTCONFIG1_REG: number;
+    let WDT_WKEY: number;
+
+    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
@@ -1367,7 +1422,15 @@ 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);
@@ -2634,7 +2697,9 @@ export class ESPLoader extends EventTarget {
   }
 
   private get _currentBaudRate(): number {
-    return this._parent ? this._parent._currentBaudRate : this.__currentBaudRate;
+    return this._parent
+      ? this._parent._currentBaudRate
+      : this.__currentBaudRate;
   }
 
   private set _currentBaudRate(value: number) {
@@ -2939,6 +3004,111 @@ export class ESPLoader extends EventTarget {
     }
   }
 
+  /**
+   * @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(): Promise<void> {
+    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.