icom-wlan-node 0.2.7 → 0.4.0

package/README.md

@@ -4,6 +4,7 @@ Icom WLAN (UDP) protocol implementation in Node.js + TypeScript, featuring:
 
 - 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
 - Audio stream send/receive (LPCM 16‑bit mono @ 12 kHz; 20 ms frames)
 - Typed, event‑based API; designed for use as a dependency in other Node projects
 
@@ -63,6 +64,15 @@ rig.events.on('audio', (frame) => {
   // frame.pcm16 is raw 16‑bit PCM mono @ 12 kHz
 });
 
+rig.events.on('scopeFrame', (frame) => {
+  console.log(
+    'Scope:',
+    `${frame.startFreqHz}..${frame.endFreqHz} Hz`,
+    `pixels=${frame.pixels.length}`,
+    `mode=${frame.mode}`
+  );
+});
+
 rig.events.on('error', (err) => console.error('UDP error', err));
 
 (async () => {
@@ -93,6 +103,37 @@ rig.sendAudioFloat32(tone, true);
 await rig.setPtt(false);
 ```
 
+### Scope / Spectrum
+
+```ts
+await rig.connect();
+
+rig.events.on('scopeSegment', (segment) => {
+  console.log(`scope segment ${segment.sequence}/${segment.sequenceMax}`);
+});
+
+rig.events.on('scopeFrame', (frame) => {
+  console.log('scope frame ready', {
+    startFreqHz: frame.startFreqHz,
+    endFreqHz: frame.endFreqHz,
+    pixelCount: frame.pixels.length,
+    outOfRange: frame.outOfRange
+  });
+});
+
+// Enable basic scope output
+await rig.enableScope();
+
+// Wait for one complete frame
+const frame = await rig.waitForScopeFrame({ timeout: 3000 });
+if (frame) {
+  console.log(frame.pixels[0], frame.pixels[1]);
+}
+
+// Disable scope output when finished
+await rig.disableScope();
+```
+
 ## API Overview
 
 - `new IcomControl(options)`
@@ -104,6 +145,8 @@ await rig.setPtt(false);
   - `capabilities(CapabilitiesInfo)` — civ address, audio name (0xA8)
   - `civ(Buffer)` — raw CI‑V payload bytes as transported over UDP
   - `civFrame(Buffer)` — one complete CI‑V frame (FE FE ... FD)
+  - `scopeSegment(IcomScopeSegmentInfo)` — one parsed `0x27` scope segment
+  - `scopeFrame(IcomScopeFrame)` — one assembled spectrum/waterfall frame
   - `audio({ pcm16: Buffer })` — audio frames
   - `error(Error)` — UDP errors
   - `connectionLost(ConnectionLostInfo)` — session timeout detected
@@ -114,6 +157,7 @@ await rig.setPtt(false);
   - **Connection**: `connect()` / `disconnect(options?)` — connects control + CIV + audio sub‑sessions; resolves when all ready
     - `disconnect()` accepts optional `DisconnectOptions` or `DisconnectReason` for better error handling
   - **Raw CI‑V**: `sendCiv(buf: Buffer)` — send a raw CI‑V frame
+  - **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()`
@@ -257,6 +301,45 @@ The library exposes common CI‑V operations as friendly methods. Addresses are
 - `readTransceiverState(options?: QueryOptions) => Promise<'TX' | 'RX' | 'UNKNOWN' | null>`
 - `readBandEdges(options?: QueryOptions) => Promise<Buffer|null>`
 
+#### Scope / Spectrum
+
+- `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
+- `waitForScopeFrame(options?: QueryOptions) => Promise<IcomScopeFrame | null>` — Wait for the next complete scope frame
+
+`IcomScopeFrame` shape:
+
+```ts
+interface IcomScopeFrame {
+  valid: boolean;
+  receiver: 0 | 1;
+  sequence: number;
+  sequenceMax: number;
+  mode: 0 | 1 | 2 | 3;
+  outOfRange: boolean;
+  startFreqHz: number;
+  endFreqHz: number;
+  pixels: Uint8Array;
+  rawCivPayloads: Buffer[];
+  transport: 'lan-civ' | 'serial';
+}
+```
+
+Current implementation notes:
+
+- Currently implements only the basic on/off controls 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
+- 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)
+
 #### Meters & Levels
 
 **Reception Meters** (available anytime):
@@ -383,6 +466,23 @@ await rig.setConnectorDataMode('WLAN');
 // Or numeric: await rig.setConnectorDataMode(0x03);
 
 await rig.setConnectorWLanLevel(120); // Set WLAN audio level
+
+// Scope capture
+await rig.enableScope();
+const scope = await rig.waitForScopeFrame({ timeout: 3000 });
+if (scope) {
+  console.log(`Scope ${scope.startFreqHz}..${scope.endFreqHz}, ${scope.pixels.length} pixels`);
+}
+await rig.disableScope();
+
+// Antenna tuner
+const atu = await rig.readTunerStatus({ timeout: 2000 });
+if (atu) {
+  console.log('ATU:', atu.state);
+}
+
+await rig.setTunerEnabled(true);
+await rig.startManualTune();
 ```
 
 ## Design Notes
@@ -393,6 +493,7 @@ await rig.setConnectorWLanLevel(120); // Set WLAN audio level
 - Credentials use the same simple substitution cipher as FT8CN’s Android client (`passCode`).
 - The 0x90/0x50 handshake strictly follows FT8CN’s timing and endianness. We pre‑open local CIV/Audio sockets, reply with local ports on first 0x90, then set remote ports upon 0x50.
 - CIV/audio sub‑sessions each run their own Ping/Idle and (for CIV) OpenClose keep‑alive.
+- Scope data is treated as CI‑V business payload, not as a separate UDP stream. `IcomControl` only bridges CI‑V frames into the reusable `IcomScopeService`.
 
 ### Endianness and parsing tips
 
@@ -418,33 +519,10 @@ 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.
+- LAN aggregate waterfall payload splitting is not implemented yet.
+- Scope control subcommands beyond basic enable/disable are not implemented yet.
 
 ## License
 
 MIT
-#### Antenna Tuner (ATU)
-
-- `readTunerStatus(options?: QueryOptions) => Promise<{ raw: number; state: 'OFF'|'ON'|'TUNING' } | null>` — 读取天调状态（CI‑V 0x1A/0x00）
-- `setTunerEnabled(enabled: boolean) => Promise<void>` — 开启/关闭内置天调（CI‑V 0x1A/0x01 00/01）
-- `startManualTune() => Promise<void>` — 触发一次手动调谐（相当于 [TUNE] 键，CI‑V 0x1A/0x02/0x00）
-
-示例：
-
-```ts
-// 读取天调状态
-const atu = await rig.readTunerStatus({ timeout: 2000 });
-if (atu) console.log('ATU:', atu.state); // OFF / ON / TUNING
-
-// 启用内置天调
-await rig.setTunerEnabled(true);
-
-// 触发一次手动调谐
-await rig.startManualTune();
-
-// 可选：轮询状态直到结束
-let status;
-do {
-  await new Promise(r => setTimeout(r, 300));
-  status = await rig.readTunerStatus({ timeout: 1000 });
-} while (status && status.state === 'TUNING');
-```

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from './types';
 export { IcomControl } from './rig/IcomControl';
+export { IcomScopeService } from './scope/IcomScopeService';
+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';

package/dist/index.js

@@ -14,12 +14,16 @@ 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.IcomControl = void 0;
+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;
 // Export types (includes ConnectionPhase, ConnectionMetrics, etc.)
 __exportStar(require("./types"), exports);
 // Export main class
 var IcomControl_1 = require("./rig/IcomControl");
 Object.defineProperty(exports, "IcomControl", { enumerable: true, get: function () { return IcomControl_1.IcomControl; } });
+var IcomScopeService_1 = require("./scope/IcomScopeService");
+Object.defineProperty(exports, "IcomScopeService", { enumerable: true, get: function () { return IcomScopeService_1.IcomScopeService; } });
+var IcomScopeCommands_1 = require("./scope/IcomScopeCommands");
+Object.defineProperty(exports, "IcomScopeCommands", { enumerable: true, get: function () { return IcomScopeCommands_1.IcomScopeCommands; } });
 // Export constants and enums
 var IcomConstants_1 = require("./rig/IcomConstants");
 Object.defineProperty(exports, "MODE_MAP", { enumerable: true, get: function () { return IcomConstants_1.MODE_MAP; } });

package/dist/rig/IcomControl.d.ts

@@ -1,6 +1,7 @@
-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 } 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 } from '../types';
 import { IcomCiv } from './IcomCiv';
 import { IcomAudio } from './IcomAudio';
+import { IcomScopeService } from '../scope/IcomScopeService';
 export declare class IcomControl {
     private ev;
     private sess;
@@ -8,6 +9,7 @@ export declare class IcomControl {
     private audioSess;
     civ: IcomCiv;
     audio: IcomAudio;
+    scope: IcomScopeService;
     private options;
     private rigName;
     private macAddress;
@@ -73,6 +75,9 @@ export declare class IcomControl {
      */
     disconnect(options?: DisconnectOptions | DisconnectReason): Promise<void>;
     sendCiv(data: Buffer): void;
+    enableScope(): Promise<void>;
+    disableScope(): Promise<void>;
+    waitForScopeFrame(options?: QueryOptions): Promise<import("../types").IcomScopeFrame | null>;
     /**
      * Set PTT (Push-To-Talk) state
      * @param on - true to key transmitter, false to unkey
@@ -209,6 +214,30 @@ export declare class IcomControl {
      * Start a manual tuning cycle (same as [TUNE] key) (CI-V 0x1A/0x02/0x00)
      */
     startManualTune(): Promise<void>;
+    /** Get AF (audio output) gain. Returns 0.0–1.0, or null on timeout. */
+    getAFGain(options?: QueryOptions): Promise<LevelReading | null>;
+    /** Set AF (audio output) gain. Value 0.0–1.0. */
+    setAFGain(value: number): void;
+    /** Get squelch level. Returns 0.0–1.0, or null on timeout. */
+    getSQL(options?: QueryOptions): Promise<LevelReading | null>;
+    /** Set squelch level. Value 0.0–1.0. */
+    setSQL(value: number): void;
+    /** Get RF transmit power. Returns 0.0–1.0, or null on timeout. */
+    getRFPower(options?: QueryOptions): Promise<LevelReading | null>;
+    /** Set RF transmit power. Value 0.0–1.0. */
+    setRFPower(value: number): void;
+    /** Get microphone gain. Returns 0.0–1.0, or null on timeout. */
+    getMicGain(options?: QueryOptions): Promise<LevelReading | null>;
+    /** Set microphone gain. Value 0.0–1.0. */
+    setMicGain(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. */
+    setNBLevel(value: number): void;
+    /** Get noise reduction level. 0.0 = off, >0.0 = on with strength. */
+    getNRLevel(options?: QueryOptions): Promise<LevelReading | null>;
+    /** Set noise reduction level. Value 0.0 (off) – 1.0. */
+    setNRLevel(value: number): void;
     /**
      * Read squelch status (noise/signal gate state)
      * @param options - Query options (timeout in ms, default 3000)
@@ -305,6 +334,17 @@ export declare class IcomControl {
     private processCivPayload;
     private waitForCivFrame;
     private static isMeterReply;
+    private static is0x14DataReply;
+    /**
+     * Read a 0x14 level value from the radio.
+     * Returns normalized value 0.0-1.0, or null on timeout/error.
+     */
+    private read0x14Level;
+    /**
+     * Write a 0x14 level value to the radio.
+     * @param value - Normalized value 0.0-1.0
+     */
+    private write0x14Level;
     private startMeterPolling;
     private stopMeterPolling;
     private onAudioData;

package/dist/rig/IcomControl.js

@@ -46,6 +46,8 @@ const IcomConstants_1 = require("./IcomConstants");
 const bcd_1 = require("../utils/bcd");
 const errors_1 = require("../utils/errors");
 const smeter_1 = require("../utils/smeter");
+const IcomScopeCommands_1 = require("../scope/IcomScopeCommands");
+const IcomScopeService_1 = require("../scope/IcomScopeService");
 class IcomControl {
     constructor(options) {
         this.ev = new events_1.EventEmitter();
@@ -92,6 +94,9 @@ class IcomControl {
         this.audioSess.open();
         this.civ = new IcomCiv_1.IcomCiv(this.civSess);
         this.audio = new IcomAudio_1.IcomAudio(this.audioSess);
+        this.scope = new IcomScopeService_1.IcomScopeService();
+        this.scope.on('scopeSegment', (segment) => this.ev.emit('scopeSegment', segment));
+        this.scope.on('scopeFrame', (frame) => this.ev.emit('scopeFrame', frame));
     }
     get events() { return this.ev; }
     // ============================================================================
@@ -510,6 +515,22 @@ class IcomControl {
         }
     }
     sendCiv(data) { this.civ.sendCivData(data); }
+    async enableScope() {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeDisplay(ctrAddr, rigAddr, true));
+        this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeDataOutput(ctrAddr, rigAddr, true));
+    }
+    async disableScope() {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeDataOutput(ctrAddr, rigAddr, false));
+        this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeDisplay(ctrAddr, rigAddr, false));
+    }
+    async waitForScopeFrame(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        return this.scope.waitForScopeFrame(timeoutMs);
+    }
     /**
      * Set PTT (Push-To-Talk) state
      * @param on - true to key transmitter, false to unkey
@@ -852,6 +873,75 @@ class IcomControl {
         const rigAddr = this.civ.civAddress & 0xff;
         this.sendCiv(IcomRigCommands_1.IcomRigCommands.startManualTune(ctrAddr, rigAddr));
     }
+    // ============================================================================
+    // 0x14 Level API — AF Gain, SQL, RF Power, MIC Gain, NB Level, NR Level
+    // ============================================================================
+    /** Get AF (audio output) gain. Returns 0.0–1.0, or null on timeout. */
+    async getAFGain(options) {
+        const v = await this.read0x14Level(0x01, options);
+        if (v === null)
+            return null;
+        return { raw: Math.round(v * 255), normalized: v };
+    }
+    /** Set AF (audio output) gain. Value 0.0–1.0. */
+    setAFGain(value) {
+        this.write0x14Level(0x01, value);
+    }
+    /** Get squelch level. Returns 0.0–1.0, or null on timeout. */
+    async getSQL(options) {
+        const v = await this.read0x14Level(0x03, options);
+        if (v === null)
+            return null;
+        return { raw: Math.round(v * 255), normalized: v };
+    }
+    /** Set squelch level. Value 0.0–1.0. */
+    setSQL(value) {
+        this.write0x14Level(0x03, value);
+    }
+    /** Get RF transmit power. Returns 0.0–1.0, or null on timeout. */
+    async getRFPower(options) {
+        const v = await this.read0x14Level(0x0a, options);
+        if (v === null)
+            return null;
+        return { raw: Math.round(v * 255), normalized: v };
+    }
+    /** Set RF transmit power. Value 0.0–1.0. */
+    setRFPower(value) {
+        this.write0x14Level(0x0a, value);
+    }
+    /** Get microphone gain. Returns 0.0–1.0, or null on timeout. */
+    async getMicGain(options) {
+        const v = await this.read0x14Level(0x0f, 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);
+    }
+    /** Get noise blanker level. 0.0 = off, >0.0 = on with strength. */
+    async getNBLevel(options) {
+        const v = await this.read0x14Level(0x12, options);
+        if (v === null)
+            return null;
+        return { raw: Math.round(v * 255), normalized: v };
+    }
+    /** Set noise blanker level. Value 0.0 (off) – 1.0. */
+    setNBLevel(value) {
+        this.write0x14Level(0x12, value);
+    }
+    /** Get noise reduction level. 0.0 = off, >0.0 = on with strength. */
+    async getNRLevel(options) {
+        const v = await this.read0x14Level(0x13, 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);
+    }
     /**
      * Read squelch status (noise/signal gate state)
      * @param options - Query options (timeout in ms, default 3000)
@@ -1445,6 +1535,7 @@ class IcomControl {
             this.civAssembleBuf = this.civAssembleBuf.subarray(end + 1);
             // Emit event
             this.ev.emit('civFrame', frame);
+            this.scope.handleCivFrame(frame, 'lan-civ');
             // Continue loop in case multiple frames are in buffer
         }
     }
@@ -1488,6 +1579,50 @@ class IcomControl {
             return false;
         return true;
     }
+    // Strict 0x14 data reply matcher: FE FE [ctr|00] [rig] 0x14 [sub] [bcd_hi] [bcd_lo] FD
+    static is0x14DataReply(frame, subcmd, ctrAddr, rigAddr) {
+        if (!(frame && frame.length >= 9))
+            return false;
+        if (frame[0] !== 0xfe || frame[1] !== 0xfe)
+            return false;
+        const addrCtrOk = frame[2] === (ctrAddr & 0xff) || frame[2] === 0x00;
+        const addrRigOk = frame[3] === (rigAddr & 0xff);
+        if (!addrCtrOk || !addrRigOk)
+            return false;
+        if (frame[4] !== 0x14)
+            return false;
+        if (frame[5] !== (subcmd & 0xff))
+            return false;
+        if (frame[frame.length - 1] !== 0xfd)
+            return false;
+        return true;
+    }
+    /**
+     * Read a 0x14 level value from the radio.
+     * Returns normalized value 0.0-1.0, or null on timeout/error.
+     */
+    async read0x14Level(subcmd, options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomRigCommands_1.IcomRigCommands.get0x14Level(ctrAddr, rigAddr, subcmd);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.is0x14DataReply(frame, subcmd, ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 9)
+            return null;
+        const raw = (0, bcd_1.parseTwoByteBcd)(resp.subarray(6, 8));
+        return raw / 255;
+    }
+    /**
+     * Write a 0x14 level value to the radio.
+     * @param value - Normalized value 0.0-1.0
+     */
+    write0x14Level(subcmd, value) {
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const raw = Math.max(0, Math.min(255, Math.round(value * 255)));
+        const bcd = (0, bcd_1.intToTwoByteBcd)(raw);
+        this.sendCiv(IcomRigCommands_1.IcomRigCommands.set0x14Level(ctrAddr, rigAddr, subcmd, bcd[0], bcd[1]));
+    }
     // Start meter polling like Java (every 500ms when PTT is on)
     startMeterPolling() {
         this.stopMeterPolling();

package/dist/rig/IcomRigCommands.d.ts

@@ -21,6 +21,17 @@ 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;
     startManualTune(ctrAddr: number, rigAddr: number): Buffer;

package/dist/rig/IcomRigCommands.js

@@ -99,6 +99,26 @@ exports.IcomRigCommands = {
         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.
+     */
+    get0x14Level(ctrAddr, rigAddr, subcmd) {
+        // FE FE [rig] [ctr] 0x14 [subcmd] FD
+        return Buffer.from([0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x14, subcmd & 0xff, 0xfd]);
+    },
+    /**
+     * 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]);
+    },
+    // =====================
     // Antenna Tuner (ATU)
     // =====================
     getTunerStatus(ctrAddr, rigAddr) {

package/dist/scope/IcomScopeCommands.d.ts

@@ -0,0 +1,4 @@
+export declare const IcomScopeCommands: {
+    setScopeDataOutput(ctrAddr: number, rigAddr: number, enabled: boolean): Buffer;
+    setScopeDisplay(ctrAddr: number, rigAddr: number, enabled: boolean): Buffer;
+};

package/dist/scope/IcomScopeCommands.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IcomScopeCommands = void 0;
+exports.IcomScopeCommands = {
+    setScopeDataOutput(ctrAddr, rigAddr, enabled) {
+        return Buffer.from([
+            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x27, 0x11, enabled ? 0x01 : 0x00, 0xfd
+        ]);
+    },
+    setScopeDisplay(ctrAddr, rigAddr, enabled) {
+        return Buffer.from([
+            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x27, 0x10, enabled ? 0x01 : 0x00, 0xfd
+        ]);
+    }
+};

package/dist/scope/IcomScopeParser.d.ts

@@ -0,0 +1,5 @@
+import { IcomScopeSegmentInfo } from '../types';
+export declare function isScopeFrame(frame: Buffer): boolean;
+export declare function bcdByteToInt(v: number): number;
+export declare function parseIcomBcdFreqLE(bytes: Buffer): number;
+export declare function parseScopeSegment(frame: Buffer, transport: 'lan-civ' | 'serial', freqLen?: number): IcomScopeSegmentInfo | null;

package/dist/scope/IcomScopeParser.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScopeFrame = isScopeFrame;
+exports.bcdByteToInt = bcdByteToInt;
+exports.parseIcomBcdFreqLE = parseIcomBcdFreqLE;
+exports.parseScopeSegment = parseScopeSegment;
+const SCOPE_PREFIX = [0x27, 0x00, 0x00];
+function isScopeFrame(frame) {
+    if (frame.length < 9)
+        return false;
+    if (frame[0] !== 0xfe || frame[1] !== 0xfe)
+        return false;
+    if (frame[frame.length - 1] !== 0xfd)
+        return false;
+    return frame[4] === SCOPE_PREFIX[0] && frame[5] === SCOPE_PREFIX[1] && frame[6] === SCOPE_PREFIX[2];
+}
+function bcdByteToInt(v) {
+    return (v & 0x0f) + (((v >> 4) & 0x0f) * 10);
+}
+function parseIcomBcdFreqLE(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 parseScopeSegment(frame, transport, freqLen = 5) {
+    if (!isScopeFrame(frame))
+        return null;
+    const payload = frame.subarray(4, frame.length - 1);
+    if (payload.length < 5)
+        return null;
+    const sequence = bcdByteToInt(payload[3]);
+    const sequenceMax = bcdByteToInt(payload[4]);
+    if (sequence <= 0 || sequenceMax <= 0 || sequence > sequenceMax)
+        return null;
+    const segment = {
+        receiver: 0,
+        sequence,
+        sequenceMax,
+        rawCivPayload: Buffer.from(payload),
+        transport
+    };
+    if (sequence === 1) {
+        const minimumHeaderLength = 3 + 2 + (freqLen * 2) + 1;
+        if (payload.length < minimumHeaderLength)
+            return null;
+        const mode = payload[5];
+        const primaryFreq = parseIcomBcdFreqLE(payload.subarray(6, 6 + freqLen));
+        const secondaryFreq = parseIcomBcdFreqLE(payload.subarray(6 + freqLen, 6 + (freqLen * 2)));
+        const outOfRange = payload[6 + (freqLen * 2)] !== 0x00;
+        let startFreqHz = primaryFreq;
+        let endFreqHz = secondaryFreq;
+        if (mode === 0) {
+            startFreqHz = Math.max(0, primaryFreq - secondaryFreq);
+            endFreqHz = primaryFreq + secondaryFreq;
+        }
+        segment.mode = mode;
+        segment.outOfRange = outOfRange;
+        segment.startFreqHz = startFreqHz;
+        segment.endFreqHz = endFreqHz;
+        const pixelOffset = 7 + (freqLen * 2);
+        segment.pixels = new Uint8Array(payload.subarray(pixelOffset));
+        return segment;
+    }
+    segment.pixels = new Uint8Array(payload.subarray(5));
+    return segment;
+}

package/dist/scope/IcomScopeService.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from 'events';
+import { IcomScopeFrame, IcomScopeSegmentInfo, IcomScopeTransport } from '../types';
+export interface IcomScopeServiceOptions {
+    assemblyTimeoutMs?: number;
+    freqLen?: number;
+}
+export declare class IcomScopeService extends EventEmitter {
+    private readonly assemblyTimeoutMs;
+    private readonly freqLen;
+    private readonly assemblies;
+    constructor(options?: IcomScopeServiceOptions);
+    handleCivFrame(frame: Buffer, transport: IcomScopeTransport): IcomScopeFrame | null;
+    handleScopeSegment(segment: IcomScopeSegmentInfo): IcomScopeFrame | null;
+    waitForScopeFrame(timeoutMs?: number): Promise<IcomScopeFrame | null>;
+    private cleanupExpiredAssemblies;
+    private concatChunks;
+}

package/dist/scope/IcomScopeService.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IcomScopeService = void 0;
+const events_1 = require("events");
+const IcomScopeParser_1 = require("./IcomScopeParser");
+class IcomScopeService extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.assemblies = new Map();
+        this.assemblyTimeoutMs = options?.assemblyTimeoutMs ?? 500;
+        this.freqLen = options?.freqLen ?? 5;
+    }
+    handleCivFrame(frame, transport) {
+        const segment = (0, IcomScopeParser_1.parseScopeSegment)(frame, transport, this.freqLen);
+        if (!segment)
+            return null;
+        return this.handleScopeSegment(segment);
+    }
+    handleScopeSegment(segment) {
+        this.cleanupExpiredAssemblies();
+        this.emit('scopeSegment', segment);
+        const key = segment.receiver;
+        const now = Date.now();
+        if (segment.sequence === 1) {
+            this.assemblies.set(key, {
+                receiver: segment.receiver,
+                expectedMax: segment.sequenceMax,
+                mode: segment.mode,
+                startFreqHz: segment.startFreqHz,
+                endFreqHz: segment.endFreqHz,
+                outOfRange: segment.outOfRange,
+                chunks: segment.pixels ? [segment.pixels] : [],
+                rawCivPayloads: [Buffer.from(segment.rawCivPayload)],
+                updatedAt: now
+            });
+        }
+        else {
+            const state = this.assemblies.get(key);
+            if (!state)
+                return null;
+            if (state.expectedMax !== segment.sequenceMax) {
+                this.assemblies.delete(key);
+                return null;
+            }
+            state.chunks.push(segment.pixels ?? new Uint8Array());
+            state.rawCivPayloads.push(Buffer.from(segment.rawCivPayload));
+            state.updatedAt = now;
+        }
+        const state = this.assemblies.get(key);
+        if (!state)
+            return null;
+        if (segment.sequence !== state.expectedMax)
+            return null;
+        if (state.mode === undefined || state.startFreqHz === undefined || state.endFreqHz === undefined || state.outOfRange === undefined) {
+            this.assemblies.delete(key);
+            return null;
+        }
+        const pixels = this.concatChunks(state.chunks);
+        const frame = {
+            valid: true,
+            receiver: state.receiver,
+            sequence: segment.sequence,
+            sequenceMax: state.expectedMax,
+            mode: state.mode,
+            outOfRange: state.outOfRange,
+            startFreqHz: state.startFreqHz,
+            endFreqHz: state.endFreqHz,
+            pixels,
+            rawCivPayloads: state.rawCivPayloads.map((payload) => Buffer.from(payload)),
+            transport: segment.transport
+        };
+        this.assemblies.delete(key);
+        this.emit('scopeFrame', frame);
+        return frame;
+    }
+    async waitForScopeFrame(timeoutMs = 3000) {
+        return new Promise((resolve) => {
+            let done = false;
+            const onFrame = (frame) => {
+                done = true;
+                this.off('scopeFrame', onFrame);
+                resolve(frame);
+            };
+            this.on('scopeFrame', onFrame);
+            setTimeout(() => {
+                if (done)
+                    return;
+                this.off('scopeFrame', onFrame);
+                resolve(null);
+            }, timeoutMs);
+        });
+    }
+    cleanupExpiredAssemblies() {
+        const now = Date.now();
+        for (const [key, state] of this.assemblies.entries()) {
+            if (now - state.updatedAt > this.assemblyTimeoutMs) {
+                this.assemblies.delete(key);
+            }
+        }
+    }
+    concatChunks(chunks) {
+        const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const out = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            out.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return out;
+    }
+}
+exports.IcomScopeService = IcomScopeService;

package/dist/types.d.ts

@@ -39,6 +39,8 @@ export interface IcomRigEvents {
     capabilities: (c: CapabilitiesInfo) => void;
     civ: (data: Buffer) => void;
     civFrame: (frame: Buffer) => void;
+    scopeSegment: (segment: IcomScopeSegmentInfo) => void;
+    scopeFrame: (frame: IcomScopeFrame) => void;
     audio: (frame: AudioFrame) => void;
     error: (err: Error) => void;
     connectionLost: (info: ConnectionLostInfo) => void;
@@ -82,6 +84,32 @@ export interface QueryOptions {
      */
     timeout?: number;
 }
+export type IcomScopeTransport = 'lan-civ' | 'serial';
+export interface IcomScopeSegmentInfo {
+    receiver: 0 | 1;
+    sequence: number;
+    sequenceMax: number;
+    mode?: 0 | 1 | 2 | 3;
+    outOfRange?: boolean;
+    startFreqHz?: number;
+    endFreqHz?: number;
+    pixels?: Uint8Array;
+    rawCivPayload: Buffer;
+    transport: IcomScopeTransport;
+}
+export interface IcomScopeFrame {
+    valid: boolean;
+    receiver: 0 | 1;
+    sequence: number;
+    sequenceMax: number;
+    mode: 0 | 1 | 2 | 3;
+    outOfRange: boolean;
+    startFreqHz: number;
+    endFreqHz: number;
+    pixels: Uint8Array;
+    rawCivPayloads: Buffer[];
+    transport: IcomScopeTransport;
+}
 /**
  * Result of a meter reading operation (SWR, ALC, etc.)
  * @deprecated Use specific types like SwrReading, AlcReading instead
@@ -96,6 +124,16 @@ export interface MeterReading {
      */
     success: boolean;
 }
+/**
+ * Result of a 0x14 level read operation.
+ * Covers AF Gain, SQL Level, RF Power, MIC Gain, NB Level, NR Level.
+ */
+export interface LevelReading {
+    /** Raw BCD-decoded integer value (0–255) */
+    raw: number;
+    /** Normalized value in range 0.0–1.0 */
+    normalized: number;
+}
 /**
  * SWR (Standing Wave Ratio) meter reading
  * Represents antenna impedance matching quality

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icom-wlan-node",
-  "version": "0.2.7",
+  "version": "0.4.0",
   "description": "Icom WLAN (CI‑V, audio) protocol implementation for Node.js/TypeScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,23 +9,37 @@
     "clean": "rimraf dist",
     "test": "jest",
     "prepublishOnly": "npm run build",
-    "lint": "eslint ."
+    "lint": "eslint .",
+    "diagnose": "tsx scripts/diagnose.ts",
+    "test:scope:real": "tsx scripts/test-scope-real.ts"
   },
-  "keywords": ["icom", "civ", "cat", "udp", "hamradio", "wlan", "audio"],
+  "keywords": [
+    "icom",
+    "civ",
+    "cat",
+    "udp",
+    "hamradio",
+    "wlan",
+    "audio"
+  ],
   "author": "boybook",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/boybook/icom-wlan-node.git"
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "devDependencies": {
     "@types/jest": "^29.5.12",
     "@types/node": "^20.10.6",
+    "commander": "^12.0.0",
     "eslint": "^8.57.0",
     "jest": "^29.7.0",
     "rimraf": "^5.0.5",
     "ts-jest": "^29.1.1",
+    "tsx": "^4.7.0",
     "typescript": "^5.4.5"
   }
 }

package/dist/demo.d.ts

@@ -1,12 +0,0 @@
-/**
- * Integration test against a real Icom WLAN radio.
- *
- * This test is skipped unless these env vars are present:
- *  - ICOM_IP: radio IP
- *  - ICOM_PORT: radio control UDP port (e.g., 50001)
- *  - ICOM_USER: username
- *  - ICOM_PASS: password
- * Optional:
- *  - ICOM_TEST_PTT=true to exercise PTT and short audio TX (be careful: this keys TX!)
- */
-export {};

package/dist/demo.js

@@ -1,329 +0,0 @@
-"use strict";
-/**
- * Integration test against a real Icom WLAN radio.
- *
- * This test is skipped unless these env vars are present:
- *  - ICOM_IP: radio IP
- *  - ICOM_PORT: radio control UDP port (e.g., 50001)
- *  - ICOM_USER: username
- *  - ICOM_PASS: password
- * Optional:
- *  - ICOM_TEST_PTT=true to exercise PTT and short audio TX (be careful: this keys TX!)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require(".");
-const IcomRigCommands_1 = require("./rig/IcomRigCommands");
-const codec_1 = require("./utils/codec");
-async function test() {
-    const ip = process.env.ICOM_IP;
-    const port = parseInt(process.env.ICOM_PORT, 10);
-    const user = process.env.ICOM_USER;
-    const pass = process.env.ICOM_PASS;
-    const testPTT = process.env.ICOM_TEST_PTT === 'true';
-    const t0 = Date.now();
-    const stamp = () => `+${(Date.now() - t0).toString().padStart(4)}ms`;
-    const rig = new _1.IcomControl({ control: { ip, port }, userName: user, password: pass });
-    let gotLogin = false;
-    let gotStatus = false;
-    let gotCap = false;
-    let civCount = 0;
-    let audioCount = 0;
-    const wait = (cond, ms = 30000) => new Promise((resolve, reject) => {
-        const start = Date.now();
-        const t = setInterval(() => {
-            if (cond()) {
-                clearInterval(t);
-                resolve();
-            }
-            else if (Date.now() - start > ms) {
-                clearInterval(t);
-                reject(new Error('timeout'));
-            }
-        }, 100);
-    });
-    const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-    const onLogin = (res) => {
-        console.log(stamp(), 'login event ok=', res.ok, 'error?', res.errorCode, 'conn=', res.connection);
-        gotLogin = res.ok;
-    };
-    const onStatus = (s) => {
-        console.log(stamp(), 'status civPort=', s.civPort, 'audioPort=', s.audioPort, 'authOK=', s.authOK, 'connected=', s.connected);
-        gotStatus = true;
-    };
-    const onCap = (c) => {
-        console.log(stamp(), 'capabilities civAddr=', c.civAddress, 'audioName=', c.audioName, 'supportTX=', c.supportTX);
-        gotCap = true;
-    };
-    const onCiv = (frame) => {
-        civCount++;
-        if (civCount <= 3)
-            console.log(stamp(), `CIV[${civCount}]`, (0, codec_1.hex)(frame.subarray(0, Math.min(16, frame.length))));
-    };
-    const onAudio = (p) => {
-        audioCount++;
-        if (audioCount % 10 === 0)
-            console.log(stamp(), `AUDIO[${audioCount}] len=`, p.pcm16.length);
-    };
-    rig.events.on('login', onLogin);
-    rig.events.on('status', onStatus);
-    rig.events.on('capabilities', onCap);
-    rig.events.on('civ', onCiv);
-    rig.events.on('audio', onAudio);
-    console.log(stamp(), 'connecting to', ip, port);
-    await rig.connect();
-    // Wait for login + status
-    console.log(stamp(), 'waiting login+status ...');
-    await wait(() => gotLogin && gotStatus, 20000);
-    console.log(stamp(), 'login+status OK');
-    // Expect at least capabilities soon
-    console.log(stamp(), 'waiting capabilities (0xA8) ...');
-    await wait(() => gotCap, 8000).catch(() => { console.log(stamp(), 'capabilities timeout (tolerated)'); });
-    // Ensure data mode and connector routing favor WLAN before CIV queries
-    console.log(stamp(), 'setMode USB-D (data) and route data to WLAN');
-    await rig.setMode('USB', { dataMode: true });
-    await rig.setConnectorDataMode('WLAN');
-    // Issue a CIV read operating frequency; expect some CIV traffic
-    const rigAddr = rig.civ.civAddress & 0xff;
-    const ctrAddr = 0xe0;
-    const readFreq = IcomRigCommands_1.IcomRigCommands.readOperatingFrequency(ctrAddr, rigAddr);
-    const civBefore = civCount;
-    rig.sendCiv(readFreq);
-    console.log(stamp(), 'sent CIV read frequency, waiting CIV traffic ...');
-    await wait(() => civCount > civBefore, 6000).catch(() => { });
-    // High-level: query frequency, set mode to USB-D (data), adjust frequency slightly and revert
-    const curHz = await rig.readOperatingFrequency({ timeout: 8000 });
-    if (curHz) {
-        console.log(stamp(), 'readOperatingFrequency =', curHz);
-        // Set data mode USB-D
-        console.log(stamp(), 'setMode USB-D');
-        await rig.setMode('USB', { dataMode: true });
-        // Route connector data to WLAN (best effort)
-        console.log(stamp(), 'setConnectorDataMode WLAN');
-        await rig.setConnectorDataMode('WLAN');
-        // Nudge frequency by +50 Hz then revert
-        const newHz = curHz + 50;
-        console.log(stamp(), 'setFrequency to', newHz);
-        await rig.setFrequency(newHz);
-        const backHz = await rig.readOperatingFrequency({ timeout: 4000 });
-        console.log(stamp(), 'verify freq after set =', backHz);
-        console.log(stamp(), 'revert frequency to', curHz);
-        await rig.setFrequency(curHz);
-    }
-    else {
-        console.log(stamp(), 'readOperatingFrequency returned null (tolerated)');
-    }
-    // ============================================================================
-    // API Demo: Demonstrate all available APIs and print their results
-    // ============================================================================
-    console.log('\n' + '='.repeat(80));
-    console.log(stamp(), '🎯 API DEMONSTRATION - Testing all available methods');
-    console.log('='.repeat(80) + '\n');
-    // 1. Mode APIs
-    console.log(stamp(), '📡 Testing Mode APIs:');
-    console.log(stamp(), '  → Setting mode to LSB (Lower Side Band)');
-    await rig.setMode('LSB');
-    await sleep(500);
-    console.log(stamp(), '  → Setting mode to USB (Upper Side Band)');
-    await rig.setMode('USB');
-    await sleep(500);
-    console.log(stamp(), '  → Setting mode to USB-D (Data mode for FT8)');
-    await rig.setMode('USB', { dataMode: true });
-    await sleep(500);
-    // 2. Frequency APIs
-    console.log(stamp(), '\n📻 Testing Frequency APIs:');
-    const currentFreq = await rig.readOperatingFrequency({ timeout: 3000 });
-    if (currentFreq) {
-        console.log(stamp(), `  ✓ Current frequency: ${(currentFreq / 1000000).toFixed(3)} MHz (${currentFreq} Hz)`);
-        // Test frequency change
-        const testFreq = 14074000; // FT8 on 20m
-        console.log(stamp(), `  → Setting frequency to ${(testFreq / 1000000).toFixed(3)} MHz`);
-        await rig.setFrequency(testFreq);
-        await sleep(500);
-        const verifyFreq = await rig.readOperatingFrequency({ timeout: 3000 });
-        if (verifyFreq) {
-            console.log(stamp(), `  ✓ Verified frequency: ${(verifyFreq / 1000000).toFixed(3)} MHz`);
-        }
-        // Restore original frequency
-        console.log(stamp(), `  → Restoring original frequency: ${(currentFreq / 1000000).toFixed(3)} MHz`);
-        await rig.setFrequency(currentFreq);
-        await sleep(500);
-    }
-    else {
-        console.log(stamp(), '  ✗ Failed to read current frequency');
-    }
-    // 3. Connector APIs
-    console.log(stamp(), '\n🔌 Testing Connector APIs:');
-    console.log(stamp(), '  → Setting connector data mode to WLAN');
-    await rig.setConnectorDataMode('WLAN');
-    await sleep(500);
-    const wlanLevel = await rig.getConnectorWLanLevel({ timeout: 2000 });
-    if (wlanLevel) {
-        console.log(stamp(), `  ✓ WLAN Level: ${wlanLevel.percent.toFixed(1)}% (raw=${wlanLevel.raw}/255)`);
-    }
-    else {
-        console.log(stamp(), '  ℹ WLAN Level: Not available (may not be supported on this radio)');
-    }
-    // Test setting WLAN level
-    console.log(stamp(), '  → Setting WLAN level to 128 (50%)');
-    await rig.setConnectorWLanLevel(128);
-    await sleep(500);
-    const newWlanLevel = await rig.getConnectorWLanLevel({ timeout: 2000 });
-    if (newWlanLevel) {
-        console.log(stamp(), `  ✓ New WLAN Level: ${newWlanLevel.percent.toFixed(1)}% (raw=${newWlanLevel.raw}/255)`);
-    }
-    // 4. Summary of RX-mode readings
-    console.log(stamp(), '\n📋 Summary of Current Radio State (RX mode):');
-    console.log(stamp(), '  ╔═══════════════════════════════════════════════════════╗');
-    if (currentFreq) {
-        console.log(stamp(), `  ║ Frequency: ${(currentFreq / 1000000).toFixed(3).padEnd(10)} MHz                         ║`);
-    }
-    console.log(stamp(), `  ║ Mode:      USB-D (Data mode)                          ║`);
-    console.log(stamp(), `  ║ Connector: WLAN                                       ║`);
-    if (newWlanLevel) {
-        console.log(stamp(), `  ║ WLAN Level: ${newWlanLevel.percent.toFixed(1).padEnd(5)}%                                    ║`);
-    }
-    console.log(stamp(), '  ╚═══════════════════════════════════════════════════════╝');
-    console.log(stamp(), '\n  ℹ️  Note: Meter readings (SWR/ALC) require TX mode - see PTT test below');
-    console.log('\n' + '='.repeat(80));
-    console.log(stamp(), '✅ API DEMONSTRATION COMPLETE (RX mode)');
-    console.log('='.repeat(80) + '\n');
-    // Expect to receive at least some audio frames if radio is streaming
-    console.log(stamp(), 'waiting audio frames ...');
-    await wait(() => audioCount > 0, 6000).catch(() => { });
-    // Try reading additional CIV info in RX mode
-    try {
-        const mode = await rig.readOperatingMode({ timeout: 1500 });
-        if (mode) {
-            const modeStr = mode.modeName ?? `0x${mode.mode.toString(16)}`;
-            const filStr = mode.filterName ?? (mode.filter !== undefined ? `FIL${mode.filter}` : '');
-            console.log(stamp(), `RX: Operating Mode = ${modeStr}${filStr ? `, ${filStr}` : ''}`);
-        }
-        else {
-            console.log(stamp(), 'RX: Operating Mode: Not available');
-        }
-    }
-    catch { }
-    try {
-        const edges = await rig.readBandEdges({ timeout: 1500 });
-        if (edges) {
-            console.log(stamp(), `RX: Band edges payload length: ${edges.length} bytes`);
-        }
-        else {
-            console.log(stamp(), 'RX: Band edges: Not available');
-        }
-    }
-    catch { }
-    // Optional: brief PTT + short audio TX (dangerous; keys TX)
-    if (testPTT && gotLogin && gotStatus) {
-        console.log('\n' + '='.repeat(80));
-        console.log(stamp(), '📡 PTT TEST & METER READINGS (TX MODE)');
-        console.log('='.repeat(80) + '\n');
-        // Ensure audio routing is set to WLAN before PTT
-        console.log(stamp(), '→ Setting connector data mode to WLAN before PTT');
-        await rig.setConnectorDataMode('WLAN');
-        console.log(stamp(), '→ PTT ON - Starting transmission');
-        await rig.setPtt(true);
-        // Wait a moment for TX to stabilize
-        await sleep(500);
-        // Generate all audio frames at once (10 seconds of 1 kHz tone)
-        const frames = 500; // 500 * 20ms = 10000ms = 10 seconds
-        const samplesPerFrame = 240;
-        const totalSamples = frames * samplesPerFrame;
-        const allAudio = new Float32Array(totalSamples);
-        // Generate 1 kHz tone for entire duration
-        for (let i = 0; i < totalSamples; i++) {
-            allAudio[i] = Math.sin(2 * Math.PI * 1000 * i / _1.AUDIO_RATE) * 0.2;
-        }
-        // Add all audio to queue at once with leading silence buffer
-        console.log(stamp(), '→ Enqueuing', frames, 'frames of audio (1kHz tone, 10 seconds)');
-        rig.sendAudioFloat32(allAudio, true); // true = add leading silence buffer
-        // ============================================================================
-        // 📊 Testing Meter APIs during TX
-        // ============================================================================
-        console.log(stamp(), '\n📊 Reading Meters during TX:');
-        // Also read TX-related CIV info
-        try {
-            const txHz = await rig.readTransmitFrequency({ timeout: 1500 });
-            if (txHz)
-                console.log(stamp(), `  TX Frequency: ${txHz} Hz`);
-            else
-                console.log(stamp(), '  TX Frequency: Not available');
-        }
-        catch { }
-        try {
-            const state = await rig.readTransceiverState({ timeout: 1500 });
-            if (state)
-                console.log(stamp(), `  Transceiver State: ${state}`);
-            else
-                console.log(stamp(), '  Transceiver State: Not available');
-        }
-        catch { }
-        // Read meters multiple times during transmission to get stable readings
-        const meterReadings = { swr: [], alc: [] };
-        for (let i = 0; i < 3; i++) {
-            await sleep(1000); // Wait 1 second between readings
-            console.log(stamp(), `  → Reading meters (${i + 1}/3)...`);
-            const swr = await rig.readSWR({ timeout: 2000 });
-            if (swr) {
-                meterReadings.swr.push(swr);
-                const swrStatus = swr.alert ? '⚠️  ALERT' : '✓ OK';
-                console.log(stamp(), `    SWR: ${swr.swr.toFixed(2)} (raw=${swr.raw}) ${swrStatus}`);
-            }
-            else {
-                console.log(stamp(), `    SWR: Not available`);
-            }
-            const alc = await rig.readALC({ timeout: 2000 });
-            if (alc) {
-                meterReadings.alc.push(alc);
-                const alcStatus = alc.alert ? '⚠️  ALERT' : '✓ OK';
-                console.log(stamp(), `    ALC: ${alc.percent.toFixed(1)}% (raw=${alc.raw}) ${alcStatus}`);
-            }
-            else {
-                console.log(stamp(), `    ALC: Not available`);
-            }
-        }
-        // Calculate and display average readings
-        if (meterReadings.swr.length > 0) {
-            const avgSwr = meterReadings.swr.reduce((sum, r) => sum + r.swr, 0) / meterReadings.swr.length;
-            const hasAlert = meterReadings.swr.some(r => r.alert);
-            console.log(stamp(), '\n  📈 Average SWR Reading:');
-            console.log(stamp(), `    - Average Value: ${avgSwr.toFixed(2)}`);
-            console.log(stamp(), `    - Status: ${hasAlert ? '⚠️  ALERT (High SWR detected!)' : '✓ OK'}`);
-            console.log(stamp(), `    - Assessment: ${avgSwr < 1.5 ? 'Excellent antenna match' : avgSwr < 2.0 ? 'Good antenna match' : 'Poor antenna match - check connections'}`);
-        }
-        if (meterReadings.alc.length > 0) {
-            const avgAlc = meterReadings.alc.reduce((sum, r) => sum + r.percent, 0) / meterReadings.alc.length;
-            const hasAlert = meterReadings.alc.some(r => r.alert);
-            console.log(stamp(), '\n  📈 Average ALC Reading:');
-            console.log(stamp(), `    - Average Level: ${avgAlc.toFixed(1)}%`);
-            console.log(stamp(), `    - Status: ${hasAlert ? '⚠️  ALERT (Over-driving!)' : '✓ OK'}`);
-            console.log(stamp(), `    - Assessment: ${avgAlc < 30 ? 'Low drive - increase audio level' : avgAlc < 70 ? 'Normal operating range' : 'High drive - reduce audio level'}`);
-        }
-        // Wait for remaining transmission to complete
-        const remainingTime = (frames * 21) - 3000; // Already waited 3 seconds for meter readings
-        if (remainingTime > 0) {
-            console.log(stamp(), `\n→ Waiting for transmission to complete (~${(remainingTime / 1000).toFixed(1)}s remaining)`);
-            await sleep(remainingTime);
-        }
-        await rig.setPtt(false);
-        console.log(stamp(), '\n→ PTT OFF - Transmission complete, trailing silence sent');
-        console.log('\n' + '='.repeat(80));
-        console.log(stamp(), '✅ PTT TEST & METER READINGS COMPLETE');
-        console.log('='.repeat(80) + '\n');
-        await sleep(1000);
-    }
-    // Clean up listeners to help jest exit
-    rig.events.off('login', onLogin);
-    rig.events.off('status', onStatus);
-    rig.events.off('capabilities', onCap);
-    rig.events.off('civ', onCiv);
-    rig.events.off('audio', onAudio);
-    console.log(stamp(), 'summary: civ=', civCount, 'audio=', audioCount);
-    console.log(stamp(), 'disconnecting...');
-    await rig.disconnect();
-    console.log(stamp(), 'disconnected');
-}
-test().then().catch(e => {
-    console.error('Test failed:', e);
-    process.exit(1);
-});