esp32tool 1.3.2 → 1.3.3

package/css/style.css

@@ -179,36 +179,7 @@ div.clear {
   display: none;
 }
 
-/* Console Container */
-.console-container {
-  height: 500px;
-  overflow: hidden;
-  transition: height 0.3s ease-in-out, visibility 0.3s ease-in-out;
-  margin: 0;
-  padding: 0;
-  visibility: visible;
-}
-
-.console-container.hidden {
-  height: 0;
-  visibility: hidden;
-  max-height: 0;
-}
-
-/* Mobile console optimization */
-@media (max-width: 768px) {
-  .console-container {
-    height: 350px;
-    font-size: 13px;
-  }
-}
-
-@media (max-width: 480px) {
-  .console-container {
-    height: 300px;
-    font-size: 12px;
-  }
-}
+/* Console Container - OLD DEFINITION REMOVED - See bottom of file for new fullscreen version */
 
 .notSupported {
   padding: 1em;
@@ -2189,11 +2160,7 @@ div.clear {
     padding-right: 10px;
   }
 
-  /* Console optimization for small screens */
-  .console-container {
-    height: 300px;
-    font-size: 12px;
-  }
+  /* Console optimization for small screens - REMOVED - Using fullscreen console now */
 
   /* Filesystem manager for small screens */
   .littlefs-manager {
@@ -2257,3 +2224,48 @@ div.clear {
     -webkit-tap-highlight-color: transparent;
   }
 }
+
+/* Console Container Styling */
+.console-container {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 1001; /* Above header and main content */
+  background-color: #1c1c1c;
+  margin: 0;
+  padding: 0;
+}
+
+.console-container.hidden {
+  display: none;
+}
+
+/* Ensure console wrapper fills the container */
+.console-container .esp32tool-console-wrapper {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+}
+
+/* Hide header and commands when console is active */
+body.console-active .header {
+  display: none !important;
+}
+
+body.console-active #commands {
+  display: none !important;
+}
+
+body.console-active #notSupported {
+  display: none !important;
+}
+
+/* Remove padding from main when console is active */
+body.console-active .main {
+  padding-top: 0 !important;
+  overflow: hidden !important;
+}

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

@@ -19,6 +19,10 @@ export declare class ESPLoader extends EventTarget {
     currentBaudRate: number;
     private _maxUSBSerialBaudrate?;
     private _reader?;
+    private SLIP_END;
+    private SLIP_ESC;
+    private SLIP_ESC_END;
+    private SLIP_ESC_ESC;
     private _isESP32S2NativeUSB;
     private _initializationSucceeded;
     private __commandLock;

package/dist/esp_loader.js

@@ -27,6 +27,10 @@ export class ESPLoader extends EventTarget {
         this.connected = true;
         this.flashSize = null;
         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, []]);
@@ -1720,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));
@@ -1767,7 +1771,7 @@ export class ESPLoader extends EventTarget {
                     }
                     else {
                         // normal byte in packet
-                        partialPacket.push(b);
+                        partialPacket.push(byte);
                     }
                 }
             }
@@ -1798,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));
@@ -1845,7 +1849,7 @@ export class ESPLoader extends EventTarget {
                     }
                     else {
                         // normal byte in packet
-                        partialPacket.push(b);
+                        partialPacket.push(byte);
                     }
                 }
             }
@@ -2770,6 +2774,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();
@@ -2792,6 +2798,19 @@ export class ESPLoader extends EventTarget {
             catch (err) {
                 this.logger.debug(`Could not reset device: ${err}`);
             }
+            // For WebUSB (Android), recreate streams after hardware reset
+            const isWebUSB = this.port.isWebUSB === true;
+            if (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
         }
     }
@@ -3181,7 +3200,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;
@@ -3345,7 +3364,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