icom-wlan-node 0.5.0 → 0.6.0

package/dist/rig/IcomProfiles.d.ts

@@ -0,0 +1,61 @@
+import type { IcomModelId } from '../types';
+export interface CalibrationPoint {
+    raw: number;
+    value: number;
+}
+export interface IcomExtParam {
+    command: number;
+    subcmd: number;
+    subext: number[];
+    dataBytes: number;
+    dataType: 'level' | 'bool' | 'int';
+}
+export interface IcomProfile {
+    modelId: IcomModelId;
+    profileName: string;
+    defaultCivAddress: number;
+    aliases: string[];
+    supportsX25X26: boolean;
+    supportsX1C03TxFreq: boolean;
+    modeWithFilter: boolean;
+    dataModeSupported: boolean;
+    defaultFilter: 1 | 2 | 3;
+    frequencyBcdBytes(freqHz: number): number;
+    scopeLineLength?: number;
+    scopeSingleFrameDataLength?: number;
+    scopeEdgeSlots: number[];
+    scopeRanges: Array<{
+        rangeId: number;
+        lowHz: number;
+        highHz: number;
+    }>;
+    calibrations: {
+        sMeterModel: string;
+        swr: CalibrationPoint[];
+        alc: CalibrationPoint[];
+        rfPowerWatts: CalibrationPoint[];
+        compDb: CalibrationPoint[];
+        voltage: CalibrationPoint[];
+        current: CalibrationPoint[];
+    };
+    extParams: {
+        usbAfLevel?: IcomExtParam;
+        afIfWlan?: IcomExtParam;
+    };
+    vendorExtensions: {
+        connectorWlanLevel?: IcomExtParam;
+        connectorDataMode?: {
+            command: number;
+            subcmd: number;
+            subext: number[];
+        };
+    };
+}
+export declare const ICOM_PROFILES: Record<IcomModelId, IcomProfile>;
+export declare function interpolateCalibration(raw: number, points: CalibrationPoint[]): number;
+export declare function getProfileByModel(model?: IcomModelId | 'auto'): IcomProfile;
+export declare function resolveIcomProfile(options: {
+    requestedModel?: IcomModelId | 'auto';
+    rigName?: string;
+    civAddress?: number;
+}): IcomProfile;

package/dist/rig/IcomProfiles.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICOM_PROFILES = void 0;
+exports.interpolateCalibration = interpolateCalibration;
+exports.getProfileByModel = getProfileByModel;
+exports.resolveIcomProfile = resolveIcomProfile;
+const HF_SCOPE_RANGES_13 = [
+    { rangeId: 1, lowHz: 30000, highHz: 1600000 },
+    { rangeId: 2, lowHz: 1600000, highHz: 2000000 },
+    { rangeId: 3, lowHz: 2000000, highHz: 6000000 },
+    { rangeId: 4, lowHz: 6000000, highHz: 8000000 },
+    { rangeId: 5, lowHz: 8000000, highHz: 11000000 },
+    { rangeId: 6, lowHz: 11000000, highHz: 15000000 },
+    { rangeId: 7, lowHz: 15000000, highHz: 20000000 },
+    { rangeId: 8, lowHz: 20000000, highHz: 22000000 },
+    { rangeId: 9, lowHz: 22000000, highHz: 26000000 },
+    { rangeId: 10, lowHz: 26000000, highHz: 30000000 },
+    { rangeId: 11, lowHz: 30000000, highHz: 45000000 },
+    { rangeId: 12, lowHz: 45000000, highHz: 60000000 },
+    { rangeId: 13, lowHz: 60000000, highHz: 74800000 },
+];
+const HF_VHF_UHF_SCOPE_RANGES_17 = [
+    ...HF_SCOPE_RANGES_13,
+    { rangeId: 14, lowHz: 74800000, highHz: 108000000 },
+    { rangeId: 15, lowHz: 108000000, highHz: 137000000 },
+    { rangeId: 16, lowHz: 137000000, highHz: 200000000 },
+    { rangeId: 17, lowHz: 400000000, highHz: 470000000 },
+];
+const IC9700_SCOPE_RANGES = [
+    { rangeId: 1, lowHz: 144000000, highHz: 148000000 },
+    { rangeId: 2, lowHz: 430000000, highHz: 450000000 },
+    { rangeId: 3, lowHz: 1240000000, highHz: 1300000000 },
+];
+const IC7610_SCOPE_RANGES = HF_SCOPE_RANGES_13.slice(0, 12);
+const DEFAULT_SWR = [
+    { raw: 0, value: 1.0 },
+    { raw: 48, value: 1.5 },
+    { raw: 80, value: 2.0 },
+    { raw: 120, value: 3.0 },
+    { raw: 240, value: 6.0 },
+];
+const DEFAULT_ALC = [
+    { raw: 0, value: 0 },
+    { raw: 120, value: 100 },
+];
+const IC7300_RF_POWER = [
+    { raw: 0, value: 0 },
+    { raw: 21, value: 5 },
+    { raw: 43, value: 10 },
+    { raw: 65, value: 15 },
+    { raw: 83, value: 20 },
+    { raw: 95, value: 25 },
+    { raw: 105, value: 30 },
+    { raw: 114, value: 35 },
+    { raw: 124, value: 40 },
+    { raw: 143, value: 50 },
+    { raw: 183, value: 75 },
+    { raw: 213, value: 100 },
+    { raw: 255, value: 120 },
+];
+const IC705_RF_POWER = IC7300_RF_POWER.map((p) => ({ raw: p.raw, value: p.value / 10 }));
+const DEFAULT_COMP = [
+    { raw: 0, value: 0 },
+    { raw: 130, value: 15 },
+    { raw: 241, value: 30 },
+];
+const IC705_COMP = [
+    { raw: 0, value: 0 },
+    { raw: 11, value: 0 },
+    { raw: 34, value: 3 },
+    { raw: 58, value: 6 },
+    { raw: 81, value: 9 },
+    { raw: 104, value: 12 },
+    { raw: 128, value: 15 },
+    { raw: 151, value: 18 },
+    { raw: 174, value: 21 },
+    { raw: 197, value: 24 },
+    { raw: 221, value: 27 },
+    { raw: 244, value: 30 },
+];
+const DEFAULT_VOLTAGE = [
+    { raw: 0, value: 0 },
+    { raw: 13, value: 10 },
+    { raw: 241, value: 16 },
+];
+const IC705_VOLTAGE = [
+    { raw: 0, value: 0 },
+    { raw: 241, value: 16 },
+];
+const DEFAULT_CURRENT = [
+    { raw: 0, value: 0 },
+    { raw: 97, value: 10 },
+    { raw: 146, value: 15 },
+    { raw: 241, value: 25 },
+];
+const IC705_CURRENT = [
+    { raw: 0, value: 0 },
+    { raw: 241, value: 4 },
+];
+function baseProfile(overrides) {
+    return {
+        supportsX25X26: true,
+        supportsX1C03TxFreq: true,
+        modeWithFilter: true,
+        dataModeSupported: true,
+        defaultFilter: 1,
+        frequencyBcdBytes: () => 5,
+        scopeLineLength: 475,
+        scopeSingleFrameDataLength: 50,
+        scopeEdgeSlots: [1, 2, 3, 4],
+        scopeRanges: HF_SCOPE_RANGES_13,
+        calibrations: {
+            sMeterModel: 'IC-705',
+            swr: DEFAULT_SWR,
+            alc: DEFAULT_ALC,
+            rfPowerWatts: IC7300_RF_POWER,
+            compDb: DEFAULT_COMP,
+            voltage: DEFAULT_VOLTAGE,
+            current: DEFAULT_CURRENT,
+        },
+        extParams: {},
+        vendorExtensions: {},
+        ...overrides,
+    };
+}
+const ic705Ext = {
+    usbAfLevel: { command: 0x1a, subcmd: 0x05, subext: [0x01, 0x13], dataBytes: 2, dataType: 'level' },
+    afIfWlan: { command: 0x1a, subcmd: 0x05, subext: [0x01, 0x14], dataBytes: 1, dataType: 'bool' },
+};
+const ic705Vendor = {
+    connectorWlanLevel: { command: 0x1a, subcmd: 0x05, subext: [0x01, 0x17], dataBytes: 2, dataType: 'level' },
+    connectorDataMode: { command: 0x1a, subcmd: 0x05, subext: [0x01, 0x19] },
+};
+exports.ICOM_PROFILES = {
+    'generic-modern-icom': baseProfile({
+        modelId: 'generic-modern-icom',
+        profileName: 'Generic modern ICOM CI-V',
+        defaultCivAddress: 0xa4,
+        aliases: ['generic', 'icom'],
+        scopeRanges: HF_VHF_UHF_SCOPE_RANGES_17,
+    }),
+    'IC-705': baseProfile({
+        modelId: 'IC-705',
+        profileName: 'Icom IC-705',
+        defaultCivAddress: 0xa4,
+        aliases: ['IC-705', 'IC705'],
+        scopeRanges: HF_VHF_UHF_SCOPE_RANGES_17,
+        calibrations: {
+            sMeterModel: 'IC-705',
+            swr: DEFAULT_SWR,
+            alc: DEFAULT_ALC,
+            rfPowerWatts: IC705_RF_POWER,
+            compDb: IC705_COMP,
+            voltage: IC705_VOLTAGE,
+            current: IC705_CURRENT,
+        },
+        extParams: ic705Ext,
+        vendorExtensions: ic705Vendor,
+    }),
+    'IC-905': baseProfile({
+        modelId: 'IC-905',
+        profileName: 'Icom IC-905',
+        defaultCivAddress: 0xac,
+        aliases: ['IC-905', 'IC905'],
+        frequencyBcdBytes: (freqHz) => freqHz > 5.85e9 ? 6 : 5,
+        scopeRanges: HF_VHF_UHF_SCOPE_RANGES_17,
+        calibrations: {
+            sMeterModel: 'IC-705',
+            swr: DEFAULT_SWR,
+            alc: DEFAULT_ALC,
+            rfPowerWatts: IC705_RF_POWER,
+            compDb: DEFAULT_COMP,
+            voltage: DEFAULT_VOLTAGE,
+            current: DEFAULT_CURRENT,
+        },
+        extParams: ic705Ext,
+        vendorExtensions: ic705Vendor,
+    }),
+    'IC-7300': baseProfile({
+        modelId: 'IC-7300',
+        profileName: 'Icom IC-7300',
+        defaultCivAddress: 0x94,
+        aliases: ['IC-7300', 'IC7300'],
+        scopeRanges: HF_SCOPE_RANGES_13,
+        extParams: {
+            usbAfLevel: { command: 0x1a, subcmd: 0x05, subext: [0x00, 0x60], dataBytes: 2, dataType: 'level' },
+        },
+    }),
+    'IC-9700': baseProfile({
+        modelId: 'IC-9700',
+        profileName: 'Icom IC-9700',
+        defaultCivAddress: 0xa2,
+        aliases: ['IC-9700', 'IC9700'],
+        scopeRanges: IC9700_SCOPE_RANGES,
+        extParams: {
+            usbAfLevel: { command: 0x1a, subcmd: 0x05, subext: [0x01, 0x06], dataBytes: 2, dataType: 'level' },
+        },
+    }),
+    'IC-7610': baseProfile({
+        modelId: 'IC-7610',
+        profileName: 'Icom IC-7610',
+        defaultCivAddress: 0x98,
+        aliases: ['IC-7610', 'IC7610'],
+        scopeLineLength: 689,
+        scopeRanges: IC7610_SCOPE_RANGES,
+        extParams: {
+            usbAfLevel: { command: 0x1a, subcmd: 0x05, subext: [0x00, 0x82], dataBytes: 2, dataType: 'level' },
+        },
+    }),
+    'IC-7760': baseProfile({
+        modelId: 'IC-7760',
+        profileName: 'Icom IC-7760',
+        defaultCivAddress: 0xb2,
+        aliases: ['IC-7760', 'IC7760'],
+        scopeRanges: HF_SCOPE_RANGES_13,
+    }),
+};
+function interpolateCalibration(raw, points) {
+    if (points.length === 0)
+        return raw;
+    const sorted = [...points].sort((a, b) => a.raw - b.raw);
+    if (raw <= sorted[0].raw)
+        return sorted[0].value;
+    for (let i = 1; i < sorted.length; i++) {
+        const left = sorted[i - 1];
+        const right = sorted[i];
+        if (raw <= right.raw) {
+            const ratio = (raw - left.raw) / (right.raw - left.raw);
+            return left.value + (right.value - left.value) * ratio;
+        }
+    }
+    return sorted[sorted.length - 1].value;
+}
+function getProfileByModel(model) {
+    if (model && model !== 'auto')
+        return exports.ICOM_PROFILES[model] ?? exports.ICOM_PROFILES['generic-modern-icom'];
+    return exports.ICOM_PROFILES['generic-modern-icom'];
+}
+function resolveIcomProfile(options) {
+    if (options.requestedModel && options.requestedModel !== 'auto') {
+        return getProfileByModel(options.requestedModel);
+    }
+    const normalizedName = options.rigName?.replace(/\s+/g, '').toUpperCase();
+    if (normalizedName) {
+        const byName = Object.values(exports.ICOM_PROFILES).find((profile) => profile.aliases.some((alias) => normalizedName.includes(alias.replace(/\s+/g, '').toUpperCase())));
+        if (byName)
+            return byName;
+    }
+    if (options.civAddress !== undefined) {
+        const byAddress = Object.values(exports.ICOM_PROFILES).find((profile) => profile.defaultCivAddress === (options.civAddress & 0xff));
+        if (byAddress)
+            return byAddress;
+    }
+    return exports.ICOM_PROFILES['generic-modern-icom'];
+}

package/dist/rig/IcomRigCommands.d.ts

@@ -1,19 +1,26 @@
 export declare const IcomRigCommands: {
     setPTT(ctrAddr: number, rigAddr: number, on: boolean): Buffer;
-    setMode(ctrAddr: number, rigAddr: number, mode: number): Buffer;
-    setFrequency(ctrAddr: number, rigAddr: number, hz: number): Buffer;
+    readPTT(ctrAddr: number, rigAddr: number): Buffer;
+    setMode(ctrAddr: number, rigAddr: number, mode: number, filter?: 1 | 2 | 3): Buffer;
+    setSelectedMode(ctrAddr: number, rigAddr: number, mode: number, dataMode?: boolean, filter?: 1 | 2 | 3, vfoNumber?: 0 | 1): Buffer;
+    setFrequency(ctrAddr: number, rigAddr: number, hz: number, bcdBytes?: number): Buffer;
+    setSelectedFrequency(ctrAddr: number, rigAddr: number, hz: number, bcdBytes?: number, vfoNumber?: 0 | 1): Buffer;
     readOperatingFrequency(ctrAddr: number, rigAddr: number): Buffer;
+    readSelectedFrequency(ctrAddr: number, rigAddr: number, vfoNumber?: 0 | 1): Buffer;
     readOperatingMode(ctrAddr: number, rigAddr: number): Buffer;
+    readSelectedMode(ctrAddr: number, rigAddr: number, vfoNumber?: 0 | 1): Buffer;
     readTransmitFrequency(ctrAddr: number, rigAddr: number): Buffer;
     readTransceiverState(ctrAddr: number, rigAddr: number): Buffer;
     readBandEdges(ctrAddr: number, rigAddr: number): Buffer;
-    setOperationDataMode(ctrAddr: number, rigAddr: number, mode: number): Buffer;
+    setOperationDataMode(ctrAddr: number, rigAddr: number, mode: number, filter?: 1 | 2 | 3): Buffer;
     getSWRState(ctrAddr: number, rigAddr: number): Buffer;
     getALCState(ctrAddr: number, rigAddr: number): Buffer;
     getLevelMeter(ctrAddr: number, rigAddr: number): Buffer;
-    getConnectorWLanLevel(ctrAddr: number, rigAddr: number): Buffer;
-    setConnectorWLanLevel(ctrAddr: number, rigAddr: number, level: number): Buffer;
-    setConnectorDataMode(ctrAddr: number, rigAddr: number, mode: number): Buffer;
+    getConnectorWLanLevel(ctrAddr: number, rigAddr: number, subext?: number[]): Buffer;
+    setConnectorWLanLevel(ctrAddr: number, rigAddr: number, level: number, subext?: number[]): Buffer;
+    setConnectorDataMode(ctrAddr: number, rigAddr: number, mode: number, subext?: number[]): Buffer;
+    getUsbAfLevel(ctrAddr: number, rigAddr: number, subext?: number[]): Buffer;
+    setUsbAfLevel(ctrAddr: number, rigAddr: number, level: number, subext?: number[]): Buffer;
     getSquelchStatus(ctrAddr: number, rigAddr: number): Buffer;
     getAudioSquelch(ctrAddr: number, rigAddr: number): Buffer;
     getOvfStatus(ctrAddr: number, rigAddr: number): Buffer;
@@ -21,16 +28,7 @@ export declare const IcomRigCommands: {
     getCompLevel(ctrAddr: number, rigAddr: number): Buffer;
     getVoltage(ctrAddr: number, rigAddr: number): Buffer;
     getCurrent(ctrAddr: number, rigAddr: number): Buffer;
-    /**
-     * Build a 0x14 level read query.
-     * Send this to request the current value; the radio responds with the same
-     * command byte + subcmd + 2-byte BCD data.
-     */
     get0x14Level(ctrAddr: number, rigAddr: number, subcmd: number): Buffer;
-    /**
-     * Build a 0x14 level write command.
-     * @param rawValue - Integer 0-255 (use intToTwoByteBcd to encode)
-     */
     set0x14Level(ctrAddr: number, rigAddr: number, subcmd: number, bcdHi: number, bcdLo: number): Buffer;
     getTunerStatus(ctrAddr: number, rigAddr: number): Buffer;
     setTunerEnabled(ctrAddr: number, rigAddr: number, on: boolean): Buffer;

package/dist/rig/IcomRigCommands.js

@@ -1,136 +1,116 @@
 "use strict";
-// Helpers to build CI-V frames for common operations (PTT, mode, frequency)
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IcomRigCommands = void 0;
+const IcomCivFrame_1 = require("./IcomCivFrame");
+const IcomCivSpec_1 = require("./IcomCivSpec");
+// Helpers to build standard CI-V frames for common rig operations.
 exports.IcomRigCommands = {
-    // FE FE [rigAddr] [ctrAddr] 1C 00 [01|00] FD
     setPTT(ctrAddr, rigAddr, on) {
-        return Buffer.from([
-            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1c, 0x00, on ? 0x01 : 0x00, 0xfd
-        ]);
-    },
-    setMode(ctrAddr, rigAddr, mode) {
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x06, mode & 0xff, 0x01, 0xfd]);
-    },
-    setFrequency(ctrAddr, rigAddr, hz) {
-        // 05: BCD format, little-endian nibbles per Java logic
-        const bcd = (n) => (((n / 10) | 0) << 4) + (n % 10);
-        const d0 = bcd(Math.floor(hz % 100));
-        const d1 = bcd(Math.floor((hz % 10000) / 100));
-        const d2 = bcd(Math.floor((hz % 1000000) / 10000));
-        const d3 = bcd(Math.floor((hz % 100000000) / 1000000));
-        const d4 = bcd(Math.floor(hz / 100000000)); // Fixed: was /1000000000
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x05, d0, d1, d2, d3, d4, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_PTT, subcmd: IcomCivSpec_1.CIV.S_PTT, payload: [on ? 0x01 : 0x00] });
+    },
+    readPTT(ctrAddr, rigAddr) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_PTT, subcmd: IcomCivSpec_1.CIV.S_PTT });
+    },
+    setMode(ctrAddr, rigAddr, mode, filter = IcomCivSpec_1.ICOM_MODE_FILTER_DEFAULT) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_SET_MODE, subcmd: mode & 0xff, payload: [filter & 0xff] });
+    },
+    setSelectedMode(ctrAddr, rigAddr, mode, dataMode = false, filter = IcomCivSpec_1.ICOM_MODE_FILTER_DEFAULT, vfoNumber = 0) {
+        return (0, IcomCivFrame_1.buildCivFrame)({
+            rigAddr,
+            ctrlAddr: ctrAddr,
+            cmd: IcomCivSpec_1.CIV.C_SEND_SEL_MODE,
+            subcmd: vfoNumber,
+            payload: [mode & 0xff, dataMode ? 0x01 : 0x00, filter & 0xff],
+        });
+    },
+    setFrequency(ctrAddr, rigAddr, hz, bcdBytes = 5) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_SET_FREQ, payload: (0, IcomCivFrame_1.encodeFrequencyBcdLE)(hz, bcdBytes) });
+    },
+    setSelectedFrequency(ctrAddr, rigAddr, hz, bcdBytes = 5, vfoNumber = 0) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_SEND_SEL_FREQ, subcmd: vfoNumber, payload: (0, IcomCivFrame_1.encodeFrequencyBcdLE)(hz, bcdBytes) });
     },
     readOperatingFrequency(ctrAddr, rigAddr) {
-        // FE FE [rigAddr] [ctrAddr] 0x03 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x03, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_FREQ });
+    },
+    readSelectedFrequency(ctrAddr, rigAddr, vfoNumber = 0) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_SEND_SEL_FREQ, subcmd: vfoNumber });
     },
     readOperatingMode(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x04 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x04, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_MODE });
+    },
+    readSelectedMode(ctrAddr, rigAddr, vfoNumber = 0) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_SEND_SEL_MODE, subcmd: vfoNumber });
     },
     readTransmitFrequency(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x1C 0x03 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1c, 0x03, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_PTT, subcmd: IcomCivSpec_1.CIV.S_RD_TX_FREQ });
     },
     readTransceiverState(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x1A 0x00 0x48 FD (not recommended by Java, but available)
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x00, 0x48, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_MEM, subcmd: [0x00, 0x48] });
     },
     readBandEdges(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x02 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x02, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_BAND });
     },
-    setOperationDataMode(ctrAddr, rigAddr, mode) {
-        // FE FE [rig] [ctr] 0x26 0x00 [mode] 0x01 0x01 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x26, 0x00, mode & 0xff, 0x01, 0x01, 0xfd]);
+    setOperationDataMode(ctrAddr, rigAddr, mode, filter = IcomCivSpec_1.ICOM_MODE_FILTER_DEFAULT) {
+        return exports.IcomRigCommands.setSelectedMode(ctrAddr, rigAddr, mode, true, filter, 0);
     },
     getSWRState(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x15 0x12 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x12, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_SQSM, subcmd: IcomCivSpec_1.CIV.S_SWR });
     },
     getALCState(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x15 0x13 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x13, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_SQSM, subcmd: IcomCivSpec_1.CIV.S_ALC });
     },
     getLevelMeter(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x15 0x02 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x02, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_SQSM, subcmd: IcomCivSpec_1.CIV.S_SML });
+    },
+    getConnectorWLanLevel(ctrAddr, rigAddr, subext = [0x01, 0x17]) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_MEM, subcmd: IcomCivSpec_1.CIV.S_MEM_PARM, payload: subext });
     },
-    getConnectorWLanLevel(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x1A 0x05 0x01 0x17 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x05, 0x01, 0x17, 0xfd]);
+    setConnectorWLanLevel(ctrAddr, rigAddr, level, subext = [0x01, 0x17]) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_MEM, subcmd: IcomCivSpec_1.CIV.S_MEM_PARM, payload: [...subext, ...(0, IcomCivFrame_1.encodeBcdBE)(level, 2)] });
     },
-    setConnectorWLanLevel(ctrAddr, rigAddr, level) {
-        // FE FE [rig] [ctr] 0x1A 0x05 0x01 0x17 [level_hi] [level_lo] FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x05, 0x01, 0x17, (level >> 8) & 0xff, level & 0xff, 0xfd]);
+    setConnectorDataMode(ctrAddr, rigAddr, mode, subext = [0x01, 0x19]) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_MEM, subcmd: IcomCivSpec_1.CIV.S_MEM_PARM, payload: [...subext, mode & 0xff] });
     },
-    setConnectorDataMode(ctrAddr, rigAddr, mode) {
-        // FE FE [rig] [ctr] 0x1A 0x05 0x01 0x19 [mode] FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x05, 0x01, 0x19, mode & 0xff, 0xfd]);
+    getUsbAfLevel(ctrAddr, rigAddr, subext = [0x01, 0x13]) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_MEM, subcmd: IcomCivSpec_1.CIV.S_MEM_PARM, payload: subext });
+    },
+    setUsbAfLevel(ctrAddr, rigAddr, level, subext = [0x01, 0x13]) {
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_MEM, subcmd: IcomCivSpec_1.CIV.S_MEM_PARM, payload: [...subext, ...(0, IcomCivFrame_1.encodeBcdBE)(level, 2)] });
     },
     getSquelchStatus(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x15 0x01 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x01, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_SQSM, subcmd: IcomCivSpec_1.CIV.S_SQL });
     },
     getAudioSquelch(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x15 0x05 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x05, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_SQSM, subcmd: IcomCivSpec_1.CIV.S_CSQL });
     },
     getOvfStatus(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x15 0x07 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x07, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_SQSM, subcmd: IcomCivSpec_1.CIV.S_OVF });
     },
     getPowerLevel(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x15 0x11 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x11, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_SQSM, subcmd: IcomCivSpec_1.CIV.S_RFML });
     },
     getCompLevel(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x15 0x14 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x14, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_SQSM, subcmd: IcomCivSpec_1.CIV.S_CMP });
     },
     getVoltage(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x15 0x15 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x15, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_SQSM, subcmd: IcomCivSpec_1.CIV.S_VD });
     },
     getCurrent(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x15 0x16 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x15, 0x16, 0xfd]);
-    },
-    // =====================
-    // 0x14 Level Commands (read/write)
-    // =====================
-    /**
-     * Build a 0x14 level read query.
-     * Send this to request the current value; the radio responds with the same
-     * command byte + subcmd + 2-byte BCD data.
-     */
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_RD_SQSM, subcmd: IcomCivSpec_1.CIV.S_ID });
+    },
     get0x14Level(ctrAddr, rigAddr, subcmd) {
-        // FE FE [rig] [ctr] 0x14 [subcmd] FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x14, subcmd & 0xff, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd });
     },
-    /**
-     * Build a 0x14 level write command.
-     * @param rawValue - Integer 0-255 (use intToTwoByteBcd to encode)
-     */
     set0x14Level(ctrAddr, rigAddr, subcmd, bcdHi, bcdLo) {
-        // FE FE [rig] [ctr] 0x14 [subcmd] [bcd_hi] [bcd_lo] FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x14, subcmd & 0xff, bcdHi & 0xff, bcdLo & 0xff, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_LVL, subcmd, payload: [bcdHi, bcdLo] });
     },
-    // =====================
-    // Antenna Tuner (ATU)
-    // =====================
     getTunerStatus(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x1A 0x00 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x00, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_PTT, subcmd: IcomCivSpec_1.CIV.S_ANT_TUN });
     },
     setTunerEnabled(ctrAddr, rigAddr, on) {
-        // FE FE [rig] [ctr] 0x1A 0x01 [00|01] FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x01, on ? 0x01 : 0x00, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_PTT, subcmd: IcomCivSpec_1.CIV.S_ANT_TUN, payload: [on ? 0x01 : 0x00] });
     },
     startManualTune(ctrAddr, rigAddr) {
-        // FE FE [rig] [ctr] 0x1A 0x02 0x00 FD
-        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x1a, 0x02, 0x00, 0xfd]);
+        return (0, IcomCivFrame_1.buildCivFrame)({ rigAddr, ctrlAddr: ctrAddr, cmd: IcomCivSpec_1.CIV.C_CTL_PTT, subcmd: IcomCivSpec_1.CIV.S_ANT_TUN, payload: [0x02] });
     }
 };

package/dist/scope/IcomScopeCommands.d.ts

@@ -3,5 +3,12 @@ export declare const IcomScopeCommands: {
     setScopeDisplay(ctrAddr: number, rigAddr: number, enabled: boolean): Buffer;
     readScopeSpan(ctrAddr: number, rigAddr: number, receiver?: 0 | 1): Buffer;
     setScopeSpan(ctrAddr: number, rigAddr: number, spanHz: number, receiver?: 0 | 1): Buffer;
+    readScopeMode(ctrAddr: number, rigAddr: number, receiver?: 0 | 1): Buffer;
+    setScopeMode(ctrAddr: number, rigAddr: number, mode: 0 | 1 | 2 | 3, receiver?: 0 | 1): Buffer;
+    readScopeEdge(ctrAddr: number, rigAddr: number, receiver?: 0 | 1): Buffer;
+    setScopeEdge(ctrAddr: number, rigAddr: number, edgeSlot: number, receiver?: 0 | 1): Buffer;
+    readScopeFixedEdge(ctrAddr: number, rigAddr: number, rangeId: number, edgeSlot: number): Buffer;
+    setScopeFixedEdge(ctrAddr: number, rigAddr: number, rangeId: number, edgeSlot: number, lowHz: number, highHz: number): Buffer;
     encodeScopeSpanHz(spanHz: number): Buffer;
+    encodeScopeFreqHz(freqHz: number): Buffer;
 };