icom-wlan-node 0.1.0

package/dist/rig/IcomControl.js

@@ -0,0 +1,912 @@
+"use strict";
+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.IcomControl = void 0;
+const events_1 = require("events");
+const IcomPackets_1 = require("../core/IcomPackets");
+const debug_1 = require("../utils/debug");
+const Session_1 = require("../core/Session");
+const IcomCiv_1 = require("./IcomCiv");
+const IcomAudio_1 = require("./IcomAudio");
+const IcomRigCommands_1 = require("./IcomRigCommands");
+const IcomConstants_1 = require("./IcomConstants");
+const bcd_1 = require("../utils/bcd");
+class IcomControl {
+    constructor(options) {
+        this.ev = new events_1.EventEmitter();
+        this.rigName = '';
+        this.macAddress = Buffer.alloc(6);
+        this.civAssembleBuf = Buffer.alloc(0); // CIV stream reassembler
+        this.options = options;
+        this.sess = new Session_1.Session({ ip: options.control.ip, port: options.control.port }, {
+            onData: (data) => this.onData(data),
+            onSendError: (e) => this.ev.emit('error', e)
+        });
+        // Pre-open local CIV/Audio sessions to obtain local ports before 0x90
+        this.civSess = new Session_1.Session({ ip: options.control.ip, port: 0 }, { onData: (b) => this.onCivData(b), onSendError: (e) => this.ev.emit('error', e) });
+        this.audioSess = new Session_1.Session({ ip: options.control.ip, port: 0 }, { onData: (b) => this.onAudioData(b), onSendError: (e) => this.ev.emit('error', e) });
+        this.civSess.open();
+        this.audioSess.open();
+        this.civ = new IcomCiv_1.IcomCiv(this.civSess);
+        this.audio = new IcomAudio_1.IcomAudio(this.audioSess);
+    }
+    get events() { return this.ev; }
+    async connect() {
+        // Initialize readiness promises
+        this.loginReady = new Promise(resolve => { this.resolveLoginReady = resolve; });
+        this.civReady = new Promise(resolve => { this.resolveCivReady = resolve; });
+        this.audioReady = new Promise(resolve => { this.resolveAudioReady = resolve; });
+        this.sess.open();
+        this.sess.startAreYouThere();
+        // Wait for all sub-sessions to be ready
+        await Promise.all([this.loginReady, this.civReady, this.audioReady]);
+        (0, debug_1.dbg)('All sessions ready (login + civ + audio)');
+    }
+    async disconnect() {
+        // 1. Stop all timers first to prevent interference
+        if (this.tokenTimer) {
+            clearInterval(this.tokenTimer);
+            this.tokenTimer = undefined;
+        }
+        this.stopMeterPolling();
+        this.sess.stopTimers();
+        if (this.civSess)
+            this.civSess.stopTimers();
+        if (this.audioSess)
+            this.audioSess.stopTimers();
+        // 2. Send DELETE token packet
+        const del = IcomPackets_1.TokenPacket.build(0, this.sess.localId, this.sess.remoteId, IcomPackets_1.TokenType.DELETE, this.sess.innerSeq, this.sess.localToken, this.sess.rigToken);
+        this.sess.innerSeq = (this.sess.innerSeq + 1) & 0xffff;
+        this.sess.sendTracked(del);
+        // 3. Send CMD_DISCONNECT to all sessions
+        this.sess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.DISCONNECT, 0, this.sess.localId, this.sess.remoteId));
+        if (this.civSess) {
+            this.civ.sendOpenClose(false);
+            this.civSess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.DISCONNECT, 0, this.civSess.localId, this.civSess.remoteId));
+        }
+        if (this.audioSess) {
+            this.audioSess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.DISCONNECT, 0, this.audioSess.localId, this.audioSess.remoteId));
+        }
+        // 4. Wait 200ms to ensure UDP packets are sent before closing sockets
+        await new Promise(resolve => setTimeout(resolve, 200));
+        // 5. Stop streams and close sockets
+        this.civ.stop();
+        this.audio.stop(); // Stop continuous audio transmission
+        this.sess.close();
+        if (this.civSess)
+            this.civSess.close();
+        if (this.audioSess)
+            this.audioSess.close();
+    }
+    sendCiv(data) { this.civ.sendCivData(data); }
+    /**
+     * Set PTT (Push-To-Talk) state
+     * @param on - true to key transmitter, false to unkey
+     */
+    async setPtt(on) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        // Send CIV PTT command
+        const frame = IcomRigCommands_1.IcomRigCommands.setPTT(ctrAddr, rigAddr, on);
+        this.sendCiv(frame);
+        // Set audio PTT flag (like Java: audioUdp.isPttOn = on)
+        this.audio.isPttOn = on;
+        // Start/stop meter polling to match Java behavior
+        if (on) {
+            this.startMeterPolling();
+        }
+        else {
+            this.stopMeterPolling();
+        }
+        // Add trailing silence when PTT off (like Java implementation)
+        if (!on) {
+            // Add 5 trailing silence frames before clearing queue
+            const silence = new Int16Array(240); // TX_BUFFER_SIZE = 240
+            for (let i = 0; i < 5; i++) {
+                this.audio.queue.push(silence);
+            }
+        }
+    }
+    /**
+     * Set operating frequency
+     * @param hz - Frequency in Hz
+     */
+    async setFrequency(hz) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setFrequency(ctrAddr, rigAddr, hz));
+    }
+    /**
+     * 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 });
+     */
+    async setMode(mode, options) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const modeCode = typeof mode === 'string' ? (0, IcomConstants_1.getModeCode)(mode) : mode;
+        if (options?.dataMode) {
+            this.sendCiv(IcomRigCommands_1.IcomRigCommands.setOperationDataMode(ctrAddr, rigAddr, modeCode));
+        }
+        else {
+            this.sendCiv(IcomRigCommands_1.IcomRigCommands.setMode(ctrAddr, rigAddr, modeCode));
+        }
+    }
+    /**
+     * 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`);
+     */
+    async readOperatingFrequency(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readOperatingFrequency(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.isReplyOf(frame, 0x03, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp)
+            return null;
+        const freq = IcomControl.parseIcomFreqFromReply(resp);
+        return freq;
+    }
+    /**
+     * Read current operating mode and filter
+     * @returns { mode: number, filter?: number } or null
+     */
+    async readOperatingMode(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readOperatingMode(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x04, [], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp)
+            return null;
+        // Expect FE FE [ctr] [rig] 0x04 [mode] [filter] FD (some rigs may omit filter)
+        const mode = resp.length > 5 ? resp[5] : undefined;
+        const filter = resp.length > 6 ? resp[6] : undefined;
+        if (mode === undefined)
+            return null;
+        // Map names using constants
+        const { getModeString, getFilterString } = await Promise.resolve().then(() => __importStar(require('./IcomConstants')));
+        const modeName = getModeString(mode);
+        const filterName = getFilterString(filter);
+        return { mode, filter, modeName, filterName };
+    }
+    /**
+     * Read current transmit frequency (when TX)
+     */
+    async readTransmitFrequency(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readTransmitFrequency(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x1c, [0x03], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp)
+            return null;
+        // Parse BCD like readOperatingFrequency, but starting after [0x1c, 0x03]
+        // Find 0x1c position and read next 2 bytes (0x03 + 5 BCD bytes)
+        let idx = resp.indexOf(0x1c, 4);
+        if (idx < 0 || idx + 6 >= resp.length)
+            idx = 4;
+        if (idx + 6 >= resp.length)
+            return null;
+        // After 0x1c 0x03, we expect 5 BCD bytes
+        if (resp[idx + 1] !== 0x03)
+            return null;
+        const d0 = resp[idx + 2];
+        const d1 = resp[idx + 3];
+        const d2 = resp[idx + 4];
+        const d3 = resp[idx + 5];
+        const d4 = resp[idx + 6];
+        const bcdToInt = (b) => ((b >> 4) & 0x0f) * 10 + (b & 0x0f);
+        const v0 = bcdToInt(d0);
+        const v1 = bcdToInt(d1);
+        const v2 = bcdToInt(d2);
+        const v3 = bcdToInt(d3);
+        const v4 = bcdToInt(d4);
+        const hz = v0 + v1 * 100 + v2 * 10000 + v3 * 1000000 + v4 * 100000000;
+        return hz;
+    }
+    /**
+     * Read transceiver state (TX/RX) via 0x1A 0x00 0x48
+     * Note: Java comments mark this as not recommended; use with caution.
+     */
+    async readTransceiverState(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readTransceiverState(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x1a, [0x00, 0x48], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp)
+            return null;
+        // Heuristic: take first data byte after subcmd2 as state
+        const pos = 5 + 2; // after 0x1a [0x00,0x48]
+        const state = resp.length > pos ? resp[pos] : undefined;
+        if (state === undefined)
+            return 'UNKNOWN';
+        if (state === 0x01)
+            return 'TX';
+        if (state === 0x00)
+            return 'RX';
+        return 'UNKNOWN';
+    }
+    /**
+     * Read band edge data (0x02). Format may vary by rig; returns raw data bytes after command.
+     */
+    async readBandEdges(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readBandEdges(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x02, [], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp)
+            return null;
+        // Return raw payload bytes after command
+        return Buffer.from(resp.subarray(5, resp.length - 1));
+    }
+    /**
+     * 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' : '✓'}`);
+     * }
+     */
+    async readSWR(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getSWRState(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.isMeterReply(frame, 0x12, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractMeterData(resp);
+        if (raw === null)
+            return null;
+        return {
+            raw,
+            swr: raw / 100,
+            alert: raw >= IcomConstants_1.METER_THRESHOLDS.SWR_ALERT
+        };
+    }
+    /**
+     * 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' : '✓'}`);
+     * }
+     */
+    async readALC(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getALCState(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.isMeterReply(frame, 0x13, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractMeterData(resp);
+        if (raw === null)
+            return null;
+        return {
+            raw,
+            percent: (raw / IcomConstants_1.METER_THRESHOLDS.ALC_MAX) * 100,
+            alert: raw > IcomConstants_1.METER_THRESHOLDS.ALC_ALERT_MAX
+        };
+    }
+    /**
+     * 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)}%`);
+     * }
+     */
+    async getConnectorWLanLevel(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getConnectorWLanLevel(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x1a, [0x05, 0x01, 0x17], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractMeterData(resp);
+        if (raw === null)
+            return null;
+        return {
+            raw,
+            percent: (raw / IcomConstants_1.METER_THRESHOLDS.WLAN_LEVEL_MAX) * 100
+        };
+    }
+    /**
+     * Read generic level meter (CI-V 0x15/0x02), raw 0-255.
+     * Many rigs return two bytes and the low byte is the level.
+     */
+    async getLevelMeter(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.getLevelMeter(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.isMeterReply(frame, 0x02, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp)
+            return null;
+        const data = resp.subarray(6, resp.length - 1);
+        if (data.length === 0)
+            return null;
+        const raw = data[data.length - 1] & 0xff; // use low byte as 0-255 level
+        return {
+            raw,
+            percent: (raw / 255) * 100
+        };
+    }
+    /**
+     * Set WLAN connector audio level
+     * @param level - Audio level (0-255)
+     */
+    async setConnectorWLanLevel(level) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setConnectorWLanLevel(ctrAddr, rigAddr, level));
+    }
+    /**
+     * Set connector data routing mode
+     * @param mode - Data routing mode (MIC, ACC, USB, WLAN)
+     * @example
+     * // Route audio to WLAN
+     * await rig.setConnectorDataMode('WLAN');
+     */
+    async setConnectorDataMode(mode) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const modeCode = typeof mode === 'string' ? (0, IcomConstants_1.getConnectorModeCode)(mode) : mode;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setConnectorDataMode(ctrAddr, rigAddr, modeCode));
+    }
+    static isReplyOf(frame, cmd, ctrAddr, rigAddr) {
+        // typical reply FE FE [ctr] [rig] cmd ... FD
+        return frame.length >= 7 && frame[0] === 0xfe && frame[1] === 0xfe && frame[4] === (cmd & 0xff);
+    }
+    /**
+     * 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
+     */
+    static extractMeterData(frame) {
+        if (!frame || frame.length < 9)
+            return null;
+        // Extract 2-byte BCD data at position 6-7 of the CI-V frame (FE FE [ctr] [rig] 0x15 [sub] [b0] [b1] FD)
+        const bcdData = frame.subarray(6, 8);
+        return (0, bcd_1.parseTwoByteBcd)(bcdData);
+    }
+    static matchCommand(frame, cmd, tail) {
+        // FE FE ?? ?? cmd ... tail... FD
+        if (!(frame.length >= 7 && frame[0] === 0xfe && frame[1] === 0xfe && frame[4] === (cmd & 0xff)))
+            return false;
+        if (tail.length === 0)
+            return true;
+        for (let i = 0; i + tail.length < frame.length; i++) {
+            let ok = true;
+            for (let j = 0; j < tail.length; j++) {
+                if (frame[i + j] !== tail[j]) {
+                    ok = false;
+                    break;
+                }
+            }
+            if (ok)
+                return true;
+        }
+        return false;
+    }
+    // Strict command matcher on full CI-V frame (optional address check)
+    static matchCommandFrame(frame, cmd, tail, ctrAddr, rigAddr) {
+        if (!(frame.length >= 7 && frame[0] === 0xfe && frame[1] === 0xfe))
+            return false;
+        if (ctrAddr !== undefined) {
+            const addrCtrOk = frame[2] === (ctrAddr & 0xff) || frame[2] === 0x00;
+            if (!addrCtrOk)
+                return false;
+        }
+        if (rigAddr !== undefined) {
+            if (frame[3] !== (rigAddr & 0xff))
+                return false;
+        }
+        if (frame[4] !== (cmd & 0xff))
+            return false;
+        // tail should match starting at byte 5
+        if (5 + tail.length > frame.length)
+            return false;
+        for (let i = 0; i < tail.length; i++) {
+            if (frame[5 + i] !== tail[i])
+                return false;
+        }
+        if (frame[frame.length - 1] !== 0xfd)
+            return false;
+        return true;
+    }
+    async waitForCiv(predicate, timeoutMs, onSend) {
+        return new Promise((resolve) => {
+            let done = false;
+            const onFrame = (data) => {
+                // our event emits Buffer of CI-V payload
+                const frame = data;
+                if (!done && predicate(frame)) {
+                    done = true;
+                    this.ev.off('civ', onFrame);
+                    resolve(frame);
+                }
+            };
+            this.ev.on('civ', onFrame);
+            if (onSend)
+                onSend();
+            setTimeout(() => {
+                if (!done) {
+                    this.ev.off('civ', onFrame);
+                    resolve(null);
+                }
+            }, timeoutMs);
+        });
+    }
+    // Parse CI-V reply for command 0x03 (read operating frequency)
+    static parseIcomFreqFromReply(frame) {
+        // Expect: FE FE [ctr] [rig] 0x03 [bcd0..bcd4] FD
+        if (!(frame && frame.length >= 7))
+            return null;
+        if (frame[0] !== 0xfe || frame[1] !== 0xfe)
+            return null;
+        if (frame[4] !== 0x03)
+            return null;
+        // Some radios may include extra bytes; find 0x03 and read next 5 bytes
+        let idx = frame.indexOf(0x03, 5);
+        if (idx < 0 || idx + 5 >= frame.length)
+            idx = 4; // fallback to standard position
+        if (idx + 5 >= frame.length)
+            return null;
+        const d0 = frame[idx + 1];
+        const d1 = frame[idx + 2];
+        const d2 = frame[idx + 3];
+        const d3 = frame[idx + 4];
+        const d4 = frame[idx + 5];
+        const bcdToInt = (b) => ((b >> 4) & 0x0f) * 10 + (b & 0x0f);
+        const v0 = bcdToInt(d0);
+        const v1 = bcdToInt(d1);
+        const v2 = bcdToInt(d2);
+        const v3 = bcdToInt(d3);
+        const v4 = bcdToInt(d4);
+        const hz = v0 + v1 * 100 + v2 * 10000 + v3 * 1000000 + v4 * 100000000;
+        return hz;
+    }
+    sendAudioFloat32(samples, addLeadingBuffer = false) {
+        this.audio.enqueueFloat32(samples, addLeadingBuffer);
+    }
+    sendAudioPcm16(samples) { this.audio.enqueuePcm16(samples); }
+    onData(buf) {
+        // common demux by length
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        // dbg/dbgV imported at top
+        switch (buf.length) {
+            case IcomPackets_1.Sizes.CONTROL: {
+                const type = IcomPackets_1.ControlPacket.getType(buf);
+                (0, debug_1.dbg)('CTRL <= type=0x' + type.toString(16));
+                if (type === IcomPackets_1.Cmd.I_AM_HERE) {
+                    this.sess.remoteId = IcomPackets_1.ControlPacket.getSentId(buf);
+                    (0, debug_1.dbg)('I_AM_HERE remoteId=', this.sess.remoteId);
+                    this.sess.stopAreYouThere();
+                    this.sess.startPing();
+                    // ask ready
+                    this.sess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.ARE_YOU_READY, 1, this.sess.localId, this.sess.remoteId));
+                }
+                else if (type === IcomPackets_1.Cmd.I_AM_READY) {
+                    (0, debug_1.dbg)('I_AM_READY -> send login');
+                    // send login
+                    const login = IcomPackets_1.LoginPacket.build(0, this.sess.localId, this.sess.remoteId, this.sess.innerSeq, this.sess.localToken, this.sess.rigToken, this.options.userName, this.options.password, 'FT8CN-Node');
+                    this.sess.innerSeq = (this.sess.innerSeq + 1) & 0xffff;
+                    this.sess.sendTracked(login);
+                    this.sess.startIdle();
+                }
+                break;
+            }
+            case IcomPackets_1.Sizes.TOKEN: {
+                // token renewal / confirm responses
+                const reqType = IcomPackets_1.TokenPacket.getRequestType(buf);
+                const reqReply = IcomPackets_1.TokenPacket.getRequestReply(buf);
+                (0, debug_1.dbg)('TOKEN <= type=', reqType, 'reply=', reqReply);
+                if (reqType === IcomPackets_1.TokenType.RENEWAL && reqReply === 0x02 && IcomPackets_1.ControlPacket.getType(buf) !== IcomPackets_1.Cmd.RETRANSMIT) {
+                    const response = IcomPackets_1.TokenPacket.getResponse(buf);
+                    (0, debug_1.dbgV)('TOKEN renewal response=', response);
+                    if (response === 0x00000000) {
+                        // ok
+                    }
+                    else if (response === 0xffffffff) {
+                        // rejected; attempt re-connect
+                        this.sess.remoteId = IcomPackets_1.ControlPacket.getSentId(buf);
+                        this.sess.localToken = IcomPackets_1.TokenPacket.getTokRequest(buf);
+                        this.sess.rigToken = IcomPackets_1.TokenPacket.getToken(buf);
+                        this.sendConnectionRequest();
+                    }
+                }
+                break;
+            }
+            case IcomPackets_1.Sizes.STATUS: {
+                const civPort = IcomPackets_1.StatusPacket.getRigCivPort(buf);
+                const audioPort = IcomPackets_1.StatusPacket.getRigAudioPort(buf);
+                (0, debug_1.dbg)('STATUS <= civPort=', civPort, 'audioPort=', audioPort, 'authOK=', IcomPackets_1.StatusPacket.authOK(buf), 'connected=', IcomPackets_1.StatusPacket.getIsConnected(buf));
+                const info = { civPort, audioPort, authOK: true, connected: true };
+                this.ev.emit('status', info);
+                // set remote ports and start AYT for civ/audio
+                if (this.civSess) {
+                    this.civSess.setRemote(this.options.control.ip, civPort);
+                    this.civSess.startAreYouThere();
+                    this.civ.start();
+                }
+                if (this.audioSess) {
+                    this.audioSess.setRemote(this.options.control.ip, audioPort);
+                    this.audioSess.startAreYouThere();
+                }
+                break;
+            }
+            case IcomPackets_1.Sizes.LOGIN_RESPONSE: {
+                const ok = IcomPackets_1.LoginResponsePacket.authOK(buf);
+                (0, debug_1.dbg)('LOGIN_RESPONSE ok=', ok, 'conn=', IcomPackets_1.LoginResponsePacket.getConnection(buf));
+                if (ok) {
+                    this.sess.rigToken = IcomPackets_1.LoginResponsePacket.getToken(buf);
+                    // send token confirm
+                    const tok = IcomPackets_1.TokenPacket.build(0, this.sess.localId, this.sess.remoteId, IcomPackets_1.TokenType.CONFIRM, this.sess.innerSeq, this.sess.localToken, this.sess.rigToken);
+                    this.sess.innerSeq = (this.sess.innerSeq + 1) & 0xffff;
+                    this.sess.sendTracked(tok);
+                    // start token renewal timer (60s)
+                    if (!this.tokenTimer) {
+                        this.tokenTimer = setInterval(() => {
+                            (0, debug_1.dbg)('TOKEN -> renewal');
+                            const renew = IcomPackets_1.TokenPacket.build(0, this.sess.localId, this.sess.remoteId, IcomPackets_1.TokenType.RENEWAL, this.sess.innerSeq, this.sess.localToken, this.sess.rigToken);
+                            this.sess.innerSeq = (this.sess.innerSeq + 1) & 0xffff;
+                            this.sess.sendTracked(renew);
+                        }, 60000);
+                    }
+                }
+                const res = { ok, errorCode: IcomPackets_1.LoginResponsePacket.errorNum(buf), connection: IcomPackets_1.LoginResponsePacket.getConnection(buf) };
+                this.ev.emit('login', res);
+                if (ok) {
+                    (0, debug_1.dbg)('Login ready - resolving loginReady promise');
+                    this.resolveLoginReady();
+                }
+                break;
+            }
+            case IcomPackets_1.Sizes.CAP_CAP: {
+                const cap = IcomPackets_1.CapCapabilitiesPacket.getRadioCapPacket(buf, 0);
+                if (cap) {
+                    const info = {
+                        civAddress: IcomPackets_1.RadioCapPacket.getCivAddress(cap),
+                        audioName: IcomPackets_1.RadioCapPacket.getAudioName(cap),
+                        supportTX: IcomPackets_1.RadioCapPacket.getSupportTX(cap)
+                    };
+                    if (info.civAddress != null)
+                        this.civ.civAddress = info.civAddress;
+                    if (info.supportTX != null)
+                        this.civ.supportTX = info.supportTX;
+                    (0, debug_1.dbgV)('CAP <= civAddr=', info.civAddress, 'audioName=', info.audioName, 'supportTX=', info.supportTX);
+                    this.ev.emit('capabilities', info);
+                }
+                break;
+            }
+            case IcomPackets_1.Sizes.CONNINFO: {
+                // rig sends twice; first time busy=false, reply with our ports
+                const busy = IcomPackets_1.ConnInfoPacket.getBusy(buf);
+                this.macAddress = IcomPackets_1.ConnInfoPacket.getMacAddress(buf);
+                this.rigName = IcomPackets_1.ConnInfoPacket.getRigName(buf);
+                (0, debug_1.dbg)('CONNINFO <= busy=', busy, 'rigName=', this.rigName);
+                if (!busy) {
+                    const reply = IcomPackets_1.ConnInfoPacket.connInfoPacketData(buf, 0, this.sess.localId, this.sess.remoteId, 0x01, 0x03, this.sess.innerSeq, this.sess.localToken, this.sess.rigToken, this.rigName, this.options.userName, IcomPackets_1.AUDIO_SAMPLE_RATE, IcomPackets_1.AUDIO_SAMPLE_RATE, this.civSess.localPort, this.audioSess.localPort, IcomPackets_1.XIEGU_TX_BUFFER_SIZE);
+                    this.sess.innerSeq = (this.sess.innerSeq + 1) & 0xffff;
+                    this.sess.sendTracked(reply);
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-var-requires
+                        const { hex } = require('../utils/codec');
+                        (0, debug_1.dbg)('CONNINFO -> reply with local civPort=', this.civSess.localPort, 'audioPort=', this.audioSess.localPort);
+                        (0, debug_1.dbgV)('CONNINFO reply hex (first 0x60):', hex(Buffer.from(reply.subarray(0, 0x60))));
+                        (0, debug_1.dbgV)('CONNINFO reply hex (0x60..0x90):', hex(Buffer.from(reply.subarray(0x60, 0x90))));
+                    }
+                    catch { }
+                }
+                break;
+            }
+            default: {
+                // CIV and Audio are variable length; route by headers
+                if (IcomPackets_1.CivPacket.isCiv(buf)) {
+                    // CIV
+                    const payload = IcomPackets_1.CivPacket.getCivData(buf);
+                    (0, debug_1.dbg)('CIV <=', payload.length, 'bytes');
+                    this.ev.emit('civ', payload);
+                }
+                else if (buf.length >= 0x18 &&
+                    (buf[0x10] === 0x97 || buf[0x10] === 0x00) &&
+                    ((buf[0x11] === 0x81) || (buf[0x11] === 0x80))) {
+                    const len = buf.readUInt16BE(0x16);
+                    const audio = Buffer.from(buf.subarray(0x18, 0x18 + len));
+                    (0, debug_1.dbg)('AUDIO <=', audio.length, 'bytes');
+                    this.ev.emit('audio', { pcm16: audio });
+                }
+                else if (buf.length === IcomPackets_1.Sizes.CONTROL && IcomPackets_1.ControlPacket.getType(buf) === IcomPackets_1.Cmd.RETRANSMIT) {
+                    (0, debug_1.dbgV)('RETRANSMIT <= single', IcomPackets_1.ControlPacket.getSeq(buf));
+                    // single retransmit
+                    this.sess.retransmit(IcomPackets_1.ControlPacket.getSeq(buf));
+                }
+                else if (IcomPackets_1.ControlPacket.getType(buf) === IcomPackets_1.Cmd.RETRANSMIT && buf.length > IcomPackets_1.Sizes.CONTROL) {
+                    (0, debug_1.dbgV)('RETRANSMIT <= multi count=', Math.floor((buf.length - 0x10) / 2));
+                    for (let i = 0x10; i + 1 < buf.length; i += 2) {
+                        const seq = buf.readUInt16LE(i);
+                        this.sess.retransmit(seq);
+                    }
+                }
+                else if (buf.length === IcomPackets_1.Sizes.PING && IcomPackets_1.Cmd.PING === IcomPackets_1.ControlPacket.getType(buf)) {
+                    // ping handling
+                    if (buf[0x10] === 0x00) {
+                        // reply to radio ping
+                        const rep = IcomPackets_1.PingPacket.buildReply(buf, this.sess.localId, this.sess.remoteId);
+                        (0, debug_1.dbgV)('PING <= request -> reply');
+                        this.sess.sendUntracked(rep);
+                    }
+                    else {
+                        // reply to our ping; seq ok -> bump
+                        if (IcomPackets_1.ControlPacket.getSeq(buf) === this.sess.pingSeq)
+                            this.sess.pingSeq = (this.sess.pingSeq + 1) & 0xffff;
+                        (0, debug_1.dbgV)('PING <= reply seq=', IcomPackets_1.ControlPacket.getSeq(buf));
+                    }
+                }
+            }
+        }
+    }
+    onCivData(buf) {
+        // mirror some generic handling on sub-session
+        if (buf.length === IcomPackets_1.Sizes.CONTROL) {
+            const type = IcomPackets_1.ControlPacket.getType(buf);
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            (0, debug_1.dbg)('CIV CTRL <= type=0x' + type.toString(16));
+            if (type === IcomPackets_1.Cmd.I_AM_HERE) {
+                this.civSess.remoteId = IcomPackets_1.ControlPacket.getSentId(buf);
+                this.civSess.stopAreYouThere();
+                this.civSess.startPing();
+                // send ARE_YOU_READY with seq=1
+                this.civSess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.ARE_YOU_READY, 1, this.civSess.localId, this.civSess.remoteId));
+                return;
+            }
+            if (type === IcomPackets_1.Cmd.I_AM_READY) {
+                this.civ.sendOpenClose(true);
+                this.civSess.startIdle();
+                (0, debug_1.dbg)('CIV ready - resolving civReady promise');
+                this.resolveCivReady();
+                return;
+            }
+        }
+        // CIV data frames
+        // Diagnostic: check for potential CIV packets
+        if (buf.length > 0x15 && buf[0x10] === 0xc1) {
+            (0, debug_1.dbg)(`CIV? len=${buf.length} [0x10]=0xc1 validating...`);
+            if (IcomPackets_1.CivPacket.isCiv(buf)) {
+                const payload = IcomPackets_1.CivPacket.getCivData(buf);
+                (0, debug_1.dbg)('CIV <=', payload.length, 'bytes');
+                // Emit raw CIV payload for backward compatibility
+                this.ev.emit('civ', payload);
+                // Reassemble CIV frames (FE FE ... FD) and emit per-frame events
+                this.processCivPayload(payload);
+                return;
+            }
+            else {
+                (0, debug_1.dbg)(`CIV validation FAILED len=${buf.length}`);
+            }
+        }
+        if (buf.length === IcomPackets_1.Sizes.PING && IcomPackets_1.Cmd.PING === IcomPackets_1.ControlPacket.getType(buf)) {
+            if (buf[0x10] === 0x00) {
+                const rep = IcomPackets_1.PingPacket.buildReply(buf, this.civSess.localId, this.civSess.remoteId);
+                this.civSess.sendUntracked(rep);
+            }
+            else if (IcomPackets_1.ControlPacket.getSeq(buf) === (this.civSess.pingSeq)) {
+                this.civSess.pingSeq = (this.civSess.pingSeq + 1) & 0xffff;
+            }
+        }
+        if (buf.length === IcomPackets_1.Sizes.CONTROL && IcomPackets_1.ControlPacket.getType(buf) === IcomPackets_1.Cmd.RETRANSMIT) {
+            this.civSess?.retransmit(IcomPackets_1.ControlPacket.getSeq(buf));
+        }
+        else if (IcomPackets_1.ControlPacket.getType(buf) === IcomPackets_1.Cmd.RETRANSMIT && buf.length > IcomPackets_1.Sizes.CONTROL) {
+            for (let i = 0x10; i + 1 < buf.length; i += 2)
+                this.civSess?.retransmit(buf.readUInt16LE(i));
+        }
+    }
+    // Append CIV payload bytes and emit complete CI-V frames (FE FE ... FD)
+    processCivPayload(payload) {
+        // Append new data
+        this.civAssembleBuf = Buffer.concat([this.civAssembleBuf, payload]);
+        // Try to extract frames in a loop
+        while (true) {
+            // Find start marker FE FE
+            let start = -1;
+            for (let i = 0; i + 1 < this.civAssembleBuf.length; i++) {
+                if (this.civAssembleBuf[i] === 0xfe && this.civAssembleBuf[i + 1] === 0xfe) {
+                    start = i;
+                    break;
+                }
+            }
+            if (start < 0) {
+                // No start marker: drop noise before potential next packet
+                if (this.civAssembleBuf.length > 1024)
+                    this.civAssembleBuf = Buffer.alloc(0);
+                return;
+            }
+            // Trim leading noise
+            if (start > 0)
+                this.civAssembleBuf = this.civAssembleBuf.subarray(start);
+            // Find end marker FD after start
+            let end = -1;
+            for (let i = 2; i < this.civAssembleBuf.length; i++) {
+                if (this.civAssembleBuf[i] === 0xfd) {
+                    end = i;
+                    break;
+                }
+            }
+            if (end < 0) {
+                // Incomplete frame, wait for more data
+                return;
+            }
+            // Extract frame [0..end]
+            const frame = Buffer.from(this.civAssembleBuf.subarray(0, end + 1));
+            // Advance buffer
+            this.civAssembleBuf = this.civAssembleBuf.subarray(end + 1);
+            // Emit event
+            this.ev.emit('civFrame', frame);
+            // Continue loop in case multiple frames are in buffer
+        }
+    }
+    // Wait for single CI-V frame that matches predicate (fed by civFrame event)
+    async waitForCivFrame(predicate, timeoutMs, onSend) {
+        return new Promise((resolve) => {
+            let done = false;
+            const onFrame = (frame) => {
+                if (!done && predicate(frame)) {
+                    done = true;
+                    this.ev.off('civFrame', onFrame);
+                    resolve(frame);
+                }
+            };
+            this.ev.on('civFrame', onFrame);
+            if (onSend)
+                onSend();
+            setTimeout(() => {
+                if (!done) {
+                    this.ev.off('civFrame', onFrame);
+                    resolve(null);
+                }
+            }, timeoutMs);
+        });
+    }
+    // Strict meter reply matcher: FE FE [ctr|00] [rig] 0x15 [sub] ... FD
+    static isMeterReply(frame, subcmd, ctrAddr, rigAddr) {
+        if (!(frame && frame.length >= 9))
+            return false;
+        if (frame[0] !== 0xfe || frame[1] !== 0xfe)
+            return false;
+        const addrCtrOk = frame[2] === (ctrAddr & 0xff) || frame[2] === 0x00;
+        const addrRigOk = frame[3] === (rigAddr & 0xff);
+        if (!addrCtrOk || !addrRigOk)
+            return false;
+        if (frame[4] !== 0x15)
+            return false;
+        if (frame[5] !== (subcmd & 0xff))
+            return false;
+        if (frame[frame.length - 1] !== 0xfd)
+            return false;
+        return true;
+    }
+    // Start meter polling like Java (every 500ms when PTT is on)
+    startMeterPolling() {
+        this.stopMeterPolling();
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.meterTimer = setInterval(() => {
+            if (!this.audio.isPttOn)
+                return; // safety
+            this.sendCiv(IcomRigCommands_1.IcomRigCommands.getSWRState(ctrAddr, rigAddr));
+            this.sendCiv(IcomRigCommands_1.IcomRigCommands.getALCState(ctrAddr, rigAddr));
+        }, IcomConstants_1.METER_TIMER_PERIOD_MS);
+    }
+    stopMeterPolling() {
+        if (this.meterTimer) {
+            clearInterval(this.meterTimer);
+            this.meterTimer = undefined;
+        }
+    }
+    onAudioData(buf) {
+        if (buf.length === IcomPackets_1.Sizes.CONTROL) {
+            const type = IcomPackets_1.ControlPacket.getType(buf);
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            (0, debug_1.dbg)('AUDIO CTRL <= type=0x' + type.toString(16));
+            if (type === IcomPackets_1.Cmd.I_AM_HERE) {
+                this.audioSess.remoteId = IcomPackets_1.ControlPacket.getSentId(buf);
+                this.audioSess.stopAreYouThere();
+                this.audioSess.startPing();
+                this.audioSess.sendUntracked(IcomPackets_1.ControlPacket.toBytes(IcomPackets_1.Cmd.ARE_YOU_READY, 1, this.audioSess.localId, this.audioSess.remoteId));
+                return;
+            }
+            if (type === IcomPackets_1.Cmd.I_AM_READY) {
+                // Start continuous audio transmission (like Java's startTxAudio on I_AM_READY)
+                this.audio.start();
+                this.audioSess.startIdle();
+                (0, debug_1.dbg)('Audio ready - started continuous audio stream, resolving audioReady promise');
+                this.resolveAudioReady();
+                return;
+            }
+        }
+        // AUDIO frames (len >= 0x18 and datalen matches). We don't strictly validate ident here to support variants.
+        if (buf.length >= 0x18) {
+            // datalen is BE (Java uses shortToByte which is big-endian)
+            const dataLen = buf.readUInt16BE(0x16);
+            if (buf.length === 0x18 + dataLen && dataLen > 0 && dataLen <= 2048) {
+                const audio = Buffer.from(buf.subarray(0x18, 0x18 + dataLen));
+                this.ev.emit('audio', { pcm16: audio });
+                return;
+            }
+        }
+        if (buf.length === IcomPackets_1.Sizes.PING && IcomPackets_1.Cmd.PING === IcomPackets_1.ControlPacket.getType(buf)) {
+            if (buf[0x10] === 0x00) {
+                const rep = IcomPackets_1.PingPacket.buildReply(buf, this.audioSess.localId, this.audioSess.remoteId);
+                this.audioSess.sendUntracked(rep);
+            }
+            else if (IcomPackets_1.ControlPacket.getSeq(buf) === (this.audioSess.pingSeq)) {
+                this.audioSess.pingSeq = (this.audioSess.pingSeq + 1) & 0xffff;
+            }
+        }
+        if (buf.length === IcomPackets_1.Sizes.CONTROL && IcomPackets_1.ControlPacket.getType(buf) === IcomPackets_1.Cmd.RETRANSMIT) {
+            this.audioSess?.retransmit(IcomPackets_1.ControlPacket.getSeq(buf));
+        }
+        else if (IcomPackets_1.ControlPacket.getType(buf) === IcomPackets_1.Cmd.RETRANSMIT && buf.length > IcomPackets_1.Sizes.CONTROL) {
+            for (let i = 0x10; i + 1 < buf.length; i += 2)
+                this.audioSess?.retransmit(buf.readUInt16LE(i));
+        }
+        // audio data routed by main handler already (if using single session). Here we may add specific behaviors if needed.
+    }
+    sendConnectionRequest() {
+        if (!this.civSess || !this.audioSess)
+            return;
+        const pkt = IcomPackets_1.ConnInfoPacket.connectRequestPacket(0, this.sess.localId, this.sess.remoteId, 0x01, 0x03, this.sess.innerSeq, this.sess.localToken, this.sess.rigToken, this.macAddress, this.rigName, this.options.userName, IcomPackets_1.AUDIO_SAMPLE_RATE, this.civSess.localPort, this.audioSess.localPort, IcomPackets_1.XIEGU_TX_BUFFER_SIZE);
+        this.sess.innerSeq = (this.sess.innerSeq + 1) & 0xffff;
+        this.sess.sendTracked(pkt);
+    }
+}
+exports.IcomControl = IcomControl;