esp32tool 1.0.0

package/dist/esp_loader.d.ts

@@ -0,0 +1,222 @@
+import { Logger, ChipFamily, SpiFlashAddresses } from "./const";
+export declare class ESPLoader extends EventTarget {
+    port: SerialPort;
+    logger: Logger;
+    private _parent?;
+    chipFamily: ChipFamily;
+    chipName: string | null;
+    chipRevision: number | null;
+    chipVariant: string | null;
+    _efuses: any[];
+    _flashsize: number;
+    debug: boolean;
+    IS_STUB: boolean;
+    connected: boolean;
+    flashSize: string | null;
+    __inputBuffer?: number[];
+    __totalBytesRead?: number;
+    private _currentBaudRate;
+    private _maxUSBSerialBaudrate?;
+    private _reader?;
+    private _isESP32S2NativeUSB;
+    private _initializationSucceeded;
+    constructor(port: SerialPort, logger: Logger, _parent?: ESPLoader | undefined);
+    private get _inputBuffer();
+    private get _totalBytesRead();
+    private set _totalBytesRead(value);
+    private detectUSBSerialChip;
+    initialize(): Promise<void>;
+    /**
+     * Detect chip type using GET_SECURITY_INFO (for newer chips) or magic value (for older chips)
+     */
+    detectChip(): Promise<void>;
+    /**
+     * Get chip revision for ESP32-P4
+     */
+    getChipRevision(): Promise<number>;
+    /**
+     * Get security info including chip ID (ESP32-C3 and later)
+     */
+    getSecurityInfo(): Promise<{
+        flags: number;
+        flashCryptCnt: number;
+        keyPurposes: number[];
+        chipId: number;
+        apiVersion: number;
+    }>;
+    /**
+     * @name readLoop
+     * Reads data from the input stream and places it in the inputBuffer
+     */
+    readLoop(): Promise<void>;
+    sleep(ms?: number): Promise<unknown>;
+    state_DTR: boolean;
+    setRTS(state: boolean): Promise<void>;
+    setDTR(state: boolean): Promise<void>;
+    hardReset(bootloader?: boolean): Promise<void>;
+    /**
+     * @name macAddr
+     * The MAC address burned into the OTP memory of the ESP chip
+     */
+    macAddr(): any[];
+    readRegister(reg: number): Promise<number>;
+    /**
+     * @name checkCommand
+     * Send a command packet, check that the command succeeded and
+     * return a tuple with the value and data.
+     * See the ESP Serial Protocol for more details on what value/data are
+     */
+    checkCommand(opcode: number, buffer: number[], checksum?: number, timeout?: number): Promise<[number, number[]]>;
+    /**
+     * @name sendCommand
+     * Send a slip-encoded, checksummed command over the UART,
+     * does not check response
+     */
+    sendCommand(opcode: number, buffer: number[], checksum?: number): Promise<void>;
+    /**
+     * @name readPacket
+     * Generator to read SLIP packets from a serial port.
+     * Yields one full SLIP packet at a time, raises exception on timeout or invalid data.
+     */
+    readPacket(timeout: number): Promise<number[]>;
+    /**
+     * @name getResponse
+     * Read response data and decodes the slip packet, then parses
+     * out the value/data and returns as a tuple of (value, data) where
+     * each is a list of bytes
+     */
+    getResponse(opcode: number, timeout?: number): Promise<[number, number[]]>;
+    /**
+     * @name checksum
+     * Calculate checksum of a blob, as it is defined by the ROM
+     */
+    checksum(data: number[], state?: number): number;
+    setBaudrate(baud: number): Promise<void>;
+    reconfigurePort(baud: number): Promise<void>;
+    /**
+     * @name sync
+     * Put into ROM bootload mode & attempt to synchronize with the
+     * ESP ROM bootloader, we will retry a few times
+     */
+    sync(): Promise<boolean>;
+    /**
+     * @name _sync
+     * Perform a soft-sync using AT sync packets, does not perform
+     * any hardware resetting
+     */
+    _sync(): Promise<boolean>;
+    /**
+     * @name getFlashWriteSize
+     * Get the Flash write size based on the chip
+     */
+    getFlashWriteSize(): 1024 | 16384;
+    /**
+     * @name flashData
+     * Program a full, uncompressed binary file into SPI Flash at
+     *   a given offset. If an ESP32 and md5 string is passed in, will also
+     *   verify memory. ESP8266 does not have checksum memory verification in
+     *   ROM
+     */
+    flashData(binaryData: ArrayBuffer, updateProgress: (bytesWritten: number, totalBytes: number) => void, offset?: number, compress?: boolean): Promise<void>;
+    /**
+     * @name flashBlock
+     * Send one block of data to program into SPI Flash memory
+     */
+    flashBlock(data: number[], seq: number, timeout?: number): Promise<void>;
+    flashDeflBlock(data: number[], seq: number, timeout?: number): Promise<void>;
+    /**
+     * @name flashBegin
+     * Prepare for flashing by attaching SPI chip and erasing the
+     *   number of blocks requred.
+     */
+    flashBegin(size?: number, offset?: number, encrypted?: boolean): Promise<number>;
+    /**
+     * @name flashDeflBegin
+     *
+     */
+    flashDeflBegin(size?: number, compressedSize?: number, offset?: number): Promise<number>;
+    flashFinish(): Promise<void>;
+    flashDeflFinish(): Promise<void>;
+    getBootloaderOffset(): number;
+    flashId(): Promise<number>;
+    getChipFamily(): ChipFamily;
+    writeRegister(address: number, value: number, mask?: number, delayUs?: number, delayAfterUs?: number): Promise<void>;
+    setDataLengths(spiAddresses: SpiFlashAddresses, mosiBits: number, misoBits: number): Promise<void>;
+    waitDone(spiCmdReg: number, spiCmdUsr: number): Promise<void>;
+    runSpiFlashCommand(spiflashCommand: number, data: number[], readBits?: number): Promise<number>;
+    detectFlashSize(): Promise<void>;
+    /**
+     * @name getEraseSize
+     * Calculate an erase size given a specific size in bytes.
+     *   Provides a workaround for the bootloader erase bug on ESP8266.
+     */
+    getEraseSize(offset: number, size: number): number;
+    /**
+     * @name memBegin (592)
+     * Start downloading an application image to RAM
+     */
+    memBegin(size: number, blocks: number, blocksize: number, offset: number): Promise<[number, number[]]>;
+    /**
+     * @name memBlock (609)
+     * Send a block of an image to RAM
+     */
+    memBlock(data: number[], seq: number): Promise<[number, number[]]>;
+    /**
+     * @name memFinish (615)
+     * Leave download mode and run the application
+     *
+     * Sending ESP_MEM_END usually sends a correct response back, however sometimes
+     * (with ROM loader) the executed code may reset the UART or change the baud rate
+     * before the transmit FIFO is empty. So in these cases we set a short timeout and
+     * ignore errors.
+     */
+    memFinish(entrypoint?: number): Promise<[number, number[]]>;
+    runStub(skipFlashDetection?: boolean): Promise<EspStubLoader>;
+    writeToStream(data: number[]): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * @name reconnectAndResume
+     * Reconnect the serial port to flush browser buffers and reload stub
+     */
+    reconnect(): Promise<void>;
+    /**
+     * @name drainInputBuffer
+     * Actively drain the input buffer by reading data for a specified time.
+     * Simple approach for some drivers (especially CP210x on Windows) that have
+     * issues with buffer flushing.
+     *
+     * Based on esptool.py fix: https://github.com/espressif/esptool/commit/5338ea054e5099ac7be235c54034802ac8a43162
+     *
+     * @param bufferingTime - Time in milliseconds to wait for the buffer to fill
+     */
+    private drainInputBuffer;
+    /**
+     * @name flushSerialBuffers
+     * Flush any pending data in the TX and RX serial port buffers
+     * This clears both the application RX buffer and waits for hardware buffers to drain
+     */
+    private flushSerialBuffers;
+    /**
+     * @name readFlash
+     * Read flash memory from the chip (only works with stub loader)
+     * @param addr - Address to read from
+     * @param size - Number of bytes to read
+     * @param onPacketReceived - Optional callback function called when packet is received
+     * @returns Uint8Array containing the flash data
+     */
+    readFlash(addr: number, size: number, onPacketReceived?: (packet: Uint8Array, progress: number, totalSize: number) => void): Promise<Uint8Array>;
+}
+declare class EspStubLoader extends ESPLoader {
+    IS_STUB: boolean;
+    /**
+     * @name memBegin (592)
+     * Start downloading an application image to RAM
+     */
+    memBegin(size: number, _blocks: number, _blocksize: number, offset: number): Promise<[number, number[]]>;
+    /**
+     * @name getEraseSize
+     * depending on flash chip model the erase may take this long (maybe longer!)
+     */
+    eraseFlash(): Promise<void>;
+}
+export {};