icom-wlan-node 0.6.1 → 0.6.3

package/dist/rig/IcomControl.js

@@ -70,6 +70,78 @@ function modeNameToCode(mode) {
         case 'scroll-fixed': return 3;
     }
 }
+const FUNCTION_SPECS = {
+    NB: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_NB },
+    NR: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_NR },
+    COMP: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_COMP },
+    VOX: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_VOX },
+    TONE: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_TONE },
+    TSQL: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_TSQL },
+    SBKIN: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_BKIN },
+    FBKIN: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_BKIN },
+    MON: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_MON },
+    ANF: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_ANF },
+    MN: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_MN },
+    LOCK: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_DIAL_LK },
+    RIT: { command: IcomCivSpec_1.CIV.C_CTL_RIT, subcmd: IcomCivSpec_1.CIV.S_RIT },
+    XIT: { command: IcomCivSpec_1.CIV.C_CTL_RIT, subcmd: IcomCivSpec_1.CIV.S_XIT },
+    TUNER: { command: IcomCivSpec_1.CIV.C_CTL_PTT, subcmd: IcomCivSpec_1.CIV.S_ANT_TUN },
+    APF: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_APF },
+    AFC: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_AFC },
+    VSC: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_VSC },
+    DUAL_WATCH: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_MEM_DUALMODE },
+    SATMODE: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_MEM_SATMODE },
+    SCOPE: { command: IcomCivSpec_1.CIV.C_CTL_SCP, subcmd: IcomCivSpec_1.CIV.S_SCP_STS },
+    SPECTRUM: { command: IcomCivSpec_1.CIV.C_CTL_SCP, subcmd: IcomCivSpec_1.CIV.S_SCP_DOP },
+    SPECTRUM_HOLD: { command: IcomCivSpec_1.CIV.C_CTL_SCP, subcmd: IcomCivSpec_1.CIV.S_SCP_HLD, payloadPrefix: [0], readPrefix: [0] },
+    OVF_STATUS: { command: IcomCivSpec_1.CIV.C_RD_SQSM, subcmd: IcomCivSpec_1.CIV.S_OVF },
+    DIGI_SEL: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_DIGISEL },
+    IPP: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_IPP },
+    TX_INHIBIT: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_TX_INHIBIT },
+    DPP: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_DPP },
+};
+function keySpeedWpmToRaw(wpm) {
+    const target = Math.max(6, Math.min(48, Math.round(wpm)));
+    return CW_LOOKUP.find(([, speed]) => speed === target)?.[0] ?? CW_LOOKUP[0][0];
+}
+function keySpeedRawToWpm(raw) {
+    return CW_LOOKUP.find(([rigValue]) => rigValue >= raw)?.[1] ?? 48;
+}
+const LEVEL_SPECS = {
+    AF: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_AF, dataBytes: 2, dataType: 'level' },
+    RF: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_RF, dataBytes: 2, dataType: 'level' },
+    SQL: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_SQL, dataBytes: 2, dataType: 'level' },
+    IF: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_IF, dataBytes: 2, dataType: 'level' },
+    APF: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_APF, dataBytes: 2, dataType: 'level' },
+    NR: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_NR, dataBytes: 2, dataType: 'level' },
+    NB: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_NB, dataBytes: 2, dataType: 'level' },
+    PBT_IN: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_PBTIN, dataBytes: 2, dataType: 'level' },
+    PBT_OUT: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_PBTOUT, dataBytes: 2, dataType: 'level' },
+    CWPITCH: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_CWPITCH, dataBytes: 2, dataType: 'int', publicToRaw: (hz) => Math.round((Math.max(300, Math.min(900, hz)) - 300) * 255 / 600), rawToPublic: (raw) => Math.round(300 + raw * 600 / 255) },
+    RFPOWER: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_RFPOWER, dataBytes: 2, dataType: 'level' },
+    MICGAIN: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_MICGAIN, dataBytes: 2, dataType: 'level' },
+    KEYSPD: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_KEYSPD, dataBytes: 2, dataType: 'int', publicToRaw: keySpeedWpmToRaw, rawToPublic: keySpeedRawToWpm },
+    NOTCHF_RAW: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_NOTCHF, dataBytes: 2, dataType: 'level' },
+    COMP: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_COMP, dataBytes: 2, dataType: 'level' },
+    BKINDL: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_BKINDL, dataBytes: 2, dataType: 'level' },
+    BALANCE: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_BALANCE, dataBytes: 2, dataType: 'level' },
+    VOXGAIN: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_VOXGAIN, dataBytes: 2, dataType: 'level' },
+    ANTIVOX: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_ANTIVOX, dataBytes: 2, dataType: 'level' },
+    MONITOR_GAIN: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_MON, dataBytes: 2, dataType: 'level' },
+    DRIVE_GAIN: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_DRIVE, dataBytes: 2, dataType: 'level' },
+    DIGI_SEL_LEVEL: { command: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd: IcomCivSpec_1.CIV.S_LVL_DIGI, dataBytes: 2, dataType: 'level' },
+    AGC: { command: IcomCivSpec_1.CIV.C_CTL_FUNC, subcmd: IcomCivSpec_1.CIV.S_FUNC_AGC, dataBytes: 1, dataType: 'int' },
+    AGC_TIME: { command: IcomCivSpec_1.CIV.C_CTL_MEM, subcmd: 0x04, dataBytes: 1, dataType: 'int' },
+};
+const CW_LOOKUP = [
+    [0, 6], [7, 7], [12, 8], [19, 9], [25, 10], [31, 11], [37, 12], [43, 13],
+    [49, 14], [55, 15], [61, 16], [67, 17], [73, 18], [79, 19], [84, 20],
+    [91, 21], [97, 22], [103, 23], [108, 24], [114, 25], [121, 26], [128, 27],
+    [134, 28], [140, 29], [144, 30], [151, 31], [156, 32], [164, 33],
+    [169, 34], [175, 35], [182, 36], [188, 37], [192, 38], [199, 39],
+    [203, 40], [211, 41], [215, 42], [224, 43], [229, 44], [234, 45],
+    [239, 46], [244, 47], [250, 48],
+];
 class IcomControl {
     constructor(options) {
         this.ev = new events_1.EventEmitter();
@@ -78,6 +150,8 @@ class IcomControl {
         this.civAssembleBuf = Buffer.alloc(0); // CIV stream reassembler
         this.activeProfile = (0, IcomProfiles_1.getProfileByModel)('generic-modern-icom');
         this.lastFilter = 1;
+        this.cwQueue = Promise.resolve();
+        this.cwGeneration = 0;
         // Connection state machine (replaces old fragmented state flags)
         this.connectionSession = {
             phase: types_1.ConnectionPhase.IDLE,
@@ -1393,6 +1467,666 @@ class IcomControl {
             amps: (0, IcomProfiles_1.interpolateCalibration)(raw, this.activeProfile.calibrations.current)
         };
     }
+    async getFunction(name, options) {
+        if (!this.activeProfile.functions.includes(name))
+            return null;
+        const ext = this.activeProfile.extParamSpecs[name];
+        if (ext) {
+            const value = await this.readExtParamValue(ext, `func-ext:${name}`, options);
+            return value === null ? null : value !== 0;
+        }
+        const spec = FUNCTION_SPECS[name];
+        if (!spec)
+            return null;
+        const raw = await this.readFunctionRaw(name, spec, options);
+        if (raw === null)
+            return null;
+        if (name === 'SBKIN')
+            return raw === 1;
+        if (name === 'FBKIN')
+            return raw === 2;
+        return raw !== 0;
+    }
+    setFunction(name, enabled) {
+        if (!this.activeProfile.functions.includes(name)) {
+            throw this.unsupported(name, 'setFunction', 'Function is not enabled for active profile');
+        }
+        const ext = this.activeProfile.extParamSpecs[name];
+        if (ext) {
+            this.writeExtParamValue(ext, enabled ? 1 : 0);
+            return;
+        }
+        const spec = FUNCTION_SPECS[name];
+        if (!spec || name === 'OVF_STATUS') {
+            throw this.unsupported(name, 'setFunction', 'Function is read-only or has no CI-V writer');
+        }
+        let value = enabled ? 1 : 0;
+        if (name === 'SBKIN')
+            value = enabled ? 1 : 0;
+        if (name === 'FBKIN')
+            value = enabled ? 2 : 0;
+        this.writeFunctionRaw(spec, value);
+    }
+    async getLevel(name, options) {
+        if (!this.activeProfile.levels.includes(name))
+            return null;
+        const ext = this.activeProfile.extParamSpecs[name];
+        if (ext) {
+            return this.readExtParamValue(ext, `level-ext:${name}`, options);
+        }
+        const spec = LEVEL_SPECS[name];
+        if (!spec)
+            return null;
+        const raw = await this.readLevelRaw(name, spec, options);
+        if (raw === null)
+            return null;
+        return spec.rawToPublic ? spec.rawToPublic(raw) : spec.dataType === 'level' ? raw / 255 : raw;
+    }
+    setLevel(name, value) {
+        if (!this.activeProfile.levels.includes(name)) {
+            throw this.unsupported(name, 'setLevel', 'Level is not enabled for active profile');
+        }
+        const ext = this.activeProfile.extParamSpecs[name];
+        if (ext) {
+            this.writeExtParamValue(ext, value);
+            return;
+        }
+        const spec = LEVEL_SPECS[name];
+        if (!spec) {
+            throw this.unsupported(name, 'setLevel', 'No level command mapping');
+        }
+        const raw = spec.publicToRaw
+            ? spec.publicToRaw(value)
+            : spec.dataType === 'level'
+                ? Math.round(Math.max(0, Math.min(1, value)) * 255)
+                : Math.round(value);
+        this.writeLevelRaw(spec, raw);
+    }
+    async getParameter(name, options) {
+        if (!this.activeProfile.parameters.includes(name))
+            return null;
+        const ext = this.activeProfile.extParamSpecs[name];
+        if (!ext)
+            return null;
+        const value = await this.readExtParamValue(ext, `parm:${name}`, options);
+        if (value === null)
+            return null;
+        return ext.dataType === 'bool' ? value !== 0 : value;
+    }
+    setParameter(name, value) {
+        if (!this.activeProfile.parameters.includes(name)) {
+            throw this.unsupported(name, 'setParameter', 'Parameter is not enabled for active profile');
+        }
+        const ext = this.activeProfile.extParamSpecs[name];
+        if (!ext) {
+            throw this.unsupported(name, 'setParameter', 'No parameter command mapping');
+        }
+        this.writeExtParamValue(ext, typeof value === 'boolean' ? (value ? 1 : 0) : value);
+    }
+    async getNoiseBlankerEnabled(options) { return this.getFunction('NB', options); }
+    setNoiseBlankerEnabled(enabled) { this.setFunction('NB', enabled); }
+    async getNoiseReductionEnabled(options) { return this.getFunction('NR', options); }
+    setNoiseReductionEnabled(enabled) { this.setFunction('NR', enabled); }
+    async getCompressorEnabled(options) { return this.getFunction('COMP', options); }
+    setCompressorEnabled(enabled) { this.setFunction('COMP', enabled); }
+    async getVoxEnabled(options) { return this.getFunction('VOX', options); }
+    setVoxEnabled(enabled) { this.setFunction('VOX', enabled); }
+    async getMonitorEnabled(options) { return this.getFunction('MON', options); }
+    setMonitorEnabled(enabled) { this.setFunction('MON', enabled); }
+    async getAutoNotchEnabled(options) { return this.getFunction('ANF', options); }
+    setAutoNotchEnabled(enabled) { this.setFunction('ANF', enabled); }
+    async getManualNotchEnabled(options) { return this.getFunction('MN', options); }
+    setManualNotchEnabled(enabled) { this.setFunction('MN', enabled); }
+    async getDialLockEnabled(options) { return this.getFunction('LOCK', options); }
+    setDialLockEnabled(enabled) { this.setFunction('LOCK', enabled); }
+    async getBreakInMode(options) {
+        const spec = FUNCTION_SPECS.SBKIN;
+        if (!spec || !this.activeProfile.functions.includes('SBKIN'))
+            return null;
+        const raw = await this.readFunctionRaw('SBKIN', spec, options);
+        if (raw === null)
+            return null;
+        return raw === 1 ? 'semi' : raw === 2 ? 'full' : 'off';
+    }
+    setBreakInMode(mode) {
+        const spec = FUNCTION_SPECS.SBKIN;
+        if (!spec || !this.activeProfile.functions.includes('SBKIN')) {
+            throw this.unsupported('SBKIN', 'setBreakInMode', 'Break-in function is not enabled for active profile');
+        }
+        this.writeFunctionRaw(spec, mode === 'semi' ? 1 : mode === 'full' ? 2 : 0);
+    }
+    async getRFGain(options) { return this.getLevel('RF', options); }
+    setRFGain(value) { this.setLevel('RF', value); }
+    async getIFShift(options) { return this.getLevel('IF', options); }
+    setIFShift(value) { this.setLevel('IF', value); }
+    async getPbtIn(options) { return this.getLevel('PBT_IN', options); }
+    setPbtIn(value) { this.setLevel('PBT_IN', value); }
+    async getPbtOut(options) { return this.getLevel('PBT_OUT', options); }
+    setPbtOut(value) { this.setLevel('PBT_OUT', value); }
+    async getCwPitch(options) { return this.getLevel('CWPITCH', options); }
+    setCwPitch(hz) { this.setLevel('CWPITCH', hz); }
+    async getKeySpeed(options) { return this.getLevel('KEYSPD', options); }
+    setKeySpeed(wpm) { this.setLevel('KEYSPD', wpm); }
+    async sendMorse(text, options = {}) {
+        const normalized = IcomControl.normalizeMorseText(text);
+        if (normalized.length === 0)
+            return;
+        const generation = this.cwGeneration;
+        return this.enqueueCw(async () => {
+            if (generation !== this.cwGeneration)
+                return;
+            if (!this.activeProfile.cw.sendMorse) {
+                throw this.unsupported('SEND_MORSE', 'sendMorse', 'CW text sending is not enabled for active profile');
+            }
+            const timeoutMs = options.timeout ?? 3000;
+            if (options.checkMode !== false) {
+                const mode = await this.readOperatingMode({ timeout: timeoutMs });
+                if (!mode || (mode.mode !== IcomConstants_1.MODE_MAP.CW && mode.mode !== IcomConstants_1.MODE_MAP.CW_R)) {
+                    throw new Error(`CW 0x17 sendMorse requires CW/CW_R mode; current mode is ${mode?.modeName ?? mode?.mode ?? 'unknown'}`);
+                }
+            }
+            const profileMax = Math.max(1, Math.min(30, this.activeProfile.cw.maxChunkLength || 30));
+            const requested = Number.isFinite(options.chunkLength) ? Math.floor(options.chunkLength) : profileMax;
+            const chunkLength = Math.max(1, Math.min(30, profileMax, requested));
+            const interChunkDelayMs = Number.isFinite(options.interChunkDelayMs)
+                ? Math.max(0, Math.floor(options.interChunkDelayMs))
+                : 0;
+            const bytes = Buffer.from(normalized, 'ascii');
+            const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+            const rigAddr = this.civ.civAddress & 0xff;
+            for (let offset = 0, chunkIndex = 1; offset < bytes.length; offset += chunkLength, chunkIndex++) {
+                if (generation !== this.cwGeneration)
+                    return;
+                const chunk = bytes.subarray(offset, Math.min(offset + chunkLength, bytes.length));
+                const frame = IcomRigCommands_1.IcomRigCommands.sendMorseText(ctrAddr, rigAddr, chunk);
+                await this.sendCwFrameAndWaitForAck(frame, timeoutMs, `chunk ${chunkIndex}`);
+                if (generation !== this.cwGeneration)
+                    return;
+                if (interChunkDelayMs > 0 && offset + chunkLength < bytes.length) {
+                    await new Promise((resolve) => setTimeout(resolve, interChunkDelayMs));
+                }
+            }
+        });
+    }
+    sendCwText(text, options) {
+        return this.sendMorse(text, options);
+    }
+    async stopMorse(options = {}) {
+        this.cwGeneration += 1;
+        return this.enqueueCw(async () => {
+            if (!this.activeProfile.cw.sendMorse) {
+                throw this.unsupported('SEND_MORSE', 'stopMorse', 'CW text sending is not enabled for active profile');
+            }
+            const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+            const rigAddr = this.civ.civAddress & 0xff;
+            await this.sendCwFrameAndWaitForAck(IcomRigCommands_1.IcomRigCommands.stopMorse(ctrAddr, rigAddr), options.timeout ?? 3000, 'stop');
+        });
+    }
+    async getNotchRaw(options) { return this.getLevel('NOTCHF_RAW', options); }
+    setNotchRaw(value) { this.setLevel('NOTCHF_RAW', value); }
+    async getCompressionLevel(options) { return this.getLevel('COMP', options); }
+    setCompressionLevel(value) { this.setLevel('COMP', value); }
+    async getMonitorGain(options) { return this.getLevel('MONITOR_GAIN', options); }
+    setMonitorGain(value) { this.setLevel('MONITOR_GAIN', value); }
+    async getVoxGain(options) { return this.getLevel('VOXGAIN', options); }
+    setVoxGain(value) { this.setLevel('VOXGAIN', value); }
+    async getAntiVox(options) { return this.getLevel('ANTIVOX', options); }
+    setAntiVox(value) { this.setLevel('ANTIVOX', value); }
+    async getRitOffset(options) { return this.readRitOffset(options); }
+    setRitOffset(offsetHz) { this.writeRitOffset(offsetHz); }
+    async getXitOffset(options) { return this.readRitOffset(options); }
+    setXitOffset(offsetHz) { this.writeRitOffset(offsetHz); }
+    async getRitEnabled(options) { return this.getFunction('RIT', options); }
+    setRitEnabled(enabled) { this.setFunction('RIT', enabled); }
+    async getXitEnabled(options) { return this.getFunction('XIT', options); }
+    setXitEnabled(enabled) { this.setFunction('XIT', enabled); }
+    async getVfo(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_SET_VFO, IcomCivSpec_1.CIV.S_BAND_SEL);
+        const resp = await this.waitForCivFrame('vfo:0x07:0xd2', (frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_SET_VFO, [IcomCivSpec_1.CIV.S_BAND_SEL], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 8)
+            return null;
+        return resp[6] === 0 ? 'MAIN' : 'SUB';
+    }
+    setVfo(vfo) {
+        const subcmd = this.vfoToSubcmd(vfo);
+        if (subcmd === null) {
+            throw this.unsupported(vfo, 'setVfo', 'VFO cannot be directly selected');
+        }
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.writeCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_SET_VFO, subcmd));
+    }
+    vfoOperation(op) {
+        if (!this.activeProfile.vfoOps.includes(op)) {
+            throw this.unsupported(op, 'vfoOperation', 'VFO operation is not enabled for active profile');
+        }
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        switch (op) {
+            case 'copy':
+                this.sendCiv(IcomRigCommands_1.IcomRigCommands.writeCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_SET_VFO, IcomCivSpec_1.CIV.S_BTOA));
+                return;
+            case 'exchange':
+                this.sendCiv(IcomRigCommands_1.IcomRigCommands.writeCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_SET_VFO, IcomCivSpec_1.CIV.S_XCHNG));
+                return;
+            case 'from-vfo':
+                this.sendCiv(IcomRigCommands_1.IcomRigCommands.writeCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_WR_MEM, undefined));
+                return;
+            case 'to-vfo':
+                this.sendCiv(IcomRigCommands_1.IcomRigCommands.writeCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_MEM2VFO, undefined));
+                return;
+            case 'memory-clear':
+                this.sendCiv(IcomRigCommands_1.IcomRigCommands.writeCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_CLR_MEM, undefined));
+                return;
+            case 'tune':
+                this.sendCiv(IcomRigCommands_1.IcomRigCommands.startManualTune(ctrAddr, rigAddr));
+                return;
+        }
+    }
+    async getSplitEnabled(options) {
+        const raw = await this.readSplitRaw(options);
+        if (raw === null)
+            return null;
+        return raw === IcomCivSpec_1.CIV.S_SPLT_ON;
+    }
+    setSplitEnabled(enabled) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setSplit(ctrAddr, rigAddr, enabled));
+    }
+    async getSplitFrequency(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readSelectedFrequency(ctrAddr, rigAddr, 1);
+        const resp = await this.waitForCivFrame('freq:0x25:1', (frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_SEND_SEL_FREQ, [0x01], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        return resp ? IcomControl.parseFrequencyReply(resp, 1) : null;
+    }
+    setSplitFrequency(hz) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setSelectedFrequency(ctrAddr, rigAddr, hz, this.activeProfile.frequencyBcdBytes(hz), 1));
+    }
+    async getSplitMode(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readSelectedMode(ctrAddr, rigAddr, 1);
+        const resp = await this.waitForCivFrame('mode:0x26:1', (frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_SEND_SEL_MODE, [0x01], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 10)
+            return null;
+        const { getModeString, getFilterString } = await Promise.resolve().then(() => __importStar(require('./IcomConstants')));
+        const mode = resp[6];
+        const dataMode = resp[7] !== 0x00;
+        const filter = resp[8];
+        return { mode, filter, dataMode, modeName: getModeString(mode), filterName: getFilterString(filter) };
+    }
+    setSplitMode(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;
+        const filter = options?.filter ?? this.lastFilter ?? this.activeProfile.defaultFilter;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setSelectedMode(ctrAddr, rigAddr, modeCode, !!options?.dataMode, filter, 1));
+    }
+    async getTuningStep(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readTuningStep(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame('ts:0x10', (frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_SET_TS, [], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 7)
+            return null;
+        return this.activeProfile.tuningSteps.find((step) => step.code === resp[5])?.hz ?? null;
+    }
+    setTuningStep(hz) {
+        const matched = this.activeProfile.tuningSteps.find((step) => step.hz === hz);
+        if (!matched) {
+            throw this.unsupported(String(hz), 'setTuningStep', 'Tuning step is not enabled for active profile');
+        }
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setTuningStep(ctrAddr, rigAddr, matched.code));
+    }
+    async getRepeaterShift(options) {
+        const raw = await this.readSplitRaw(options);
+        if (raw === null)
+            return null;
+        if (raw === IcomCivSpec_1.CIV.S_DUP_M)
+            return 'minus';
+        if (raw === IcomCivSpec_1.CIV.S_DUP_P)
+            return 'plus';
+        return 'none';
+    }
+    setRepeaterShift(shift) {
+        if (!this.activeProfile.repeater) {
+            throw this.unsupported(shift, 'setRepeaterShift', 'Repeater controls are not enabled for active profile');
+        }
+        const code = shift === 'minus' ? IcomCivSpec_1.CIV.S_DUP_M : shift === 'plus' ? IcomCivSpec_1.CIV.S_DUP_P : IcomCivSpec_1.CIV.S_DUP_OFF;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setRepeaterShift(ctrAddr, rigAddr, code));
+    }
+    async getRepeaterOffset(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_RD_OFFS);
+        const resp = await this.waitForCivFrame('rptr:offset', (frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_RD_OFFS, [], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 9)
+            return null;
+        return (0, IcomCivFrame_1.decodeFrequencyBcdLE)(resp.subarray(5, 8)) * 100;
+    }
+    setRepeaterOffset(offsetHz) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.writeCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_SET_OFFS, undefined, (0, IcomCivFrame_1.encodeFrequencyBcdLE)(Math.round(offsetHz / 100), 3)));
+    }
+    async getToneFrequency(options) { return this.readTone(IcomCivSpec_1.CIV.S_TONE_RPTR, options); }
+    setToneFrequency(hz) { this.writeTone(IcomCivSpec_1.CIV.S_TONE_RPTR, hz); }
+    async getToneSquelchFrequency(options) { return this.readTone(IcomCivSpec_1.CIV.S_TONE_SQL, options); }
+    setToneSquelchFrequency(hz) { this.writeTone(IcomCivSpec_1.CIV.S_TONE_SQL, hz); }
+    async getBeepEnabled(options) { return this.getParameter('BEEP', options); }
+    setBeepEnabled(enabled) { this.setParameter('BEEP', enabled); }
+    async getBacklight(options) { return this.getParameter('BACKLIGHT', options); }
+    setBacklight(value) { this.setParameter('BACKLIGHT', value); }
+    async getScreenSaver(options) { return this.getParameter('SCREENSAVER', options); }
+    setScreenSaver(value) { this.setParameter('SCREENSAVER', value); }
+    async getKeyerType(options) { return this.getParameter('KEYERTYPE', options); }
+    setKeyerType(value) { this.setParameter('KEYERTYPE', value); }
+    async getAudioIfMode(options) {
+        for (const source of ['wlan', 'lan', 'acc']) {
+            const parm = this.audioIfSourceToParameter(source);
+            if (parm && this.activeProfile.parameters.includes(parm)) {
+                const enabled = await this.getParameter(parm, options);
+                if (enabled === true)
+                    return source;
+            }
+        }
+        return this.activeProfile.audioIfSources.includes('default') ? 'default' : null;
+    }
+    setAudioIfMode(source) {
+        if (!this.activeProfile.audioIfSources.includes(source)) {
+            throw this.unsupported(source, 'setAudioIfMode', 'Audio IF source is not enabled for active profile');
+        }
+        for (const candidate of ['wlan', 'lan', 'acc']) {
+            const parm = this.audioIfSourceToParameter(candidate);
+            if (parm && this.activeProfile.parameters.includes(parm)) {
+                this.setParameter(parm, source === candidate);
+            }
+        }
+        if (this.activeProfile.parameters.includes('AFIF')) {
+            this.setParameter('AFIF', source !== 'default');
+        }
+    }
+    async getSpectrumDataOutput(options) {
+        return this.getScopeBoolean(IcomCivSpec_1.CIV.S_SCP_DOP, [], 'spectrum:data-output', options);
+    }
+    setSpectrumDataOutput(enabled) { this.writeScopeSimple(IcomCivSpec_1.CIV.S_SCP_DOP, [enabled ? 1 : 0]); }
+    async getSpectrumHold(options) {
+        const receiver = options?.receiver ?? 0;
+        return this.getScopeBoolean(IcomCivSpec_1.CIV.S_SCP_HLD, [receiver], `spectrum:hold:${receiver}`, options);
+    }
+    setSpectrumHold(enabled, options) {
+        const receiver = options?.receiver ?? 0;
+        this.writeScopeSimple(IcomCivSpec_1.CIV.S_SCP_HLD, [receiver, enabled ? 1 : 0]);
+    }
+    async getSpectrumSpeed(options) {
+        const receiver = options?.receiver ?? 0;
+        const raw = await this.getScopeByte(IcomCivSpec_1.CIV.S_SCP_SWP, [receiver], `spectrum:speed:${receiver}`, options);
+        if (raw === null)
+            return null;
+        return raw === 0 ? 'fast' : raw === 1 ? 'mid' : 'slow';
+    }
+    setSpectrumSpeed(speed, options) {
+        const receiver = options?.receiver ?? 0;
+        const raw = speed === 'fast' ? 0 : speed === 'mid' ? 1 : 2;
+        this.writeScopeSimple(IcomCivSpec_1.CIV.S_SCP_SWP, [receiver, raw]);
+    }
+    async getSpectrumRef(options) {
+        const receiver = options?.receiver ?? 0;
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_CTL_SCP, IcomCivSpec_1.CIV.S_SCP_REF, [receiver]);
+        const resp = await this.waitForCivFrame(`spectrum:ref:${receiver}`, (frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_CTL_SCP, [IcomCivSpec_1.CIV.S_SCP_REF, receiver], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 10)
+            return null;
+        const value = (0, IcomCivFrame_1.decodeBcdBE)(resp.subarray(7, 9)) / 100;
+        return resp[9] ? -value : value;
+    }
+    setSpectrumRef(db, options) {
+        const receiver = options?.receiver ?? 0;
+        const rounded = Math.round(db * 2) / 2;
+        this.writeScopeSimple(IcomCivSpec_1.CIV.S_SCP_REF, [receiver, ...(0, IcomCivFrame_1.encodeBcdBE)(Math.abs(Math.round(rounded * 100)), 2), rounded < 0 ? 1 : 0]);
+    }
+    async getSpectrumAverage(options) { return this.getLevel('SPECTRUM_AVG', options); }
+    setSpectrumAverage(value) { this.setLevel('SPECTRUM_AVG', value); }
+    async getSpectrumVbw(options) {
+        const receiver = options?.receiver ?? 0;
+        return this.getScopeByte(IcomCivSpec_1.CIV.S_SCP_VBW, [receiver], `spectrum:vbw:${receiver}`, options);
+    }
+    setSpectrumVbw(value, options) {
+        const receiver = options?.receiver ?? 0;
+        this.writeScopeSimple(IcomCivSpec_1.CIV.S_SCP_VBW, [receiver, Math.max(0, Math.min(1, Math.trunc(value)))]);
+    }
+    async getSpectrumRbw(options) {
+        const receiver = options?.receiver ?? 0;
+        return this.getScopeByte(IcomCivSpec_1.CIV.S_SCP_RBW, [receiver], `spectrum:rbw:${receiver}`, options);
+    }
+    setSpectrumRbw(value, options) {
+        const receiver = options?.receiver ?? 0;
+        this.writeScopeSimple(IcomCivSpec_1.CIV.S_SCP_RBW, [receiver, Math.max(0, Math.min(2, Math.trunc(value)))]);
+    }
+    async getSpectrumDuringTx(options) {
+        return this.getScopeBoolean(IcomCivSpec_1.CIV.S_SCP_STX, [], 'spectrum:during-tx', options);
+    }
+    setSpectrumDuringTx(enabled) { this.writeScopeSimple(IcomCivSpec_1.CIV.S_SCP_STX, [enabled ? 1 : 0]); }
+    async getSpectrumCenterType(options) {
+        const raw = await this.getScopeByte(IcomCivSpec_1.CIV.S_SCP_CFQ, [], 'spectrum:center-type', options);
+        if (raw === null)
+            return null;
+        return raw === 1 ? 'carrier-point-center' : raw === 2 ? 'carrier-point-center-abs' : 'filter-center';
+    }
+    setSpectrumCenterType(type) {
+        const raw = type === 'carrier-point-center' ? 1 : type === 'carrier-point-center-abs' ? 2 : 0;
+        this.writeScopeSimple(IcomCivSpec_1.CIV.S_SCP_CFQ, [raw]);
+    }
+    unsupported(commandName, api, reason) {
+        return new errors_1.UnsupportedCommandError({
+            modelId: this.getProfileModelId(),
+            commandName: api,
+            civCommand: commandName,
+            reason,
+        });
+    }
+    enqueueCw(operation) {
+        const run = this.cwQueue.then(operation, operation);
+        this.cwQueue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async sendCwFrameAndWaitForAck(frame, timeoutMs, label) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const resp = await this.waitForCivFrame('cw:ack:0x17', (candidate) => IcomControl.matchAckNakFrame(candidate, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(frame));
+        if (!resp) {
+            throw new Error(`CW 0x17 ${label} ACK timeout`);
+        }
+        if (resp[4] === IcomCivSpec_1.CIV.NAK) {
+            throw new Error(`CW 0x17 ${label} NAK received`);
+        }
+    }
+    async readFunctionRaw(name, spec, options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const prefix = spec.readPrefix ?? [];
+        const req = IcomRigCommands_1.IcomRigCommands.readCommand(ctrAddr, rigAddr, spec.command, spec.subcmd, prefix);
+        const tail = [spec.subcmd, ...prefix];
+        const resp = await this.waitForCivFrame(`func:0x${spec.command.toString(16)}:0x${spec.subcmd.toString(16)}:${prefix.join('.')}:${name}`, (frame) => IcomControl.matchCommandFrame(frame, spec.command, tail, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp)
+            return null;
+        const index = 5 + tail.length;
+        return index < resp.length - 1 ? resp[index] : null;
+    }
+    writeFunctionRaw(spec, value) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const payload = [...(spec.payloadPrefix ?? []), value & 0xff];
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.writeCommand(ctrAddr, rigAddr, spec.command, spec.subcmd, payload));
+    }
+    async readLevelRaw(name, spec, options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readCommand(ctrAddr, rigAddr, spec.command, spec.subcmd);
+        const resp = await this.waitForCivFrame(`level:0x${spec.command.toString(16)}:0x${spec.subcmd.toString(16)}:${name}`, (frame) => IcomControl.matchCommandFrame(frame, spec.command, [spec.subcmd], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp)
+            return null;
+        const data = resp.subarray(6, resp.length - 1);
+        if (data.length < spec.dataBytes)
+            return null;
+        return (0, IcomCivFrame_1.decodeBcdBE)(data.subarray(0, spec.dataBytes));
+    }
+    writeLevelRaw(spec, raw) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.writeCommand(ctrAddr, rigAddr, spec.command, spec.subcmd, IcomControl.encodeDataValue(raw, spec.dataType, spec.dataBytes)));
+    }
+    async readExtParamValue(ext, keyPrefix, options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readExtParam(ctrAddr, rigAddr, ext.command, ext.subcmd, ext.subext);
+        const tail = [ext.subcmd, ...ext.subext];
+        const resp = await this.waitForCivFrame(`${keyPrefix}:0x${ext.command.toString(16)}:0x${ext.subcmd.toString(16)}:${ext.subext.join('.')}`, (frame) => IcomControl.matchCommandFrame(frame, ext.command, tail, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp)
+            return null;
+        const start = 5 + tail.length;
+        return IcomControl.decodeDataValue(resp.subarray(start, resp.length - 1), ext.dataType, ext.dataBytes);
+    }
+    writeExtParamValue(ext, value) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const raw = ext.dataType === 'level' ? Math.round(Math.max(0, Math.min(1, value)) * 255) : Math.round(value);
+        const payload = IcomControl.encodeDataValue(raw, ext.dataType, ext.dataBytes);
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.writeExtParam(ctrAddr, rigAddr, ext.command, ext.subcmd, ext.subext, payload));
+    }
+    static encodeDataValue(value, dataType, bytes) {
+        if (dataType === 'time') {
+            const seconds = Math.max(0, Math.round(value));
+            const hhmm = Math.floor(seconds / 3600) * 100 + Math.floor(seconds / 60) % 60;
+            return (0, IcomCivFrame_1.encodeBcdBE)(hhmm, bytes);
+        }
+        return (0, IcomCivFrame_1.encodeBcdBE)(value, bytes);
+    }
+    static decodeDataValue(data, dataType, bytes) {
+        if (data.length < bytes)
+            return null;
+        const value = (0, IcomCivFrame_1.decodeBcdBE)(data.subarray(0, bytes));
+        if (dataType === 'level')
+            return value / 255;
+        if (dataType === 'bool')
+            return value === 0 ? 0 : 1;
+        if (dataType === 'time') {
+            const hours = Math.floor(value / 100);
+            const minutes = value % 100;
+            return hours * 3600 + minutes * 60;
+        }
+        return value;
+    }
+    async readRitOffset(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readRitOffset(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame('rit:offset', (frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_CTL_RIT, [IcomCivSpec_1.CIV.S_RIT_FREQ], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 9)
+            return null;
+        const value = (0, IcomCivFrame_1.decodeFrequencyBcdLE)(resp.subarray(6, 8));
+        return resp[8] === 0 ? value : -value;
+    }
+    writeRitOffset(offsetHz) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const payload = [...(0, IcomCivFrame_1.encodeFrequencyBcdLE)(Math.abs(Math.round(offsetHz)), 2), offsetHz < 0 ? 1 : 0];
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setRitOffset(ctrAddr, rigAddr, payload));
+    }
+    vfoToSubcmd(vfo) {
+        switch (vfo) {
+            case 'A': return IcomCivSpec_1.CIV.S_VFOA;
+            case 'B': return IcomCivSpec_1.CIV.S_VFOB;
+            case 'MAIN':
+            case 'MAIN_A':
+            case 'MAIN_B': return IcomCivSpec_1.CIV.S_MAIN;
+            case 'SUB':
+            case 'SUB_A':
+            case 'SUB_B': return IcomCivSpec_1.CIV.S_SUB;
+            case 'CURR':
+            case 'TX': return null;
+            case 'MEM': return null;
+        }
+    }
+    async readSplitRaw(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readSplit(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame('split:0x0f', (frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_CTL_SPLT, [], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 7)
+            return null;
+        return resp[5];
+    }
+    async readTone(subcmd, options) {
+        if (!this.activeProfile.tone)
+            return null;
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readTone(ctrAddr, rigAddr, subcmd);
+        const resp = await this.waitForCivFrame(`tone:0x${subcmd.toString(16)}`, (frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_SET_TONE, [subcmd], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 10)
+            return null;
+        return (0, IcomCivFrame_1.decodeBcdBE)(resp.subarray(6, 9)) / 10;
+    }
+    writeTone(subcmd, hz) {
+        if (!this.activeProfile.tone) {
+            throw this.unsupported(String(subcmd), 'setToneFrequency', 'Tone controls are not enabled for active profile');
+        }
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setTone(ctrAddr, rigAddr, subcmd, Math.round(hz * 10)));
+    }
+    audioIfSourceToParameter(source) {
+        switch (source) {
+            case 'wlan': return 'AFIF_WLAN';
+            case 'lan': return 'AFIF_LAN';
+            case 'acc': return 'AFIF_ACC';
+            case 'default': return 'AFIF';
+        }
+    }
+    async getScopeBoolean(subcmd, payload, key, options) {
+        const raw = await this.getScopeByte(subcmd, payload, key, options);
+        return raw === null ? null : raw !== 0;
+    }
+    async getScopeByte(subcmd, payload, key, options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.readCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_CTL_SCP, subcmd, payload);
+        const resp = await this.waitForCivFrame(key, (frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_CTL_SCP, [subcmd, ...payload], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp)
+            return null;
+        const index = 5 + 1 + payload.length;
+        return index < resp.length - 1 ? resp[index] : null;
+    }
+    writeScopeSimple(subcmd, payload) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.writeCommand(ctrAddr, rigAddr, IcomCivSpec_1.CIV.C_CTL_SCP, subcmd, payload));
+    }
     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);
@@ -1463,6 +2197,29 @@ class IcomControl {
             return false;
         return true;
     }
+    static matchAckNakFrame(frame, ctrAddr, rigAddr) {
+        if (!(frame.length >= 6 && frame[0] === IcomCivSpec_1.CIV.PR && frame[1] === IcomCivSpec_1.CIV.PR))
+            return false;
+        const addrCtrOk = frame[2] === (ctrAddr & 0xff) || frame[2] === 0x00;
+        if (!addrCtrOk || frame[3] !== (rigAddr & 0xff))
+            return false;
+        if (frame[4] !== IcomCivSpec_1.CIV.ACK && frame[4] !== IcomCivSpec_1.CIV.NAK)
+            return false;
+        return frame[frame.length - 1] === IcomCivSpec_1.CIV.FI;
+    }
+    static normalizeMorseText(text) {
+        if (typeof text !== 'string') {
+            throw new Error('CW 0x17 sendMorse text must be a string');
+        }
+        const normalized = text.toUpperCase().replace(/[\r\n\t]/g, ' ');
+        for (let i = 0; i < normalized.length; i++) {
+            const code = normalized.charCodeAt(i);
+            if (code < 0x20 || code > 0x7e) {
+                throw new Error(`CW 0x17 sendMorse text contains unsupported non-printable or non-ASCII character at index ${i}`);
+            }
+        }
+        return normalized;
+    }
     async waitForCiv(predicate, timeoutMs, onSend) {
         return new Promise((resolve) => {
             let done = false;