node-ch347 0.0.1

package/dist/gpio.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * CH347 GPIO Control
+ *
+ * Protocol from ch347-gpio.c:
+ * - GPIO buffer is 11 bytes: [0xCC, length(8), 0x00, pin0, pin1, pin2, pin3, pin4, pin5, pin6, pin7]
+ * - Each pin byte has control bits:
+ *   - Bit 7 (0x80): In response, indicates output direction
+ *   - Bit 6 (0x40): Enable pin change (out) / Current value (in)
+ *   - Bit 5-4 (0x30): Set direction to output
+ *   - Bit 3 (0x08): Set pin value high
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CH347GPIO = void 0;
+const constants_1 = require("./constants");
+class CH347GPIO {
+    usb;
+    pinStates = [];
+    constructor(usb) {
+        this.usb = usb;
+        // Initialize pin states
+        for (let i = 0; i < constants_1.CH347_GPIO_COUNT; i++) {
+            this.pinStates[i] = {
+                pin: i,
+                direction: 'input',
+                value: false,
+            };
+        }
+    }
+    /**
+     * Build GPIO command buffer
+     */
+    buildCommandBuffer(pinConfigs) {
+        const buf = Buffer.alloc(11);
+        buf[0] = constants_1.CH347_CMD_GPIO;
+        buf[1] = 8; // Length of pin data
+        buf[2] = 0;
+        // Set pin bytes
+        for (const [pin, config] of pinConfigs) {
+            if (pin >= 0 && pin < constants_1.CH347_GPIO_COUNT) {
+                let pinByte = 0;
+                if (config.setDir || config.setValue) {
+                    pinByte |= constants_1.GPIO_PIN_ENABLE; // Enable change (0xC0)
+                }
+                if (config.setDir && config.dirOut) {
+                    pinByte |= constants_1.GPIO_PIN_DIR_OUT; // Set output direction (0x30)
+                }
+                if (config.setValue && config.value) {
+                    pinByte |= constants_1.GPIO_PIN_VALUE_HIGH; // Set value high (0x08)
+                }
+                buf[3 + pin] = pinByte;
+            }
+        }
+        return buf;
+    }
+    /**
+     * Parse GPIO response buffer
+     */
+    parseResponse(buf) {
+        const states = [];
+        for (let i = 0; i < constants_1.CH347_GPIO_COUNT; i++) {
+            const pinByte = buf[3 + i];
+            states.push({
+                pin: i,
+                direction: (pinByte & constants_1.GPIO_PIN_IS_OUTPUT) ? 'output' : 'input',
+                value: (pinByte & constants_1.GPIO_PIN_VALUE) !== 0,
+            });
+        }
+        return states;
+    }
+    /**
+     * Read all GPIO states
+     */
+    async readAll() {
+        // Send read command (empty pin config)
+        const cmdBuf = this.buildCommandBuffer(new Map());
+        const response = await this.usb.transfer(cmdBuf, 11);
+        this.pinStates = this.parseResponse(response);
+        return this.pinStates;
+    }
+    /**
+     * Read single GPIO pin state
+     */
+    async read(pin) {
+        if (pin < 0 || pin >= constants_1.CH347_GPIO_COUNT) {
+            throw new Error(`Invalid pin number: ${pin}`);
+        }
+        const states = await this.readAll();
+        return states[pin];
+    }
+    /**
+     * Configure GPIO pin direction
+     */
+    async setDirection(pin, direction) {
+        if (pin < 0 || pin >= constants_1.CH347_GPIO_COUNT) {
+            throw new Error(`Invalid pin number: ${pin}`);
+        }
+        const pinConfig = new Map();
+        pinConfig.set(pin, {
+            setDir: true,
+            dirOut: direction === 'output',
+            setValue: true,
+            value: this.pinStates[pin]?.value ?? false,
+        });
+        const cmdBuf = this.buildCommandBuffer(pinConfig);
+        const response = await this.usb.transfer(cmdBuf, 11);
+        this.pinStates = this.parseResponse(response);
+    }
+    /**
+     * Set GPIO output value
+     */
+    async write(pin, value) {
+        if (pin < 0 || pin >= constants_1.CH347_GPIO_COUNT) {
+            throw new Error(`Invalid pin number: ${pin}`);
+        }
+        // First ensure pin is set as output
+        const pinConfig = new Map();
+        pinConfig.set(pin, {
+            setDir: true,
+            dirOut: true,
+            setValue: true,
+            value: value,
+        });
+        const cmdBuf = this.buildCommandBuffer(pinConfig);
+        const response = await this.usb.transfer(cmdBuf, 11);
+        this.pinStates = this.parseResponse(response);
+    }
+    /**
+     * Set multiple GPIO pins at once
+     */
+    async writeMultiple(pins) {
+        const pinConfig = new Map();
+        for (const { pin, value } of pins) {
+            if (pin < 0 || pin >= constants_1.CH347_GPIO_COUNT) {
+                throw new Error(`Invalid pin number: ${pin}`);
+            }
+            pinConfig.set(pin, {
+                setDir: true,
+                dirOut: true,
+                setValue: true,
+                value: value,
+            });
+        }
+        const cmdBuf = this.buildCommandBuffer(pinConfig);
+        const response = await this.usb.transfer(cmdBuf, 11);
+        this.pinStates = this.parseResponse(response);
+    }
+    /**
+     * Configure multiple GPIO pins
+     */
+    async configure(configs) {
+        const pinConfig = new Map();
+        for (const config of configs) {
+            if (config.pin < 0 || config.pin >= constants_1.CH347_GPIO_COUNT) {
+                throw new Error(`Invalid pin number: ${config.pin}`);
+            }
+            pinConfig.set(config.pin, {
+                setDir: true,
+                dirOut: config.direction === 'output',
+                setValue: config.value !== undefined,
+                value: config.value ?? false,
+            });
+        }
+        const cmdBuf = this.buildCommandBuffer(pinConfig);
+        const response = await this.usb.transfer(cmdBuf, 11);
+        this.pinStates = this.parseResponse(response);
+    }
+    /**
+     * Pulse a GPIO pin (useful for buttons)
+     */
+    async pulse(pin, durationMs = 100, activeHigh = true) {
+        await this.write(pin, activeHigh);
+        await this.delay(durationMs);
+        await this.write(pin, !activeHigh);
+    }
+    /**
+     * Toggle GPIO pin
+     */
+    async toggle(pin) {
+        const state = await this.read(pin);
+        const newValue = !state.value;
+        await this.write(pin, newValue);
+        return newValue;
+    }
+    /**
+     * Get cached pin states (call readAll() to refresh)
+     */
+    getPinStates() {
+        return [...this.pinStates];
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.CH347GPIO = CH347GPIO;
+//# sourceMappingURL=gpio.js.map

package/dist/index.d.ts

@@ -0,0 +1,149 @@
+/**
+ * CH347 Library
+ *
+ * A Node.js library for interfacing with CH347 USB devices.
+ * Supports GPIO and SPI flash programming.
+ * UART path discovery is provided; use external serial libraries for UART communication.
+ *
+ * Cross-platform: Linux and macOS
+ */
+export { CH347USB } from './usb';
+export { CH347GPIO } from './gpio';
+export { CH347SPI } from './spi';
+export { CH347Flash } from './flash';
+export { listDevicesWithSerial, CH347DeviceWithSerial, } from './config';
+export * from './types';
+export * from './constants';
+import { CH347GPIO } from './gpio';
+import { CH347SPI } from './spi';
+import { CH347Flash } from './flash';
+import { CH347DeviceWithSerial } from './config';
+import { CH347DeviceInfo, SPIConfig, FlashInfo, GPIOState } from './types';
+export interface CH347DeviceOptions {
+    spi?: Partial<SPIConfig>;
+}
+/**
+ * Main CH347 device class
+ * Provides unified access to GPIO, SPI, and Flash functionality
+ */
+export declare class CH347Device {
+    private usb;
+    private _gpio;
+    private _spi;
+    private _flash;
+    private options;
+    constructor(options?: CH347DeviceOptions);
+    /**
+     * List all connected CH347 devices
+     */
+    static listDevices(): CH347DeviceInfo[];
+    /**
+     * List all connected CH347 devices with their serial numbers
+     */
+    static listDevicesWithSerial(): Promise<CH347DeviceWithSerial[]>;
+    /**
+     * Open connection to CH347 device
+     * @param deviceIndex Index of device to open (default 0)
+     */
+    open(deviceIndex?: number): Promise<void>;
+    /**
+     * Close connection
+     */
+    close(): void;
+    /**
+     * Check if device is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get the UART tty path for this CH347 device
+     * Returns the serial port path (e.g., '/dev/ttyACM0' on Linux, '/dev/tty.usbmodem*' on macOS)
+     */
+    getUARTPath(): string | null;
+    /**
+     * Get GPIO controller
+     */
+    get gpio(): CH347GPIO;
+    /**
+     * Get SPI controller
+     */
+    get spi(): CH347SPI;
+    /**
+     * Get Flash programmer
+     */
+    get flash(): CH347Flash;
+    /**
+     * Read all GPIO pin states
+     */
+    gpioReadAll(): Promise<GPIOState[]>;
+    /**
+     * Set GPIO pin output value
+     */
+    gpioWrite(pin: number, value: boolean): Promise<void>;
+    /**
+     * Read GPIO pin state
+     */
+    gpioRead(pin: number): Promise<GPIOState>;
+    /**
+     * Pulse GPIO pin (for button press simulation)
+     */
+    gpioPulse(pin: number, durationMs?: number, activeHigh?: boolean): Promise<void>;
+    /**
+     * Initialize SPI interface
+     */
+    spiInit(config?: Partial<SPIConfig>): Promise<void>;
+    /**
+     * Read flash JEDEC ID
+     */
+    flashReadId(): Promise<FlashInfo>;
+    /**
+     * Read data from flash
+     */
+    flashRead(address: number, length: number, onProgress?: (progress: {
+        percentage: number;
+    }) => void): Promise<Buffer>;
+    /**
+     * Write data to flash
+     */
+    flashWrite(address: number, data: Buffer, onProgress?: (progress: {
+        percentage: number;
+    }) => void): Promise<void>;
+    /**
+     * Erase flash sector (4KB)
+     */
+    flashEraseSector(address: number): Promise<void>;
+    /**
+     * Erase entire flash chip
+     */
+    flashEraseChip(onProgress?: (progress: {
+        percentage: number;
+    }) => void): Promise<void>;
+    /**
+     * Program flash (erase + write + verify)
+     */
+    flashProgram(address: number, data: Buffer, options?: {
+        erase?: boolean;
+        verify?: boolean;
+        onProgress?: (progress: {
+            percentage: number;
+        }) => void;
+    }): Promise<boolean>;
+    /**
+     * Program flash from a binary file
+     * If address is not specified, requires file size to match flash size (call flashReadId first)
+     */
+    flashProgramFile(filePath: string, address?: number, options?: {
+        erase?: boolean;
+        verify?: boolean;
+        onProgress?: (progress: {
+            percentage: number;
+        }) => void;
+    }): Promise<boolean>;
+    /**
+     * Read flash contents to a binary file
+     */
+    flashReadToFile(filePath: string, address?: number, length?: number, onProgress?: (progress: {
+        percentage: number;
+    }) => void): Promise<void>;
+}
+export default CH347Device;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * CH347 Library
+ *
+ * A Node.js library for interfacing with CH347 USB devices.
+ * Supports GPIO and SPI flash programming.
+ * UART path discovery is provided; use external serial libraries for UART communication.
+ *
+ * Cross-platform: Linux and macOS
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CH347Device = exports.listDevicesWithSerial = exports.CH347Flash = exports.CH347SPI = exports.CH347GPIO = exports.CH347USB = void 0;
+// Core modules
+var usb_1 = require("./usb");
+Object.defineProperty(exports, "CH347USB", { enumerable: true, get: function () { return usb_1.CH347USB; } });
+var gpio_1 = require("./gpio");
+Object.defineProperty(exports, "CH347GPIO", { enumerable: true, get: function () { return gpio_1.CH347GPIO; } });
+var spi_1 = require("./spi");
+Object.defineProperty(exports, "CH347SPI", { enumerable: true, get: function () { return spi_1.CH347SPI; } });
+var flash_1 = require("./flash");
+Object.defineProperty(exports, "CH347Flash", { enumerable: true, get: function () { return flash_1.CH347Flash; } });
+// Device configuration (serial number, etc.)
+var config_1 = require("./config");
+Object.defineProperty(exports, "listDevicesWithSerial", { enumerable: true, get: function () { return config_1.listDevicesWithSerial; } });
+// Types
+__exportStar(require("./types"), exports);
+// Constants
+__exportStar(require("./constants"), exports);
+// Convenience class that combines all functionality
+const usb_2 = require("./usb");
+const gpio_2 = require("./gpio");
+const spi_2 = require("./spi");
+const flash_2 = require("./flash");
+const config_2 = require("./config");
+/**
+ * Main CH347 device class
+ * Provides unified access to GPIO, SPI, and Flash functionality
+ */
+class CH347Device {
+    usb;
+    _gpio = null;
+    _spi = null;
+    _flash = null;
+    options;
+    constructor(options = {}) {
+        this.usb = new usb_2.CH347USB();
+        this.options = options;
+    }
+    /**
+     * List all connected CH347 devices
+     */
+    static listDevices() {
+        return usb_2.CH347USB.listDevices();
+    }
+    /**
+     * List all connected CH347 devices with their serial numbers
+     */
+    static async listDevicesWithSerial() {
+        return (0, config_2.listDevicesWithSerial)();
+    }
+    /**
+     * Open connection to CH347 device
+     * @param deviceIndex Index of device to open (default 0)
+     */
+    async open(deviceIndex = 0) {
+        await this.usb.open(deviceIndex);
+        // Initialize GPIO
+        this._gpio = new gpio_2.CH347GPIO(this.usb);
+        // Initialize SPI with optional config
+        this._spi = new spi_2.CH347SPI(this.usb, this.options.spi);
+        // Initialize Flash (wraps SPI)
+        this._flash = new flash_2.CH347Flash(this._spi);
+    }
+    /**
+     * Close connection
+     */
+    close() {
+        this.usb.close();
+        this._gpio = null;
+        this._spi = null;
+        this._flash = null;
+    }
+    /**
+     * Check if device is connected
+     */
+    isConnected() {
+        return this.usb.isConnected();
+    }
+    /**
+     * Get the UART tty path for this CH347 device
+     * Returns the serial port path (e.g., '/dev/ttyACM0' on Linux, '/dev/tty.usbmodem*' on macOS)
+     */
+    getUARTPath() {
+        return this.usb.getUARTPath();
+    }
+    /**
+     * Get GPIO controller
+     */
+    get gpio() {
+        if (!this._gpio) {
+            throw new Error('Device not open');
+        }
+        return this._gpio;
+    }
+    /**
+     * Get SPI controller
+     */
+    get spi() {
+        if (!this._spi) {
+            throw new Error('Device not open');
+        }
+        return this._spi;
+    }
+    /**
+     * Get Flash programmer
+     */
+    get flash() {
+        if (!this._flash) {
+            throw new Error('Device not open');
+        }
+        return this._flash;
+    }
+    // ==================== GPIO Convenience Methods ====================
+    /**
+     * Read all GPIO pin states
+     */
+    async gpioReadAll() {
+        return this.gpio.readAll();
+    }
+    /**
+     * Set GPIO pin output value
+     */
+    async gpioWrite(pin, value) {
+        return this.gpio.write(pin, value);
+    }
+    /**
+     * Read GPIO pin state
+     */
+    async gpioRead(pin) {
+        return this.gpio.read(pin);
+    }
+    /**
+     * Pulse GPIO pin (for button press simulation)
+     */
+    async gpioPulse(pin, durationMs = 100, activeHigh = true) {
+        return this.gpio.pulse(pin, durationMs, activeHigh);
+    }
+    // ==================== SPI Flash Convenience Methods ====================
+    /**
+     * Initialize SPI interface
+     */
+    async spiInit(config) {
+        return this.spi.init(config);
+    }
+    /**
+     * Read flash JEDEC ID
+     */
+    async flashReadId() {
+        return this.flash.readJedecId();
+    }
+    /**
+     * Read data from flash
+     */
+    async flashRead(address, length, onProgress) {
+        return this.flash.read(address, length, onProgress);
+    }
+    /**
+     * Write data to flash
+     */
+    async flashWrite(address, data, onProgress) {
+        return this.flash.write(address, data, onProgress);
+    }
+    /**
+     * Erase flash sector (4KB)
+     */
+    async flashEraseSector(address) {
+        return this.flash.eraseSector(address);
+    }
+    /**
+     * Erase entire flash chip
+     */
+    async flashEraseChip(onProgress) {
+        return this.flash.eraseChip(onProgress);
+    }
+    /**
+     * Program flash (erase + write + verify)
+     */
+    async flashProgram(address, data, options) {
+        return this.flash.program(address, data, options);
+    }
+    /**
+     * Program flash from a binary file
+     * If address is not specified, requires file size to match flash size (call flashReadId first)
+     */
+    async flashProgramFile(filePath, address, options) {
+        return this.flash.programFile(filePath, address, options);
+    }
+    /**
+     * Read flash contents to a binary file
+     */
+    async flashReadToFile(filePath, address = 0, length, onProgress) {
+        return this.flash.readToFile(filePath, address, length, onProgress);
+    }
+}
+exports.CH347Device = CH347Device;
+// Default export
+exports.default = CH347Device;
+//# sourceMappingURL=index.js.map

package/dist/spi.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 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
+ */
+import { CH347USB } from './usb';
+import { SPIConfig } from './types';
+export declare class CH347SPI {
+    private usb;
+    private config;
+    private isInitialized;
+    constructor(usb: CH347USB, config?: Partial<SPIConfig>);
+    /**
+     * Initialize SPI interface with configuration
+     */
+    init(config?: Partial<SPIConfig>): Promise<void>;
+    /**
+     * Control chip select
+     */
+    setChipSelect(active: boolean): Promise<void>;
+    /**
+     * 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
+     */
+    writeRead(data: Buffer, csControl?: boolean): Promise<Buffer>;
+    /**
+     * SPI write only
+     * @param data Data to write
+     * @param csControl If true, automatically control CS (default true)
+     */
+    write(data: Buffer, csControl?: boolean): Promise<void>;
+    /**
+     * SPI read only
+     * @param length Number of bytes to read
+     * @param csControl If true, automatically control CS (default true)
+     * @returns Data read
+     */
+    read(length: number, csControl?: boolean): Promise<Buffer>;
+    /**
+     * Execute SPI command with CS control
+     * Useful for sending flash commands
+     */
+    command(writeData: Buffer, readLength?: number): Promise<Buffer>;
+    /**
+     * Execute SPI command with full duplex transfer
+     */
+    transfer(data: Buffer): Promise<Buffer>;
+    /**
+     * Get current configuration
+     */
+    getConfig(): SPIConfig;
+    /**
+     * Check if SPI is initialized
+     */
+    isReady(): boolean;
+}
+//# sourceMappingURL=spi.d.ts.map