d0kuhn/esptool-js-openDTU
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update esploader file name

Browse Source 
fix lint rm webserial js
This commit is contained in:
Brian Ignacio 2022-11-22 12:38:50 +08:00
parent 3154aa9439
commit 2ed745673c
9 changed files with 40 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.github/workflows/publish.yml vendored
View File

@ -14,14 +14,16 @@ jobs:
registry-url: 'https://registry.npmjs.org'
- name: Install dependencies and build 🔧
run: npm ci && npm run build
- name: Run lint
run: npm run lint
- name: Run tests
run: npm run test
- name: Package .vsix
- name: Package module
run: npm pack
- name: Determine version
id: version
run: "echo ::set-output name=version::${GITHUB_REF:11}"
- name: Upload .vsix File
- name: Upload npm package file
uses: actions/upload-artifact@v1
with:
name: esptool-js-${{ steps.version.outputs.version }}.tgz

4
src/espLoader.ts → src/esploader.ts
View File

@ -307,6 +307,7 @@ export class ESPLoader {
while (i--) {
try {
const resp = await this.sync();
this.log(resp[0].toString(0));
return "success";
} catch (error) {
this.log(error);
@ -727,6 +728,7 @@ export class ESPLoader {
const second_arg = this.IS_STUB ? this.transport.baudrate : 0;
const pkt = this._appendArray(this._int_to_bytearray(this.baudrate), this._int_to_bytearray(second_arg));
const resp = await this.command(this.ESP_CHANGE_BAUDRATE, pkt);
this.log(resp[0].toString());
this.log("Changed");
await this.transport.disconnect();
await this._sleep(50);
@ -893,7 +895,7 @@ export class ESPLoader {
}
let seq = 0;
let bytes_sent = 0;
const bytes_written = 0;
// const bytes_written = 0;
const totalBytes = image.length;
if (reportProgress) reportProgress(i, 0, totalBytes);

2
src/index.ts
View File

@ -1,2 +1,2 @@
export { IEspLoaderTerminal, ESPLoader } from "./esploader";
export { IEspLoaderTerminal, ESPLoader, ESPBinFile } from "./esploader";
export { Transport } from "./webserial";

14
src/targets/esp32.ts
View File

@ -100,14 +100,14 @@ export default class ESP32ROM extends ROM {
const addr = this.EFUSE_RD_REG_BASE + 4 * offset;
loader.log("Read efuse " + addr);
return await loader.read_reg(addr);
};
}
public async get_pkg_version(loader: ESPLoader) {
const word3 = await this.read_efuse(loader, 3);
let pkg_version = (word3 >> 9) & 0x07;
pkg_version += ((word3 >> 2) & 0x1) << 3;
return pkg_version;
};
}
public async get_chip_revision(loader: ESPLoader) {
const word3 = await this.read_efuse(loader, 3);
@ -129,7 +129,7 @@ export default class ESP32ROM extends ROM {
}
}
return 0;
};
}
public async get_chip_description(loader: ESPLoader) {
const chip_desc = [
@ -164,7 +164,7 @@ export default class ESP32ROM extends ROM {
chip_name += "-V3";
}
return chip_name + " (revision " + chip_revision + ")";
};
}
public async get_chip_features(loader: ESPLoader) {
const features = ["Wi-Fi"];
@ -218,7 +218,7 @@ export default class ESP32ROM extends ROM {
features.push(" Coding Scheme " + coding_scheme_arr[coding_scheme]);
return features;
};
}
public async get_crystal_freq(loader: ESPLoader) {
const uart_div = (await loader.read_reg(this.UART_CLKDIV_REG)) & this.UART_CLKDIV_MASK;
@ -233,7 +233,7 @@ export default class ESP32ROM extends ROM {
loader.log("WARNING: Unsupported crystal in use");
}
return norm_xtal;
};
}
public _d2h(d: number) {
const h = (+d).toString(16);
@ -266,5 +266,5 @@ export default class ESP32ROM extends ROM {
":" +
this._d2h(mac[5])
);
};
}
}

16
src/targets/esp32c3.ts
View File

@ -101,7 +101,7 @@ export default class ESP32C3ROM extends ROM {
const word3 = await loader.read_reg(addr);
const pkg_version = (word3 >> 21) & 0x07;
return pkg_version;
};
}
public async get_chip_revision(loader: ESPLoader) {
const block1_addr = this.EFUSE_BASE + 0x044;
@ -110,10 +110,10 @@ export default class ESP32C3ROM extends ROM {
const addr = block1_addr + 4 * num_word;
const ret = ((await loader.read_reg(addr)) & (0x7 << pos)) >> pos;
return ret;
};
}
public async get_chip_description(loader: ESPLoader) {
let desc;
let desc: string;
const pkg_ver = await this.get_pkg_version(loader);
if (pkg_ver === 0) {
desc = "ESP32-C3";
@ -123,15 +123,15 @@ export default class ESP32C3ROM extends ROM {
const chip_rev = await this.get_chip_revision(loader);
desc += " (revision " + chip_rev + ")";
return desc;
};
}
public async get_chip_features(loader: ESPLoader) {
return ["Wi-Fi"];
};
}
public async get_crystal_freq(loader: ESPLoader) {
return 40;
};
}
public _d2h(d: number) {
const h = (+d).toString(16);
@ -164,9 +164,9 @@ export default class ESP32C3ROM extends ROM {
":" +
this._d2h(mac[5])
);
};
}
public get_erase_size(offset: number, size: number) {
return size;
};
}
}

10
src/targets/esp32s2.ts
View File

@ -111,7 +111,7 @@ export default class ESP32S2ROM extends ROM {
const word3 = await loader.read_reg(addr);
const pkg_version = (word3 >> 21) & 0x0f;
return pkg_version;
};
}
public async get_chip_description(loader: ESPLoader) {
const chip_desc = ["ESP32-S2", "ESP32-S2FH16", "ESP32-S2FH32"];
@ -121,7 +121,7 @@ export default class ESP32S2ROM extends ROM {
} else {
return "unknown ESP32-S2";
}
};
}
public async get_chip_features(loader: ESPLoader) {
const features = ["Wi-Fi"];
@ -141,11 +141,11 @@ export default class ESP32S2ROM extends ROM {
features.push("ADC and temperature sensor calibration in BLK2 of efuse");
}
return features;
};
}
public async get_crystal_freq(loader: ESPLoader) {
return 40;
};
}
public _d2h(d: number) {
const h = (+d).toString(16);
return h.length === 1 ? "0" + h : h;
@ -176,7 +176,7 @@ export default class ESP32S2ROM extends ROM {
":" +
this._d2h(mac[5])
);
};
}
public get_erase_size(offset: number, size: number) {
return size;

12
src/targets/esp32s3.ts
View File

@ -121,13 +121,13 @@ export default class ESP32S3ROM extends ROM {
public async get_chip_description(loader: ESPLoader) {
return "ESP32-S3";
};
}
public async get_chip_features(loader: ESPLoader) {
return ["Wi-Fi", "BLE"];
};
}
public async get_crystal_freq(loader: ESPLoader) {
return 40;
};
}
public _d2h(d: number) {
const h = (+d).toString(16);
return h.length === 1 ? "0" + h : h;
@ -139,7 +139,7 @@ export default class ESP32S3ROM extends ROM {
if (buf_no == this.UARTDEV_BUF_NO_USB) {
loader.ESP_RAM_BLOCK = this.USB_RAM_BLOCK;
}
};
}
public async read_mac(loader: ESPLoader) {
let mac0 = await loader.read_reg(this.MAC_EFUSE_REG);
@ -167,9 +167,9 @@ export default class ESP32S3ROM extends ROM {
":" +
this._d2h(mac[5])
);
};
}
public get_erase_size(offset: number, size: number) {
return size;
};
}
}

12
src/targets/esp8266.ts
View File

@ -187,9 +187,9 @@ export default class ESP8266ROM extends ROM {
public async read_efuse(loader: ESPLoader, offset: number) {
const addr = this.EFUSE_RD_REG_BASE + 4 * offset;
console.log("Read efuse " + addr);
loader.log("Read efuse " + addr);
return await loader.read_reg(addr);
};
}
public async get_chip_description(loader: ESPLoader) {
const efuse3 = await this.read_efuse(loader, 2);
@ -197,7 +197,7 @@ export default class ESP8266ROM extends ROM {
const is_8285 = ((efuse0 & (1 << 4)) | (efuse3 & (1 << 16))) != 0; // One or the other efuse bit is set for ESP8285
return is_8285 ? "ESP8285" : "ESP8266EX";
};
}
public get_chip_features = async (loader: ESPLoader) => {
const features = ["WiFi"];
@ -224,7 +224,7 @@ export default class ESP8266ROM extends ROM {
);
}
return norm_xtal;
};
}
public _d2h(d: number) {
const h = (+d).toString(16);
@ -273,9 +273,9 @@ export default class ESP8266ROM extends ROM {
":" +
this._d2h(mac[5])
);
};
}
public get_erase_size(offset: number, size: number) {
return size;
};
}
}

194
webserial.js
View File

@ -1,194 +0,0 @@
import { TimeoutError } from "./error.js";
class Transport {
constructor(device) {
this.device = device;
this.slip_reader_enabled = false;
this.left_over = new Uint8Array(0);
}
get_info(){
const info = this.device.getInfo();
return "WebSerial VendorID 0x"+info.usbVendorId.toString(16)+ " ProductID 0x"+info.usbProductId.toString(16);
}
slip_writer(data) {
var count_esc = 0;
var i = 0, j = 0;
for (i = 0; i < data.length; i++) {
if (data[i] === 0xC0 || data[i] === 0xDB) {
count_esc++;
}
}
var out_data = new Uint8Array(2 + count_esc + data.length);
out_data[0] = 0xC0;
j = 1;
for (i = 0; i < data.length; i++, j++) {
if (data[i] === 0xC0) {
out_data[j++] = 0xDB;
out_data[j] = 0xDC;
continue;
}
if (data[i] === 0xDB) {
out_data[j++] = 0xDB;
out_data[j] = 0xDD;
continue;
}
out_data[j] = data[i];
}
out_data[j] = 0xC0;
return out_data;
}
async write(data) {
const writer = this.device.writable.getWriter();
var out_data = this.slip_writer(data);
await writer.write(out_data.buffer);
writer.releaseLock();
}
_appendBuffer(buffer1, buffer2) {
var tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength);
tmp.set(new Uint8Array(buffer1), 0);
tmp.set(new Uint8Array(buffer2), buffer1.byteLength);
return tmp.buffer;
}
/* this function expects complete packet (hence reader reads for atleast 8 bytes. This function is
* stateless and returns the first wellformed packet only after replacing escape sequence */
slip_reader(data) {
var i = 0;
var data_start = 0, data_end = 0;
var state = "init";
var packet, temp_pkt;
while (i < data.length) {
if (state === "init" && data[i] == 0xC0) {
data_start = i + 1;
state = "valid_data";
i++;
continue;
}
if (state === "valid_data" && data[i] == 0xC0) {
data_end = i - 1;
state = "packet_complete";
break;
}
i++;
}
if (state !== "packet_complete") {
this.left_over = data;
return new Uint8Array(0);
}
this.left_over = data.slice(data_end + 2);
var temp_pkt = new Uint8Array(data_end - data_start + 1);
var j = 0;
for (i = data_start; i <= data_end; i++, j++) {
if (data[i] === 0xDB && data[i+1] === 0xDC) {
temp_pkt[j] = 0xC0;
i++;
continue;
}
if (data[i] === 0xDB && data[i+1] === 0xDD) {
temp_pkt[j] = 0xDB;
i++;
continue;
}
temp_pkt[j] = data[i];
}
packet = temp_pkt.slice(0, j); /* Remove unused bytes due to escape seq */
return packet;
}
async read({timeout=0, min_data=12} = {}) {
console.log("Read with timeout " + timeout);
let t;
let packet = this.left_over;
this.left_over = new Uint8Array(0);
if (this.slip_reader_enabled) {
const val_final = this.slip_reader(packet);
if (val_final.length > 0) {
return val_final;
}
packet = this.left_over;
this.left_over = new Uint8Array(0);
}
const reader = this.device.readable.getReader();
try {
if (timeout > 0) {
t = setTimeout(function() {
reader.cancel();
}, timeout);
}
do {
const {value, done} = await reader.read();
if (done) {
this.left_over = packet;
throw new TimeoutError("Timeout");
}
var p = new Uint8Array(this._appendBuffer(packet.buffer, value.buffer));
packet = p;
} while (packet.length < min_data);
} finally {
if (timeout > 0) {
clearTimeout(t);
}
reader.releaseLock();
}
if (this.slip_reader_enabled) {
return this.slip_reader(packet);
}
return packet;
}
async rawRead({timeout=0} = {}) {
if (this.left_over.length != 0) {
const p = this.left_over;
this.left_over = new Uint8Array(0);
return p;
}
const reader = this.device.readable.getReader();
let t;
try {
if (timeout > 0) {
t = setTimeout(function() {
reader.cancel();
}, timeout);
}
const {value, done} = await reader.read();
if (done) {
throw new TimeoutError("Timeout");
}
return value;
} finally {
if (timeout > 0) {
clearTimeout(t);
}
reader.releaseLock();
}
}
async setRTS(state) {
await this.device.setSignals({requestToSend:state});
}
async setDTR(state) {
await this.device.setSignals({dataTerminalReady:state});
}
async connect({baud=115200} = {}) {
await this.device.open({baudRate: baud});
this.baudrate = baud;
this.left_over = new Uint8Array(0);
}
async disconnect() {
await this.device.close();
}
}
export { Transport };