node-ch347 0.0.1

package/dist/uart.js

@@ -0,0 +1,343 @@
+"use strict";
+/**
+ * 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.
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CH347UART = void 0;
+const events_1 = require("events");
+const constants_1 = require("./constants");
+// We'll use the native serialport package for UART
+// Since it requires native bindings, we'll make it optional
+let SerialPort = null;
+try {
+    // Dynamic import to avoid hard dependency
+    SerialPort = require('serialport').SerialPort;
+}
+catch {
+    // SerialPort not available
+}
+const DEFAULT_UART_CONFIG = {
+    baudRate: constants_1.CH347_UART_DEFAULT_BAUD,
+    dataBits: 8,
+    stopBits: 1,
+    parity: 'none',
+    flowControl: 'none',
+};
+class CH347UART extends events_1.EventEmitter {
+    config;
+    port = null;
+    portPath = null;
+    isOpen = false;
+    constructor(config) {
+        super();
+        this.config = { ...DEFAULT_UART_CONFIG, ...config };
+    }
+    /**
+     * List available serial ports that might be CH347 UART
+     * Returns array of tty paths (e.g., '/dev/ttyACM0')
+     */
+    static async listPorts() {
+        if (!SerialPort) {
+            throw new Error('serialport package not installed. Install with: npm install serialport');
+        }
+        const { SerialPort: SP } = await Promise.resolve().then(() => __importStar(require('serialport')));
+        const ports = await SP.list();
+        // Filter for potential CH347 devices
+        // CH347 uses VID 1a86, PID 55db/55dd
+        return ports
+            .filter((port) => {
+            // Include all ports but prioritize CH347 devices
+            const vid = port.vendorId?.toLowerCase();
+            return vid === '1a86' || port.path.includes('ttyACM') || port.path.includes('usbmodem');
+        })
+            .map((port) => port.path);
+    }
+    /**
+     * Open UART port
+     */
+    async open(portPath, config) {
+        if (!SerialPort) {
+            throw new Error('serialport package not installed. Install with: npm install serialport');
+        }
+        if (this.isOpen) {
+            await this.close();
+        }
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+        this.portPath = portPath;
+        return new Promise((resolve, reject) => {
+            this.port = new SerialPort({
+                path: portPath,
+                baudRate: this.config.baudRate,
+                dataBits: this.config.dataBits,
+                stopBits: this.config.stopBits,
+                parity: this.config.parity,
+                rtscts: this.config.flowControl === 'hardware',
+                autoOpen: false,
+            });
+            this.port.on('data', (data) => {
+                this.emit('data', data);
+            });
+            this.port.on('error', (err) => {
+                this.emit('error', err);
+            });
+            this.port.on('close', () => {
+                this.isOpen = false;
+                this.emit('close');
+            });
+            this.port.open((err) => {
+                if (err) {
+                    reject(new Error(`Failed to open port: ${err.message}`));
+                }
+                else {
+                    this.isOpen = true;
+                    this.emit('open');
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Close UART port
+     */
+    async close() {
+        if (!this.port || !this.isOpen) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            this.port.close((err) => {
+                if (err) {
+                    reject(new Error(`Failed to close port: ${err.message}`));
+                }
+                else {
+                    this.isOpen = false;
+                    this.port = null;
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Write data to UART
+     */
+    async write(data) {
+        if (!this.port || !this.isOpen) {
+            throw new Error('Port not open');
+        }
+        const buffer = typeof data === 'string' ? Buffer.from(data) : data;
+        return new Promise((resolve, reject) => {
+            this.port.write(buffer, (err) => {
+                if (err) {
+                    reject(new Error(`Failed to write: ${err.message}`));
+                }
+                else {
+                    this.port.drain((drainErr) => {
+                        if (drainErr) {
+                            reject(new Error(`Failed to drain: ${drainErr.message}`));
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                }
+            });
+        });
+    }
+    /**
+     * Read data from UART (with timeout)
+     */
+    async read(length, timeoutMs = 1000) {
+        if (!this.port || !this.isOpen) {
+            throw new Error('Port not open');
+        }
+        const chunks = [];
+        let totalRead = 0;
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                cleanup();
+                resolve(Buffer.concat(chunks));
+            }, timeoutMs);
+            const onData = (data) => {
+                chunks.push(data);
+                totalRead += data.length;
+                if (totalRead >= length) {
+                    cleanup();
+                    resolve(Buffer.concat(chunks).subarray(0, length));
+                }
+            };
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                this.port.off('data', onData);
+            };
+            this.port.on('data', onData);
+        });
+    }
+    /**
+     * Read line (until newline)
+     */
+    async readLine(timeoutMs = 1000) {
+        if (!this.port || !this.isOpen) {
+            throw new Error('Port not open');
+        }
+        const chunks = [];
+        return new Promise((resolve) => {
+            const timeoutId = setTimeout(() => {
+                cleanup();
+                resolve(Buffer.concat(chunks).toString('utf8'));
+            }, timeoutMs);
+            const onData = (data) => {
+                chunks.push(data);
+                const str = Buffer.concat(chunks).toString('utf8');
+                const newlineIndex = str.indexOf('\n');
+                if (newlineIndex !== -1) {
+                    cleanup();
+                    resolve(str.substring(0, newlineIndex + 1));
+                }
+            };
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                this.port.off('data', onData);
+            };
+            this.port.on('data', onData);
+        });
+    }
+    /**
+     * Write and wait for response
+     */
+    async writeRead(data, responseLength, timeoutMs = 1000) {
+        await this.write(data);
+        return this.read(responseLength, timeoutMs);
+    }
+    /**
+     * Set baud rate
+     */
+    async setBaudRate(baudRate) {
+        if (!this.port || !this.isOpen) {
+            throw new Error('Port not open');
+        }
+        return new Promise((resolve, reject) => {
+            this.port.update({ baudRate }, (err) => {
+                if (err) {
+                    reject(new Error(`Failed to set baud rate: ${err.message}`));
+                }
+                else {
+                    this.config.baudRate = baudRate;
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Flush input/output buffers
+     */
+    async flush() {
+        if (!this.port || !this.isOpen) {
+            throw new Error('Port not open');
+        }
+        return new Promise((resolve, reject) => {
+            this.port.flush((err) => {
+                if (err) {
+                    reject(new Error(`Failed to flush: ${err.message}`));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Set DTR signal
+     */
+    async setDTR(value) {
+        if (!this.port || !this.isOpen) {
+            throw new Error('Port not open');
+        }
+        return new Promise((resolve, reject) => {
+            this.port.set({ dtr: value }, (err) => {
+                if (err) {
+                    reject(new Error(`Failed to set DTR: ${err.message}`));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Set RTS signal
+     */
+    async setRTS(value) {
+        if (!this.port || !this.isOpen) {
+            throw new Error('Port not open');
+        }
+        return new Promise((resolve, reject) => {
+            this.port.set({ rts: value }, (err) => {
+                if (err) {
+                    reject(new Error(`Failed to set RTS: ${err.message}`));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Check if port is open
+     */
+    isConnected() {
+        return this.isOpen;
+    }
+    /**
+     * Get current port path
+     */
+    getPortPath() {
+        return this.portPath;
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+exports.CH347UART = CH347UART;
+//# sourceMappingURL=uart.js.map

package/dist/usb.d.ts

@@ -0,0 +1,80 @@
+/**
+ * CH347 USB Communication Layer
+ */
+import * as usb from 'usb';
+import { CH347DeviceInfo } from './types';
+export declare class CH347USB {
+    private device;
+    private interface;
+    private epIn;
+    private epOut;
+    private isOpen;
+    /**
+     * Get the underlying USB device (for advanced operations)
+     */
+    getDevice(): usb.Device | null;
+    /**
+     * List all connected CH347 devices
+     */
+    static listDevices(): CH347DeviceInfo[];
+    /**
+     * Open connection to CH347 device
+     */
+    open(deviceIndex?: number): Promise<void>;
+    /**
+     * Close connection
+     */
+    close(): void;
+    /**
+     * Check if device is open
+     */
+    isConnected(): boolean;
+    /**
+     * Send data to device
+     */
+    write(data: Buffer): Promise<number>;
+    /**
+     * Read data from device
+     */
+    read(length?: number, timeout?: number): Promise<Buffer>;
+    /**
+     * Write and then read response
+     */
+    transfer(outData: Buffer, readLength?: number): Promise<Buffer>;
+    /**
+     * Bulk write for large data transfers
+     */
+    bulkWrite(data: Buffer, chunkSize?: number): Promise<void>;
+    /**
+     * Bulk read for large data transfers
+     */
+    bulkRead(totalLength: number, chunkSize?: number): Promise<Buffer>;
+    /**
+     * USB control transfer (for vendor-specific commands)
+     */
+    controlTransfer(bmRequestType: number, bRequest: number, wValue: number, wIndex: number, dataOrLength: Buffer | number): Promise<Buffer | number>;
+    /**
+     * Get USB string descriptor
+     */
+    getStringDescriptor(index: number): Promise<string>;
+    /**
+     * Get device descriptor info including serial number index
+     */
+    getDeviceDescriptor(): usb.DeviceDescriptor | null;
+    /**
+     * Get the UART tty path for this CH347 device
+     * On Linux: scans /sys/class/tty for matching USB device
+     * On macOS: scans /dev for matching usbmodem device
+     */
+    getUARTPath(): string | null;
+    /**
+     * Find TTY device on Linux by scanning sysfs
+     */
+    private findLinuxTTY;
+    /**
+     * Find TTY device on macOS
+     * macOS names CDC ACM devices as /dev/tty.usbmodem* with location ID
+     */
+    private findMacOSTTY;
+}
+//# sourceMappingURL=usb.d.ts.map