icom-wlan-node 0.1.0

package/dist/rig/IcomRigCommands.d.ts

@@ -0,0 +1,17 @@
+export declare const IcomRigCommands: {
+    setPTT(ctrAddr: number, rigAddr: number, on: boolean): Buffer;
+    setMode(ctrAddr: number, rigAddr: number, mode: number): Buffer;
+    setFrequency(ctrAddr: number, rigAddr: number, hz: number): Buffer;
+    readOperatingFrequency(ctrAddr: number, rigAddr: number): Buffer;
+    readOperatingMode(ctrAddr: number, rigAddr: number): Buffer;
+    readTransmitFrequency(ctrAddr: number, rigAddr: number): Buffer;
+    readTransceiverState(ctrAddr: number, rigAddr: number): Buffer;
+    readBandEdges(ctrAddr: number, rigAddr: number): Buffer;
+    setOperationDataMode(ctrAddr: number, rigAddr: number, mode: number): Buffer;
+    getSWRState(ctrAddr: number, rigAddr: number): Buffer;
+    getALCState(ctrAddr: number, rigAddr: number): Buffer;
+    getLevelMeter(ctrAddr: number, rigAddr: number): Buffer;
+    getConnectorWLanLevel(ctrAddr: number, rigAddr: number): Buffer;
+    setConnectorWLanLevel(ctrAddr: number, rigAddr: number, level: number): Buffer;
+    setConnectorDataMode(ctrAddr: number, rigAddr: number, mode: number): Buffer;
+};

package/dist/rig/IcomRigCommands.js

@@ -0,0 +1,73 @@
+"use strict";
+// Helpers to build CI-V frames for common operations (PTT, mode, frequency)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IcomRigCommands = void 0;
+exports.IcomRigCommands = {
+    // FE FE [rigAddr] [ctrAddr] 1C 00 [01|00] FD
+    setPTT(ctrAddr, rigAddr, on) {
+        return Buffer.from([
+            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1c, 0x00, on ? 0x01 : 0x00, 0xfd
+        ]);
+    },
+    setMode(ctrAddr, rigAddr, mode) {
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x06, mode & 0xff, 0x01, 0xfd]);
+    },
+    setFrequency(ctrAddr, rigAddr, hz) {
+        // 05: BCD format, little-endian nibbles per Java logic
+        const bcd = (n) => (((n / 10) | 0) << 4) + (n % 10);
+        const d0 = bcd(Math.floor(hz % 100));
+        const d1 = bcd(Math.floor((hz % 10000) / 100));
+        const d2 = bcd(Math.floor((hz % 1000000) / 10000));
+        const d3 = bcd(Math.floor((hz % 100000000) / 1000000));
+        const d4 = bcd(Math.floor(hz / 100000000)); // Fixed: was /1000000000
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x05, d0, d1, d2, d3, d4, 0xfd]);
+    },
+    readOperatingFrequency(ctrAddr, rigAddr) {
+        // FE FE [rigAddr] [ctrAddr] 0x03 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x03, 0xfd]);
+    },
+    readOperatingMode(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x04 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x04, 0xfd]);
+    },
+    readTransmitFrequency(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x1C 0x03 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1c, 0x03, 0xfd]);
+    },
+    readTransceiverState(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x1A 0x00 0x48 FD (not recommended by Java, but available)
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x00, 0x48, 0xfd]);
+    },
+    readBandEdges(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x02 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x02, 0xfd]);
+    },
+    setOperationDataMode(ctrAddr, rigAddr, mode) {
+        // FE FE [rig] [ctr] 0x26 0x00 [mode] 0x01 0x01 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x26, 0x00, mode & 0xff, 0x01, 0x01, 0xfd]);
+    },
+    getSWRState(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x15 0x12 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x12, 0xfd]);
+    },
+    getALCState(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x15 0x13 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x13, 0xfd]);
+    },
+    getLevelMeter(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x15 0x02 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x02, 0xfd]);
+    },
+    getConnectorWLanLevel(ctrAddr, rigAddr) {
+        // FE FE [rig] [ctr] 0x1A 0x05 0x01 0x17 FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x05, 0x01, 0x17, 0xfd]);
+    },
+    setConnectorWLanLevel(ctrAddr, rigAddr, level) {
+        // FE FE [rig] [ctr] 0x1A 0x05 0x01 0x17 [level_hi] [level_lo] FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x05, 0x01, 0x17, (level >> 8) & 0xff, level & 0xff, 0xfd]);
+    },
+    setConnectorDataMode(ctrAddr, rigAddr, mode) {
+        // FE FE [rig] [ctr] 0x1A 0x05 0x01 0x19 [mode] FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x05, 0x01, 0x19, mode & 0xff, 0xfd]);
+    }
+};

package/dist/transport/UdpClient.d.ts

@@ -0,0 +1,14 @@
+import dgram from 'dgram';
+import { EventEmitter } from 'events';
+export interface UdpClientEvents {
+    data: (rinfo: dgram.RemoteInfo, data: Buffer) => void;
+    error: (err: Error) => void;
+}
+export declare class UdpClient extends EventEmitter {
+    private socket?;
+    private _localPort;
+    get localPort(): number;
+    open(localPort?: number): void;
+    close(): void;
+    send(buf: Buffer, ip: string, port: number): void;
+}

package/dist/transport/UdpClient.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UdpClient = void 0;
+const dgram_1 = __importDefault(require("dgram"));
+const events_1 = require("events");
+class UdpClient extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this._localPort = 0;
+    }
+    get localPort() { return this._localPort; }
+    open(localPort) {
+        if (this.socket)
+            return;
+        this.socket = dgram_1.default.createSocket('udp4');
+        const sock = this.socket;
+        sock.on('message', (msg, rinfo) => this.emit('data', rinfo, Buffer.from(msg)));
+        sock.on('error', (err) => this.emit('error', err));
+        sock.bind(localPort ?? 0, () => {
+            if (!sock)
+                return;
+            const addr = sock.address();
+            if (typeof addr === 'object')
+                this._localPort = addr.port;
+        });
+    }
+    close() {
+        if (!this.socket)
+            return;
+        try {
+            this.socket.close();
+        }
+        finally {
+            this.socket = undefined;
+            this._localPort = 0;
+        }
+    }
+    send(buf, ip, port) {
+        if (!this.socket)
+            throw new Error('UDP socket not opened');
+        this.socket.send(buf, port, ip);
+    }
+}
+exports.UdpClient = UdpClient;

package/dist/types.d.ts

@@ -0,0 +1,160 @@
+import { EventEmitter } from 'events';
+import { MODE_MAP, CONNECTOR_MODE_MAP } from './rig/IcomConstants';
+export type UdpAddress = {
+    ip: string;
+    port: number;
+};
+export interface IcomCredentials {
+    userName: string;
+    password: string;
+}
+export interface IcomRigOptions extends IcomCredentials {
+    control: UdpAddress;
+}
+export interface CivCommand {
+    bytes: Buffer;
+}
+export interface AudioFrame {
+    pcm16: Buffer;
+}
+export interface LoginResult {
+    ok: boolean;
+    errorCode?: number;
+    connection?: string;
+}
+export interface StatusInfo {
+    civPort: number;
+    audioPort: number;
+    authOK: boolean;
+    connected: boolean;
+}
+export interface CapabilitiesInfo {
+    civAddress?: number;
+    audioName?: string;
+    supportTX?: boolean;
+}
+export interface IcomRigEvents {
+    login: (res: LoginResult) => void;
+    status: (s: StatusInfo) => void;
+    capabilities: (c: CapabilitiesInfo) => void;
+    civ: (data: Buffer) => void;
+    civFrame: (frame: Buffer) => void;
+    audio: (frame: AudioFrame) => void;
+    error: (err: Error) => void;
+}
+export interface Disposable {
+    dispose(): void;
+}
+export type RigEventEmitter = EventEmitter & {
+    on<U extends keyof IcomRigEvents>(event: U, listener: IcomRigEvents[U]): RigEventEmitter;
+    emit<U extends keyof IcomRigEvents>(event: U, ...args: Parameters<IcomRigEvents[U]>): boolean;
+};
+/**
+ * Operating mode for ICOM radios
+ * LSB, USB, AM, CW, RTTY, FM, WFM, CW_R, RTTY_R, DV
+ */
+export type IcomMode = keyof typeof MODE_MAP;
+/**
+ * Connector data routing mode
+ * MIC: Microphone, ACC: Accessory port, USB: USB audio, WLAN: Network audio
+ */
+export type ConnectorDataMode = keyof typeof CONNECTOR_MODE_MAP;
+/**
+ * Options for setting operating mode
+ */
+export interface SetModeOptions {
+    /**
+     * Enable data mode (e.g., USB-D for digital modes)
+     * Uses CI-V command 0x26 instead of 0x06
+     */
+    dataMode?: boolean;
+}
+/**
+ * Options for query operations (frequency, meters, etc.)
+ */
+export interface QueryOptions {
+    /**
+     * Timeout in milliseconds (default: 3000)
+     */
+    timeout?: number;
+}
+/**
+ * Result of a meter reading operation (SWR, ALC, etc.)
+ * @deprecated Use specific types like SwrReading, AlcReading instead
+ */
+export interface MeterReading {
+    /**
+     * Raw meter value as buffer
+     */
+    value: Buffer;
+    /**
+     * Whether the reading was successful
+     */
+    success: boolean;
+}
+/**
+ * SWR (Standing Wave Ratio) meter reading
+ * Represents antenna impedance matching quality
+ */
+export interface SwrReading {
+    /**
+     * Raw BCD value (0-300+)
+     * Actual SWR = raw / 100
+     * Example: 120 = SWR 1.2, 250 = SWR 2.5
+     */
+    raw: number;
+    /**
+     * Calculated SWR value (typically 1.0 - 3.0)
+     * 1.0 = perfect match, >2.0 = poor match
+     */
+    swr: number;
+    /**
+     * Alert flag when SWR is too high (≥1.2)
+     * High SWR can damage transmitter
+     */
+    alert: boolean;
+}
+/**
+ * ALC (Automatic Level Control) meter reading
+ * Represents transmitter output power control level
+ */
+export interface AlcReading {
+    /**
+     * Raw BCD value (0-255)
+     */
+    raw: number;
+    /**
+     * Percentage of maximum ALC (0-100%)
+     */
+    percent: number;
+    /**
+     * Alert flag when ALC exceeds safe threshold (>120)
+     * Excessive ALC indicates over-driving the transmitter
+     */
+    alert: boolean;
+}
+/**
+ * WLAN connector audio level reading
+ * Represents network audio signal strength/quality
+ */
+export interface WlanLevelReading {
+    /**
+     * Raw value (0-255)
+     * Higher values indicate stronger signal
+     */
+    raw: number;
+    /**
+     * Percentage of maximum level (0-100%)
+     */
+    percent: number;
+}
+/**
+ * Generic level meter (0-255) reading
+ * For CI-V 0x15/0x02 experimental level meter
+ */
+export interface LevelMeterReading {
+    /** Raw 0-255 value */
+    raw: number;
+    /** Percentage (0-100%) */
+    percent: number;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/bcd.d.ts

@@ -0,0 +1,36 @@
+/**
+ * BCD (Binary Coded Decimal) parsing utilities
+ * Based on FT8CN's IcomRigConstant.java twoByteBcdToInt()
+ */
+/**
+ * Parse a two-byte BCD encoded value to integer
+ *
+ * BCD format encodes decimal digits as nibbles (4-bit values):
+ * - Byte 0: thousands (high nibble) + hundreds (low nibble)
+ * - Byte 1: tens (high nibble) + ones (low nibble)
+ *
+ * @param data - Buffer containing at least 2 bytes of BCD data
+ * @returns Parsed integer value, or 0 if data is invalid
+ *
+ * @example
+ * // Buffer [0x12, 0x34] represents 1234
+ * const value = parseTwoByteBcd(Buffer.from([0x12, 0x34]));
+ * console.log(value); // 1234
+ *
+ * @example
+ * // Buffer [0x02, 0x40] represents 240 (SWR 2.40)
+ * const swr = parseTwoByteBcd(Buffer.from([0x02, 0x40]));
+ * console.log(swr / 100); // 2.40
+ */
+export declare function parseTwoByteBcd(data: Buffer): number;
+/**
+ * Convert integer to two-byte BCD format
+ *
+ * @param value - Integer value (0-9999)
+ * @returns Buffer containing 2 bytes of BCD data
+ *
+ * @example
+ * const bcd = intToTwoByteBcd(1234);
+ * console.log(bcd); // Buffer [0x12, 0x34]
+ */
+export declare function intToTwoByteBcd(value: number): Buffer;

package/dist/utils/bcd.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * BCD (Binary Coded Decimal) parsing utilities
+ * Based on FT8CN's IcomRigConstant.java twoByteBcdToInt()
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTwoByteBcd = parseTwoByteBcd;
+exports.intToTwoByteBcd = intToTwoByteBcd;
+/**
+ * Parse a two-byte BCD encoded value to integer
+ *
+ * BCD format encodes decimal digits as nibbles (4-bit values):
+ * - Byte 0: thousands (high nibble) + hundreds (low nibble)
+ * - Byte 1: tens (high nibble) + ones (low nibble)
+ *
+ * @param data - Buffer containing at least 2 bytes of BCD data
+ * @returns Parsed integer value, or 0 if data is invalid
+ *
+ * @example
+ * // Buffer [0x12, 0x34] represents 1234
+ * const value = parseTwoByteBcd(Buffer.from([0x12, 0x34]));
+ * console.log(value); // 1234
+ *
+ * @example
+ * // Buffer [0x02, 0x40] represents 240 (SWR 2.40)
+ * const swr = parseTwoByteBcd(Buffer.from([0x02, 0x40]));
+ * console.log(swr / 100); // 2.40
+ */
+function parseTwoByteBcd(data) {
+    if (data.length < 2)
+        return 0;
+    // Extract nibbles from each byte
+    const ones = data[1] & 0x0f; // Low nibble of byte 1
+    const tens = (data[1] >> 4) & 0x0f; // High nibble of byte 1
+    const hundreds = data[0] & 0x0f; // Low nibble of byte 0
+    const thousands = (data[0] >> 4) & 0x0f; // High nibble of byte 0
+    return ones + tens * 10 + hundreds * 100 + thousands * 1000;
+}
+/**
+ * Convert integer to two-byte BCD format
+ *
+ * @param value - Integer value (0-9999)
+ * @returns Buffer containing 2 bytes of BCD data
+ *
+ * @example
+ * const bcd = intToTwoByteBcd(1234);
+ * console.log(bcd); // Buffer [0x12, 0x34]
+ */
+function intToTwoByteBcd(value) {
+    // Clamp to valid range
+    const val = Math.max(0, Math.min(9999, Math.floor(value)));
+    const ones = val % 10;
+    const tens = Math.floor((val % 100) / 10);
+    const hundreds = Math.floor((val % 1000) / 100);
+    const thousands = Math.floor(val / 1000);
+    const byte0 = (thousands << 4) | hundreds;
+    const byte1 = (tens << 4) | ones;
+    return Buffer.from([byte0, byte1]);
+}

package/dist/utils/codec.d.ts

@@ -0,0 +1,22 @@
+export declare const be16: {
+    read: (buf: Buffer, off: number) => number;
+    write: (buf: Buffer, off: number, v: number) => number;
+};
+export declare const be32: {
+    read: (buf: Buffer, off: number) => number;
+    write: (buf: Buffer, off: number, v: number) => number;
+};
+export declare const le16: {
+    read: (buf: Buffer, off: number) => number;
+    write: (buf: Buffer, off: number, v: number) => number;
+};
+export declare const le32: {
+    read: (buf: Buffer, off: number) => number;
+    write: (buf: Buffer, off: number, v: number) => number;
+};
+export declare function shortToBytesLE(n: number): Buffer;
+export declare function shortToBytesBE(n: number): Buffer;
+export declare function intToBytesLE(n: number): Buffer;
+export declare function intToBytesBE(n: number): Buffer;
+export declare function strToFixedBytes(str: string, len: number): Buffer;
+export declare function hex(buf: Buffer): string;

package/dist/utils/codec.js

@@ -0,0 +1,56 @@
+"use strict";
+// Byte order helpers for Icom packet formats
+// Note: These now use CORRECT naming (be = Big-Endian, le = Little-Endian)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.le32 = exports.le16 = exports.be32 = exports.be16 = void 0;
+exports.shortToBytesLE = shortToBytesLE;
+exports.shortToBytesBE = shortToBytesBE;
+exports.intToBytesLE = intToBytesLE;
+exports.intToBytesBE = intToBytesBE;
+exports.strToFixedBytes = strToFixedBytes;
+exports.hex = hex;
+exports.be16 = {
+    read: (buf, off) => buf.readUInt16BE(off), // Big-Endian: high byte first
+    write: (buf, off, v) => buf.writeUInt16BE(v & 0xffff, off)
+};
+exports.be32 = {
+    read: (buf, off) => buf.readUInt32BE(off), // Big-Endian: high byte first
+    write: (buf, off, v) => buf.writeUInt32BE(v >>> 0, off)
+};
+exports.le16 = {
+    read: (buf, off) => buf.readUInt16LE(off), // Little-Endian: low byte first
+    write: (buf, off, v) => buf.writeUInt16LE(v & 0xffff, off)
+};
+exports.le32 = {
+    read: (buf, off) => buf.readUInt32LE(off), // Little-Endian: low byte first
+    write: (buf, off, v) => buf.writeUInt32LE(v >>> 0, off)
+};
+function shortToBytesLE(n) {
+    const b = Buffer.alloc(2);
+    exports.le16.write(b, 0, n);
+    return b;
+}
+function shortToBytesBE(n) {
+    const b = Buffer.alloc(2);
+    exports.be16.write(b, 0, n);
+    return b;
+}
+function intToBytesLE(n) {
+    const b = Buffer.alloc(4);
+    exports.le32.write(b, 0, n);
+    return b;
+}
+function intToBytesBE(n) {
+    const b = Buffer.alloc(4);
+    exports.be32.write(b, 0, n);
+    return b;
+}
+function strToFixedBytes(str, len) {
+    const out = Buffer.alloc(len, 0);
+    const src = Buffer.from(str, 'utf8');
+    src.copy(out, 0, 0, Math.min(len, src.length));
+    return out;
+}
+function hex(buf) {
+    return [...buf].map(b => b.toString(16).padStart(2, '0')).join(' ');
+}

package/dist/utils/debug.d.ts

@@ -0,0 +1,4 @@
+export declare const DEBUG_ICOM: boolean;
+export declare const DEBUG_ICOM_LEVEL: number;
+export declare function dbg(...args: any[]): void;
+export declare function dbgV(...args: any[]): void;

package/dist/utils/debug.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEBUG_ICOM_LEVEL = exports.DEBUG_ICOM = void 0;
+exports.dbg = dbg;
+exports.dbgV = dbgV;
+exports.DEBUG_ICOM = process.env.DEBUG_ICOM === '1' || process.env.DEBUG_ICOM === 'true';
+exports.DEBUG_ICOM_LEVEL = Number.parseInt(process.env.DEBUG_ICOM_LEVEL || (exports.DEBUG_ICOM ? '1' : '0'), 10) || 0;
+function dbg(...args) {
+    if (exports.DEBUG_ICOM_LEVEL >= 1)
+        console.log('[icom]', ...args);
+}
+function dbgV(...args) {
+    if (exports.DEBUG_ICOM_LEVEL >= 2)
+        console.log('[icom]', ...args);
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "icom-wlan-node",
+  "version": "0.1.0",
+  "description": "Icom WLAN (CI‑V, audio) protocol implementation for Node.js/TypeScript.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rimraf dist",
+    "test": "jest",
+    "prepublishOnly": "npm run build",
+    "lint": "eslint ."
+  },
+  "keywords": ["icom", "civ", "cat", "udp", "hamradio", "wlan", "audio"],
+  "author": "boybook",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/boybook/icom-wlan-node.git"
+  },
+  "files": ["dist"],
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.10.6",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.5",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.4.5"
+  }
+}