tasmota-webserial-esptool 7.1.0 → 7.2.1

package/README.md

@@ -8,7 +8,7 @@ WebSerial ESPTool is **not** based on esptool.js
 ## Local development
 
 - Clone this repository.
-- Install dependencies with `yarn`
+- Install dependencies with `npm install`
 - Run `script/develop`
 - Open http://localhost:5004/
 

package/css/style.css

@@ -70,6 +70,24 @@
   color: #000;
 }
 
+.header button.highlight {
+  background-color: #ff6b00;
+  border-color: #ff6b00;
+  color: #fff;
+  animation: pulse 1.5s infinite;
+}
+
+@keyframes pulse {
+  0%, 100% {
+    transform: scale(1);
+    box-shadow: 0 0 0 0 rgba(255, 107, 0, 0.7);
+  }
+  50% {
+    transform: scale(1.05);
+    box-shadow: 0 0 0 10px rgba(255, 107, 0, 0);
+  }
+}
+
 .header select {
   height: 30px;
 }
@@ -550,3 +568,80 @@ div.clear {
 .center {
   text-align: center;
 }
+
+/* ESP32-S2 Reconnect Modal */
+.modal {
+  display: flex;
+  position: fixed;
+  z-index: 9999;
+  left: 0;
+  top: 0;
+  width: 100%;
+  height: 100%;
+  background-color: rgba(0, 0, 0, 0.7);
+  align-items: center;
+  justify-content: center;
+}
+
+.modal.hidden {
+  display: none;
+}
+
+.modal-content {
+  background-color: #fff;
+  padding: 40px;
+  border-radius: 15px;
+  box-shadow: 0 5px 30px rgba(0, 0, 0, 0.3);
+  text-align: center;
+  max-width: 500px;
+  animation: modalSlideIn 0.3s ease-out;
+}
+
+@keyframes modalSlideIn {
+  from {
+    transform: translateY(-50px);
+    opacity: 0;
+  }
+  to {
+    transform: translateY(0);
+    opacity: 1;
+  }
+}
+
+.modal-content h2 {
+  color: #4a4a4a;
+  margin-top: 0;
+  font-size: 24px;
+  margin-bottom: 20px;
+}
+
+.modal-content p {
+  font-size: 16px;
+  line-height: 1.6;
+  margin: 15px 0;
+  color: #333;
+}
+
+.modal-button {
+  background-color: #fff;
+  color: #6b6b6b;
+  border: 2px solid #6b6b6b;
+  padding: 12px 40px;
+  font-size: 18px;
+  font-weight: 600;
+  border-radius: 25px;
+  cursor: pointer;
+  margin-top: 20px;
+  transition: background-color 0.2s, color 0.2s, border-color 0.2s;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  line-height: normal;
+  text-align: center;
+}
+
+.modal-button:hover {
+  background-color: #71ae1e;
+  color: #fff;
+  border-color: #71ae1e;
+}

package/dist/const.js

@@ -244,30 +244,6 @@ export const CHIP_DETECT_MAGIC_VALUES = {
     0xfff0c101: { name: "ESP8266", family: CHIP_FAMILY_ESP8266 },
     0x00f01d83: { name: "ESP32", family: CHIP_FAMILY_ESP32 },
     0x000007c6: { name: "ESP32-S2", family: CHIP_FAMILY_ESP32S2 },
-    0x9: { name: "ESP32-S3", family: CHIP_FAMILY_ESP32S3 },
-    0x0c21e06f: { name: "ESP32-C2", family: CHIP_FAMILY_ESP32C2 },
-    0x6f51306f: { name: "ESP32-C2", family: CHIP_FAMILY_ESP32C2 },
-    0x7c41a06f: { name: "ESP32-C2", family: CHIP_FAMILY_ESP32C2 },
-    0x1b31506f: { name: "ESP32-C3", family: CHIP_FAMILY_ESP32C3 },
-    0x4361606f: { name: "ESP32-C3", family: CHIP_FAMILY_ESP32C3 },
-    0x4881606f: { name: "ESP32-C3", family: CHIP_FAMILY_ESP32C3 },
-    0x6921506f: { name: "ESP32-C3", family: CHIP_FAMILY_ESP32C3 },
-    0x1101406f: { name: "ESP32-C5", family: CHIP_FAMILY_ESP32C5 },
-    0x5fd1406f: { name: "ESP32-C5", family: CHIP_FAMILY_ESP32C5 },
-    0x5c501458: { name: "ESP32-C5", family: CHIP_FAMILY_ESP32C5 },
-    0x63e1406f: { name: "ESP32-C5", family: CHIP_FAMILY_ESP32C5 },
-    0x2ce0806f: { name: "ESP32-C6", family: CHIP_FAMILY_ESP32C6 },
-    0x2421606f: { name: "ESP32-C61", family: CHIP_FAMILY_ESP32C61 },
-    0x33f0206f: { name: "ESP32-C61", family: CHIP_FAMILY_ESP32C61 },
-    0x4f81606f: { name: "ESP32-C61", family: CHIP_FAMILY_ESP32C61 },
-    0x7211606f: { name: "ESP32-C61", family: CHIP_FAMILY_ESP32C61 },
-    0x97e30068: { name: "ESP32-H2", family: CHIP_FAMILY_ESP32H2 },
-    0xd7b73e80: { name: "ESP32-H2", family: CHIP_FAMILY_ESP32H2 },
-    // ESP32-P4 old revisions (< Rev. 300) - use magic value detection
-    // Rev. 300+ uses IMAGE_CHIP_ID detection instead
-    0x0: { name: "ESP32-P4", family: CHIP_FAMILY_ESP32P4 },
-    0x7039ad9: { name: "ESP32-P4", family: CHIP_FAMILY_ESP32P4 },
-    0x0addbad0: { name: "ESP32-P4", family: CHIP_FAMILY_ESP32P4 },
 };
 // Commands supported by ESP8266 ROM bootloader
 export const ESP_FLASH_BEGIN = 0x02;

package/dist/esp_loader.d.ts

@@ -18,6 +18,8 @@ export declare class ESPLoader extends EventTarget {
     private _currentBaudRate;
     private _maxUSBSerialBaudrate?;
     private _reader?;
+    private _isESP32S2NativeUSB;
+    private _initializationSucceeded;
     constructor(port: SerialPort, logger: Logger, _parent?: ESPLoader | undefined);
     private get _inputBuffer();
     private get _totalBytesRead();

package/dist/esp_loader.js

@@ -21,6 +21,8 @@ export class ESPLoader extends EventTarget {
         this.connected = true;
         this.flashSize = null;
         this._currentBaudRate = ESP_ROM_BAUD;
+        this._isESP32S2NativeUSB = false;
+        this._initializationSucceeded = false;
         this.state_DTR = false;
     }
     get _inputBuffer() {
@@ -44,8 +46,13 @@ export class ESPLoader extends EventTarget {
         const chips = {
             0x1a86: {
                 // QinHeng Electronics
+                0x7522: { name: "CH340", maxBaudrate: 460800 },
                 0x7523: { name: "CH340", maxBaudrate: 460800 },
+                0x7584: { name: "CH340", maxBaudrate: 460800 },
+                0x5523: { name: "CH341", maxBaudrate: 2000000 },
+                0x55d3: { name: "CH343", maxBaudrate: 6000000 },
                 0x55d4: { name: "CH9102", maxBaudrate: 6000000 },
+                0x55d8: { name: "CH9101", maxBaudrate: 3000000 },
             },
             0x10c4: {
                 // Silicon Labs
@@ -92,6 +99,13 @@ export class ESPLoader extends EventTarget {
                     this._maxUSBSerialBaudrate = chipInfo.maxBaudrate;
                     this.logger.log(`Max baudrate: ${chipInfo.maxBaudrate}`);
                 }
+                // Detect ESP32-S2 Native USB
+                // PID 0x0002 = TinyUSB CDC (after flash)
+                // PID 0x1001 = ROM Bootloader (before flash)
+                if (portInfo.usbVendorId === 0x303a &&
+                    (portInfo.usbProductId === 0x2 || portInfo.usbProductId === 0x1001)) {
+                    this._isESP32S2NativeUSB = true;
+                }
             }
             // Don't await this promise so it doesn't block rest of method.
             this.readLoop();
@@ -109,6 +123,8 @@ export class ESPLoader extends EventTarget {
         }
         this.logger.log(`Chip type ${this.chipName}`);
         this.logger.debug(`Bootloader flash offset: 0x${FlAddr.flashOffs.toString(16)}`);
+        // Mark initialization as successful
+        this._initializationSucceeded = true;
     }
     /**
      * Detect chip type using GET_SECURITY_INFO (for newer chips) or magic value (for older chips)
@@ -154,7 +170,7 @@ export class ESPLoader extends EventTarget {
                 this.logger.debug(`Re-sync after GET_SECURITY_INFO failure: ${syncErr}`);
             }
         }
-        // Fallback: Use magic value detection for ESP8266, ESP32, ESP32-S2, and ESP32-P4 RC versions
+        // Fallback: Use magic value detection for ESP8266, ESP32, ESP32-S2
         const chipMagicValue = await this.readRegister(CHIP_DETECT_MAGIC_REG_ADDR);
         const chip = CHIP_DETECT_MAGIC_VALUES[chipMagicValue >>> 0];
         if (chip === undefined) {
@@ -162,7 +178,6 @@ export class ESPLoader extends EventTarget {
         }
         this.chipName = chip.name;
         this.chipFamily = chip.family;
-        // For ESP32-P4 detected via magic value (old revisions), set variant
         if (this.chipFamily === CHIP_FAMILY_ESP32P4) {
             this.chipRevision = await this.getChipRevision();
             this.logger.debug(`ESP32-P4 revision: ${this.chipRevision}`);
@@ -256,6 +271,14 @@ export class ESPLoader extends EventTarget {
         }
         // Disconnected!
         this.connected = false;
+        // Check if this is ESP32-S2 Native USB that needs port reselection
+        // Only trigger reconnect if initialization did NOT succeed (wrong port)
+        if (this._isESP32S2NativeUSB && !this._initializationSucceeded) {
+            this.logger.log("ESP32-S2 Native USB detected - requesting port reselection");
+            this.dispatchEvent(new CustomEvent("esp32s2-usb-reconnect", {
+                detail: { message: "ESP32-S2 Native USB requires port reselection" },
+            }));
+        }
         this.dispatchEvent(new Event("disconnect"));
         this.logger.debug("Finished read loop");
     }
@@ -907,7 +930,7 @@ export class ESPLoader extends EventTarget {
     }
     async setDataLengths(spiAddresses, mosiBits, misoBits) {
         if (spiAddresses.mosiDlenOffs != -1) {
-            // ESP32/32S2/32S3/32C3 has a more sophisticated way to set up "user" commands
+            // Actual MCUs have a more sophisticated way to set up "user" commands
             const SPI_MOSI_DLEN_REG = spiAddresses.regBase + spiAddresses.mosiDlenOffs;
             const SPI_MISO_DLEN_REG = spiAddresses.regBase + spiAddresses.misoDlenOffs;
             if (mosiBits > 0) {
@@ -948,7 +971,7 @@ export class ESPLoader extends EventTarget {
         const SPI_USR_COMMAND = 1 << 31;
         const SPI_USR_MISO = 1 << 28;
         const SPI_USR_MOSI = 1 << 27;
-        // SPI registers, base address differs ESP32* vs 8266
+        // SPI registers, base address differs
         const spiAddresses = getSpiFlashAddresses(this.getChipFamily());
         const base = spiAddresses.regBase;
         const SPI_CMD_REG = base;
@@ -1100,6 +1123,10 @@ export class ESPLoader extends EventTarget {
         return espStubLoader;
     }
     async writeToStream(data) {
+        if (!this.port.writable) {
+            this.logger.debug("Port writable stream not available, skipping write");
+            return;
+        }
         const writer = this.port.writable.getWriter();
         await writer.write(new Uint8Array(data));
         try {
@@ -1114,6 +1141,10 @@ export class ESPLoader extends EventTarget {
             await this._parent.disconnect();
             return;
         }
+        if (!this.port.writable) {
+            this.logger.debug("Port already closed, skipping disconnect");
+            return;
+        }
         await this.port.writable.getWriter().close();
         await new Promise((resolve) => {
             if (!this._reader) {
@@ -1146,7 +1177,6 @@ export class ESPLoader extends EventTarget {
             }
             this._reader = undefined;
         }
-        await sleep(SYNC_TIMEOUT);
         // Close port
         try {
             await this.port.close();
@@ -1155,8 +1185,6 @@ export class ESPLoader extends EventTarget {
         catch (err) {
             this.logger.debug(`Port close error: ${err}`);
         }
-        // Wait for port to fully close
-        await sleep(SYNC_TIMEOUT);
         // Open the port
         this.logger.debug("Opening port...");
         try {
@@ -1166,8 +1194,6 @@ export class ESPLoader extends EventTarget {
         catch (err) {
             throw new Error(`Failed to open port: ${err}`);
         }
-        // Wait for port to be fully ready
-        await sleep(SYNC_TIMEOUT);
         // 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})`);
@@ -1178,7 +1204,7 @@ export class ESPLoader extends EventTarget {
         const savedChipRevision = this.chipRevision;
         const savedChipVariant = this.chipVariant;
         const savedFlashSize = this.flashSize;
-        // Reinitialize without chip detection
+        // Reinitialize
         await this.hardReset(true);
         if (!this._parent) {
             this.__inputBuffer = [];
@@ -1187,7 +1213,7 @@ export class ESPLoader extends EventTarget {
         }
         await this.flushSerialBuffers();
         await this.sync();
-        // Restore chip info (skip detection)
+        // Restore chip info
         this.chipFamily = savedChipFamily;
         this.chipName = savedChipName;
         this.chipRevision = savedChipRevision;
@@ -1198,14 +1224,12 @@ export class ESPLoader extends EventTarget {
         if (!this.port.writable || !this.port.readable) {
             throw new Error("Port not ready after reconnect");
         }
-        // Load stub (skip flash detection)
+        // Load stub
         const stubLoader = await this.runStub(true);
         this.logger.debug("Stub loaded");
         // Restore baudrate if it was changed
         if (this._currentBaudRate !== ESP_ROM_BAUD) {
             await stubLoader.setBaudrate(this._currentBaudRate);
-            // Wait for port to be ready after baudrate change
-            await sleep(SYNC_TIMEOUT);
             // Verify port is still ready after baudrate change
             if (!this.port.writable || !this.port.readable) {
                 throw new Error(`Port not ready after baudrate change (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`);
@@ -1223,18 +1247,12 @@ export class ESPLoader extends EventTarget {
      * This clears both the application RX buffer and waits for hardware buffers to drain
      */
     async flushSerialBuffers() {
-        // Clear application RX buffer
+        // Clear application buffer
         if (!this._parent) {
             this.__inputBuffer = [];
         }
-        // Wait for any pending TX operations and in-flight RX data
+        // Wait for any pending data
         await sleep(SYNC_TIMEOUT);
-        // Clear RX buffer again
-        if (!this._parent) {
-            this.__inputBuffer = [];
-        }
-        // Wait longer to ensure all stale data has been received and discarded
-        await sleep(SYNC_TIMEOUT * 2);
         // Final clear
         if (!this._parent) {
             this.__inputBuffer = [];
@@ -1253,20 +1271,6 @@ export class ESPLoader extends EventTarget {
         if (!this.IS_STUB) {
             throw new Error("Reading flash is only supported in stub mode. Please run runStub() first.");
         }
-        // Check if we should reconnect BEFORE starting the read
-        // Reconnect if total bytes read >= 4MB to ensure clean state
-        if (this._totalBytesRead >= 4 * 1024 * 1024) {
-            this.logger.log(
-            // `Total bytes read: ${this._totalBytesRead}. Reconnecting before new read...`,
-            `Reconnecting before new read...`);
-            try {
-                await this.reconnect();
-            }
-            catch (err) {
-                // If reconnect fails, throw error - don't continue with potentially broken state
-                throw new Error(`Reconnect failed: ${err}`);
-            }
-        }
         // Flush serial buffers before flash read operation
         await this.flushSerialBuffers();
         this.logger.log(`Reading ${size} bytes from flash at address 0x${addr.toString(16)}...`);
@@ -1275,16 +1279,6 @@ export class ESPLoader extends EventTarget {
         let currentAddr = addr;
         let remainingSize = size;
         while (remainingSize > 0) {
-            // Reconnect every 4MB to prevent browser buffer issues
-            if (allData.length > 0 && allData.length % (4 * 1024 * 1024) === 0) {
-                this.logger.debug(`Read ${allData.length} bytes. Reconnecting to clear buffers...`);
-                try {
-                    await this.reconnect();
-                }
-                catch (err) {
-                    throw new Error(`Reconnect failed during read: ${err}`);
-                }
-            }
             const chunkSize = Math.min(CHUNK_SIZE, remainingSize);
             let chunkSuccess = false;
             let retryCount = 0;