icom-wlan-node 0.1.0

package/dist/rig/IcomAudio.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUDIO_RATE = exports.IcomAudio = void 0;
+const IcomPackets_1 = require("../core/IcomPackets");
+class IcomAudio {
+    constructor(sess) {
+        this.sess = sess;
+        this.sendSeq = 0;
+        this.sendSeqForTiming = 0; // Separate counter for drift compensation
+        this.isPttOn = false;
+        this.queue = []; // Public for PTT control to clear queue
+        this.volume = 1.0; // 0.0 ~ 2.0
+        this.running = false;
+        this.startTime = 0; // Absolute start time for drift compensation
+        this.FRAME_INTERVAL_MS = 20;
+        this.frameCount = 0;
+        this.debugInterval = 0;
+        this.debugIntervalStart = 0;
+    }
+    start() {
+        // Start continuous audio transmission with drift compensation
+        if (this.running)
+            return;
+        this.running = true;
+        this.startTime = performance.now();
+        this.sendSeqForTiming = 0;
+        this.frameCount = 0;
+        this.debugInterval = 0;
+        this.debugIntervalStart = 0;
+        this.scheduleSend();
+    }
+    scheduleSend() {
+        if (!this.running)
+            return;
+        const now = performance.now();
+        // Calculate ideal send time for next frame (with drift compensation)
+        const nextFrameIndex = this.sendSeqForTiming + 1;
+        const idealTime = this.startTime + (nextFrameIndex * this.FRAME_INTERVAL_MS);
+        const timeUntilSend = idealTime - now;
+        if (timeUntilSend <= 0) {
+            // We're at or past send time! Send immediately
+            this.sendFrame();
+            this.sendSeqForTiming++;
+            // Schedule next check immediately (tight loop for precision)
+            this.txTimer = setImmediate(() => this.scheduleSend());
+        }
+        else if (timeUntilSend <= 0.5) {
+            // Very close (within 0.5ms), tight loop with setImmediate
+            this.txTimer = setImmediate(() => this.scheduleSend());
+        }
+        else if (timeUntilSend <= 3) {
+            // Close (1-3ms), use minimal setTimeout
+            setTimeout(() => this.scheduleSend(), 0);
+        }
+        else {
+            // Further away, wait conservatively then tight loop
+            const waitTime = Math.max(1, Math.floor(timeUntilSend - 2));
+            setTimeout(() => this.scheduleSend(), waitTime);
+        }
+    }
+    sendFrame() {
+        let frame;
+        const hasData = this.queue.length > 0;
+        if (hasData) {
+            // Send audio from queue when available
+            frame = this.queue.shift();
+        }
+        else {
+            // Send silence when queue is empty
+            frame = new Int16Array(IcomPackets_1.TX_BUFFER_SIZE);
+        }
+        const buf = Buffer.alloc(IcomPackets_1.TX_BUFFER_SIZE * 2);
+        for (let i = 0; i < IcomPackets_1.TX_BUFFER_SIZE; i++)
+            buf.writeInt16LE(frame[i] ?? 0, i * 2);
+        const pkt = IcomPackets_1.AudioPacket.getTxAudioPacket(buf, 0, this.sess.localId, this.sess.remoteId, this.sendSeq);
+        this.sendSeq = (this.sendSeq + 1) & 0xffff;
+        this.sess.sendTracked(pkt);
+        // Debug: log timing info every 50 frames (~1 second)
+        this.frameCount++;
+        if (this.frameCount % 50 === 0 && hasData) {
+            const now = performance.now();
+            if (this.debugIntervalStart > 0) {
+                const elapsed = now - this.debugIntervalStart;
+                const avgInterval = elapsed / 50;
+                const drift = elapsed - (50 * this.FRAME_INTERVAL_MS);
+                console.log(`[AudioTiming] Avg: ${avgInterval.toFixed(2)}ms (target: ${this.FRAME_INTERVAL_MS}ms), drift: ${drift.toFixed(2)}ms, queue: ${this.queue.length}`);
+            }
+            this.debugIntervalStart = now;
+        }
+    }
+    stop() {
+        // Stop continuous audio transmission (only on disconnect)
+        this.running = false;
+        if (this.txTimer) {
+            clearImmediate(this.txTimer);
+            this.txTimer = undefined;
+        }
+        this.queue.length = 0;
+        this.isPttOn = false;
+        this.frameCount = 0;
+        this.debugInterval = 0;
+    }
+    // Add leading silence frames (like Java's front buffer)
+    addLeadingSilence(frameCount = 3) {
+        const silence = new Int16Array(IcomPackets_1.TX_BUFFER_SIZE);
+        for (let i = 0; i < frameCount; i++) {
+            this.queue.push(silence);
+        }
+    }
+    // Add trailing silence frames (like Java's tail buffer)
+    addTrailingSilence(frameCount = 5) {
+        const silence = new Int16Array(IcomPackets_1.TX_BUFFER_SIZE);
+        for (let i = 0; i < frameCount; i++) {
+            this.queue.push(silence);
+        }
+    }
+    // Push Float32 samples; they will be converted to 16-bit and sliced into 20ms frames
+    enqueueFloat32(samples, addLeadingBuffer = false) {
+        // Add leading silence buffer if requested (used at PTT start)
+        if (addLeadingBuffer && this.queue.length === 0) {
+            this.addLeadingSilence(3);
+        }
+        const out = new Int16Array(samples.length);
+        for (let i = 0; i < samples.length; i++) {
+            let x = Math.max(-1, Math.min(1, samples[i]));
+            out[i] = (x * this.volume * 32767) | 0;
+        }
+        this.enqueuePcm16(out);
+    }
+    enqueuePcm16(samples) {
+        // slice into TX_BUFFER_SIZE frames
+        for (let i = 0; i < samples.length; i += IcomPackets_1.TX_BUFFER_SIZE) {
+            const slice = samples.subarray(i, Math.min(samples.length, i + IcomPackets_1.TX_BUFFER_SIZE));
+            // Always create a new buffer to avoid issues with subarray views
+            const frame = new Int16Array(IcomPackets_1.TX_BUFFER_SIZE);
+            frame.set(slice);
+            this.queue.push(frame);
+        }
+    }
+    setVolume(multiplier) { this.volume = Math.max(0, multiplier); }
+}
+exports.IcomAudio = IcomAudio;
+exports.AUDIO_RATE = IcomPackets_1.AUDIO_SAMPLE_RATE;

package/dist/rig/IcomCiv.d.ts

@@ -0,0 +1,14 @@
+import { Session } from '../core/Session';
+export declare class IcomCiv {
+    private sess;
+    civAddress: number;
+    supportTX: boolean;
+    private civSeq;
+    private idleTimer?;
+    private openTimer?;
+    constructor(sess: Session);
+    start(): void;
+    stop(): void;
+    sendOpenClose(open: boolean): void;
+    sendCivData(data: Buffer): void;
+}

package/dist/rig/IcomCiv.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IcomCiv = void 0;
+const IcomPackets_1 = require("../core/IcomPackets");
+const debug_1 = require("../utils/debug");
+class IcomCiv {
+    constructor(sess) {
+        this.sess = sess;
+        this.civAddress = 0xA4;
+        this.supportTX = true;
+        this.civSeq = 0;
+    }
+    start() {
+        this.stop();
+        // keep-alive open/close
+        this.openTimer = setInterval(() => {
+            if (Date.now() - this.sess.lastReceivedTime > 2000) {
+                this.sendOpenClose(true);
+            }
+        }, 500);
+    }
+    stop() {
+        if (this.openTimer)
+            clearInterval(this.openTimer);
+        if (this.idleTimer)
+            clearInterval(this.idleTimer);
+        this.openTimer = undefined;
+        this.idleTimer = undefined;
+    }
+    sendOpenClose(open) {
+        const magic = open ? 0x04 : 0x00;
+        const pkt = IcomPackets_1.OpenClosePacket.toBytes(0, this.sess.localId, this.sess.remoteId, this.civSeq, magic);
+        this.civSeq = (this.civSeq + 1) & 0xffff;
+        (0, debug_1.dbg)(`CIV -> OpenClose ${open ? 'OPEN' : 'CLOSE'} seq=${this.civSeq - 1}`);
+        this.sess.sendTracked(pkt);
+    }
+    sendCivData(data) {
+        const pkt = IcomPackets_1.CivPacket.setCivData(0, this.sess.localId, this.sess.remoteId, this.civSeq, data);
+        this.civSeq = (this.civSeq + 1) & 0xffff;
+        (0, debug_1.dbg)(`CIV -> data len=${data.length} seq=${this.civSeq - 1}`);
+        this.sess.sendTracked(pkt);
+    }
+}
+exports.IcomCiv = IcomCiv;

package/dist/rig/IcomConstants.d.ts

@@ -0,0 +1,84 @@
+/**
+ * ICOM radio constants and mappings
+ * Based on FT8CN's IcomRigConstant.java
+ */
+/**
+ * Operating modes supported by ICOM radios
+ * LSB:0, USB:1, AM:2, CW:3, RTTY:4, FM:5, WFM:6, CW_R:7, RTTY_R:8, DV:17
+ */
+export declare const MODE_MAP: {
+    readonly LSB: 0;
+    readonly USB: 1;
+    readonly AM: 2;
+    readonly CW: 3;
+    readonly RTTY: 4;
+    readonly FM: 5;
+    readonly WFM: 6;
+    readonly CW_R: 7;
+    readonly RTTY_R: 8;
+    readonly DV: 23;
+};
+/**
+ * Connector data routing modes
+ * Based on ICOM's connector data mode settings
+ */
+export declare const CONNECTOR_MODE_MAP: {
+    readonly MIC: 0;
+    readonly ACC: 1;
+    readonly USB: 2;
+    readonly WLAN: 3;
+};
+/**
+ * Default controller address (typically 0xE0 for PC/controller)
+ */
+export declare const DEFAULT_CONTROLLER_ADDR = 224;
+/**
+ * Helper function to get mode code from string
+ */
+export declare function getModeCode(mode: keyof typeof MODE_MAP): number;
+/**
+ * Helper function to get connector mode code from string
+ */
+export declare function getConnectorModeCode(mode: keyof typeof CONNECTOR_MODE_MAP): number;
+/**
+ * Helper function to get mode string from code
+ */
+export declare function getModeString(code: number): string | undefined;
+/**
+ * Helper function to get connector mode string from code
+ */
+export declare function getConnectorModeString(code: number): string | undefined;
+/**
+ * ICOM filter code to string mapping
+ * Common rigs use 0x01(FIL1), 0x02(FIL2), 0x03(FIL3)
+ */
+export declare function getFilterString(code: number | undefined): string | undefined;
+/**
+ * Meter alert thresholds
+ * Based on FT8CN's IcomRigConstant.java
+ */
+export declare const METER_THRESHOLDS: {
+    /**
+     * SWR alert threshold (raw value)
+     * Alert when SWR ≥ 1.2 (raw value ≥ 120)
+     */
+    readonly SWR_ALERT: 120;
+    /**
+     * ALC maximum alert threshold (raw value)
+     * Alert when ALC > 120
+     */
+    readonly ALC_ALERT_MAX: 120;
+    /**
+     * Maximum ALC value for percentage calculation
+     */
+    readonly ALC_MAX: 255;
+    /**
+     * Maximum WLAN level value for percentage calculation
+     */
+    readonly WLAN_LEVEL_MAX: 255;
+};
+/**
+ * Period for meter polling during TX (milliseconds)
+ * Matches FT8CN's IComPacketTypes.METER_TIMER_PERIOD_MS
+ */
+export declare const METER_TIMER_PERIOD_MS = 500;

package/dist/rig/IcomConstants.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * ICOM radio constants and mappings
+ * Based on FT8CN's IcomRigConstant.java
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METER_TIMER_PERIOD_MS = exports.METER_THRESHOLDS = exports.DEFAULT_CONTROLLER_ADDR = exports.CONNECTOR_MODE_MAP = exports.MODE_MAP = void 0;
+exports.getModeCode = getModeCode;
+exports.getConnectorModeCode = getConnectorModeCode;
+exports.getModeString = getModeString;
+exports.getConnectorModeString = getConnectorModeString;
+exports.getFilterString = getFilterString;
+/**
+ * Operating modes supported by ICOM radios
+ * LSB:0, USB:1, AM:2, CW:3, RTTY:4, FM:5, WFM:6, CW_R:7, RTTY_R:8, DV:17
+ */
+exports.MODE_MAP = {
+    LSB: 0x00, // Lower Side Band (下边带)
+    USB: 0x01, // Upper Side Band (上边带)
+    AM: 0x02, // Amplitude Modulation (调幅)
+    CW: 0x03, // Continuous Wave (连续波/莫尔斯码)
+    RTTY: 0x04, // Radio Teletype (频移键控)
+    FM: 0x05, // Frequency Modulation (调频)
+    WFM: 0x06, // Wide FM (宽带调频)
+    CW_R: 0x07, // CW Reverse (反向连续波)
+    RTTY_R: 0x08, // RTTY Reverse (反向频移键控)
+    DV: 0x17 // Digital Voice (数字语音, decimal 23)
+};
+/**
+ * Connector data routing modes
+ * Based on ICOM's connector data mode settings
+ */
+exports.CONNECTOR_MODE_MAP = {
+    MIC: 0x00, // Microphone input
+    ACC: 0x01, // ACC (Accessory) port
+    USB: 0x02, // USB audio
+    WLAN: 0x03 // WLAN (network) audio
+};
+/**
+ * Default controller address (typically 0xE0 for PC/controller)
+ */
+exports.DEFAULT_CONTROLLER_ADDR = 0xe0;
+/**
+ * Helper function to get mode code from string
+ */
+function getModeCode(mode) {
+    return exports.MODE_MAP[mode];
+}
+/**
+ * Helper function to get connector mode code from string
+ */
+function getConnectorModeCode(mode) {
+    return exports.CONNECTOR_MODE_MAP[mode];
+}
+/**
+ * Helper function to get mode string from code
+ */
+function getModeString(code) {
+    const entry = Object.entries(exports.MODE_MAP).find(([_, value]) => value === code);
+    return entry?.[0];
+}
+/**
+ * Helper function to get connector mode string from code
+ */
+function getConnectorModeString(code) {
+    const entry = Object.entries(exports.CONNECTOR_MODE_MAP).find(([_, value]) => value === code);
+    return entry?.[0];
+}
+/**
+ * ICOM filter code to string mapping
+ * Common rigs use 0x01(FIL1), 0x02(FIL2), 0x03(FIL3)
+ */
+function getFilterString(code) {
+    if (code === undefined)
+        return undefined;
+    if (code === 0x01)
+        return 'FIL1';
+    if (code === 0x02)
+        return 'FIL2';
+    if (code === 0x03)
+        return 'FIL3';
+    return 'FIL' + code;
+}
+/**
+ * Meter alert thresholds
+ * Based on FT8CN's IcomRigConstant.java
+ */
+exports.METER_THRESHOLDS = {
+    /**
+     * SWR alert threshold (raw value)
+     * Alert when SWR ≥ 1.2 (raw value ≥ 120)
+     */
+    SWR_ALERT: 120,
+    /**
+     * ALC maximum alert threshold (raw value)
+     * Alert when ALC > 120
+     */
+    ALC_ALERT_MAX: 120,
+    /**
+     * Maximum ALC value for percentage calculation
+     */
+    ALC_MAX: 255,
+    /**
+     * Maximum WLAN level value for percentage calculation
+     */
+    WLAN_LEVEL_MAX: 255
+};
+/**
+ * Period for meter polling during TX (milliseconds)
+ * Matches FT8CN's IComPacketTypes.METER_TIMER_PERIOD_MS
+ */
+exports.METER_TIMER_PERIOD_MS = 500;

package/dist/rig/IcomControl.d.ts

@@ -0,0 +1,155 @@
+import { IcomRigOptions, RigEventEmitter, IcomMode, ConnectorDataMode, SetModeOptions, QueryOptions, SwrReading, AlcReading, WlanLevelReading, LevelMeterReading } from '../types';
+import { IcomCiv } from './IcomCiv';
+import { IcomAudio } from './IcomAudio';
+export declare class IcomControl {
+    private ev;
+    private sess;
+    private civSess;
+    private audioSess;
+    civ: IcomCiv;
+    audio: IcomAudio;
+    private options;
+    private rigName;
+    private macAddress;
+    private tokenTimer?;
+    private civAssembleBuf;
+    private meterTimer?;
+    private loginReady;
+    private civReady;
+    private audioReady;
+    private resolveLoginReady;
+    private resolveCivReady;
+    private resolveAudioReady;
+    constructor(options: IcomRigOptions);
+    get events(): RigEventEmitter;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendCiv(data: Buffer): void;
+    /**
+     * Set PTT (Push-To-Talk) state
+     * @param on - true to key transmitter, false to unkey
+     */
+    setPtt(on: boolean): Promise<void>;
+    /**
+     * Set operating frequency
+     * @param hz - Frequency in Hz
+     */
+    setFrequency(hz: number): Promise<void>;
+    /**
+     * Set operating mode
+     * @param mode - Operating mode (LSB, USB, AM, CW, RTTY, FM, WFM, CW_R, RTTY_R, DV)
+     * @param options - Mode options (dataMode for digital modes like USB-D)
+     * @example
+     * // Set USB mode
+     * await rig.setMode('USB');
+     * // Set USB-D (data mode) for FT8
+     * await rig.setMode('USB', { dataMode: true });
+     */
+    setMode(mode: IcomMode | number, options?: SetModeOptions): Promise<void>;
+    /**
+     * Read current operating frequency
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns Frequency in Hz, or null if timeout/error
+     * @example
+     * const hz = await rig.readOperatingFrequency({ timeout: 5000 });
+     * console.log(`Frequency: ${hz} Hz`);
+     */
+    readOperatingFrequency(options?: QueryOptions): Promise<number | null>;
+    /**
+     * Read current operating mode and filter
+     * @returns { mode: number, filter?: number } or null
+     */
+    readOperatingMode(options?: QueryOptions): Promise<{
+        mode: number;
+        filter?: number;
+        modeName?: string;
+        filterName?: string;
+    } | null>;
+    /**
+     * Read current transmit frequency (when TX)
+     */
+    readTransmitFrequency(options?: QueryOptions): Promise<number | null>;
+    /**
+     * Read transceiver state (TX/RX) via 0x1A 0x00 0x48
+     * Note: Java comments mark this as not recommended; use with caution.
+     */
+    readTransceiverState(options?: QueryOptions): Promise<'TX' | 'RX' | 'UNKNOWN' | null>;
+    /**
+     * Read band edge data (0x02). Format may vary by rig; returns raw data bytes after command.
+     */
+    readBandEdges(options?: QueryOptions): Promise<Buffer | null>;
+    /**
+     * Read SWR (Standing Wave Ratio) meter
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns SWR reading with raw value, calculated SWR, and alert status
+     * @example
+     * const swr = await rig.readSWR({ timeout: 2000 });
+     * if (swr) {
+     *   console.log(`SWR: ${swr.swr.toFixed(2)} ${swr.alert ? '⚠️ HIGH' : '✓'}`);
+     * }
+     */
+    readSWR(options?: QueryOptions): Promise<SwrReading | null>;
+    /**
+     * Read ALC (Automatic Level Control) meter
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns ALC reading with raw value, percent, and alert status
+     * @example
+     * const alc = await rig.readALC({ timeout: 2000 });
+     * if (alc) {
+     *   console.log(`ALC: ${alc.percent.toFixed(1)}% ${alc.alert ? '⚠️ HIGH' : '✓'}`);
+     * }
+     */
+    readALC(options?: QueryOptions): Promise<AlcReading | null>;
+    /**
+     * Get WLAN connector audio level setting
+     * @param options - Query options (timeout in ms, default 3000)
+     * @returns WLAN level reading with raw value and percent
+     * @example
+     * const level = await rig.getConnectorWLanLevel({ timeout: 2000 });
+     * if (level) {
+     *   console.log(`WLAN Level: ${level.percent.toFixed(1)}%`);
+     * }
+     */
+    getConnectorWLanLevel(options?: QueryOptions): Promise<WlanLevelReading | null>;
+    /**
+     * Read generic level meter (CI-V 0x15/0x02), raw 0-255.
+     * Many rigs return two bytes and the low byte is the level.
+     */
+    getLevelMeter(options?: QueryOptions): Promise<LevelMeterReading | null>;
+    /**
+     * Set WLAN connector audio level
+     * @param level - Audio level (0-255)
+     */
+    setConnectorWLanLevel(level: number): Promise<void>;
+    /**
+     * Set connector data routing mode
+     * @param mode - Data routing mode (MIC, ACC, USB, WLAN)
+     * @example
+     * // Route audio to WLAN
+     * await rig.setConnectorDataMode('WLAN');
+     */
+    setConnectorDataMode(mode: ConnectorDataMode | number): Promise<void>;
+    private static isReplyOf;
+    /**
+     * Extract meter data from CI-V response frame
+     * CI-V format: FE FE [ctr] [rig] [cmd] [subcmd] [data0] [data1] FD
+     * @param frame - CI-V response buffer
+     * @returns Parsed BCD integer value, or null if invalid
+     */
+    private static extractMeterData;
+    private static matchCommand;
+    private static matchCommandFrame;
+    private waitForCiv;
+    static parseIcomFreqFromReply(frame: Buffer): number | null;
+    sendAudioFloat32(samples: Float32Array, addLeadingBuffer?: boolean): void;
+    sendAudioPcm16(samples: Int16Array): void;
+    private onData;
+    private onCivData;
+    private processCivPayload;
+    private waitForCivFrame;
+    private static isMeterReply;
+    private startMeterPolling;
+    private stopMeterPolling;
+    private onAudioData;
+    private sendConnectionRequest;
+}