icom-wlan-node 0.4.0 → 0.5.1

package/README.md

@@ -306,6 +306,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`
+- `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:
@@ -328,7 +340,7 @@ interface IcomScopeFrame {
 
 Current implementation notes:
 
-- Currently implements only the basic on/off controls and `0x27 00 00` scope data capture
+- Currently implements basic on/off controls, `0x27 0x15` span read/write, 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
@@ -519,9 +531,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/rig/IcomControl.d.ts

@@ -1,4 +1,4 @@
-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 { 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';
@@ -77,6 +77,76 @@ export declare class IcomControl {
     sendCiv(data: Buffer): void;
     enableScope(): Promise<void>;
     disableScope(): Promise<void>;
+    readScopeSpan(options?: QueryOptions & {
+        receiver?: 0 | 1;
+    }): Promise<IcomScopeSpanInfo | null>;
+    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

package/dist/rig/IcomControl.js

@@ -47,7 +47,45 @@ 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 IcomScopeParser_1 = require("../scope/IcomScopeParser");
 const IcomScopeService_1 = require("../scope/IcomScopeService");
+const DEFAULT_SCOPE_EDGE_SLOTS = [1, 2, 3, 4];
+const DEFAULT_SCOPE_SPANS_HZ = [25000000, 10000000, 5000000, 2500000, 1000000, 500000, 250000, 100000, 50000, 25000, 10000, 5000, 2500];
+const DEFAULT_SCOPE_FREQUENCY_RANGES = [
+    { 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 },
+    { rangeId: 14, lowHz: 74800000, highHz: 108000000 },
+    { rangeId: 15, lowHz: 108000000, highHz: 137000000 },
+    { rangeId: 16, lowHz: 137000000, highHz: 200000000 },
+    { rangeId: 17, lowHz: 400000000, highHz: 470000000 },
+];
+function modeCodeToName(mode) {
+    switch (mode) {
+        case 0: return 'center';
+        case 1: return 'fixed';
+        case 2: return 'scroll-center';
+        case 3: return 'scroll-fixed';
+    }
+}
+function modeNameToCode(mode) {
+    switch (mode) {
+        case 'center': return 0;
+        case 'fixed': return 1;
+        case 'scroll-center': return 2;
+        case 'scroll-fixed': return 3;
+    }
+}
 class IcomControl {
     constructor(options) {
         this.ev = new events_1.EventEmitter();
@@ -527,6 +565,202 @@ class IcomControl {
         this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeDataOutput(ctrAddr, rigAddr, false));
         this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeDisplay(ctrAddr, rigAddr, false));
     }
+    async readScopeSpan(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const receiver = options?.receiver ?? 0;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomScopeCommands_1.IcomScopeCommands.readScopeSpan(ctrAddr, rigAddr, receiver);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x27, [0x15, receiver], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 13) {
+            return null;
+        }
+        const spanHz = (0, IcomScopeParser_1.parseIcomBcdFreqLE)(resp.subarray(7, 12));
+        return {
+            receiver,
+            spanHz,
+        };
+    }
+    async setScopeSpan(spanHz, options) {
+        const receiver = options?.receiver ?? 0;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeSpan(ctrAddr, rigAddr, spanHz, receiver));
+    }
+    async readScopeMode(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const receiver = options?.receiver ?? 0;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomScopeCommands_1.IcomScopeCommands.readScopeMode(ctrAddr, rigAddr, receiver);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x27, [0x14, receiver], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 9) {
+            return null;
+        }
+        const mode = resp[7];
+        return {
+            receiver,
+            mode,
+            modeName: modeCodeToName(mode),
+        };
+    }
+    async setScopeMode(mode, options) {
+        const receiver = options?.receiver ?? 0;
+        const modeCode = typeof mode === 'string' ? modeNameToCode(mode) : mode;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeMode(ctrAddr, rigAddr, modeCode, receiver));
+    }
+    async readScopeEdge(options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const receiver = options?.receiver ?? 0;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomScopeCommands_1.IcomScopeCommands.readScopeEdge(ctrAddr, rigAddr, receiver);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x27, [0x16, receiver], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 9) {
+            return null;
+        }
+        return {
+            receiver,
+            edgeSlot: resp[7],
+        };
+    }
+    async setScopeEdge(edgeSlot, options) {
+        const receiver = options?.receiver ?? 0;
+        const safeEdgeSlot = Math.max(1, Math.min(4, Math.trunc(edgeSlot)));
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeEdge(ctrAddr, rigAddr, safeEdgeSlot, receiver));
+    }
+    async readScopeFixedEdge(rangeId, edgeSlot, options) {
+        const timeoutMs = options?.timeout ?? 3000;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        const req = IcomScopeCommands_1.IcomScopeCommands.readScopeFixedEdge(ctrAddr, rigAddr, rangeId, edgeSlot);
+        const resp = await this.waitForCivFrame((frame) => IcomControl.matchCommandFrame(frame, 0x27, [0x1e, rangeId, edgeSlot], ctrAddr, rigAddr), timeoutMs, () => this.sendCiv(req));
+        if (!resp || resp.length < 18) {
+            return null;
+        }
+        return {
+            rangeId,
+            edgeSlot,
+            lowHz: (0, IcomScopeParser_1.parseIcomBcdFreqLE)(resp.subarray(8, 13)),
+            highHz: (0, IcomScopeParser_1.parseIcomBcdFreqLE)(resp.subarray(13, 18)),
+        };
+    }
+    async setScopeFixedEdge(options) {
+        const rangeId = options.rangeId ?? await this.resolveScopeFrequencyRangeId();
+        const edgeInfo = options.edgeSlot
+            ? { edgeSlot: options.edgeSlot }
+            : await this.readScopeEdge({ receiver: 0, timeout: 3000 });
+        const edgeSlot = edgeInfo?.edgeSlot ?? 1;
+        const ctrAddr = IcomConstants_1.DEFAULT_CONTROLLER_ADDR;
+        const rigAddr = this.civ.civAddress & 0xff;
+        this.sendCiv(IcomScopeCommands_1.IcomScopeCommands.setScopeFixedEdge(ctrAddr, rigAddr, rangeId, edgeSlot, options.lowHz, options.highHz));
+        return {
+            rangeId,
+            edgeSlot,
+            lowHz: options.lowHz,
+            highHz: options.highHz,
+        };
+    }
+    async resolveScopeFrequencyRangeId(frequencyHz) {
+        const targetFrequency = frequencyHz ?? await this.readOperatingFrequency({ timeout: 3000 });
+        if (!targetFrequency) {
+            throw new Error('Unable to resolve scope frequency range without operating frequency');
+        }
+        const matched = DEFAULT_SCOPE_FREQUENCY_RANGES.find((range) => targetFrequency >= range.lowHz && targetFrequency < range.highHz);
+        if (!matched) {
+            throw new Error(`No scope frequency range matches ${targetFrequency} Hz`);
+        }
+        return matched.rangeId;
+    }
+    getScopeSupportedEdgeSlots() {
+        return [...DEFAULT_SCOPE_EDGE_SLOTS];
+    }
+    async getSpectrumDisplayState(options) {
+        const receiver = options?.receiver ?? 0;
+        const [modeInfo, spanInfo, edgeInfo] = await Promise.all([
+            this.readScopeMode({ ...options, receiver }),
+            this.readScopeSpan({ ...options, receiver }),
+            this.readScopeEdge({ ...options, receiver }),
+        ]);
+        let fixedEdgeInfo = null;
+        if (modeInfo?.modeName === 'fixed' || modeInfo?.modeName === 'scroll-fixed') {
+            try {
+                const rangeId = await this.resolveScopeFrequencyRangeId();
+                fixedEdgeInfo = await this.readScopeFixedEdge(rangeId, edgeInfo?.edgeSlot ?? 1, options);
+            }
+            catch (_) {
+                fixedEdgeInfo = null;
+            }
+        }
+        return {
+            mode: modeInfo?.modeName ?? null,
+            modeCode: modeInfo?.mode ?? null,
+            spanHz: spanInfo?.spanHz ?? (fixedEdgeInfo ? fixedEdgeInfo.highHz - fixedEdgeInfo.lowHz : null),
+            edgeSlot: edgeInfo?.edgeSlot ?? null,
+            edgeLowHz: fixedEdgeInfo?.lowHz ?? null,
+            edgeHighHz: fixedEdgeInfo?.highHz ?? null,
+            supportedModes: ['center', 'fixed', 'scroll-center', 'scroll-fixed'],
+            supportedSpans: [...DEFAULT_SCOPE_SPANS_HZ],
+            supportedEdgeSlots: this.getScopeSupportedEdgeSlots(),
+            supportsFixedEdges: true,
+            supportsEdgeSlotSelection: true,
+        };
+    }
+    async configureSpectrumDisplay(config = {}) {
+        const receiver = config.receiver ?? 0;
+        if (config.mode !== undefined) {
+            await this.setScopeMode(config.mode, { receiver });
+        }
+        if (config.edgeSlot !== undefined) {
+            await this.setScopeEdge(config.edgeSlot, { receiver });
+        }
+        if (config.spanHz !== undefined && (!config.mode || config.mode === 'center' || config.mode === 'scroll-center')) {
+            await this.setScopeSpan(config.spanHz, { receiver });
+        }
+        if (config.edgeLowHz !== undefined && config.edgeHighHz !== undefined && (!config.mode || config.mode === 'fixed' || config.mode === 'scroll-fixed')) {
+            await this.setScopeFixedEdge({
+                rangeId: config.rangeId,
+                edgeSlot: config.edgeSlot,
+                lowHz: config.edgeLowHz,
+                highHz: config.edgeHighHz,
+            });
+        }
+        return this.getSpectrumDisplayState({ receiver, timeout: 3000 });
+    }
+    async getSpectrumMode(options) {
+        return (await this.readScopeMode(options))?.modeName ?? null;
+    }
+    async setSpectrumMode(mode, options) {
+        await this.setScopeMode(mode, options);
+    }
+    async getSpectrumSpan(options) {
+        return (await this.readScopeSpan(options))?.spanHz ?? null;
+    }
+    async setSpectrumSpan(spanHz, options) {
+        await this.setScopeSpan(spanHz, options);
+    }
+    async getSpectrumEdgeSlot(options) {
+        return (await this.readScopeEdge(options))?.edgeSlot ?? null;
+    }
+    async setSpectrumEdgeSlot(edgeSlot, options) {
+        await this.setScopeEdge(edgeSlot, options);
+    }
+    async getSpectrumFixedEdges(options) {
+        const rangeId = options?.rangeId ?? await this.resolveScopeFrequencyRangeId();
+        const edgeSlot = options?.edgeSlot ?? await this.getSpectrumEdgeSlot(options) ?? 1;
+        const info = await this.readScopeFixedEdge(rangeId, edgeSlot, options);
+        if (!info) {
+            return null;
+        }
+        return info;
+    }
+    async setSpectrumFixedEdges(options) {
+        return this.setScopeFixedEdge(options);
+    }
     async waitForScopeFrame(options) {
         const timeoutMs = options?.timeout ?? 3000;
         return this.scope.waitForScopeFrame(timeoutMs);

package/dist/scope/IcomScopeCommands.d.ts

@@ -1,4 +1,14 @@
 export declare const IcomScopeCommands: {
     setScopeDataOutput(ctrAddr: number, rigAddr: number, enabled: boolean): Buffer;
     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;
 };

package/dist/scope/IcomScopeCommands.js

@@ -11,5 +11,73 @@ exports.IcomScopeCommands = {
         return Buffer.from([
             0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x27, 0x10, enabled ? 0x01 : 0x00, 0xfd
         ]);
+    },
+    readScopeSpan(ctrAddr, rigAddr, receiver = 0) {
+        return Buffer.from([
+            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x27, 0x15, receiver & 0xff, 0xfd
+        ]);
+    },
+    setScopeSpan(ctrAddr, rigAddr, spanHz, receiver = 0) {
+        const bytes = exports.IcomScopeCommands.encodeScopeSpanHz(spanHz);
+        return Buffer.from([
+            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x27, 0x15, receiver & 0xff, ...bytes, 0xfd
+        ]);
+    },
+    readScopeMode(ctrAddr, rigAddr, receiver = 0) {
+        return Buffer.from([
+            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x27, 0x14, receiver & 0xff, 0xfd
+        ]);
+    },
+    setScopeMode(ctrAddr, rigAddr, mode, receiver = 0) {
+        return Buffer.from([
+            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x27, 0x14, receiver & 0xff, mode & 0xff, 0xfd
+        ]);
+    },
+    readScopeEdge(ctrAddr, rigAddr, receiver = 0) {
+        return Buffer.from([
+            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x27, 0x16, receiver & 0xff, 0xfd
+        ]);
+    },
+    setScopeEdge(ctrAddr, rigAddr, edgeSlot, receiver = 0) {
+        return Buffer.from([
+            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x27, 0x16, receiver & 0xff, edgeSlot & 0xff, 0xfd
+        ]);
+    },
+    readScopeFixedEdge(ctrAddr, rigAddr, rangeId, edgeSlot) {
+        return Buffer.from([
+            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x27, 0x1e, rangeId & 0xff, edgeSlot & 0xff, 0xfd
+        ]);
+    },
+    setScopeFixedEdge(ctrAddr, rigAddr, rangeId, edgeSlot, lowHz, highHz) {
+        return Buffer.from([
+            0xfe, 0xfe, rigAddr & 0xff, ctrAddr & 0xff, 0x27, 0x1e,
+            rangeId & 0xff,
+            edgeSlot & 0xff,
+            ...exports.IcomScopeCommands.encodeScopeFreqHz(lowHz),
+            ...exports.IcomScopeCommands.encodeScopeFreqHz(highHz),
+            0xfd
+        ]);
+    },
+    encodeScopeSpanHz(spanHz) {
+        const safeSpanHz = Math.max(0, Math.round(spanHz));
+        const out = Buffer.alloc(5);
+        let remaining = safeSpanHz;
+        for (let i = 0; i < out.length; i++) {
+            const twoDigits = remaining % 100;
+            out[i] = ((((twoDigits / 10) | 0) & 0x0f) << 4) | (twoDigits % 10);
+            remaining = Math.floor(remaining / 100);
+        }
+        return out;
+    },
+    encodeScopeFreqHz(freqHz) {
+        const safeFreqHz = Math.max(0, Math.round(freqHz));
+        const out = Buffer.alloc(5);
+        let remaining = safeFreqHz;
+        for (let i = 0; i < out.length; i++) {
+            const twoDigits = remaining % 100;
+            out[i] = ((((twoDigits / 10) | 0) & 0x0f) << 4) | (twoDigits % 10);
+            remaining = Math.floor(remaining / 100);
+        }
+        return out;
     }
 };

package/dist/types.d.ts

@@ -110,6 +110,48 @@ export interface IcomScopeFrame {
     rawCivPayloads: Buffer[];
     transport: IcomScopeTransport;
 }
+export interface IcomScopeSpanInfo {
+    receiver: 0 | 1;
+    spanHz: number;
+}
+export type IcomScopeMode = 'center' | 'fixed' | 'scroll-center' | 'scroll-fixed';
+export interface IcomScopeModeInfo {
+    receiver: 0 | 1;
+    mode: 0 | 1 | 2 | 3;
+    modeName: IcomScopeMode;
+}
+export interface IcomScopeEdgeInfo {
+    receiver: 0 | 1;
+    edgeSlot: number;
+}
+export interface IcomScopeFixedEdgeInfo {
+    rangeId: number;
+    edgeSlot: number;
+    lowHz: number;
+    highHz: number;
+}
+export interface IcomSpectrumDisplayState {
+    mode: IcomScopeMode | null;
+    modeCode: 0 | 1 | 2 | 3 | null;
+    spanHz: number | null;
+    edgeSlot: number | null;
+    edgeLowHz: number | null;
+    edgeHighHz: number | null;
+    supportedModes: IcomScopeMode[];
+    supportedSpans: number[];
+    supportedEdgeSlots: number[];
+    supportsFixedEdges: boolean;
+    supportsEdgeSlotSelection: boolean;
+}
+export interface IcomSpectrumDisplayConfig {
+    receiver?: 0 | 1;
+    mode?: IcomScopeMode;
+    spanHz?: number;
+    edgeSlot?: number;
+    rangeId?: number;
+    edgeLowHz?: number;
+    edgeHighHz?: number;
+}
 /**
  * Result of a meter reading operation (SWR, ALC, etc.)
  * @deprecated Use specific types like SwrReading, AlcReading instead

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icom-wlan-node",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Icom WLAN (CI‑V, audio) protocol implementation for Node.js/TypeScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",