icom-wlan-node 0.5.0 → 0.6.0

package/dist/rig/IcomControl.js

@@ -49,12 +49,34 @@ const smeter_1 = require("../utils/smeter");
 const IcomScopeCommands_1 = require("../scope/IcomScopeCommands");
 const IcomScopeParser_1 = require("../scope/IcomScopeParser");
 const IcomScopeService_1 = require("../scope/IcomScopeService");
+const IcomCivFrame_1 = require("./IcomCivFrame");
+const IcomCivSpec_1 = require("./IcomCivSpec");
+const IcomProfiles_1 = require("./IcomProfiles");
+const DEFAULT_SCOPE_SPANS_HZ = [25000000, 10000000, 5000000, 2500000, 1000000, 500000, 250000, 100000, 50000, 25000, 10000, 5000, 2500];
+function modeCodeToName(mode) {
+    switch (mode) {
+        case 0: return 'center';
+        case 1: return 'fixed';
+        case 2: return 'scroll-center';
+        case 3: return 'scroll-fixed';
+    }
+}
+function modeNameToCode(mode) {
+    switch (mode) {
+        case 'center': return 0;
+        case 'fixed': return 1;
+        case 'scroll-center': return 2;
+        case 'scroll-fixed': return 3;
+    }
+}
 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.activeProfile = (0, IcomProfiles_1.getProfileByModel)('generic-modern-icom');
+        this.lastFilter = 1;
         // Connection state machine (replaces old fragmented state flags)
         this.connectionSession = {
             phase: types_1.ConnectionPhase.IDLE,
@@ -72,7 +94,8 @@ class IcomControl {
             reconnectBaseDelay: 2000,
             reconnectMaxDelay: 30000
         };
-        this.options = options;
+        this.options = { ...options, model: options.model ?? 'auto' };
+        this.activeProfile = (0, IcomProfiles_1.resolveIcomProfile)({ requestedModel: this.options.model });
         // Setup control session
         this.sess = new Session_1.Session({ ip: options.control.ip, port: options.control.port }, {
             onData: (data) => this.onData(data),
@@ -100,6 +123,25 @@ class IcomControl {
         this.scope.on('scopeFrame', (frame) => this.ev.emit('scopeFrame', frame));
     }
     get events() { return this.ev; }
+    get profile() { return this.activeProfile; }
+    resolveActiveProfile(context = {}) {
+        const next = (0, IcomProfiles_1.resolveIcomProfile)({
+            requestedModel: this.options.model,
+            rigName: context.rigName ?? this.rigName,
+            civAddress: context.civAddress ?? this.civ.civAddress,
+        });
+        if (this.options.model && this.options.model !== 'auto' && context.civAddress !== undefined && next.defaultCivAddress !== (context.civAddress & 0xff)) {
+            (0, debug_1.dbg)(`Configured profile ${next.modelId} default CI-V 0x${next.defaultCivAddress.toString(16)} differs from radio CI-V 0x${(context.civAddress & 0xff).toString(16)}`);
+        }
+        if (next.modelId !== this.activeProfile.modelId) {
+            (0, debug_1.dbg)(`ICOM profile selected: ${next.profileName}`);
+        }
+        this.activeProfile = next;
+        this.lastFilter = next.defaultFilter;
+    }
+    getProfileModelId() {
+        return this.activeProfile.modelId;
+    }
     // ============================================================================
     // State Machine Management
     // ============================================================================
@@ -538,10 +580,10 @@ class IcomControl {
         if (!resp || resp.length < 13) {
             return null;
         }
-        const spanHz = (0, IcomScopeParser_1.parseIcomBcdFreqLE)(resp.subarray(7, 12));
+        const encodedSpanHz = (0, IcomScopeParser_1.parseIcomBcdFreqLE)(resp.subarray(7, 12));
         return {
             receiver,
-            spanHz,
+            spanHz: encodedSpanHz * 2,
         };
     }
     async setScopeSpan(spanHz, options) {
@@ -550,6 +592,182 @@ class IcomControl {
         const rigAddr = this.civ.civAddress & 0xff;
         this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeSpan(ctrAddr, rigAddr, spanHz, receiver));
     }
+    async readScopeMode(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const receiver = options?.receiver ?? 0;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomScopeCommands_1.IcomScopeCommands.readScopeMode(ctrAddr, rigAddr, receiver);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x27, [0x14, receiver], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 9) {
+            return null;
+        }
+        const mode = resp[7];
+        return {
+            receiver,
+            mode,
+            modeName: modeCodeToName(mode),
+        };
+    }
+    async setScopeMode(mode, options) {
+        const receiver = options?.receiver ?? 0;
+        const modeCode = typeof mode === 'string' ? modeNameToCode(mode) : mode;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeMode(ctrAddr, rigAddr, modeCode, receiver));
+    }
+    async readScopeEdge(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const receiver = options?.receiver ?? 0;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomScopeCommands_1.IcomScopeCommands.readScopeEdge(ctrAddr, rigAddr, receiver);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x27, [0x16, receiver], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 9) {
+            return null;
+        }
+        return {
+            receiver,
+            edgeSlot: resp[7],
+        };
+    }
+    async setScopeEdge(edgeSlot, options) {
+        const receiver = options?.receiver ?? 0;
+        const slots = this.activeProfile.scopeEdgeSlots;
+        const maxSlot = slots.length ? Math.max(...slots) : 4;
+        const safeEdgeSlot = Math.max(1, Math.min(maxSlot, Math.trunc(edgeSlot)));
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeEdge(ctrAddr, rigAddr, safeEdgeSlot, receiver));
+    }
+    async readScopeFixedEdge(rangeId, edgeSlot, options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomScopeCommands_1.IcomScopeCommands.readScopeFixedEdge(ctrAddr, rigAddr, rangeId, edgeSlot);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x27, [0x1e, rangeId, edgeSlot], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 18) {
+            return null;
+        }
+        return {
+            rangeId,
+            edgeSlot,
+            lowHz: (0, IcomScopeParser_1.parseIcomBcdFreqLE)(resp.subarray(8, 13)),
+            highHz: (0, IcomScopeParser_1.parseIcomBcdFreqLE)(resp.subarray(13, 18)),
+        };
+    }
+    async setScopeFixedEdge(options) {
+        const rangeId = options.rangeId ?? await this.resolveScopeFrequencyRangeId();
+        const edgeInfo = options.edgeSlot
+            ? { edgeSlot: options.edgeSlot }
+            : await this.readScopeEdge({ receiver: 0, timeout: 3000 });
+        const edgeSlot = edgeInfo?.edgeSlot ?? 1;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeFixedEdge(ctrAddr, rigAddr, rangeId, edgeSlot, options.lowHz, options.highHz));
+        return {
+            rangeId,
+            edgeSlot,
+            lowHz: options.lowHz,
+            highHz: options.highHz,
+        };
+    }
+    async resolveScopeFrequencyRangeId(frequencyHz) {
+        const targetFrequency = frequencyHz ?? await this.readOperatingFrequency({ timeout: 3000 });
+        if (!targetFrequency) {
+            throw new Error('Unable to resolve scope frequency range without operating frequency');
+        }
+        const matched = this.activeProfile.scopeRanges.find((range) => targetFrequency >= range.lowHz && targetFrequency < range.highHz);
+        if (!matched) {
+            throw new Error(`No scope frequency range matches ${targetFrequency} Hz`);
+        }
+        return matched.rangeId;
+    }
+    getScopeSupportedEdgeSlots() {
+        return [...this.activeProfile.scopeEdgeSlots];
+    }
+    async getSpectrumDisplayState(options) {
+        const receiver = options?.receiver ?? 0;
+        const [modeInfo, spanInfo, edgeInfo] = await Promise.all([
+            this.readScopeMode({ ...options, receiver }),
+            this.readScopeSpan({ ...options, receiver }),
+            this.readScopeEdge({ ...options, receiver }),
+        ]);
+        let fixedEdgeInfo = null;
+        if (modeInfo?.modeName === 'fixed' || modeInfo?.modeName === 'scroll-fixed') {
+            try {
+                const rangeId = await this.resolveScopeFrequencyRangeId();
+                fixedEdgeInfo = await this.readScopeFixedEdge(rangeId, edgeInfo?.edgeSlot ?? 1, options);
+            }
+            catch (_) {
+                fixedEdgeInfo = null;
+            }
+        }
+        return {
+            mode: modeInfo?.modeName ?? null,
+            modeCode: modeInfo?.mode ?? null,
+            spanHz: spanInfo?.spanHz ?? (fixedEdgeInfo ? fixedEdgeInfo.highHz - fixedEdgeInfo.lowHz : null),
+            edgeSlot: edgeInfo?.edgeSlot ?? null,
+            edgeLowHz: fixedEdgeInfo?.lowHz ?? null,
+            edgeHighHz: fixedEdgeInfo?.highHz ?? null,
+            supportedModes: ['center', 'fixed', 'scroll-center', 'scroll-fixed'],
+            supportedSpans: [...DEFAULT_SCOPE_SPANS_HZ],
+            supportedEdgeSlots: this.getScopeSupportedEdgeSlots(),
+            supportsFixedEdges: this.activeProfile.scopeRanges.length > 0,
+            supportsEdgeSlotSelection: this.activeProfile.scopeEdgeSlots.length > 0,
+        };
+    }
+    async configureSpectrumDisplay(config = {}) {
+        const receiver = config.receiver ?? 0;
+        if (config.mode !== undefined) {
+            await this.setScopeMode(config.mode, { receiver });
+        }
+        if (config.edgeSlot !== undefined) {
+            await this.setScopeEdge(config.edgeSlot, { receiver });
+        }
+        if (config.spanHz !== undefined && (!config.mode || config.mode === 'center' || config.mode === 'scroll-center')) {
+            await this.setScopeSpan(config.spanHz, { receiver });
+        }
+        if (config.edgeLowHz !== undefined && config.edgeHighHz !== undefined && (!config.mode || config.mode === 'fixed' || config.mode === 'scroll-fixed')) {
+            await this.setScopeFixedEdge({
+                rangeId: config.rangeId,
+                edgeSlot: config.edgeSlot,
+                lowHz: config.edgeLowHz,
+                highHz: config.edgeHighHz,
+            });
+        }
+        return this.getSpectrumDisplayState({ receiver, timeout: 3000 });
+    }
+    async getSpectrumMode(options) {
+        return (await this.readScopeMode(options))?.modeName ?? null;
+    }
+    async setSpectrumMode(mode, options) {
+        await this.setScopeMode(mode, options);
+    }
+    async getSpectrumSpan(options) {
+        return (await this.readScopeSpan(options))?.spanHz ?? null;
+    }
+    async setSpectrumSpan(spanHz, options) {
+        await this.setScopeSpan(spanHz, options);
+    }
+    async getSpectrumEdgeSlot(options) {
+        return (await this.readScopeEdge(options))?.edgeSlot ?? null;
+    }
+    async setSpectrumEdgeSlot(edgeSlot, options) {
+        await this.setScopeEdge(edgeSlot, options);
+    }
+    async getSpectrumFixedEdges(options) {
+        const rangeId = options?.rangeId ?? await this.resolveScopeFrequencyRangeId();
+        const edgeSlot = options?.edgeSlot ?? await this.getSpectrumEdgeSlot(options) ?? 1;
+        const info = await this.readScopeFixedEdge(rangeId, edgeSlot, options);
+        if (!info) {
+            return null;
+        }
+        return info;
+    }
+    async setSpectrumFixedEdges(options) {
+        return this.setScopeFixedEdge(options);
+    }
     async waitForScopeFrame(options) {
         const timeoutMs = options?.timeout ?? 3000;
         return this.scope.waitForScopeFrame(timeoutMs);
@@ -589,7 +807,11 @@ class IcomControl {
     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));
+        const bcdBytes = this.activeProfile.frequencyBcdBytes(hz);
+        const frame = this.activeProfile.supportsX25X26
+            ? IcomRigCommands_1.IcomRigCommands.setSelectedFrequency(ctrAddr, rigAddr, hz, bcdBytes, 0)
+            : IcomRigCommands_1.IcomRigCommands.setFrequency(ctrAddr, rigAddr, hz, bcdBytes);
+        this.sendCiv(frame);
     }
     /**
      * Set operating mode
@@ -605,11 +827,16 @@ class IcomControl {
         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));
+        const filter = options?.filter ?? this.lastFilter ?? this.activeProfile.defaultFilter;
+        if (this.activeProfile.supportsX25X26 && this.activeProfile.modeWithFilter) {
+            this.sendCiv(IcomRigCommands_1.IcomRigCommands.setSelectedMode(ctrAddr, rigAddr, modeCode, !!options?.dataMode, filter, 0));
+            return;
+        }
+        if (options?.dataMode && this.activeProfile.dataModeSupported) {
+            this.sendCiv(IcomRigCommands_1.IcomRigCommands.setOperationDataMode(ctrAddr, rigAddr, modeCode, filter));
         }
         else {
-            this.sendCiv(IcomRigCommands_1.IcomRigCommands.setMode(ctrAddr, rigAddr, modeCode));
+            this.sendCiv(IcomRigCommands_1.IcomRigCommands.setMode(ctrAddr, rigAddr, modeCode, filter));
         }
     }
     /**
@@ -624,12 +851,16 @@ class IcomControl {
         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));
+        const useX25 = this.activeProfile.supportsX25X26;
+        const req = useX25
+            ? IcomRigCommands_1.IcomRigCommands.readSelectedFrequency(ctrAddr, rigAddr, 0)
+            : IcomRigCommands_1.IcomRigCommands.readOperatingFrequency(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => useX25
+            ? IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_SEND_SEL_FREQ, [0x00], ctrAddr, rigAddr)
+            : IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_RD_FREQ, [], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
         if (!resp)
             return null;
-        const freq = IcomControl.parseIcomFreqFromReply(resp);
-        return freq;
+        return IcomControl.parseFrequencyReply(resp, useX25 ? 1 : 0);
     }
     /**
      * Read current operating mode and filter
@@ -639,78 +870,56 @@ class IcomControl {
         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));
+        const useX26 = this.activeProfile.supportsX25X26 && this.activeProfile.modeWithFilter;
+        const req = useX26 ? IcomRigCommands_1.IcomRigCommands.readSelectedMode(ctrAddr, rigAddr, 0) : IcomRigCommands_1.IcomRigCommands.readOperatingMode(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => useX26
+            ? IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_SEND_SEL_MODE, [0x00], ctrAddr, rigAddr)
+            : IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_RD_MODE, [], 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;
+        const mode = useX26 ? resp[6] : resp[5];
+        const dataMode = useX26 ? resp[7] !== 0x00 : undefined;
+        const filter = useX26 ? resp[8] : (resp.length > 6 ? resp[6] : undefined);
         if (mode === undefined)
             return null;
-        // Map names using constants
+        if (filter === 1 || filter === 2 || filter === 3)
+            this.lastFilter = filter;
         const { getModeString, getFilterString } = await Promise.resolve().then(() => __importStar(require('./IcomConstants')));
         const modeName = getModeString(mode);
         const filterName = getFilterString(filter);
-        return { mode, filter, modeName, filterName };
+        return { mode, filter, modeName, filterName, dataMode };
     }
     /**
      * Read current transmit frequency (when TX)
      */
     async readTransmitFrequency(options) {
+        if (!this.activeProfile.supportsX1C03TxFreq)
+            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.readTransmitFrequency(ctrAddr, rigAddr);
-        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x1c, [0x03], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_CTL_PTT, [IcomCivSpec_1.CIV.S_RD_TX_FREQ], 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;
+        return IcomControl.parseFrequencyReply(resp, 1);
     }
-    /**
-     * Read transceiver state (TX/RX) via 0x1A 0x00 0x48
-     * Note: Java comments mark this as not recommended; use with caution.
-     */
-    async readTransceiverState(options) {
+    async readPtt(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)
+        const req = IcomRigCommands_1.IcomRigCommands.readPTT(ctrAddr, rigAddr);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_CTL_PTT, [IcomCivSpec_1.CIV.S_PTT], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 7)
+            return null;
+        return resp[6] !== 0x00;
+    }
+    /** Read transceiver state (TX/RX) using standard Hamlib-aligned PTT status. */
+    async readTransceiverState(options) {
+        const ptt = await this.readPtt(options);
+        if (ptt === null)
             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';
+        return ptt ? 'TX' : 'RX';
     }
     /**
      * Read band edge data (0x02). Format may vary by rig; returns raw data bytes after command.
@@ -747,8 +956,8 @@ class IcomControl {
             return null;
         return {
             raw,
-            swr: raw / 100,
-            alert: raw >= IcomConstants_1.METER_THRESHOLDS.SWR_ALERT
+            swr: (0, IcomProfiles_1.interpolateCalibration)(raw, this.activeProfile.calibrations.swr),
+            alert: (0, IcomProfiles_1.interpolateCalibration)(raw, this.activeProfile.calibrations.swr) >= 3.0
         };
     }
     /**
@@ -772,8 +981,8 @@ class IcomControl {
             return null;
         return {
             raw,
-            percent: (raw / IcomConstants_1.METER_THRESHOLDS.ALC_MAX) * 100,
-            alert: raw > IcomConstants_1.METER_THRESHOLDS.ALC_ALERT_MAX
+            percent: (0, IcomProfiles_1.interpolateCalibration)(raw, this.activeProfile.calibrations.alc),
+            alert: (0, IcomProfiles_1.interpolateCalibration)(raw, this.activeProfile.calibrations.alc) > 100
         };
     }
     /**
@@ -787,12 +996,15 @@ class IcomControl {
      * }
      */
     async getConnectorWLanLevel(options) {
+        const ext = this.activeProfile.vendorExtensions.connectorWlanLevel;
+        if (!ext)
+            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.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);
+        const req = IcomRigCommands_1.IcomRigCommands.getConnectorWLanLevel(ctrAddr, rigAddr, ext.subext);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, ext.command, [ext.subcmd, ...ext.subext], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractTrailingBcd(resp, ext.dataBytes);
         if (raw === null)
             return null;
         return {
@@ -829,18 +1041,44 @@ class IcomControl {
         if (data.length === 0)
             return null;
         const raw = data[data.length - 1] & 0xff; // use low byte as 0-255 level
-        // Convert raw value to S-meter reading with physical units
-        // Uses IC-705 calibration by default (can be extended to support other models)
-        return (0, smeter_1.rawToSMeter)(raw, 'IC-705');
+        return (0, smeter_1.rawToSMeter)(raw, this.activeProfile.calibrations.sMeterModel);
     }
     /**
      * Set WLAN connector audio level
      * @param level - Audio level (0-255)
      */
     async setConnectorWLanLevel(level) {
+        const ext = this.activeProfile.vendorExtensions.connectorWlanLevel;
+        if (!ext) {
+            throw new errors_1.UnsupportedCommandError({ modelId: this.getProfileModelId(), commandName: 'setConnectorWLanLevel', civCommand: '0x1a/0x05', reason: 'No vendor WLAN level extension for active profile' });
+        }
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setConnectorWLanLevel(ctrAddr, rigAddr, level, ext.subext));
+    }
+    async getUsbAfLevel(options) {
+        const ext = this.activeProfile.extParams.usbAfLevel;
+        if (!ext)
+            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.getUsbAfLevel(ctrAddr, rigAddr, ext.subext);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, ext.command, [ext.subcmd, ...ext.subext], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const raw = IcomControl.extractTrailingBcd(resp, ext.dataBytes);
+        if (raw === null)
+            return null;
+        return { raw, percent: (raw / 255) * 100 };
+    }
+    async setUsbAfLevel(level) {
+        const ext = this.activeProfile.extParams.usbAfLevel;
+        if (!ext) {
+            throw new errors_1.UnsupportedCommandError({ modelId: this.getProfileModelId(), commandName: 'setUsbAfLevel', civCommand: '0x1a/0x05', reason: 'No USB AF level extension for active profile' });
+        }
         const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
         const rigAddr = this.civ.civAddress & 0xff;
-        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setConnectorWLanLevel(ctrAddr, rigAddr, level));
+        const raw = Math.max(0, Math.min(255, Math.round(level)));
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setUsbAfLevel(ctrAddr, rigAddr, raw, ext.subext));
     }
     /**
      * Set connector data routing mode
@@ -850,10 +1088,14 @@ class IcomControl {
      * await rig.setConnectorDataMode('WLAN');
      */
     async setConnectorDataMode(mode) {
+        const ext = this.activeProfile.vendorExtensions.connectorDataMode;
+        if (!ext) {
+            throw new errors_1.UnsupportedCommandError({ modelId: this.getProfileModelId(), commandName: 'setConnectorDataMode', civCommand: '0x1a/0x05', reason: 'No vendor connector data-mode extension for active profile' });
+        }
         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));
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.setConnectorDataMode(ctrAddr, rigAddr, modeCode, ext.subext));
     }
     /**
      * ==============================
@@ -861,7 +1103,7 @@ class IcomControl {
      * ==============================
      */
     /**
-     * Read antenna tuner status (CI-V 0x1A/0x00)
+     * Read antenna tuner status (CI-V 0x1C/0x01)
      * 00=OFF, 01=ON, 02=TUNING
      */
     async readTunerStatus(options) {
@@ -869,10 +1111,10 @@ class IcomControl {
         const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
         const rigAddr = this.civ.civAddress & 0xff;
         const req = IcomRigCommands_1.IcomRigCommands.getTunerStatus(ctrAddr, rigAddr);
-        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x1a, [0x00], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_CTL_PTT, [IcomCivSpec_1.CIV.S_ANT_TUN], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
         if (!resp)
             return null;
-        // Expect FE FE [ctr] [rig] 0x1A 0x00 [status] FD
+        // Expect FE FE [ctr] [rig] 0x1C 0x01 [status] FD
         const raw = resp.length > 6 ? (resp[6] & 0xff) : undefined;
         if (raw === undefined)
             return null;
@@ -880,7 +1122,7 @@ class IcomControl {
         return { raw, state };
     }
     /**
-     * Enable or disable internal antenna tuner (CI-V 0x1A/0x01)
+     * Enable or disable internal antenna tuner (CI-V 0x1C/0x01)
      * @param enabled true to enable, false to disable
      */
     async setTunerEnabled(enabled) {
@@ -889,7 +1131,7 @@ class IcomControl {
         this.sendCiv(IcomRigCommands_1.IcomRigCommands.setTunerEnabled(ctrAddr, rigAddr, enabled));
     }
     /**
-     * Start a manual tuning cycle (same as [TUNE] key) (CI-V 0x1A/0x02/0x00)
+     * Start a manual tuning cycle (same as [TUNE] key) (CI-V 0x1C/0x01/0x02)
      */
     async startManualTune() {
         const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
@@ -934,14 +1176,25 @@ class IcomControl {
     }
     /** Get microphone gain. Returns 0.0–1.0, or null on timeout. */
     async getMicGain(options) {
-        const v = await this.read0x14Level(0x0f, options);
+        const v = await this.read0x14Level(IcomCivSpec_1.CIV.S_LVL_MICGAIN, options);
         if (v === null)
             return null;
         return { raw: Math.round(v * 255), normalized: v };
     }
     /** Set microphone gain. Value 0.0–1.0. */
     setMicGain(value) {
-        this.write0x14Level(0x0f, value);
+        this.write0x14Level(IcomCivSpec_1.CIV.S_LVL_MICGAIN, value);
+    }
+    /** Get break-in delay. Returns 0.0–1.0, or null on timeout. */
+    async getBreakInDelay(options) {
+        const v = await this.read0x14Level(IcomCivSpec_1.CIV.S_LVL_BKINDL, options);
+        if (v === null)
+            return null;
+        return { raw: Math.round(v * 255), normalized: v };
+    }
+    /** Set break-in delay. Value 0.0–1.0. */
+    setBreakInDelay(value) {
+        this.write0x14Level(IcomCivSpec_1.CIV.S_LVL_BKINDL, value);
     }
     /** Get noise blanker level. 0.0 = off, >0.0 = on with strength. */
     async getNBLevel(options) {
@@ -956,14 +1209,14 @@ class IcomControl {
     }
     /** Get noise reduction level. 0.0 = off, >0.0 = on with strength. */
     async getNRLevel(options) {
-        const v = await this.read0x14Level(0x13, options);
+        const v = await this.read0x14Level(IcomCivSpec_1.CIV.S_LVL_NR, options);
         if (v === null)
             return null;
         return { raw: Math.round(v * 255), normalized: v };
     }
     /** Set noise reduction level. Value 0.0 (off) – 1.0. */
     setNRLevel(value) {
-        this.write0x14Level(0x13, value);
+        this.write0x14Level(IcomCivSpec_1.CIV.S_LVL_NR, value);
     }
     /**
      * Read squelch status (noise/signal gate state)
@@ -1056,9 +1309,12 @@ class IcomControl {
         const raw = IcomControl.extractMeterData(resp);
         if (raw === null)
             return null;
+        const watts = (0, IcomProfiles_1.interpolateCalibration)(raw, this.activeProfile.calibrations.rfPowerWatts);
+        const maxWatts = this.activeProfile.calibrations.rfPowerWatts[this.activeProfile.calibrations.rfPowerWatts.length - 1]?.value ?? 100;
         return {
             raw,
-            percent: (0, IcomConstants_1.rawToPowerPercent)(raw)
+            percent: maxWatts > 0 ? Math.min(100, (watts / maxWatts) * 100) : 0,
+            watts
         };
     }
     /**
@@ -1080,9 +1336,11 @@ class IcomControl {
         const raw = IcomControl.extractMeterData(resp);
         if (raw === null)
             return null;
+        const db = (0, IcomProfiles_1.interpolateCalibration)(raw, this.activeProfile.calibrations.compDb);
         return {
             raw,
-            percent: (raw / 255) * 100
+            percent: (db / 30) * 100,
+            db
         };
     }
     /**
@@ -1106,7 +1364,7 @@ class IcomControl {
             return null;
         return {
             raw,
-            volts: (0, IcomConstants_1.rawToVoltage)(raw)
+            volts: (0, IcomProfiles_1.interpolateCalibration)(raw, this.activeProfile.calibrations.voltage)
         };
     }
     /**
@@ -1130,7 +1388,7 @@ class IcomControl {
             return null;
         return {
             raw,
-            amps: (0, IcomConstants_1.rawToCurrent)(raw)
+            amps: (0, IcomProfiles_1.interpolateCalibration)(raw, this.activeProfile.calibrations.current)
         };
     }
     static isReplyOf(frame, cmd, ctrAddr, rigAddr) {
@@ -1146,9 +1404,17 @@ class IcomControl {
     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);
+        // FE FE [ctr] [rig] 0x15 [sub] [bcd_hi] [bcd_lo] FD
+        return (0, IcomCivFrame_1.decodeBcdBE)(frame.subarray(6, 8));
+    }
+    static extractTrailingBcd(frame, byteLength) {
+        if (!frame || frame.length < 6 + byteLength)
+            return null;
+        const end = frame.length - 1;
+        const start = end - byteLength;
+        if (start < 5)
+            return null;
+        return (0, IcomCivFrame_1.decodeBcdBE)(frame.subarray(start, end));
     }
     static matchCommand(frame, cmd, tail) {
         // FE FE ?? ?? cmd ... tail... FD
@@ -1218,34 +1484,23 @@ class IcomControl {
             }, timeoutMs);
         });
     }
-    // Parse CI-V reply for command 0x03 (read operating frequency)
-    static parseIcomFreqFromReply(frame) {
-        // Expect: FE FE [ctr] [rig] 0x03 [bcd0..bcd4] FD
+    static parseFrequencyReply(frame, payloadOffsetAfterCommand, byteLength) {
         if (!(frame && frame.length >= 7))
             return null;
-        if (frame[0] !== 0xfe || frame[1] !== 0xfe)
+        if (frame[0] !== 0xfe || frame[1] !== 0xfe || frame[frame.length - 1] !== 0xfd)
             return null;
-        if (frame[4] !== 0x03)
+        const start = 5 + payloadOffsetAfterCommand;
+        const maxBytes = frame.length - 1 - start;
+        const len = byteLength ?? (maxBytes >= 6 ? 6 : 5);
+        if (maxBytes < len || len <= 0)
             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 (0, IcomCivFrame_1.decodeFrequencyBcdLE)(frame.subarray(start, start + len));
+    }
+    // Parse standard CI-V 0x03 read-frequency replies.
+    static parseIcomFreqFromReply(frame) {
+        if (!IcomControl.matchCommandFrame(frame, IcomCivSpec_1.CIV.C_RD_FREQ, []))
             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;
+        return IcomControl.parseFrequencyReply(frame, 0);
     }
     sendAudioFloat32(samples, addLeadingBuffer = false) {
         this.audio.enqueueFloat32(samples, addLeadingBuffer);
@@ -1380,11 +1635,15 @@ class IcomControl {
                         audioName: IcomPackets_1.RadioCapPacket.getAudioName(cap),
                         supportTX: IcomPackets_1.RadioCapPacket.getSupportTX(cap)
                     };
-                    if (info.civAddress != null)
+                    if (info.civAddress != null) {
                         this.civ.civAddress = info.civAddress;
+                        this.resolveActiveProfile({ civAddress: info.civAddress });
+                        info.modelId = this.activeProfile.modelId;
+                        info.profileName = this.activeProfile.profileName;
+                    }
                     if (info.supportTX != null)
                         this.civ.supportTX = info.supportTX;
-                    (0, debug_1.dbgV)('CAP <= civAddr=', info.civAddress, 'audioName=', info.audioName, 'supportTX=', info.supportTX);
+                    (0, debug_1.dbgV)('CAP <= civAddr=', info.civAddress, 'audioName=', info.audioName, 'supportTX=', info.supportTX, 'profile=', info.modelId);
                     this.ev.emit('capabilities', info);
                 }
                 break;
@@ -1396,7 +1655,8 @@ class IcomControl {
                 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);
+                this.resolveActiveProfile({ rigName: this.rigName });
+                (0, debug_1.dbg)('CONNINFO <= busy=', busy, 'rigName=', this.rigName, 'profile=', this.activeProfile.modelId);
                 if (busy) {
                     (0, debug_1.dbg)('CONNINFO busy=true detected - likely reconnecting while rig still has old session');
                     (0, debug_1.dbg)('Sending ConnInfo reply anyway to allow STATUS packet delivery');