rm packet from transport read

Author: brianignacio5

src/esploader.ts

@@ -104,7 +104,7 @@ export interface LoaderOptions {
    * Flag indicating whether to enable SLIP read data formatting.
    * @type {boolean}
    */
-  enableSlipRead: boolean;
+  enableSlipRead?: boolean;
 
   /**
    * Reset functions for connection. If undefined will use default ones.
@@ -139,7 +139,7 @@ export interface LoaderOptions {
    * The Trace object to log all communication output.
    * @type {ITrace}
    */
-  tracer: ITrace;
+  tracer?: ITrace;
 
   /**
    * The transport mechanism to communicate with the device.
@@ -306,7 +306,7 @@ export class ESPLoader {
    * such as read/write flash memory and registers using a LoaderOptions object.
    * @param {LoaderOptions} options - LoaderOptions object argument for ESPLoader.
    * ```
-   * const myLoader = new ESPLoader({ transport: Transport, baudrate: number, terminal?: IEspLoaderTerminal });
+   * const myLoader = new ESPLoader({ transport: Transport, serialOptions: {baudrate: number}, terminal?: IEspLoaderTerminal });
    * ```
    */
   constructor(options: LoaderOptions) {
@@ -618,7 +618,7 @@ export class ESPLoader {
     let i;
     let resp;
     this.info("Connecting...", false);
-    await this.transport.connect({ baudRate: this.romBaudrate });
+    await this.transport.connect(this.serialOptions);
     for (i = 0; i < attempts; i++) {
       resp = await this._connectAttempt(mode, false);
       if (resp === "success") {
@@ -1479,4 +1479,24 @@ export class ESPLoader {
       await this.command(this.ESP_RUN_USER_CODE, undefined, undefined, false);
     }
   }
+
+  /**
+   * Send reset sequence to the device chip
+   *
+   * Commands (e.g. R0) are defined by a code (R) and an argument (0).
+   *
+   * The commands are:
+   *
+   * D: setDTR - 1=True / 0=False
+   *
+   * R: setRTS - 1=True / 0=False
+   *
+   * W: Wait (time delay) - positive integer number (miliseconds)
+   *
+   * "D0|R1|W100|D1|R0|W50|D0" represents the classic reset strategy
+   * @param {string} resetSequence String represetting the reset sequence
+   */
+  async resetFromStrSequence(resetSequence: string) {
+    await this.resetFunctions.customReset(this.transport, resetSequence);
+  }
 }

src/reset.ts

@@ -28,14 +28,8 @@ function sleep(ms: number): Promise<void> {
  * @param {ISerialTransport} transport Transport class to perform serial communication.
  * @param {number} resetDelay Delay in milliseconds for reset.
  */
-export async function classicReset(transport: ISerialTransport, resetDelay = DEFAULT_RESET_DELAY) {
-  await transport.setDTR(false);
-  await transport.setRTS(true);
-  await sleep(100);
-  await transport.setDTR(true);
-  await transport.setRTS(false);
-  await sleep(resetDelay);
-  await transport.setDTR(false);
+export async function classicReset(transport: ISerialTransport, resetDelay: number = DEFAULT_RESET_DELAY) {
+  await customReset(transport, `D0|R1|W100|D1|R0|W${resetDelay}|D0`);
 }
 
 /**
@@ -53,21 +47,7 @@ export async function classicReset(transport: ISerialTransport, resetDelay = DEF
  * @param {ISerialTransport} transport Transport class to perform serial communication.
  */
 export async function usbJTAGSerialReset(transport: ISerialTransport) {
-  await transport.setRTS(false);
-  await transport.setDTR(false);
-  await sleep(100);
-
-  await transport.setDTR(true);
-  await transport.setRTS(false);
-  await sleep(100);
-
-  await transport.setRTS(true);
-  await transport.setDTR(false);
-  await transport.setRTS(true);
-
-  await sleep(100);
-  await transport.setRTS(false);
-  await transport.setDTR(false);
+  await customReset(transport, `R0|D0|W100|D1|R0|W100|R1|D0|R1|W100|R0|D0`);
 }
 
 /**
@@ -85,16 +65,9 @@ export async function usbJTAGSerialReset(transport: ISerialTransport) {
  * @param {ISerialTransport} transport Transport class to perform serial communication.
  * @param {boolean} usingUsbOtg is it using USB-OTG ?
  */
-export async function hardReset(transport: ISerialTransport, usingUsbOtg = false) {
-  await transport.setRTS(true);
-  if (usingUsbOtg) {
-    await sleep(200);
-    await transport.setRTS(false);
-    await sleep(200);
-  } else {
-    await sleep(100);
-    await transport.setRTS(false);
-  }
+export async function hardReset(transport: ISerialTransport, usingUsbOtg: boolean = false) {
+  const resetSequence = usingUsbOtg ? `R1|W200|R0|W200` : `R1|W100|R0`;
+  await customReset(transport, resetSequence);
 }
 
 type CmdsArgsTypes = {

src/transport/ITransport.ts

@@ -43,10 +43,9 @@ export interface ISerialTransport {
    * Read from serial device without formatting.
    * @param {number} timeout Read timeout in milliseconds (ms)
    * @param {number} minData Minimum packet array length
-   * @param {Uint8Array} packet Unsigned 8 bit array from the device read stream.
    * @returns {Promise<Uint8Array>} 8 bit unsigned data array read from device.
    */
-  read(timeout?: number, minData?: number, packet?: Uint8Array): Promise<Uint8Array>;
+  read(timeout?: number, minData?: number): Promise<Uint8Array>;
 
   /**
    * Send the dataTerminalReady (DTS) signal to given state

src/transport/WebSerialTransport.ts

@@ -44,7 +44,7 @@ export interface SerialOptions extends ISerialOptions {
 /**
  * Wrapper class around Webserial API to communicate with the serial device.
  * @param {typeof import("w3c-web-serial").SerialPort} device - Requested device prompted by the browser.
- * @param {ITrace} trace Object that log or trace all serial messages.
+ * @param {ITrace} tracer Object that log or trace all serial messages.
  *
  * ```
  * const port = await navigator.serial.requestPort();
@@ -81,8 +81,10 @@ export class WebSerialTransport implements ISerialTransport {
   async write(data: Uint8Array) {
     if (this.device.writable) {
       const writer = this.device.writable.getWriter();
-      this.tracer.trace("Write bytes");
-      this.tracer.trace(`Write ${data.length} bytes: ${hexConvert(data)}`);
+      if (this.tracer) {
+        this.tracer.trace("Write bytes");
+        this.tracer.trace(`Write ${data.length} bytes: ${hexConvert(data)}`);
+      }
       await writer.write(data);
       writer.releaseLock();
     }
@@ -95,7 +97,7 @@ export class WebSerialTransport implements ISerialTransport {
    * @param {Uint8Array} packet Unsigned 8 bit array from the device read stream.
    * @returns {Promise<Uint8Array>} 8 bit unsigned data array read from device.
    */
-  async read(timeout: number = 0, minData: number = 0, packet?: Uint8Array): Promise<Uint8Array> {
+  async read(timeout: number = 0, minData: number = 0): Promise<Uint8Array> {
     if (this.leftOver.length != 0) {
       const p = this.leftOver;
       this.leftOver = new Uint8Array(0);
@@ -106,9 +108,6 @@ export class WebSerialTransport implements ISerialTransport {
     }
     this.reader = this.device.readable.getReader();
     let t;
-    if (!packet) {
-      packet = this.leftOver;
-    }
     try {
       if (timeout > 0) {
         t = setTimeout(() => {
@@ -117,15 +116,17 @@ export class WebSerialTransport implements ISerialTransport {
           }
         }, timeout);
       }
-
+      let packet = this.leftOver;
       do {
         const { value, done } = await this.reader.read();
         if (done) {
           this.leftOver = packet;
           throw new Error("Timeout");
         }
-        this.tracer.trace("Raw Read bytes");
-        this.tracer.trace(`Read ${value.length} bytes: ${hexConvert(value)}`);
+        if (this.tracer) {
+          this.tracer.trace("Raw Read bytes");
+          this.tracer.trace(`Read ${value.length} bytes: ${hexConvert(value)}`);
+        }
         const p = appendArray(packet, value);
         packet = p;
       } while (packet.length < minData);
@@ -145,7 +146,7 @@ export class WebSerialTransport implements ISerialTransport {
    */
   async unRead(buffer?: Uint8Array): Promise<Uint8Array> {
     const leftOver = this.leftOver;
-    this.leftOver = buffer ? buffer : new Uint8Array(0);
+    this.leftOver = buffer ? appendArray(leftOver, buffer) : new Uint8Array(0);
     return leftOver;
   }
 

src/utils/slip.ts

@@ -114,10 +114,9 @@ export class Slip {
       if (valFinal.length > 0) {
         return valFinal;
       }
-      packet = slipResult.newLeftOver;
-      await this.transport.unRead();
+      await this.transport.unRead(slipResult.packet);
     }
-    packet = await this.transport.read(timeout, minData, packet);
+    packet = await this.transport.read(timeout, minData);
 
     if (this.tracer) {
       this.tracer.trace("Read SLIP bytes");