node-ch347 0.0.1

package/dist/spi.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * CH347 SPI Interface
+ *
+ * Protocol based on official WCH SDK and flashrom implementation.
+ * Commands:
+ *   0xC0 - SPI_SET_CFG: Configure SPI
+ *   0xC1 - SPI_CS_CTRL: Chip select control
+ *   0xC2 - SPI_OUT_IN: Bidirectional transfer
+ *   0xC3 - SPI_IN: Read only
+ *   0xC4 - SPI_OUT: Write only
+ *   0xCA - SPI_GET_CFG: Get configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CH347SPI = void 0;
+const constants_1 = require("./constants");
+// Default SPI configuration
+const DEFAULT_SPI_CONFIG = {
+    speed: constants_1.SPISpeed.CLK_15M,
+    mode: constants_1.SPIMode.MODE_0,
+    chipSelect: 0,
+    bitOrder: 'MSB',
+};
+class CH347SPI {
+    usb;
+    config;
+    isInitialized = false;
+    constructor(usb, config) {
+        this.usb = usb;
+        this.config = { ...DEFAULT_SPI_CONFIG, ...config };
+    }
+    /**
+     * Initialize SPI interface with configuration
+     */
+    async init(config) {
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+        // Build SPI configuration packet (29 bytes total)
+        const cfgBuf = Buffer.alloc(29);
+        cfgBuf[0] = this.config.mode; // SPI Mode 0/1/2/3
+        cfgBuf[1] = this.config.speed; // Clock divisor
+        cfgBuf[2] = this.config.bitOrder === 'LSB' ? 0 : 1; // Byte order: 0=LSB, 1=MSB
+        cfgBuf[3] = 0; // SpiWriteReadInterval low byte
+        cfgBuf[4] = 0; // SpiWriteReadInterval high byte
+        cfgBuf[5] = 0xff; // SpiOutDefaultData
+        cfgBuf[6] = (this.config.chipSelect === 0 ? 0x80 : 0x81); // ChipSelect: bit7=1 means valid, bit0=CS selection
+        cfgBuf[7] = 0; // CS1 polarity (0=active low)
+        cfgBuf[8] = 0; // CS2 polarity (0=active low)
+        cfgBuf[9] = 0; // IsAutoDeactiveCS low byte
+        cfgBuf[10] = 0; // IsAutoDeactiveCS high byte
+        cfgBuf[11] = 0; // ActiveDelay low byte
+        cfgBuf[12] = 0; // ActiveDelay high byte
+        cfgBuf[13] = 0; // DelayDeactive byte 0
+        cfgBuf[14] = 0; // DelayDeactive byte 1
+        cfgBuf[15] = 0; // DelayDeactive byte 2
+        cfgBuf[16] = 0; // DelayDeactive byte 3
+        // Build command packet
+        const cmdLen = 3 + cfgBuf.length;
+        const cmdBuf = Buffer.alloc(cmdLen);
+        cmdBuf[0] = constants_1.CH347_CMD_SPI_SET_CFG;
+        cmdBuf[1] = cfgBuf.length & 0xff; // Length low byte
+        cmdBuf[2] = (cfgBuf.length >> 8) & 0xff; // Length high byte
+        cfgBuf.copy(cmdBuf, 3);
+        await this.usb.write(cmdBuf);
+        const response = await this.usb.read(4);
+        // Check response
+        if (response[0] !== constants_1.CH347_CMD_SPI_SET_CFG || response[3] !== 0) {
+            throw new Error('Failed to configure SPI');
+        }
+        this.isInitialized = true;
+    }
+    /**
+     * Control chip select
+     */
+    async setChipSelect(active) {
+        const cmdBuf = Buffer.alloc(4);
+        cmdBuf[0] = constants_1.CH347_CMD_SPI_CS_CTRL;
+        cmdBuf[1] = 1; // Length
+        cmdBuf[2] = 0;
+        cmdBuf[3] = constants_1.CH347_CS_CHANGE | (active ? constants_1.CH347_CS_ASSERT : constants_1.CH347_CS_DEASSERT);
+        await this.usb.write(cmdBuf);
+        await this.usb.read(4);
+    }
+    /**
+     * SPI write and read (full duplex transfer)
+     * @param data Data to write
+     * @param csControl If true, automatically control CS (default true)
+     * @returns Data read during transfer
+     */
+    async writeRead(data, csControl = true) {
+        if (!this.isInitialized) {
+            await this.init();
+        }
+        const result = Buffer.alloc(data.length);
+        let offset = 0;
+        const maxPayload = constants_1.CH347_PACKET_SIZE - 3; // Command header is 3 bytes
+        // Control CS
+        const csFlag = csControl ? 0x80 : 0x00;
+        while (offset < data.length) {
+            const chunkSize = Math.min(data.length - offset, maxPayload);
+            const chunk = data.subarray(offset, offset + chunkSize);
+            // Build command packet
+            const cmdBuf = Buffer.alloc(3 + chunkSize);
+            cmdBuf[0] = constants_1.CH347_CMD_SPI_OUT_IN;
+            cmdBuf[1] = chunkSize & 0xff;
+            cmdBuf[2] = ((chunkSize >> 8) & 0xff) | csFlag;
+            chunk.copy(cmdBuf, 3);
+            await this.usb.write(cmdBuf);
+            const response = await this.usb.read(constants_1.CH347_PACKET_SIZE);
+            // Extract data from response
+            if (response[0] === constants_1.CH347_CMD_SPI_OUT_IN) {
+                const responseLen = response[1] | (response[2] << 8);
+                response.copy(result, offset, 3, 3 + Math.min(responseLen, chunkSize));
+            }
+            offset += chunkSize;
+        }
+        return result;
+    }
+    /**
+     * SPI write only
+     * @param data Data to write
+     * @param csControl If true, automatically control CS (default true)
+     */
+    async write(data, csControl = true) {
+        if (!this.isInitialized) {
+            await this.init();
+        }
+        const maxPayload = constants_1.CH347_PACKET_SIZE - 3;
+        const csFlag = csControl ? 0x80 : 0x00;
+        let offset = 0;
+        while (offset < data.length) {
+            const chunkSize = Math.min(data.length - offset, maxPayload);
+            const chunk = data.subarray(offset, offset + chunkSize);
+            const cmdBuf = Buffer.alloc(3 + chunkSize);
+            cmdBuf[0] = constants_1.CH347_CMD_SPI_OUT;
+            cmdBuf[1] = chunkSize & 0xff;
+            cmdBuf[2] = ((chunkSize >> 8) & 0xff) | csFlag;
+            chunk.copy(cmdBuf, 3);
+            await this.usb.write(cmdBuf);
+            await this.usb.read(4); // Read acknowledgment
+            offset += chunkSize;
+        }
+    }
+    /**
+     * SPI read only
+     * @param length Number of bytes to read
+     * @param csControl If true, automatically control CS (default true)
+     * @returns Data read
+     */
+    async read(length, csControl = true) {
+        if (!this.isInitialized) {
+            await this.init();
+        }
+        const result = Buffer.alloc(length);
+        const maxPayload = constants_1.CH347_PACKET_SIZE - 3;
+        const csFlag = csControl ? 0x80 : 0x00;
+        let offset = 0;
+        while (offset < length) {
+            const chunkSize = Math.min(length - offset, maxPayload);
+            const cmdBuf = Buffer.alloc(7);
+            cmdBuf[0] = constants_1.CH347_CMD_SPI_IN;
+            cmdBuf[1] = 4; // Length of parameters
+            cmdBuf[2] = csFlag;
+            cmdBuf[3] = chunkSize & 0xff;
+            cmdBuf[4] = (chunkSize >> 8) & 0xff;
+            cmdBuf[5] = (chunkSize >> 16) & 0xff;
+            cmdBuf[6] = (chunkSize >> 24) & 0xff;
+            await this.usb.write(cmdBuf);
+            const response = await this.usb.read(constants_1.CH347_PACKET_SIZE);
+            if (response[0] === constants_1.CH347_CMD_SPI_IN) {
+                const responseLen = response[1] | (response[2] << 8);
+                response.copy(result, offset, 3, 3 + Math.min(responseLen, chunkSize));
+            }
+            offset += chunkSize;
+        }
+        return result;
+    }
+    /**
+     * Execute SPI command with CS control
+     * Useful for sending flash commands
+     */
+    async command(writeData, readLength = 0) {
+        await this.setChipSelect(true);
+        try {
+            if (readLength === 0) {
+                // Write only
+                await this.write(writeData, false);
+                return Buffer.alloc(0);
+            }
+            else {
+                // Write then read
+                await this.write(writeData, false);
+                return await this.read(readLength, false);
+            }
+        }
+        finally {
+            await this.setChipSelect(false);
+        }
+    }
+    /**
+     * Execute SPI command with full duplex transfer
+     */
+    async transfer(data) {
+        await this.setChipSelect(true);
+        try {
+            return await this.writeRead(data, false);
+        }
+        finally {
+            await this.setChipSelect(false);
+        }
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Check if SPI is initialized
+     */
+    isReady() {
+        return this.isInitialized;
+    }
+}
+exports.CH347SPI = CH347SPI;
+//# sourceMappingURL=spi.js.map

package/dist/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * CH347 Type Definitions
+ */
+import { SPISpeed, SPIMode, I2CSpeed } from './constants';
+export interface CH347DeviceInfo {
+    vendorId: number;
+    productId: number;
+    serialNumber?: string;
+    manufacturer?: string;
+    product?: string;
+    busNumber: number;
+    deviceAddress: number;
+}
+export interface GPIOConfig {
+    pin: number;
+    direction: 'input' | 'output';
+    value?: boolean;
+}
+export interface GPIOState {
+    pin: number;
+    direction: 'input' | 'output';
+    value: boolean;
+}
+export interface SPIConfig {
+    speed: SPISpeed;
+    mode: SPIMode;
+    chipSelect: 0 | 1;
+    bitOrder: 'MSB' | 'LSB';
+}
+export interface EraseType {
+    command: number;
+    size: number;
+    timeoutMs: number;
+}
+export interface FlashInfo {
+    manufacturerId: number;
+    memoryType: number;
+    capacity: number;
+    jedecId: number;
+    size: number;
+    name?: string;
+    sfdpSupported?: boolean;
+    pageSize?: number;
+    eraseTypes?: EraseType[];
+}
+export interface FlashProgress {
+    operation: 'read' | 'write' | 'erase' | 'verify';
+    current: number;
+    total: number;
+    percentage: number;
+}
+export type FlashProgressCallback = (progress: FlashProgress) => void;
+export interface I2CConfig {
+    speed: I2CSpeed;
+}
+export interface UARTConfig {
+    baudRate: number;
+    dataBits: 5 | 6 | 7 | 8;
+    stopBits: 1 | 2;
+    parity: 'none' | 'odd' | 'even';
+    flowControl: 'none' | 'hardware';
+}
+export interface CH347Options {
+    gpio?: Partial<GPIOConfig>[];
+    spi?: Partial<SPIConfig>;
+    i2c?: Partial<I2CConfig>;
+    uart?: Partial<UARTConfig>;
+}
+export declare const FlashManufacturers: Record<number, string>;
+export declare const FlashDatabase: Record<number, {
+    name: string;
+    size: number;
+}>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * CH347 Type Definitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlashDatabase = exports.FlashManufacturers = void 0;
+// Known flash manufacturers
+exports.FlashManufacturers = {
+    0xef: 'Winbond',
+    0xc8: 'GigaDevice',
+    0x20: 'Micron/Numonyx/ST',
+    0x1f: 'Atmel/Adesto',
+    0xbf: 'SST/Microchip',
+    0xc2: 'Macronix',
+    0x9d: 'ISSI',
+    0x01: 'Spansion/Cypress',
+    0x1c: 'EON',
+    0xa1: 'Fudan',
+    0x68: 'Boya',
+    0x85: 'Puya',
+    0x5e: 'Zbit',
+};
+// Common flash chips database
+exports.FlashDatabase = {
+    // Winbond
+    0xef4014: { name: 'W25Q80', size: 1024 * 1024 },
+    0xef4015: { name: 'W25Q16', size: 2 * 1024 * 1024 },
+    0xef4016: { name: 'W25Q32', size: 4 * 1024 * 1024 },
+    0xef4017: { name: 'W25Q64', size: 8 * 1024 * 1024 },
+    0xef4018: { name: 'W25Q128', size: 16 * 1024 * 1024 },
+    0xef4019: { name: 'W25Q256', size: 32 * 1024 * 1024 },
+    // GigaDevice
+    0xc84014: { name: 'GD25Q80', size: 1024 * 1024 },
+    0xc84015: { name: 'GD25Q16', size: 2 * 1024 * 1024 },
+    0xc84016: { name: 'GD25Q32', size: 4 * 1024 * 1024 },
+    0xc84017: { name: 'GD25Q64', size: 8 * 1024 * 1024 },
+    0xc84018: { name: 'GD25Q128', size: 16 * 1024 * 1024 },
+    // Macronix
+    0xc22014: { name: 'MX25L8005', size: 1024 * 1024 },
+    0xc22015: { name: 'MX25L1605', size: 2 * 1024 * 1024 },
+    0xc22016: { name: 'MX25L3205', size: 4 * 1024 * 1024 },
+    0xc22017: { name: 'MX25L6405', size: 8 * 1024 * 1024 },
+    0xc22018: { name: 'MX25L12805', size: 16 * 1024 * 1024 },
+};
+//# sourceMappingURL=types.js.map

package/dist/uart.d.ts

@@ -0,0 +1,81 @@
+/**
+ * CH347 UART Interface
+ *
+ * The CH347 UART interface appears as a virtual COM port (CDC ACM).
+ * On Linux/macOS, it typically shows up as /dev/ttyACM0 or /dev/tty.usbmodem*
+ *
+ * This module provides a cross-platform wrapper around the serial port.
+ */
+import { EventEmitter } from 'events';
+import { UARTConfig } from './types';
+export interface CH347UARTEvents {
+    data: (data: Buffer) => void;
+    error: (error: Error) => void;
+    open: () => void;
+    close: () => void;
+}
+export declare class CH347UART extends EventEmitter {
+    private config;
+    private port;
+    private portPath;
+    private isOpen;
+    constructor(config?: Partial<UARTConfig>);
+    /**
+     * List available serial ports that might be CH347 UART
+     * Returns array of tty paths (e.g., '/dev/ttyACM0')
+     */
+    static listPorts(): Promise<string[]>;
+    /**
+     * Open UART port
+     */
+    open(portPath: string, config?: Partial<UARTConfig>): Promise<void>;
+    /**
+     * Close UART port
+     */
+    close(): Promise<void>;
+    /**
+     * Write data to UART
+     */
+    write(data: Buffer | string): Promise<void>;
+    /**
+     * Read data from UART (with timeout)
+     */
+    read(length: number, timeoutMs?: number): Promise<Buffer>;
+    /**
+     * Read line (until newline)
+     */
+    readLine(timeoutMs?: number): Promise<string>;
+    /**
+     * Write and wait for response
+     */
+    writeRead(data: Buffer | string, responseLength: number, timeoutMs?: number): Promise<Buffer>;
+    /**
+     * Set baud rate
+     */
+    setBaudRate(baudRate: number): Promise<void>;
+    /**
+     * Flush input/output buffers
+     */
+    flush(): Promise<void>;
+    /**
+     * Set DTR signal
+     */
+    setDTR(value: boolean): Promise<void>;
+    /**
+     * Set RTS signal
+     */
+    setRTS(value: boolean): Promise<void>;
+    /**
+     * Check if port is open
+     */
+    isConnected(): boolean;
+    /**
+     * Get current port path
+     */
+    getPortPath(): string | null;
+    /**
+     * Get current configuration
+     */
+    getConfig(): UARTConfig;
+}
+//# sourceMappingURL=uart.d.ts.map