esp32tool 1.3.7 → 1.4.0

package/js/script.js

@@ -9,13 +9,14 @@ if (!globalThis.requestSerialPort) {
 }
 
 // Utility functions imported from esptool module
-let toHex, formatMacAddr, sleep;
+let toHex, formatMacAddr, sleep, CHIP_FAMILY_ESP32S2;
 
 // Load utilities from esptool package
 window.esptoolPackage.then((esptoolMod) => {
   toHex = esptoolMod.toHex;
   formatMacAddr = esptoolMod.formatMacAddr;
   sleep = esptoolMod.sleep;
+  CHIP_FAMILY_ESP32S2 = esptoolMod.CHIP_FAMILY_ESP32S2;
 });
 
 let espStub;
@@ -36,6 +37,7 @@ let espLoaderBeforeConsole = null; // Store original ESPLoader before console
 let chipFamilyBeforeConsole = null; // Store chipFamily before opening console
 let consoleResetHandler = null;
 let consoleCloseHandler = null;
+let consoleBootloaderHandlerModule = null;
 
 /**
  * Get display name for current filesystem type
@@ -368,16 +370,16 @@ document.addEventListener("DOMContentLoaded", () => {
   // Initialize upload rows visibility - only show first row
   updateUploadRowsVisibility();
   
-  autoscroll.addEventListener("click", clickAutoscroll);
+  bindCheckboxSetting(autoscroll, "autoscroll");
   consoleSwitch.addEventListener("click", clickConsole);
   baudRateSelect.addEventListener("change", changeBaudRate);
   advancedMode.addEventListener("change", clickAdvancedMode);
   chunkSizeSelect.addEventListener("change", changeAdvancedParam);
   blockSizeSelect.addEventListener("change", changeAdvancedParam);
   maxInFlightSelect.addEventListener("change", changeAdvancedParam);
-  darkMode.addEventListener("click", clickDarkMode);
-  debugMode.addEventListener("click", clickDebugMode);
-  showLog.addEventListener("click", clickShowLog);
+  bindCheckboxSetting(darkMode, "darkmode", () => updateTheme());
+  bindCheckboxSetting(debugMode, "debugmode", (v) => logMsg("Debug mode " + (v ? "enabled" : "disabled")));
+  bindCheckboxSetting(showLog, "showlog", () => updateLogVisibility());
   window.addEventListener("error", function (event) {
     console.log("Got an uncaught error: ", event.error);
   });
@@ -811,75 +813,95 @@ async function changeBaudRate() {
   }
 }
 
-/**
- * @name clickAutoscroll
- * Change handler for the Autoscroll checkbox.
- */
-async function clickAutoscroll() {
-  saveSetting("autoscroll", autoscroll.checked);
-}
-
-/**
- * @name clickDarkMode
- * Change handler for the Dark Mode checkbox.
- */
-async function clickDarkMode() {
-  updateTheme();
-  saveSetting("darkmode", darkMode.checked);
+function bindCheckboxSetting(checkbox, key, onChange) {
+  checkbox.addEventListener("click", () => {
+    saveSetting(key, checkbox.checked);
+    if (onChange) onChange(checkbox.checked);
+  });
 }
 
 /**
- * @name clickDebugMode
- * Change handler for the Debug Mode checkbox.
+ * @name requestPort
+ * Request a serial port from the user (WebUSB or Web Serial)
  */
-async function clickDebugMode() {
-  saveSetting("debugmode", debugMode.checked);
-  logMsg("Debug mode " + (debugMode.checked ? "enabled" : "disabled"));
+async function requestPort() {
+  return isUsingWebUSB()
+    ? await WebUSBSerial.requestPort((...args) => logMsg(...args))
+    : await navigator.serial.requestPort();
 }
 
 /**
- * @name clickShowLog
- * Change handler for the Show Log checkbox.
+ * @name showS2Modal
+ * Show the ESP32-S2 modal with given title/text and return a Promise
+ * that resolves when the user clicks the reconnect button.
  */
-async function clickShowLog() {
-  saveSetting("showlog", showLog.checked);
-  updateLogVisibility();
+function showS2Modal(title, text) {
+  return new Promise((resolve) => {
+    const modal = document.getElementById("esp32s2Modal");
+    const reconnectBtn = document.getElementById("butReconnectS2");
+    const modalTitle = modal.querySelector("h2");
+    const modalText = modal.querySelector("p");
+    if (modalTitle) modalTitle.textContent = title;
+    if (modalText) modalText.textContent = text;
+    modal.classList.remove("hidden");
+    reconnectBtn.addEventListener("click", () => {
+      modal.classList.add("hidden");
+      resolve();
+    }, { once: true });
+  });
 }
 
 /**
- * @name openConsolePortAndInit
- * Helper to open port for console and initialize console UI
- * Avoids code duplication across different console init flows
+ * @name assignPort
+ * Assign a new port to espStub, its parent, and espLoaderBeforeConsole
  */
-async function openConsolePortAndInit(newPort) {
-  // Open the port at 115200 for console
-  await newPort.open({ baudRate: 115200 });
+function assignPort(newPort) {
   espStub.port = newPort;
   espStub.connected = true;
-  
-  // Keep parent/loader in sync (used by closeConsole)
+  espStub._writer = undefined;
+  espStub._reader = undefined;
   if (espStub._parent) {
     espStub._parent.port = newPort;
   }
   if (espLoaderBeforeConsole) {
     espLoaderBeforeConsole.port = newPort;
+    espLoaderBeforeConsole.connected = true;
   }
+}
+
+/**
+ * @name openConsolePortAndInit
+ * Helper to open port for console and initialize console UI
+ * @param {SerialPort} newPort - The port to open
+ */
+async function openConsolePortAndInit(newPort) {
+  await newPort.open({ baudRate: 115200 });
+  assignPort(newPort);
   
   debugMsg("Port opened for console at 115200 baud");
   
-  // Device is already in firmware mode, port is open at 115200
-  // Initialize console directly
+  // WebUSB needs extra time for USB interface and streams to stabilize
+  if (isUsingWebUSB()) {
+    let retries = 30;
+    while (retries > 0 && !newPort.readable) {
+      await sleep(100);
+      retries--;
+    }
+    if (!newPort.readable) {
+      throw new Error("Port readable stream not available after open");
+    }
+    debugMsg("WebUSB port streams ready for console");
+  }
+  
   consoleSwitch.checked = true;
   saveSetting("console", true);
   
-  // Initialize console UI and handlers
   await initConsoleUI();
 }
 
 /**
  * @name initConsoleUI
  * Initialize console UI, event handlers, and start console instance
- * Extracted helper to avoid duplication across different console init flows
  */
 async function initConsoleUI() {
   // Wait for port to be ready
@@ -897,20 +919,6 @@ async function initConsoleUI() {
   consoleInstance = new ESP32ToolConsole(espStub.port, consoleContainer, true);
   await consoleInstance.init();
   
-  // Check if console reset is supported and hide button if not
-  if (espLoaderBeforeConsole && typeof espLoaderBeforeConsole.isConsoleResetSupported === 'function') {
-    const resetSupported = espLoaderBeforeConsole.isConsoleResetSupported();
-    const resetBtn = consoleContainer.querySelector("#console-reset-btn");
-    if (resetBtn) {
-      if (resetSupported) {
-        resetBtn.style.display = "";
-      } else {
-        resetBtn.style.display = "none";
-        debugMsg("Console reset disabled for ESP32-S2 USB-JTAG/CDC (hardware limitation)");
-      }
-    }
-  }
-  
   // Listen for console reset events
   if (consoleResetHandler) {
     consoleContainer.removeEventListener('console-reset', consoleResetHandler);
@@ -918,9 +926,45 @@ async function initConsoleUI() {
   consoleResetHandler = async () => {
     if (espLoaderBeforeConsole && typeof espLoaderBeforeConsole.resetInConsoleMode === 'function') {
       try {
-        debugMsg("Resetting device from console...");
-        await espLoaderBeforeConsole.resetInConsoleMode();
-        debugMsg("Device reset successful");
+        const isS2 = chipFamilyBeforeConsole === CHIP_FAMILY_ESP32S2;
+        
+        if (isS2) {
+          debugMsg("ESP32-S2 console reset: entering bootloader, then WDT reset to firmware...");
+          
+          if (consoleInstance) {
+            await consoleInstance.disconnect();
+          }
+          
+          await espLoaderBeforeConsole.resetInConsoleMode();
+          
+          const waitTime = isUsingWebUSB() ? 1000 : 500;
+          await sleep(waitTime);
+          
+          // Step 1: Select bootloader port for WDT reset
+          const portLabel = isUsingWebUSB() ? "USB device" : "serial port";
+          await showS2Modal("Select bootloader port", `Select the ${portLabel} (bootloader) to reset the device.`);
+          const bootloaderPort = await requestPort();
+          
+          debugMsg("Syncing with bootloader and performing WDT reset...");
+          await espLoaderBeforeConsole.syncAndWdtReset(bootloaderPort);
+          try { await bootloaderPort.close(); } catch (e) { /* port may already be gone */ }
+          
+          debugMsg("Waiting for device to boot into firmware...");
+          await sleep(waitTime);
+          
+          // Step 2: Select firmware port for console
+          await showS2Modal("Select console port", `Select the ${portLabel} (firmware) for console.`);
+          const consolePort = await requestPort();
+          
+          await consolePort.open({ baudRate: 115200 });
+          assignPort(consolePort);
+          await consoleInstance.reconnect(consolePort);
+          debugMsg("Console reconnected after S2 reset");
+        } else {
+          debugMsg("Resetting device from console...");
+          await espLoaderBeforeConsole.resetInConsoleMode();
+          debugMsg("Device reset successful");
+        }
       } catch (err) {
         errorMsg("Failed to reset device: " + err.message);
       }
@@ -941,6 +985,29 @@ async function initConsoleUI() {
   };
   consoleContainer.addEventListener('console-close', consoleCloseHandler);
   
+  // Listen for console bootloader detection events
+  // The console detects bootloader patterns in real-time as data arrives
+  // and dispatches this event when bootloader is detected
+  if (consoleBootloaderHandlerModule) {
+    consoleContainer.removeEventListener('console-bootloader', consoleBootloaderHandlerModule);
+  }
+  consoleBootloaderHandlerModule = async () => {
+    logMsg("Console detected bootloader mode - resetting to firmware...");
+    if (espLoaderBeforeConsole && typeof espLoaderBeforeConsole.resetInConsoleMode === 'function') {
+      try {
+        await espLoaderBeforeConsole.resetInConsoleMode();
+        logMsg("✅ Device reset to firmware mode");
+        // Clear console to see new output after reset
+        if (consoleInstance && typeof consoleInstance.clear === 'function') {
+          consoleInstance.clear();
+        }
+      } catch (err) {
+        errorMsg("Failed to reset device: " + err.message);
+      }
+    }
+  };
+  consoleContainer.addEventListener('console-bootloader', consoleBootloaderHandlerModule);
+  
   logMsg("Console initialized");
 }
 
@@ -994,7 +1061,7 @@ async function clickConsole() {
             
             // Check if this is ESP32-S2 or if we're on Android (WebUSB)
             // Both need modal for user gesture
-            const isS2 = chipFamilyBeforeConsole === 0x3252; // CHIP_FAMILY_ESP32S2 = 0x3252
+            const isS2 = chipFamilyBeforeConsole === CHIP_FAMILY_ESP32S2;
             const needsModal = isS2 || isWebUSB;
             
             if (needsModal) {
@@ -1022,58 +1089,20 @@ async function clickConsole() {
               // Wait for browser to process port closure and USB re-enumeration
               await sleep(300);
               
-              // Show modal for port selection (requires user gesture)
-              const modal = document.getElementById("esp32s2Modal");
-              const reconnectBtn = document.getElementById("butReconnectS2");
-              
-              // Update modal text for console mode
-              const modalTitle = modal.querySelector("h2");
-              const modalText = modal.querySelector("p");
-              if (modalTitle) modalTitle.textContent = "Device has been reset to firmware mode";
-              if (modalText) {
-                modalText.textContent = isWebUSB 
-                  ? "Please click the button below to select the USB device for console."
-                  : "Please click the button below to select the serial port for console.";
-              }
-              
-              modal.classList.remove("hidden");
-              
-              // Handle reconnect button click (single-fire to prevent multiple prompts)
-              const handleReconnect = async () => {
-                modal.classList.add("hidden");
-                
-                try {
-                  // Request the NEW port (user gesture from button click)
-                  debugMsg("Please select the port for console mode...");
-                  const newPort = isWebUSB
-                    ? await WebUSBSerial.requestPort((...args) => logMsg(...args))
-                    : await navigator.serial.requestPort();
-                  
-                  // Use helper to open port and initialize console
-                  await openConsolePortAndInit(newPort);
-                } catch (err) {
-                  errorMsg(`Failed to open port for console: ${err.message}`);
-                  consoleSwitch.checked = false;
-                  saveSetting("console", false);
-                }
-              };
-              
-              // Use { once: true } to ensure single-fire and automatic cleanup
-              reconnectBtn.addEventListener("click", handleReconnect, { once: true });
-            } else {
-              // Desktop (Web Serial) with ESP32-S3/C3/C5/C6/H2/P4: Direct requestPort
-              try {
-                // Request port selection from user (direct)
-                debugMsg("Please select the serial port again for console mode...");
-                const newPort = await navigator.serial.requestPort();
-                
-                // Use helper to open port and initialize console
-                await openConsolePortAndInit(newPort);
-              } catch (err) {
-                errorMsg(`Failed to open port for console: ${err.message}`);
-                consoleSwitch.checked = false;
-                saveSetting("console", false);
-              }
+              const portLabel = isWebUSB ? "USB device" : "serial port";
+              await showS2Modal(
+                "Device has been reset to firmware mode",
+                `Please click the button below to select the ${portLabel} for console.`
+              );
+            }
+
+            try {
+              const newPort = await requestPort();
+              await openConsolePortAndInit(newPort);
+            } catch (err) {
+              errorMsg(`Failed to open port for console: ${err.message}`);
+              consoleSwitch.checked = false;
+              saveSetting("console", false);
             }
             
             return;
@@ -1091,7 +1120,7 @@ async function clickConsole() {
         // Wait for:
         // - Firmware to start after reset
         // - Port to be ready for new reader
-        await sleep(200);
+        await sleep(500);
         
         // Initialize console UI and handlers
         await initConsoleUI();
@@ -1144,6 +1173,20 @@ async function closeConsole() {
       consoleInstance = null;
     }
     
+    // Remove console event handlers
+    if (consoleResetHandler) {
+      consoleContainer.removeEventListener('console-reset', consoleResetHandler);
+      consoleResetHandler = null;
+    }
+    if (consoleCloseHandler) {
+      consoleContainer.removeEventListener('console-close', consoleCloseHandler);
+      consoleCloseHandler = null;
+    }
+    if (consoleBootloaderHandlerModule) {
+      consoleContainer.removeEventListener('console-bootloader', consoleBootloaderHandlerModule);
+      consoleBootloaderHandlerModule = null;
+    }
+    
     // Use esp_loader's exitConsoleMode function
     try {
       const needsManualReconnect = await espLoaderBeforeConsole.exitConsoleMode();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esp32tool",
-  "version": "1.3.7",
+  "version": "1.4.0",
   "type": "module",
   "description": "Flash & Read ESP devices using WebSerial, Electron, and also Android mobile via WebUSB",
   "main": "electron/main.cjs",

package/src/console.ts

@@ -179,19 +179,36 @@ export class ESP32ToolConsole {
   private async _connect(abortSignal: AbortSignal) {
     console.log("Starting console read loop");
 
-    // Check if port.readable is available
-    if (!this.port.readable) {
-      this.console!.addLine("");
-      this.console!.addLine("");
-      this.console!.addLine(
-        `Terminal disconnected: Port readable stream not available`,
-      );
-      console.error(
-        "Port readable stream not available - port may need to be reopened at correct baudrate",
-      );
-      return;
+    // Wait for readable stream to be available with timeout
+    const maxWaitTime = 3000; // 3 seconds
+    const startTime = Date.now();
+
+    while (!this.port.readable) {
+      const elapsed = Date.now() - startTime;
+      if (elapsed > maxWaitTime) {
+        this.console!.addLine("");
+        this.console!.addLine("");
+        this.console!.addLine(
+          `Terminal disconnected: Port readable stream not available after ${maxWaitTime}ms`,
+        );
+        this.console!.addLine(`This can happen if:`);
+        this.console!.addLine(
+          `1. Port was just opened and streams are not ready yet`,
+        );
+        this.console!.addLine(
+          `2. Device was reset and port needs to be reopened`,
+        );
+        this.console!.addLine(`3. USB device re-enumerated after reset`);
+        console.error(
+          "Port readable stream not available - port may need to be reopened at correct baudrate",
+        );
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
     }
 
+    console.log("Port readable stream is ready - starting console");
+
     try {
       await this.port
         .readable!.pipeThrough(

package/src/const.ts

@@ -286,6 +286,11 @@ export const ESP32C61_SPI_MISO_DLEN_OFFS = 0x28;
 export const ESP32C61_SPI_W0_OFFS = 0x58;
 export const ESP32C61_UART_DATE_REG_ADDR = 0x6000007c;
 export const ESP32C61_BOOTLOADER_FLASH_OFFSET = 0x0000;
+// ESP32-C61 USB-JTAG/Serial detection (dynamic based on chip revision)
+export const ESP32C61_UARTDEV_BUF_NO_REV_LE2 = 0x4084f5ec; // revision <= 2
+export const ESP32C61_UARTDEV_BUF_NO_REV_GT2 = 0x4084f5e4; // revision > 2
+export const ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_LE2 = 3; // revision <= 2
+export const ESP32C61_UARTDEV_BUF_NO_USB_JTAG_SERIAL_REV_GT2 = 4; // revision > 2
 
 export const ESP32H2_SPI_REG_BASE = 0x60003000;
 export const ESP32H2_BASEFUSEADDR = 0x600b0800;
@@ -335,6 +340,9 @@ export const ESP32H4_RTC_CNTL_WDTCONFIG1_REG =
   ESP32H4_DR_REG_LP_WDT_BASE + 0x0004; // LP_WDT_RWDT_CONFIG1_REG
 export const ESP32H4_RTC_CNTL_WDT_WKEY = 0x50d83aa1; // LP_WDT_SWD_WKEY, same as WDT key in this case
 export const ESP32H4_RTC_CNTL_SWD_WKEY = 0x50d83aa1; // LP_WDT_SWD_WKEY, same as WDT key in this case
+// ESP32-H4 USB-JTAG/Serial detection
+export const ESP32H4_UARTDEV_BUF_NO = 0x4087f580; // Variable in ROM .bss which indicates the port in use
+export const ESP32H4_UARTDEV_BUF_NO_USB_JTAG_SERIAL = 3; // The above var when USB-JTAG/Serial is used
 
 export const ESP32H21_SPI_REG_BASE = 0x60003000;
 export const ESP32H21_BASEFUSEADDR = 0x600b4000;