stable esp uploading

mrfrase3 · mrfrase3 · commit abd585b9fc4c · 2022-10-25T19:40:50.000+08:00
diff --git a/src/esp/ESPLoader.ts b/src/esp/ESPLoader.ts
diff --git a/src/esp/StubLoader.ts b/src/esp/StubLoader.ts
@@ -1,5 +1,17 @@
 import axios from 'axios';
 
+/*
+  Stub loaders are uploaded and run in-memory on the target device.
+  They are usually more efficient than the default ROM loader and
+  more up-to-date with the latest features and bug fixes.
+
+  https://docs.espressif.com/projects/esptool/en/latest/esp32/esptool/flasher-stub.html
+
+  The data for stub loaders can be quite large, and there are different ones
+  for different esp chips, so we download it from the internet during run-time
+  rather than including it in the package bundle.
+*/
+
 interface StubDef {
   data: Buffer;
   text: Buffer;
@@ -18,24 +30,23 @@ export default class StubLoader {
   stubsUrl: string
 
   constructor(stubsUrl?: string) {
-    // TODO; Change branch from esp-support to main
-    this.stubsUrl = stubsUrl || 'https://raw.githubusercontent.com/duinoapp/upload-multitool/esp-support/src/esp/stubs/';
+    this.stubsUrl = stubsUrl || 'https://raw.githubusercontent.com/espressif/esptool/master/esptool/targets/stub_flasher/';
     this.stubsUrl = this.stubsUrl.replace(/\/$/, '');
   }
 
   async loadStub(chipName: string) {
-    const stubName = chipName.replace(/-/g, '').toLowerCase();
+    const stubName = chipName.replace(/-/g, '').toLowerCase().replace('esp', '');
     if (cache[stubName]) {
       return cache[stubName];
     }
-    const { data: res } = await axios.get(`${this.stubsUrl}/${stubName}.json`);
+    const { data: res } = await axios.get(`${this.stubsUrl}/stub_flasher_${stubName}.json`);
 
     const stub = {
       data: Buffer.from(res.data, 'base64'),
       text: Buffer.from(res.text, 'base64'),
       entry: res.entry,
-      textStart: res.textStart,
-      dataStart: res.dataStart,
+      textStart: res.text_start,
+      dataStart: res.data_start,
     } as StubDef;
 
     cache[stubName] = stub;
diff --git a/src/esp/index.ts b/src/esp/index.ts
@@ -11,22 +11,26 @@ export const upload = async (serial: SerialPort, config: ProgramConfig) => {
   const log = (...args: any[]) => console.log(...args);
   // const term = { log, debug: log, write: config.debug };
 
-  // const { port } = serial;
-  // const transport = new Transport(port, term);
-  let espLoader;
+  // serial.on('data', (data: Buffer) => {
+  //   console.log('read (utf8)', data.toString('utf-8'));
+  //   console.log('read (hex)', data.toString('hex'));
+  // });
 
+  let espLoader;
   try {
-    log('> Connecting...');
     espLoader = new ESPLoader(serial, {
       quiet: !config.verbose,
     } as ESPOptions);
     await espLoader.mainFn();
     // await espLoader.flash_id();
     log('> Connected');
+
+    if (config.uploadSpeed) {
+      await espLoader.changeBaudrate(config.uploadSpeed);
+    }
   } catch (err) {
     // eslint-disable-next-line no-console
     console.error(err);
-    // log('Failed to connect:', typeof err === 'string' ? err : err.message);
     try {
       await serial.close();
     } catch (err2) {
@@ -37,21 +41,19 @@ export const upload = async (serial: SerialPort, config: ProgramConfig) => {
   }
 
   try {
-    // if (board.config?.wipe && board.config.wipe !== 'none') {
-    //   log('> Erasing device flash...');
-    //   await espLoader.erase_flash();
-    //   log('> Successfully erased device flash');
-    // }
     log('> Writing main data partition, this may take a while...');
     await espLoader.writeFlash({
       fileArray: config.files.map((file) => ({ ...file, data: Buffer.from(file.data, 'base64') })),
-      flashSize: 'keep',
-      // flash_freq,
-      // flash_mode,
+      flashSize: '4MB',
+      flashFreq: config.flashFreq || 'keep',
+      flashMode: config.flashMode || 'keep',
       // compress: board.props?.build?.mcu !== 'esp8266',
     });
-    await espLoader.flashDeflFinish({ reboot: true });
+    await espLoader.reboot();
     await asyncTimeout(100);
+    if (config.uploadSpeed) {
+      await serial.update({ baudRate: config.speed || 115200 });
+    }
     log('> Successfully written data partition');
     log('> Flashing succeeded! Have a nice day! :)');
   } catch (err) {
@@ -60,12 +62,6 @@ export const upload = async (serial: SerialPort, config: ProgramConfig) => {
     log('Failed to upload:', err instanceof Error ? err.message : err);
   }
 
-  // try {
-  //   await serial.close();
-  // } catch (err) {
-  //   // eslint-disable-next-line no-console
-  //   console.error(err);
-  // }
 };
 
 export default { upload, isSupported };
diff --git a/src/esp/roms/esp32c3.ts b/src/esp/roms/esp32c3.ts
@@ -7,6 +7,7 @@ const EFUSE_BASE = 0x60008800;
 export default {
   CHIP_NAME: 'ESP32-C3',
   IS_STUB: true,
+  SUPPORTS_ENCRYPTION: true,
   IMAGE_CHIP_ID: 5,
   CHIP_DETECT_MAGIC_VALUE: 0x6921506f,
   EFUSE_BASE,
diff --git a/src/esp/roms/esp32s2.ts b/src/esp/roms/esp32s2.ts
@@ -5,6 +5,7 @@ import { toMac } from './util';
 export default {
   CHIP_NAME: 'ESP32-S2',
   IS_STUB: true,
+  SUPPORTS_ENCRYPTION: true,
   IMAGE_CHIP_ID: 2,
   CHIP_DETECT_MAGIC_VALUE: 0x000007c6,
   MAC_EFUSE_REG: 0x3f41A044,
diff --git a/src/esp/roms/rom.d.ts b/src/esp/roms/rom.d.ts
@@ -7,6 +7,7 @@ interface flashSizes {
 export default interface ROM {
   CHIP_NAME: string;
   IS_STUB: boolean;
+  SUPPORTS_ENCRYPTION?: boolean;
   FLASH_SIZES: flashSizes;
   IMAGE_CHIP_ID?: number;
   CHIP_DETECT_MAGIC_VALUE: number;
diff --git a/src/global.d.ts b/src/global.d.ts
@@ -1 +1,3 @@
 declare module 'intel-hex';
+declare module 'pako';
+declare module 'crypto-js';
diff --git a/src/index.d.ts b/src/index.d.ts
@@ -7,7 +7,10 @@ export interface ProgramConfig {
   hex?: Buffer;
   files?: ProgramFile[];
   speed?: number;
+  uploadSpeed?: number;
   tool?: string;
   cpu?: string;
   verbose?: boolean;
+  flashMode?: string;
+  flashFreq?: string;
 }
diff --git a/src/util/serial-helpers.ts b/src/util/serial-helpers.ts
@@ -8,7 +8,7 @@ export const waitForOpen = (serial: SerialPort, timeout: number = 1000): Promise
     let cleanup = () => {};
     const timer = setTimeout(() => {
       cleanup();
-      reject(new Error('Timeout'));
+      reject(new Error('Timeout opening port'));
     }, timeout);
     const handleOpen = () => {
       cleanup();
diff --git a/test/boards.ts b/test/boards.ts
@@ -3,58 +3,85 @@ import { expect } from 'chai';
 import 'mocha';
 import { SerialPort } from 'serialport';
 import { upload } from '../src/index';
-import { waitForData, config, getHex } from './util';
+import { waitForData, config, getHex, espIdentify, ESPIdentifyResult } from './util';
 import { waitForOpen } from '../src/util/serial-helpers';
 import { ProgramFile } from '../src/index.d';
 
+const numEsps = Object.values(config.devices).filter((d) => d.espChip).length;
+const listPromise = espIdentify(numEsps);
+
 Object.keys(config.devices).forEach((deviceRef) => {
   const device = config.devices[deviceRef];
   let key = '';
   let hex: Buffer | undefined;
   let files: ProgramFile[] | undefined;
   let serial: SerialPort;
+  let flashMode: string | undefined;
+  let flashFreq: string | undefined;
+  let portList: ESPIdentifyResult[] = [];
 
   describe(`upload to ${device.name}`, function () {
     this.timeout(120 * 1000);
 
     before(async () => {
-      const res = await getHex(device.code, device.fqbn);
+      const res = await getHex(device.code, device.fqbn.trim());
       key = res.key;
       hex = res.hex;
       files = res.files;
+      flashMode = res.flashMode;
+      flashFreq = res.flashFreq;
       console.log('compiled hex');
     });
 
     beforeEach(async () => {
       if (serial?.isOpen) await (new Promise(resolve => serial.close(resolve)));
       
-      // dynamically find the device path by using VID & PID
-      const list = await SerialPort.list();
-      const port = list.find(p => device.vendorIds.includes(p.vendorId) && device.productIds.includes(p.productId));
+      // dynamically find the device path by using VID & PID or esp props
+      portList = await listPromise;
+      const port = portList.find(p => {
+        if (device.vendorIds && device.productIds) {
+          return device.vendorIds.includes(p.vendorId || '') && device.productIds.includes(p.productId || '');
+        }
+        if (device.espChip) {
+          return p.esp?.chip === device.espChip;
+        }
+        if (device.mac) {
+          return p.esp?.mac === device.mac;
+        }
+        return false;
+      });
       if (!port) throw new Error(`could not locate ${device.name}`);
 
       // connect to the device
       serial = new SerialPort({ path: port.path, baudRate: device.speed });
       await waitForOpen(serial);
-      console.log(`connected to ${device.name}`);
+      console.log(`connected to ${device.name} on ${port.path}`);
     });
 
     this.afterEach(async () => {
       // make sure connection is closed when we're done
       if (serial?.isOpen) await (new Promise(resolve => serial.close(resolve)));
     });
 
-    it(`should upload to ${device.name}`, async () => {
+    it(`should upload to ${device.name}`, async function() {
+      this.retries(config.retries || 1);
       await upload(serial, {
         hex,
         files,
+        flashMode,
+        flashFreq,
         speed: device.speed,
+        uploadSpeed: device.uploadSpeed,
         tool: device.tool,
         cpu: device.cpu,
         verbose: config.verbose,
       });
+
       console.log(`uploaded to ${device.name}, validating...`);
-      expect(await waitForData(serial, key, 3000)).to.be.true;
+      if (device.code === 'ping') {
+        await serial.write('ping\n');
+      }
+      expect(await waitForData(serial, key, 5000)).to.be.true;
     });
   });
 });
diff --git a/test/code/ping.ino b/test/code/ping.ino
@@ -0,0 +1,42 @@
+/*
+  Ping
+
+  Turns an LED on for one second, then off for one second, repeatedly.
+
+  Also prints pong to the serial monitor when ping is received.
+
+  Some boards may interfere with the serial detectability when printing
+  so this sketch only prints when ping is received.
+
+*/
+
+// the setup function runs once when you press reset or power the board
+void setup() {
+  // initialize digital pin LED_BUILTIN as an output.
+  pinMode(LED_BUILTIN, OUTPUT);
+  Serial.begin(115200);
+  Serial.setTimeout(500);
+}
+
+// read the serial port for ping, and respond with pong
+void pingCheck() {
+  if (!Serial.available()) {
+    return;
+  }
+  String input = Serial.readStringUntil('\n');
+  input.trim();
+  if (input == "ping") {
+    delay(100);
+    Serial.println("pong {{key}}");
+  }
+}
+
+// the loop function runs over and over again forever
+void loop() {
+  digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
+  pingCheck();
+  delay(500);                       // wait for half a second
+  digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
+  pingCheck();
+  delay(500);                       // wait for half a second
+}
diff --git a/test/index.ts b/test/index.ts
@@ -9,10 +9,20 @@ describe('isSupported', () => {
     expect(result).to.be.true;
   });
 
-  it('should be false for non-existant cpu', () => {
+  it('should be true for esp8266', () => {
+    const result = isSupported('esptool', 'esp8266');
+    expect(result).to.be.true;
+  });
+
+  it('should be false for non-existant cpu (atmega420)', () => {
     const result = isSupported('avrdude', 'atmega420');
     expect(result).to.be.false;
   });
+
+  it('should be false for non-existant cpu (esp69)', () => {
+    const result = isSupported('esptool', 'esp69');
+    expect(result).to.be.false;
+  });
   
   it('should be false for non-existant tool', () => {
     const result = isSupported('bob', 'atmega328p');
diff --git a/test/test-config.yml b/test/test-config.yml
diff --git a/test/util.ts b/test/util.ts

Original file line number	Diff line number	Diff line change
`@@ -1 +1,3 @@`
`1`	`1`	`declare module 'intel-hex';`
	`2`	`+declare module 'pako';`
	`3`	`+declare module 'crypto-js';`