hamlib 0.3.1 → 0.3.3

package/README.md

@@ -204,11 +204,29 @@ Spectrum API summary:
 - `getSpectrumCapabilities()` returns conservative backend metadata exposed by the native addon.
 - `getSpectrumSupportSummary()` returns a product-oriented summary of whether official spectrum streaming is usable on the current rig/backend.
 - `configureSpectrum()` applies supported `SPECTRUM_*` levels and optional `SPECTRUM_HOLD`.
+- `getSpectrumDisplayState()` returns a normalized display state with `mode/span/fixed edges/edge slot`.
+- `configureSpectrumDisplay()` applies a normalized display config and reads back the resulting state.
+- `getSpectrumEdgeSlot()` / `setSpectrumEdgeSlot()` expose backend edge-slot control when available.
+- `getSpectrumFixedEdges()` / `setSpectrumFixedEdges()` expose direct fixed-range control using `SPECTRUM_EDGE_LOW/HIGH`.
 - `startSpectrumStream(callback?)` registers the official Hamlib spectrum callback only.
 - `stopSpectrumStream()` unregisters the official spectrum callback.
 - `startManagedSpectrum(config?)` runs the validated startup sequence for Icom/Hamlib async spectrum.
 - `stopManagedSpectrum()` runs the symmetric shutdown sequence and unregisters the callback.
 
+Fixed-range example:
+
+```javascript
+await rig.configureSpectrumDisplay({
+  mode: 'fixed',
+  edgeSlot: 1,
+  edgeLowHz: 14074000,
+  edgeHighHz: 14077000,
+});
+
+const displayState = await rig.getSpectrumDisplayState();
+console.log(displayState);
+```
+
 Emitted events:
 
 - `spectrumLine` carries a single `SpectrumLine` object with frequency edges, mode, and raw bin payload.

package/index.d.ts

@@ -200,17 +200,40 @@ interface SpectrumSupportSummary extends SpectrumCapabilities {
   hasSpectrumHoldFunction: boolean;
   hasTransceiveFunction: boolean;
   configurableLevels: string[];
+  supportsFixedEdges: boolean;
+  supportsEdgeSlotSelection: boolean;
+  supportedEdgeSlots: number[];
 }
 
+type SpectrumDisplayMode = 'center' | 'fixed' | 'scroll-center' | 'scroll-fixed';
+
 interface SpectrumConfig {
   hold?: boolean;
-  mode?: number;
+  mode?: number | SpectrumDisplayMode;
   spanHz?: number;
+  edgeSlot?: number;
+  edgeLowHz?: number;
+  edgeHighHz?: number;
   speed?: number;
   referenceLevel?: number;
   averageMode?: number;
 }
 
+interface SpectrumDisplayState {
+  mode: SpectrumDisplayMode | null;
+  modeId: number | null;
+  modeName: string | null;
+  spanHz: number | null;
+  edgeSlot: number | null;
+  edgeLowHz: number | null;
+  edgeHighHz: number | null;
+  supportedModes: SpectrumModeInfo[];
+  supportedSpans: number[];
+  supportedEdgeSlots: number[];
+  supportsFixedEdges: boolean;
+  supportsEdgeSlotSelection: boolean;
+}
+
 /**
  * Split mode info interface
  */
@@ -599,7 +622,7 @@ declare class HamLib extends EventEmitter {
    * @param levelType Level type ('AF', 'RF', 'SQL', 'RFPOWER', etc.)
    * @param value Level value (0.0-1.0 typically)
    */
-  setLevel(levelType: LevelType, value: number): Promise<number>;
+  setLevel(levelType: LevelType, value: number, vfo?: string): Promise<number>;
 
   /**
    * Get radio level
@@ -1287,6 +1310,41 @@ declare class HamLib extends EventEmitter {
    */
   configureSpectrum(config?: SpectrumConfig): Promise<SpectrumSupportSummary>;
 
+  /**
+   * Get the current spectrum edge slot if exposed by the backend.
+   */
+  getSpectrumEdgeSlot(): Promise<number>;
+
+  /**
+   * Set the current spectrum edge slot if exposed by the backend.
+   */
+  setSpectrumEdgeSlot(slot: number): Promise<number>;
+
+  /**
+   * Get supported spectrum edge slots.
+   */
+  getSpectrumSupportedEdgeSlots(): Promise<number[]>;
+
+  /**
+   * Read current fixed spectrum edges.
+   */
+  getSpectrumFixedEdges(): Promise<{lowHz: number, highHz: number}>;
+
+  /**
+   * Set current fixed spectrum edges.
+   */
+  setSpectrumFixedEdges(range: {lowHz: number, highHz: number}): Promise<{lowHz: number, highHz: number}>;
+
+  /**
+   * Get a normalized spectrum display state for application use.
+   */
+  getSpectrumDisplayState(): Promise<SpectrumDisplayState>;
+
+  /**
+   * Configure spectrum display state using a normalized application-facing shape.
+   */
+  configureSpectrumDisplay(config?: SpectrumConfig): Promise<SpectrumDisplayState>;
+
   /**
    * Start receiving official Hamlib spectrum line events.
    */

package/lib/index.js

@@ -4,6 +4,17 @@ const nodeGypBuild = require('node-gyp-build');
 // Ensure loader resolves from package root (contains prebuilds/ and build/)
 const nativeModule = nodeGypBuild(path.join(__dirname, '..'));
 
+const DEFAULT_SPECTRUM_EDGE_SLOTS = [1, 2, 3, 4];
+
+function normalizeSpectrumModeName(name) {
+  const normalized = String(name || '').trim().toLowerCase();
+  if (normalized === 'center') return 'center';
+  if (normalized === 'fixed') return 'fixed';
+  if (normalized === 'center scroll' || normalized === 'center-scroll' || normalized === 'scroll-center') return 'scroll-center';
+  if (normalized === 'fixed scroll' || normalized === 'fixed-scroll' || normalized === 'scroll-fixed') return 'scroll-fixed';
+  return null;
+}
+
 /**
  * HamLib class for controlling amateur radio devices
  * 
@@ -22,6 +33,29 @@ class HamLib extends EventEmitter {
     super();
     this._nativeInstance = new nativeModule.HamLib(model, port);
     this._managedSpectrumRunning = false;
+    this._lastSpectrumLine = null;
+  }
+
+  _recordSpectrumLine(line) {
+    if (!line || typeof line !== 'object') {
+      return line;
+    }
+    this._lastSpectrumLine = line;
+    return line;
+  }
+
+  _getLastSpectrumDisplayStateFromLine() {
+    const line = this._lastSpectrumLine;
+    if (!line || typeof line !== 'object') {
+      return null;
+    }
+
+    return {
+      modeId: Number.isFinite(line.mode) ? line.mode : null,
+      spanHz: Number.isFinite(line.spanHz) ? line.spanHz : null,
+      edgeLowHz: Number.isFinite(line.lowEdgeFreq) ? line.lowEdgeFreq : null,
+      edgeHighHz: Number.isFinite(line.highEdgeFreq) ? line.highEdgeFreq : null,
+    };
   }
 
   /**
@@ -311,7 +345,10 @@ class HamLib extends EventEmitter {
    * @param {string} levelType - Level type ('AF', 'RF', 'SQL', 'RFPOWER', etc.)
    * @param {number} value - Level value (0.0-1.0 typically)
    */
-  async setLevel(levelType, value) {
+  async setLevel(levelType, value, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setLevel(levelType, value, vfo);
+    }
     return this._nativeInstance.setLevel(levelType, value);
   }
 
@@ -1180,8 +1217,16 @@ class HamLib extends EventEmitter {
     const hasSpectrumHoldFunction = supportedFunctions.includes('SPECTRUM_HOLD');
     const hasTransceiveFunction = supportedFunctions.includes('TRANSCEIVE');
     const asyncDataSupported = capabilities.asyncDataSupported ?? hasSpectrumFunction;
-    const configurableLevels = ['SPECTRUM_MODE', 'SPECTRUM_SPAN', 'SPECTRUM_SPEED', 'SPECTRUM_REF', 'SPECTRUM_AVG']
+    const configurableLevels = ['SPECTRUM_MODE', 'SPECTRUM_SPAN', 'SPECTRUM_EDGE_LOW', 'SPECTRUM_EDGE_HIGH', 'SPECTRUM_SPEED', 'SPECTRUM_REF', 'SPECTRUM_AVG']
       .filter((name) => supportedLevels.includes(name));
+    let supportsEdgeSlotSelection = false;
+
+    try {
+      const edgeSlot = await this.getConf('SPECTRUM_EDGE');
+      supportsEdgeSlotSelection = Number.isFinite(Number.parseInt(String(edgeSlot), 10));
+    } catch (_) {
+      supportsEdgeSlotSelection = false;
+    }
 
     return {
       supported: Boolean(hasSpectrumFunction),
@@ -1190,6 +1235,9 @@ class HamLib extends EventEmitter {
       hasSpectrumHoldFunction,
       hasTransceiveFunction,
       configurableLevels,
+      supportsFixedEdges: configurableLevels.includes('SPECTRUM_EDGE_LOW') && configurableLevels.includes('SPECTRUM_EDGE_HIGH'),
+      supportsEdgeSlotSelection,
+      supportedEdgeSlots: supportsEdgeSlotSelection ? [...DEFAULT_SPECTRUM_EDGE_SLOTS] : [],
       scopes: capabilities.scopes ?? [],
       modes: capabilities.modes ?? [],
       spans: capabilities.spans ?? [],
@@ -1208,13 +1256,36 @@ class HamLib extends EventEmitter {
       if (value === undefined || !summary.configurableLevels.includes(name)) return;
       await this.setLevel(name, value);
     };
+    const resolveModeId = async (mode) => {
+      if (mode === undefined || mode === null) return undefined;
+      if (Number.isFinite(mode)) return mode;
+      const requested = normalizeSpectrumModeName(mode);
+      if (!requested) {
+        throw new Error(`Unsupported spectrum mode: ${mode}`);
+      }
+      const matched = (summary.modes ?? []).find((entry) => normalizeSpectrumModeName(entry?.name) === requested);
+      if (!matched) {
+        throw new Error(`Spectrum mode not supported by this backend: ${mode}`);
+      }
+      return matched.id;
+    };
 
     if (summary.hasSpectrumHoldFunction && config.hold !== undefined) {
       await this.setFunction('SPECTRUM_HOLD', Boolean(config.hold));
     }
 
-    await applyLevel('SPECTRUM_MODE', config.mode);
+    if (config.edgeSlot !== undefined && summary.supportsEdgeSlotSelection) {
+      await this.setSpectrumEdgeSlot(config.edgeSlot);
+    }
+
+    await applyLevel('SPECTRUM_MODE', await resolveModeId(config.mode));
     await applyLevel('SPECTRUM_SPAN', config.spanHz);
+    if (config.edgeLowHz !== undefined || config.edgeHighHz !== undefined) {
+      await this.setSpectrumFixedEdges({
+        lowHz: config.edgeLowHz,
+        highHz: config.edgeHighHz,
+      });
+    }
     await applyLevel('SPECTRUM_SPEED', config.speed);
     await applyLevel('SPECTRUM_REF', config.referenceLevel);
     await applyLevel('SPECTRUM_AVG', config.averageMode);
@@ -1222,15 +1293,114 @@ class HamLib extends EventEmitter {
     return summary;
   }
 
+  async getSpectrumEdgeSlot() {
+    const raw = await this.getConf('SPECTRUM_EDGE');
+    const parsed = Number.parseInt(String(raw), 10);
+    if (!Number.isFinite(parsed)) {
+      throw new Error('Spectrum edge slot is not available');
+    }
+    return parsed;
+  }
+
+  async setSpectrumEdgeSlot(slot) {
+    const parsed = Number.parseInt(String(slot), 10);
+    if (!Number.isFinite(parsed) || parsed < 1) {
+      throw new Error(`Invalid spectrum edge slot: ${slot}`);
+    }
+    await this.setConf('SPECTRUM_EDGE', String(parsed));
+    return parsed;
+  }
+
+  async getSpectrumSupportedEdgeSlots() {
+    const summary = await this.getSpectrumSupportSummary();
+    return summary.supportedEdgeSlots ?? [];
+  }
+
+  async getSpectrumFixedEdges() {
+    const lineState = this._getLastSpectrumDisplayStateFromLine();
+    if (lineState?.edgeLowHz !== null && lineState?.edgeHighHz !== null) {
+      return { lowHz: lineState.edgeLowHz, highHz: lineState.edgeHighHz };
+    }
+
+    const targetVfo = 'VFO-A';
+    const [lowHz, highHz] = await Promise.all([
+      this.getLevel('SPECTRUM_EDGE_LOW', targetVfo),
+      this.getLevel('SPECTRUM_EDGE_HIGH', targetVfo),
+    ]);
+    return { lowHz, highHz };
+  }
+
+  async setSpectrumFixedEdges({ lowHz, highHz }) {
+    if (!Number.isFinite(lowHz) || !Number.isFinite(highHz) || lowHz >= highHz) {
+      throw new Error('Spectrum fixed edge range must satisfy lowHz < highHz');
+    }
+    const targetVfo = 'VFO-A';
+    await this.setLevel('SPECTRUM_EDGE_LOW', lowHz, targetVfo);
+    await this.setLevel('SPECTRUM_EDGE_HIGH', highHz, targetVfo);
+    return { lowHz, highHz };
+  }
+
+  async getSpectrumDisplayState() {
+    const summary = await this.getSpectrumSupportSummary();
+    const lineState = this._getLastSpectrumDisplayStateFromLine();
+    const [queriedModeId, queriedSpanHz, fixedEdges, edgeSlot] = await Promise.all([
+      summary.configurableLevels.includes('SPECTRUM_MODE') ? this.getLevel('SPECTRUM_MODE') : Promise.resolve(null),
+      summary.configurableLevels.includes('SPECTRUM_SPAN') ? this.getLevel('SPECTRUM_SPAN') : Promise.resolve(null),
+      summary.supportsFixedEdges ? this.getSpectrumFixedEdges().catch(() => null) : Promise.resolve(null),
+      summary.supportsEdgeSlotSelection ? this.getSpectrumEdgeSlot().catch(() => null) : Promise.resolve(null),
+    ]);
+
+    const modeId = queriedModeId ?? lineState?.modeId ?? null;
+    const spanHz = queriedSpanHz ?? lineState?.spanHz ?? null;
+    const modeInfo = (summary.modes ?? []).find((entry) => entry.id === modeId) ?? null;
+    const mode = normalizeSpectrumModeName(modeInfo?.name);
+    const edgeLowHz = fixedEdges?.lowHz ?? lineState?.edgeLowHz ?? null;
+    const edgeHighHz = fixedEdges?.highHz ?? lineState?.edgeHighHz ?? null;
+    const derivedSpanHz = (edgeLowHz !== null && edgeHighHz !== null) ? (edgeHighHz - edgeLowHz) : null;
+
+    return {
+      mode,
+      modeId,
+      modeName: modeInfo?.name ?? null,
+      spanHz: spanHz ?? derivedSpanHz,
+      edgeSlot,
+      edgeLowHz,
+      edgeHighHz,
+      supportedModes: summary.modes ?? [],
+      supportedSpans: summary.spans ?? [],
+      supportedEdgeSlots: summary.supportedEdgeSlots ?? [],
+      supportsFixedEdges: Boolean(summary.supportsFixedEdges),
+      supportsEdgeSlotSelection: Boolean(summary.supportsEdgeSlotSelection),
+    };
+  }
+
+  async configureSpectrumDisplay(config = {}) {
+    const normalizedConfig = { ...config };
+    if ((normalizedConfig.mode === 'fixed' || normalizedConfig.mode === 'scroll-fixed')
+      && normalizedConfig.edgeLowHz !== undefined
+      && normalizedConfig.edgeHighHz !== undefined
+      && normalizedConfig.edgeLowHz >= normalizedConfig.edgeHighHz) {
+      throw new Error('Spectrum fixed edge range must satisfy edgeLowHz < edgeHighHz');
+    }
+
+    await this.configureSpectrum(normalizedConfig);
+    return this.getSpectrumDisplayState();
+  }
+
   /**
    * Start the official Hamlib spectrum callback stream.
    * @param {(line: Object) => void} [callback]
    * @returns {Promise<boolean>}
    */
   async startSpectrumStream(callback) {
-    const listener = typeof callback === 'function'
-      ? callback
-      : (line) => this.emit('spectrumLine', line);
+    const listener = (line) => {
+      const recorded = this._recordSpectrumLine(line);
+      if (typeof callback === 'function') {
+        callback(recorded);
+        return;
+      }
+      this.emit('spectrumLine', recorded);
+    };
     return this._nativeInstance.startSpectrumStream(listener);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hamlib",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Node.js bindings for Hamlib rig control with official spectrum streaming support",
   "main": "index.js",
   "module": "lib/index.mjs",

package/src/hamlib.cpp

@@ -2938,12 +2938,21 @@ Napi::Value NodeHamLib::SetLevel(const Napi::CallbackInfo & info) {
   }
   
   if (info.Length() < 2 || !info[0].IsString() || !info[1].IsNumber()) {
-    Napi::TypeError::New(env, "Expected (levelType: string, value: number)").ThrowAsJavaScriptException();
+    Napi::TypeError::New(env, "Expected (levelType: string, value: number, vfo?: string)").ThrowAsJavaScriptException();
     return env.Null();
   }
   
   std::string levelTypeStr = info[0].As<Napi::String>().Utf8Value();
   double levelValue = info[1].As<Napi::Number>().DoubleValue();
+  int vfo = SHIM_RIG_VFO_CURR;
+  if (info.Length() >= 3 && info[2].IsString()) {
+    std::string vfoStr = info[2].As<Napi::String>().Utf8Value();
+    if (vfoStr == "VFO-A") {
+      vfo = SHIM_RIG_VFO_A;
+    } else if (vfoStr == "VFO-B") {
+      vfo = SHIM_RIG_VFO_B;
+    }
+  }
   
   // Map level type strings to hamlib constants
   uint64_t levelType;
@@ -3021,8 +3030,8 @@ Napi::Value NodeHamLib::SetLevel(const Napi::CallbackInfo & info) {
   if (isSpectrumLevel) {
     Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
     int result = shim_rig_level_is_float(levelType)
-      ? shim_rig_set_level_f(my_rig, SHIM_RIG_VFO_CURR, levelType, static_cast<float>(levelValue))
-      : shim_rig_set_level_i(my_rig, SHIM_RIG_VFO_CURR, levelType, static_cast<int>(levelValue));
+      ? shim_rig_set_level_f(my_rig, vfo, levelType, static_cast<float>(levelValue))
+      : shim_rig_set_level_i(my_rig, vfo, levelType, static_cast<int>(levelValue));
 
     if (result != SHIM_RIG_OK) {
       deferred.Reject(Napi::Error::New(env, shim_rigerror(result)).Value());