icom-wlan-node 0.5.0 → 0.6.0

package/README.md

@@ -2,6 +2,8 @@
 
 Icom WLAN (UDP) protocol implementation in Node.js + TypeScript, featuring:
 
+CI-V profile support is Hamlib-aligned for modern ICOM radios: WLAN UDP packets carry standard CI-V frames, with model-specific profiles for IC-705, IC-905, IC-7300, IC-9700, IC-7610, and IC-7760.
+
 - Control channel handshake (AreYouThere/AreYouReady), login (0x80/0x60), token confirm/renew (0x40)
 - CI‑V over UDP encapsulation (open/close keep‑alive + CIV frame transport)
 - Scope/spectrum data capture over CI‑V `0x27`, with automatic segment assembly into friendly frame events
@@ -35,7 +37,8 @@ import { IcomControl, AUDIO_RATE, DisconnectReason } from 'icom-wlan-node';
 const rig = new IcomControl({
   control: { ip: '192.168.1.50', port: 50001 },
   userName: 'user',
-  password: 'pass'
+  password: 'pass',
+  model: 'auto' // or force a profile, e.g. 'IC-705'
 });
 
 rig.events.on('login', (res) => {
@@ -48,7 +51,7 @@ rig.events.on('status', (s) => {
 });
 
 rig.events.on('capabilities', (c) => {
-  console.log('CIV address:', c.civAddress, 'audio:', c.audioName);
+  console.log('CIV address:', c.civAddress, 'audio:', c.audioName, 'profile:', c.profileName);
 });
 
 rig.events.on('civ', (bytes) => {
@@ -87,6 +90,42 @@ rig.events.on('error', (err) => console.error('UDP error', err));
 rig.sendCiv(Buffer.from([0xfe,0xfe,0xa4,0xe0,0x03,0xfd]));
 ```
 
+### Main Rig Control Usage
+
+Modern ICOM LAN/WLAN radios still transport standard serial CI‑V frames inside the UDP CIV payload. `icom-wlan-node` selects a model profile automatically from the radio name or CI‑V address, or you can force one with `model`.
+
+```ts
+const rig = new IcomControl({
+  control: { ip: '192.168.1.50', port: 50001 },
+  userName: 'icom',
+  password: 'icomicom',
+  model: 'auto' // 'IC-705', 'IC-905', 'IC-7300', 'IC-9700', 'IC-7610', 'IC-7760'
+});
+
+await rig.connect();
+
+// Frequency and mode are profile-aware:
+// modern profiles use CI-V 0x25/0x26, legacy fallback uses 0x05/0x06.
+await rig.setFrequency(14074000);
+await rig.setMode('USB', { dataMode: true, filter: 1 }); // USB-D, filter 1
+
+const freqHz = await rig.readOperatingFrequency();
+const mode = await rig.readOperatingMode();
+const tx = await rig.readPtt();
+console.log({ freqHz, mode, state: tx ? 'TX' : 'RX' });
+
+// Tuner uses Hamlib-aligned CI-V 0x1C/0x01.
+const tuner = await rig.readTunerStatus();
+await rig.setTunerEnabled(true);
+
+// Meters use active-profile calibration tables.
+const swr = await rig.readSWR();
+const power = await rig.readPowerLevel();
+console.log({ tuner, swr, watts: power?.watts, powerPercent: power?.percent });
+```
+
+Profile-specific behavior includes IC-905 6-byte frequency BCD above 5.85 GHz, model-specific scope fixed-edge ranges, and calibrated SWR/ALC/RF power/COMP/voltage/current meters. Private connector commands such as WLAN level or connector data mode are only enabled when the active profile declares the vendor extension; unsupported writes throw `UnsupportedCommandError`.
+
 ### PTT and Audio TX
 
 ```ts
@@ -136,7 +175,7 @@ await rig.disableScope();
 
 ## API Overview
 
-- `new IcomControl(options)`
+- `new IcomControl(options)` — `options.model` may be `'auto'` or a supported model profile such as `'IC-705'`, `'IC-905'`, `'IC-7300'`, `'IC-9700'`, `'IC-7610'`, or `'IC-7760'`
   - `options.control`: `{ ip, port }` radio control UDP endpoint
   - `options.userName`, `options.password`
 - Events (`rig.events.on(...)`)
@@ -160,12 +199,12 @@ await rig.disableScope();
   - **Scope / Spectrum**: `scope`, `enableScope()`, `disableScope()`, `waitForScopeFrame()`
   - **Audio TX**: `setPtt(on: boolean)`, `sendAudioFloat32()`, `sendAudioPcm16()`
   - **Rig Control**: `setFrequency()`, `setMode()`, `setConnectorDataMode()`, `setConnectorWLanLevel()`
-  - **Rig Query**: `readOperatingFrequency()`, `readOperatingMode()`, `readTransmitFrequency()`, `readTransceiverState()`, `readBandEdges()`
+  - **Rig Query**: `readOperatingFrequency()`, `readOperatingMode()`, `readTransmitFrequency()`, `readPtt()`, `readTransceiverState()`, `readBandEdges()`
   - **Antenna Tuner**: `readTunerStatus()`, `setTunerEnabled()`, `startManualTune()`
   - **Meters (RX)**: `readSquelchStatus()`, `readAudioSquelch()`, `readOvfStatus()`, `getLevelMeter()`
   - **Meters (TX)**: `readSWR()`, `readALC()`, `readPowerLevel()`, `readCompLevel()`
   - **Power Supply**: `readVoltage()`, `readCurrent()`
-  - **Audio Config**: `getConnectorWLanLevel()`
+  - **Audio Config**: `getUsbAfLevel()`, `setUsbAfLevel()`, `getConnectorWLanLevel()`
   - **Connection Monitoring**: `getConnectionPhase()`, `getConnectionMetrics()`, `getConnectionState()`, `isAnySessionDisconnected()`, `configureMonitoring()`
 
 ### Connection Management & Auto-Reconnect
@@ -285,8 +324,8 @@ The library exposes common CI‑V operations as friendly methods. Addresses are
 
 #### Rig Control
 
-- `setFrequency(hz: number)` — Set operating frequency in Hz
-- `setMode(mode: IcomMode | number, options?: { dataMode?: boolean })` — Set mode (supports string or numeric code)
+- `setFrequency(hz: number)` — Set operating frequency in Hz; modern profiles use targetable CI-V `0x25`, and IC-905 uses 6-byte BCD above 5.85 GHz
+- `setMode(mode: IcomMode | number, options?: { dataMode?: boolean; filter?: 1|2|3 })` — Set mode; modern profiles use CI-V `0x26` with VFO, data-mode and filter
 - `setPtt(on: boolean)` — Key/unkey transmitter
 
 **Supported Modes** (IcomMode string constants):
@@ -296,8 +335,9 @@ The library exposes common CI‑V operations as friendly methods. Addresses are
 #### Rig Query
 
 - `readOperatingFrequency(options?: QueryOptions) => Promise<number|null>`
-- `readOperatingMode(options?: QueryOptions) => Promise<{ mode: number; filter?: number; modeName?: string; filterName?: string } | null>`
+- `readOperatingMode(options?: QueryOptions) => Promise<{ mode: number; filter?: number; modeName?: string; filterName?: string; dataMode?: boolean } | null>`
 - `readTransmitFrequency(options?: QueryOptions) => Promise<number|null>`
+- `readPtt(options?: QueryOptions) => Promise<boolean|null>`
 - `readTransceiverState(options?: QueryOptions) => Promise<'TX' | 'RX' | 'UNKNOWN' | null>`
 - `readBandEdges(options?: QueryOptions) => Promise<Buffer|null>`
 
@@ -306,8 +346,18 @@ The library exposes common CI‑V operations as friendly methods. Addresses are
 - `scope: IcomScopeService` — Standalone scope service object that can be reused with other CI‑V transport paths in the future
 - `enableScope() => Promise<void>` — Send the minimal command sequence to enable basic scope output
 - `disableScope() => Promise<void>` — Send the minimal command sequence to disable scope output
+- `readScopeMode(options?: QueryOptions & { receiver?: 0 | 1 }) => Promise<IcomScopeModeInfo | null>` — Read current scope mode using CI‑V `0x27 0x14`
+- `setScopeMode(mode: IcomScopeMode | 0 | 1 | 2 | 3, options?: { receiver?: 0 | 1 }) => Promise<void>` — Set current scope mode
 - `readScopeSpan(options?: QueryOptions & { receiver?: 0 | 1 }) => Promise<{ receiver: 0 | 1; spanHz: number } | null>` — Read current scope span
-- `setScopeSpan(spanHz: number, options?: { receiver?: 0 | 1 }) => Promise<void>` — Set scope span using CI‑V `0x27 0x15`
+- `setScopeSpan(spanHz: number, options?: { receiver?: 0 | 1 }) => Promise<void>` — Set public scope span using CI‑V `0x27 0x15`; the wire value is `spanHz / 2` per Hamlib
+- `readScopeEdge(options?: QueryOptions & { receiver?: 0 | 1 }) => Promise<IcomScopeEdgeInfo | null>` — Read active fixed-edge slot using CI‑V `0x27 0x16`
+- `setScopeEdge(edgeSlot: number, options?: { receiver?: 0 | 1 }) => Promise<void>` — Select active fixed-edge slot
+- `readScopeFixedEdge(rangeId: number, edgeSlot: number, options?: QueryOptions) => Promise<IcomScopeFixedEdgeInfo | null>` — Read fixed-edge frequencies using CI‑V `0x27 0x1E`
+- `setScopeFixedEdge({ rangeId?, edgeSlot?, lowHz, highHz }) => Promise<IcomScopeFixedEdgeInfo>` — Set fixed-edge frequencies, auto-resolving `rangeId` from the current rig frequency when omitted
+- `resolveScopeFrequencyRangeId(frequencyHz?: number) => Promise<number>` — Resolve ICOM fixed-edge range ID from a target or current operating frequency
+- `getSpectrumMode()/setSpectrumMode()` / `getSpectrumSpan()/setSpectrumSpan()` / `getSpectrumEdgeSlot()/setSpectrumEdgeSlot()` / `getSpectrumFixedEdges()/setSpectrumFixedEdges()` — Hamlib-like convenience aliases over the scope-specific methods
+- `getSpectrumDisplayState(options?: QueryOptions & { receiver?: 0 | 1 }) => Promise<IcomSpectrumDisplayState>` — Read a Hamlib-like normalized display state
+- `configureSpectrumDisplay(config?: IcomSpectrumDisplayConfig) => Promise<IcomSpectrumDisplayState>` — Apply a normalized display config covering center/fixed modes
 - `waitForScopeFrame(options?: QueryOptions) => Promise<IcomScopeFrame | null>` — Wait for the next complete scope frame
 
 `IcomScopeFrame` shape:
@@ -330,17 +380,17 @@ interface IcomScopeFrame {
 
 Current implementation notes:
 
-- Currently implements basic on/off controls, `0x27 0x15` span read/write, and `0x27 00 00` scope data capture
+- Implements basic on/off controls, `0x27 0x15` span read/write, fixed-edge selection/ranges, and `0x27 00 00` scope data capture
 - The parsing layer is decoupled from the UDP session layer and only depends on complete CI‑V frames
-- Frequency fields are currently parsed with `freqLen=5` by default
+- Frequency and fixed-edge ranges are profile-aware; unsupported model-specific variants should be added in `src/rig/IcomProfiles.ts`
 - LAN aggregate waterfall payload splitting is not implemented yet; standard segment input is supported
 - The `scope` logic is designed to be reusable for future serial CI‑V or Hamlib CI‑V integration
 
 #### Antenna Tuner (ATU)
 
-- `readTunerStatus(options?: QueryOptions) => Promise<{ raw: number; state: 'OFF'|'ON'|'TUNING' } | null>` — Read tuner status (CI‑V 0x1A/0x00)
-- `setTunerEnabled(enabled: boolean) => Promise<void>` — Enable/disable internal tuner (CI‑V 0x1A/0x01)
-- `startManualTune() => Promise<void>` — Trigger one manual tune cycle (CI‑V 0x1A/0x02/0x00)
+- `readTunerStatus(options?: QueryOptions) => Promise<{ raw: number; state: 'OFF'|'ON'|'TUNING' } | null>` — Read tuner status (Hamlib-aligned CI-V `0x1C 0x01`)
+- `setTunerEnabled(enabled: boolean) => Promise<void>` — Enable/disable internal tuner (Hamlib-aligned CI‑V `0x1C 0x01 0x00/0x01`)
+- `startManualTune() => Promise<void>` — Trigger one manual tune cycle (Hamlib-aligned CI‑V `0x1C 0x01 0x02`)
 
 #### Meters & Levels
 
@@ -353,20 +403,20 @@ Current implementation notes:
 **Transmission Meters** (require PTT on):
 - `readSWR(options?: QueryOptions) => Promise<{ raw: number; swr: number; alert: boolean } | null>` — SWR meter (CI-V 0x15/0x12)
 - `readALC(options?: QueryOptions) => Promise<{ raw: number; percent: number; alert: boolean } | null>` — ALC meter (CI-V 0x15/0x13)
-- `readPowerLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>` — Output power level (CI-V 0x15/0x11)
-- `readCompLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>` — Voice compression level (CI-V 0x15/0x14)
+- `readPowerLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number; watts?: number } | null>` — Output power level (CI-V 0x15/0x11)
+- `readCompLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number; db?: number } | null>` — Voice compression level (CI-V 0x15/0x14)
 
 **Power Supply Monitoring**:
 - `readVoltage(options?: QueryOptions) => Promise<{ raw: number; volts: number } | null>` — Supply voltage (CI-V 0x15/0x15)
 - `readCurrent(options?: QueryOptions) => Promise<{ raw: number; amps: number } | null>` — Supply current draw (CI-V 0x15/0x16)
 
 **Audio Configuration**:
-- `getConnectorWLanLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>` — Get WLAN audio level (CI-V 0x1A/0x05/0x01/0x17)
-- `setConnectorWLanLevel(level: number)` — Set WLAN audio level (0-255)
+- `getUsbAfLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>` / `setUsbAfLevel(level: number)` — Hamlib-aligned USB AF level when the active profile declares it
+- `getConnectorWLanLevel(options?: QueryOptions) => Promise<{ raw: number; percent: number } | null>` / `setConnectorWLanLevel(level: number)` — Private `icom-wlan-node` WLAN level extension; returns `null` or throws `UnsupportedCommandError` when the active profile does not declare it
 
 #### Connector Settings
 
-- `setConnectorDataMode(mode: ConnectorDataMode | number)` — Set data routing mode (supports string or numeric)
+- `setConnectorDataMode(mode: ConnectorDataMode | number)` — Private connector routing extension; supported only on profiles that declare the vendor command
 
 **Supported Connector Modes** (ConnectorDataMode string constants):
 - `'MIC'` (0x00), `'ACC'` (0x01), `'USB'` (0x02), `'WLAN'` (0x03)
@@ -447,17 +497,17 @@ if (alc) {
 
 const power = await rig.readPowerLevel({ timeout: 2000 });
 if (power) {
-  console.log(`Power: ${power.percent.toFixed(1)}%`);
+  console.log(`Power: ${power.percent.toFixed(1)}%${power.watts != null ? ` (${power.watts.toFixed(1)} W)` : ''}`);
 }
 
 const comp = await rig.readCompLevel({ timeout: 2000 });
 if (comp) {
-  console.log(`COMP: ${comp.percent.toFixed(1)}%`);
+  console.log(`COMP: ${comp.percent.toFixed(1)}%${comp.db != null ? ` (${comp.db.toFixed(1)} dB)` : ''}`);
 }
 
 await rig.setPtt(false);
 
-// Configure WLAN connector
+// Configure WLAN connector (private extension; profile-gated)
 const wlanLevel = await rig.getConnectorWLanLevel({ timeout: 2000 });
 if (wlanLevel) {
   console.log(`WLAN Level: ${wlanLevel.percent.toFixed(1)}%`);
@@ -521,9 +571,8 @@ ICOM_IP=192.168.31.253 ICOM_PORT=50001 ICOM_USER=icom ICOM_PASS=icomicom npm tes
 - Full token renewal loop and advanced status flag parsing simplified.
 - Audio receive/playback is library‑only; playback is up to the integrator.
 - Robust retransmit/multi‑retransmit handling can be extended.
-- Scope support is currently limited to basic on/off commands plus standard `0x27 00 00` segment parsing.
+- Scope support includes basic enable/disable, mode/span/edge/fixed-edge control, and standard `0x27 00 00` segment parsing.
 - LAN aggregate waterfall payload splitting is not implemented yet.
-- Scope control subcommands beyond basic enable/disable are not implemented yet.
 
 ## License
 

package/dist/index.d.ts

@@ -5,6 +5,9 @@ export { IcomScopeCommands } from './scope/IcomScopeCommands';
 export { MODE_MAP, CONNECTOR_MODE_MAP, DEFAULT_CONTROLLER_ADDR, METER_THRESHOLDS, METER_CALIBRATION, getModeCode, getConnectorModeCode, getModeString, getConnectorModeString, getFilterString, rawToPowerPercent, rawToVoltage, rawToCurrent } from './rig/IcomConstants';
 export { parseTwoByteBcd, intToTwoByteBcd } from './utils/bcd';
 export { IcomRigCommands } from './rig/IcomRigCommands';
+export { CIV } from './rig/IcomCivSpec';
+export { buildCivFrame, encodeFrequencyBcdLE, decodeFrequencyBcdLE, encodeBcdBE, decodeBcdBE } from './rig/IcomCivFrame';
+export { ICOM_PROFILES, resolveIcomProfile, getProfileByModel, interpolateCalibration } from './rig/IcomProfiles';
 export { AUDIO_RATE } from './rig/IcomAudio';
 export { setupGlobalErrorHandlers, setupBasicErrorProtection, GlobalErrorHandlerOptions } from './utils/errorHandling';
-export { ConnectionAbortedError, getDisconnectMessage } from './utils/errors';
+export { ConnectionAbortedError, UnsupportedCommandError, getDisconnectMessage } from './utils/errors';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDisconnectMessage = exports.ConnectionAbortedError = exports.setupBasicErrorProtection = exports.setupGlobalErrorHandlers = exports.AUDIO_RATE = exports.IcomRigCommands = exports.intToTwoByteBcd = exports.parseTwoByteBcd = exports.rawToCurrent = exports.rawToVoltage = exports.rawToPowerPercent = exports.getFilterString = exports.getConnectorModeString = exports.getModeString = exports.getConnectorModeCode = exports.getModeCode = exports.METER_CALIBRATION = exports.METER_THRESHOLDS = exports.DEFAULT_CONTROLLER_ADDR = exports.CONNECTOR_MODE_MAP = exports.MODE_MAP = exports.IcomScopeCommands = exports.IcomScopeService = exports.IcomControl = void 0;
+exports.getDisconnectMessage = exports.UnsupportedCommandError = exports.ConnectionAbortedError = exports.setupBasicErrorProtection = exports.setupGlobalErrorHandlers = exports.AUDIO_RATE = exports.interpolateCalibration = exports.getProfileByModel = exports.resolveIcomProfile = exports.ICOM_PROFILES = exports.decodeBcdBE = exports.encodeBcdBE = exports.decodeFrequencyBcdLE = exports.encodeFrequencyBcdLE = exports.buildCivFrame = exports.CIV = exports.IcomRigCommands = exports.intToTwoByteBcd = exports.parseTwoByteBcd = exports.rawToCurrent = exports.rawToVoltage = exports.rawToPowerPercent = exports.getFilterString = exports.getConnectorModeString = exports.getModeString = exports.getConnectorModeCode = exports.getModeCode = exports.METER_CALIBRATION = exports.METER_THRESHOLDS = exports.DEFAULT_CONTROLLER_ADDR = exports.CONNECTOR_MODE_MAP = exports.MODE_MAP = exports.IcomScopeCommands = exports.IcomScopeService = exports.IcomControl = void 0;
 // Export types (includes ConnectionPhase, ConnectionMetrics, etc.)
 __exportStar(require("./types"), exports);
 // Export main class
@@ -46,6 +46,19 @@ Object.defineProperty(exports, "intToTwoByteBcd", { enumerable: true, get: funct
 // Export low-level utilities (for advanced users)
 var IcomRigCommands_1 = require("./rig/IcomRigCommands");
 Object.defineProperty(exports, "IcomRigCommands", { enumerable: true, get: function () { return IcomRigCommands_1.IcomRigCommands; } });
+var IcomCivSpec_1 = require("./rig/IcomCivSpec");
+Object.defineProperty(exports, "CIV", { enumerable: true, get: function () { return IcomCivSpec_1.CIV; } });
+var IcomCivFrame_1 = require("./rig/IcomCivFrame");
+Object.defineProperty(exports, "buildCivFrame", { enumerable: true, get: function () { return IcomCivFrame_1.buildCivFrame; } });
+Object.defineProperty(exports, "encodeFrequencyBcdLE", { enumerable: true, get: function () { return IcomCivFrame_1.encodeFrequencyBcdLE; } });
+Object.defineProperty(exports, "decodeFrequencyBcdLE", { enumerable: true, get: function () { return IcomCivFrame_1.decodeFrequencyBcdLE; } });
+Object.defineProperty(exports, "encodeBcdBE", { enumerable: true, get: function () { return IcomCivFrame_1.encodeBcdBE; } });
+Object.defineProperty(exports, "decodeBcdBE", { enumerable: true, get: function () { return IcomCivFrame_1.decodeBcdBE; } });
+var IcomProfiles_1 = require("./rig/IcomProfiles");
+Object.defineProperty(exports, "ICOM_PROFILES", { enumerable: true, get: function () { return IcomProfiles_1.ICOM_PROFILES; } });
+Object.defineProperty(exports, "resolveIcomProfile", { enumerable: true, get: function () { return IcomProfiles_1.resolveIcomProfile; } });
+Object.defineProperty(exports, "getProfileByModel", { enumerable: true, get: function () { return IcomProfiles_1.getProfileByModel; } });
+Object.defineProperty(exports, "interpolateCalibration", { enumerable: true, get: function () { return IcomProfiles_1.interpolateCalibration; } });
 var IcomAudio_1 = require("./rig/IcomAudio");
 Object.defineProperty(exports, "AUDIO_RATE", { enumerable: true, get: function () { return IcomAudio_1.AUDIO_RATE; } });
 // Export error handling utilities (optional, for robustness)
@@ -55,4 +68,5 @@ Object.defineProperty(exports, "setupBasicErrorProtection", { enumerable: true,
 // Export disconnect error utilities
 var errors_1 = require("./utils/errors");
 Object.defineProperty(exports, "ConnectionAbortedError", { enumerable: true, get: function () { return errors_1.ConnectionAbortedError; } });
+Object.defineProperty(exports, "UnsupportedCommandError", { enumerable: true, get: function () { return errors_1.UnsupportedCommandError; } });
 Object.defineProperty(exports, "getDisconnectMessage", { enumerable: true, get: function () { return errors_1.getDisconnectMessage; } });

package/dist/rig/IcomCivFrame.d.ts

@@ -0,0 +1,13 @@
+export interface CivFrameBuildOptions {
+    rigAddr: number;
+    ctrlAddr: number;
+    cmd: number;
+    subcmd?: number | number[];
+    payload?: Buffer | number[];
+}
+export declare function buildCivFrame(options: CivFrameBuildOptions): Buffer;
+export declare function encodeFrequencyBcdLE(freqHz: number, byteLength?: number): Buffer;
+export declare function decodeFrequencyBcdLE(bytes: Buffer | Uint8Array): number;
+export declare function encodeBcdBE(value: number, byteLength: number): Buffer;
+export declare function decodeBcdBE(bytes: Buffer | Uint8Array): number;
+export declare function getCivPayload(frame: Buffer): Buffer | null;

package/dist/rig/IcomCivFrame.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCivFrame = buildCivFrame;
+exports.encodeFrequencyBcdLE = encodeFrequencyBcdLE;
+exports.decodeFrequencyBcdLE = decodeFrequencyBcdLE;
+exports.encodeBcdBE = encodeBcdBE;
+exports.decodeBcdBE = decodeBcdBE;
+exports.getCivPayload = getCivPayload;
+const IcomCivSpec_1 = require("./IcomCivSpec");
+function buildCivFrame(options) {
+    const subcmd = options.subcmd === undefined
+        ? []
+        : Array.isArray(options.subcmd)
+            ? options.subcmd
+            : [options.subcmd];
+    const payload = options.payload ? Array.from(options.payload) : [];
+    return Buffer.from([
+        IcomCivSpec_1.CIV.PR,
+        IcomCivSpec_1.CIV.PR,
+        options.rigAddr & 0xff,
+        options.ctrlAddr & 0xff,
+        options.cmd & 0xff,
+        ...subcmd.map((v) => v & 0xff),
+        ...payload.map((v) => v & 0xff),
+        IcomCivSpec_1.CIV.FI,
+    ]);
+}
+function encodeFrequencyBcdLE(freqHz, byteLength = 5) {
+    const out = Buffer.alloc(byteLength);
+    let remaining = Math.max(0, Math.round(freqHz));
+    for (let i = 0; i < byteLength; i++) {
+        const twoDigits = remaining % 100;
+        out[i] = ((((twoDigits / 10) | 0) & 0x0f) << 4) | (twoDigits % 10);
+        remaining = Math.floor(remaining / 100);
+    }
+    return out;
+}
+function decodeFrequencyBcdLE(bytes) {
+    let hz = 0;
+    let multiplier = 1;
+    for (const byte of bytes) {
+        hz += (byte & 0x0f) * multiplier;
+        multiplier *= 10;
+        hz += ((byte >> 4) & 0x0f) * multiplier;
+        multiplier *= 10;
+    }
+    return hz;
+}
+function encodeBcdBE(value, byteLength) {
+    const out = Buffer.alloc(byteLength);
+    let remaining = Math.max(0, Math.floor(value));
+    for (let i = byteLength - 1; i >= 0; i--) {
+        const twoDigits = remaining % 100;
+        out[i] = ((((twoDigits / 10) | 0) & 0x0f) << 4) | (twoDigits % 10);
+        remaining = Math.floor(remaining / 100);
+    }
+    return out;
+}
+function decodeBcdBE(bytes) {
+    let value = 0;
+    for (const byte of bytes) {
+        value = value * 100 + (((byte >> 4) & 0x0f) * 10) + (byte & 0x0f);
+    }
+    return value;
+}
+function getCivPayload(frame) {
+    if (frame.length < 6)
+        return null;
+    if (frame[0] !== IcomCivSpec_1.CIV.PR || frame[1] !== IcomCivSpec_1.CIV.PR || frame[frame.length - 1] !== IcomCivSpec_1.CIV.FI)
+        return null;
+    return frame.subarray(4, frame.length - 1);
+}

package/dist/rig/IcomCivSpec.d.ts

@@ -0,0 +1,54 @@
+/** Hamlib-aligned CI-V command and subcommand constants. */
+export declare const CIV: {
+    readonly PR: 254;
+    readonly FI: 253;
+    readonly ACK: 251;
+    readonly NAK: 250;
+    readonly CTRLID: 224;
+    readonly C_RD_BAND: 2;
+    readonly C_RD_FREQ: 3;
+    readonly C_RD_MODE: 4;
+    readonly C_SET_FREQ: 5;
+    readonly C_SET_MODE: 6;
+    readonly C_CTL_LVL: 20;
+    readonly C_RD_SQSM: 21;
+    readonly C_CTL_FUNC: 22;
+    readonly C_CTL_MEM: 26;
+    readonly C_CTL_PTT: 28;
+    readonly C_SEND_SEL_FREQ: 37;
+    readonly C_SEND_SEL_MODE: 38;
+    readonly C_CTL_SCP: 39;
+    readonly S_PTT: 0;
+    readonly S_ANT_TUN: 1;
+    readonly S_RD_TX_FREQ: 3;
+    readonly S_MEM_PARM: 5;
+    readonly S_MEM_DATA_MODE: 6;
+    readonly S_LVL_AF: 1;
+    readonly S_LVL_RF: 2;
+    readonly S_LVL_SQL: 3;
+    readonly S_LVL_NR: 6;
+    readonly S_LVL_RFPOWER: 10;
+    readonly S_LVL_MICGAIN: 11;
+    readonly S_LVL_COMP: 14;
+    readonly S_LVL_BKINDL: 15;
+    readonly S_LVL_NB: 18;
+    readonly S_LVL_DIGI: 19;
+    readonly S_SQL: 1;
+    readonly S_SML: 2;
+    readonly S_CSQL: 5;
+    readonly S_OVF: 7;
+    readonly S_RFML: 17;
+    readonly S_SWR: 18;
+    readonly S_ALC: 19;
+    readonly S_CMP: 20;
+    readonly S_VD: 21;
+    readonly S_ID: 22;
+    readonly S_SCP_DAT: 0;
+    readonly S_SCP_STS: 16;
+    readonly S_SCP_DOP: 17;
+    readonly S_SCP_MOD: 20;
+    readonly S_SCP_SPN: 21;
+    readonly S_SCP_EDG: 22;
+    readonly S_SCP_FEF: 30;
+};
+export declare const ICOM_MODE_FILTER_DEFAULT: 1;

package/dist/rig/IcomCivSpec.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICOM_MODE_FILTER_DEFAULT = exports.CIV = void 0;
+/** Hamlib-aligned CI-V command and subcommand constants. */
+exports.CIV = {
+    PR: 0xfe,
+    FI: 0xfd,
+    ACK: 0xfb,
+    NAK: 0xfa,
+    CTRLID: 0xe0,
+    C_RD_BAND: 0x02,
+    C_RD_FREQ: 0x03,
+    C_RD_MODE: 0x04,
+    C_SET_FREQ: 0x05,
+    C_SET_MODE: 0x06,
+    C_CTL_LVL: 0x14,
+    C_RD_SQSM: 0x15,
+    C_CTL_FUNC: 0x16,
+    C_CTL_MEM: 0x1a,
+    C_CTL_PTT: 0x1c,
+    C_SEND_SEL_FREQ: 0x25,
+    C_SEND_SEL_MODE: 0x26,
+    C_CTL_SCP: 0x27,
+    S_PTT: 0x00,
+    S_ANT_TUN: 0x01,
+    S_RD_TX_FREQ: 0x03,
+    S_MEM_PARM: 0x05,
+    S_MEM_DATA_MODE: 0x06,
+    S_LVL_AF: 0x01,
+    S_LVL_RF: 0x02,
+    S_LVL_SQL: 0x03,
+    S_LVL_NR: 0x06,
+    S_LVL_RFPOWER: 0x0a,
+    S_LVL_MICGAIN: 0x0b,
+    S_LVL_COMP: 0x0e,
+    S_LVL_BKINDL: 0x0f,
+    S_LVL_NB: 0x12,
+    S_LVL_DIGI: 0x13,
+    S_SQL: 0x01,
+    S_SML: 0x02,
+    S_CSQL: 0x05,
+    S_OVF: 0x07,
+    S_RFML: 0x11,
+    S_SWR: 0x12,
+    S_ALC: 0x13,
+    S_CMP: 0x14,
+    S_VD: 0x15,
+    S_ID: 0x16,
+    S_SCP_DAT: 0x00,
+    S_SCP_STS: 0x10,
+    S_SCP_DOP: 0x11,
+    S_SCP_MOD: 0x14,
+    S_SCP_SPN: 0x15,
+    S_SCP_EDG: 0x16,
+    S_SCP_FEF: 0x1e,
+};
+exports.ICOM_MODE_FILTER_DEFAULT = 1;

package/dist/rig/IcomControl.d.ts

@@ -1,7 +1,8 @@
-import { IcomRigOptions, RigEventEmitter, IcomMode, ConnectorDataMode, SetModeOptions, QueryOptions, SwrReading, AlcReading, WlanLevelReading, LevelMeterReading, SquelchStatusReading, AudioSquelchReading, OvfStatusReading, PowerLevelReading, CompLevelReading, VoltageReading, CurrentReading, ConnectionState, ConnectionMonitorConfig, ConnectionPhase, ConnectionMetrics, DisconnectReason, DisconnectOptions, TunerStatusReading, LevelReading, IcomScopeSpanInfo } from '../types';
+import { IcomRigOptions, RigEventEmitter, IcomMode, ConnectorDataMode, SetModeOptions, QueryOptions, SwrReading, AlcReading, WlanLevelReading, LevelMeterReading, SquelchStatusReading, AudioSquelchReading, OvfStatusReading, PowerLevelReading, CompLevelReading, VoltageReading, CurrentReading, ConnectionState, ConnectionMonitorConfig, ConnectionPhase, ConnectionMetrics, DisconnectReason, DisconnectOptions, TunerStatusReading, LevelReading, IcomScopeSpanInfo, IcomScopeMode, IcomScopeModeInfo, IcomScopeEdgeInfo, IcomScopeFixedEdgeInfo, IcomSpectrumDisplayState, IcomSpectrumDisplayConfig } from '../types';
 import { IcomCiv } from './IcomCiv';
 import { IcomAudio } from './IcomAudio';
 import { IcomScopeService } from '../scope/IcomScopeService';
+import { IcomProfile } from './IcomProfiles';
 export declare class IcomControl {
     private ev;
     private sess;
@@ -16,6 +17,8 @@ export declare class IcomControl {
     private tokenTimer?;
     private civAssembleBuf;
     private meterTimer?;
+    private activeProfile;
+    private lastFilter;
     private connectionSession;
     private nextSessionId;
     private abortHandlers;
@@ -23,6 +26,9 @@ export declare class IcomControl {
     private monitorConfig;
     constructor(options: IcomRigOptions);
     get events(): RigEventEmitter;
+    get profile(): IcomProfile;
+    private resolveActiveProfile;
+    private getProfileModelId;
     /**
      * Transition to a new connection phase with logging
      * @private
@@ -83,6 +89,70 @@ export declare class IcomControl {
     setScopeSpan(spanHz: number, options?: {
         receiver?: 0 | 1;
     }): Promise<void>;
+    readScopeMode(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<IcomScopeModeInfo | null>;
+    setScopeMode(mode: IcomScopeMode | 0 | 1 | 2 | 3, options?: {
+        receiver?: 0 | 1;
+    }): Promise<void>;
+    readScopeEdge(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<IcomScopeEdgeInfo | null>;
+    setScopeEdge(edgeSlot: number, options?: {
+        receiver?: 0 | 1;
+    }): Promise<void>;
+    readScopeFixedEdge(rangeId: number, edgeSlot: number, options?: QueryOptions): Promise<IcomScopeFixedEdgeInfo | null>;
+    setScopeFixedEdge(options: {
+        rangeId?: number;
+        edgeSlot?: number;
+        lowHz: number;
+        highHz: number;
+    }): Promise<IcomScopeFixedEdgeInfo>;
+    resolveScopeFrequencyRangeId(frequencyHz?: number): Promise<number>;
+    getScopeSupportedEdgeSlots(): number[];
+    getSpectrumDisplayState(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<IcomSpectrumDisplayState>;
+    configureSpectrumDisplay(config?: IcomSpectrumDisplayConfig): Promise<IcomSpectrumDisplayState>;
+    getSpectrumMode(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<IcomScopeMode | null>;
+    setSpectrumMode(mode: IcomScopeMode, options?: {
+        receiver?: 0 | 1;
+    }): Promise<void>;
+    getSpectrumSpan(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<number | null>;
+    setSpectrumSpan(spanHz: number, options?: {
+        receiver?: 0 | 1;
+    }): Promise<void>;
+    getSpectrumEdgeSlot(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<number | null>;
+    setSpectrumEdgeSlot(edgeSlot: number, options?: {
+        receiver?: 0 | 1;
+    }): Promise<void>;
+    getSpectrumFixedEdges(options?: QueryOptions & {
+        receiver?: 0 | 1;
+        rangeId?: number;
+        edgeSlot?: number;
+    }): Promise<{
+        lowHz: number;
+        highHz: number;
+        rangeId: number;
+        edgeSlot: number;
+    } | null>;
+    setSpectrumFixedEdges(options: {
+        rangeId?: number;
+        edgeSlot?: number;
+        lowHz: number;
+        highHz: number;
+    }): Promise<{
+        lowHz: number;
+        highHz: number;
+        rangeId: number;
+        edgeSlot: number;
+    }>;
     waitForScopeFrame(options?: QueryOptions): Promise<import("../types").IcomScopeFrame | null>;
     /**
      * Set PTT (Push-To-Talk) state
@@ -123,15 +193,14 @@ export declare class IcomControl {
         filter?: number;
         modeName?: string;
         filterName?: string;
+        dataMode?: boolean;
     } | null>;
     /**
      * Read current transmit frequency (when TX)
      */
     readTransmitFrequency(options?: QueryOptions): Promise<number | null>;
-    /**
-     * Read transceiver state (TX/RX) via 0x1A 0x00 0x48
-     * Note: Java comments mark this as not recommended; use with caution.
-     */
+    readPtt(options?: QueryOptions): Promise<boolean | null>;
+    /** Read transceiver state (TX/RX) using standard Hamlib-aligned PTT status. */
     readTransceiverState(options?: QueryOptions): Promise<'TX' | 'RX' | 'UNKNOWN' | null>;
     /**
      * Read band edge data (0x02). Format may vary by rig; returns raw data bytes after command.
@@ -193,6 +262,8 @@ export declare class IcomControl {
      * @param level - Audio level (0-255)
      */
     setConnectorWLanLevel(level: number): Promise<void>;
+    getUsbAfLevel(options?: QueryOptions): Promise<WlanLevelReading | null>;
+    setUsbAfLevel(level: number): Promise<void>;
     /**
      * Set connector data routing mode
      * @param mode - Data routing mode (MIC, ACC, USB, WLAN)
@@ -207,17 +278,17 @@ export declare class IcomControl {
      * ==============================
      */
     /**
-     * Read antenna tuner status (CI-V 0x1A/0x00)
+     * Read antenna tuner status (CI-V 0x1C/0x01)
      * 00=OFF, 01=ON, 02=TUNING
      */
     readTunerStatus(options?: QueryOptions): Promise<TunerStatusReading | null>;
     /**
-     * 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
      */
     setTunerEnabled(enabled: boolean): Promise<void>;
     /**
-     * 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)
      */
     startManualTune(): Promise<void>;
     /** Get AF (audio output) gain. Returns 0.0–1.0, or null on timeout. */
@@ -236,6 +307,10 @@ export declare class IcomControl {
     getMicGain(options?: QueryOptions): Promise<LevelReading | null>;
     /** Set microphone gain. Value 0.0–1.0. */
     setMicGain(value: number): void;
+    /** Get break-in delay. Returns 0.0–1.0, or null on timeout. */
+    getBreakInDelay(options?: QueryOptions): Promise<LevelReading | null>;
+    /** Set break-in delay. Value 0.0–1.0. */
+    setBreakInDelay(value: number): void;
     /** Get noise blanker level. 0.0 = off, >0.0 = on with strength. */
     getNBLevel(options?: QueryOptions): Promise<LevelReading | null>;
     /** Set noise blanker level. Value 0.0 (off) – 1.0. */
@@ -329,9 +404,11 @@ export declare class IcomControl {
      * @returns Parsed BCD integer value, or null if invalid
      */
     private static extractMeterData;
+    private static extractTrailingBcd;
     private static matchCommand;
     private static matchCommandFrame;
     private waitForCiv;
+    static parseFrequencyReply(frame: Buffer, payloadOffsetAfterCommand: number, byteLength?: number): number | null;
     static parseIcomFreqFromReply(frame: Buffer): number | null;
     sendAudioFloat32(samples: Float32Array, addLeadingBuffer?: boolean): void;
     sendAudioPcm16(samples: Int16Array): void;