fix: derive spectrum display state from official spectrum frames

Author: boybook

index.d.ts

@@ -622,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

lib/index.js

@@ -33,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,
+    };
   }
 
   /**
@@ -322,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);
   }
 
@@ -1254,8 +1280,12 @@ class HamLib extends EventEmitter {
 
     await applyLevel('SPECTRUM_MODE', await resolveModeId(config.mode));
     await applyLevel('SPECTRUM_SPAN', config.spanHz);
-    await applyLevel('SPECTRUM_EDGE_LOW', config.edgeLowHz);
-    await applyLevel('SPECTRUM_EDGE_HIGH', config.edgeHighHz);
+    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);
@@ -1287,9 +1317,15 @@ class HamLib extends EventEmitter {
   }
 
   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'),
-      this.getLevel('SPECTRUM_EDGE_HIGH'),
+      this.getLevel('SPECTRUM_EDGE_LOW', targetVfo),
+      this.getLevel('SPECTRUM_EDGE_HIGH', targetVfo),
     ]);
     return { lowHz, highHz };
   }
@@ -1298,23 +1334,28 @@ class HamLib extends EventEmitter {
     if (!Number.isFinite(lowHz) || !Number.isFinite(highHz) || lowHz >= highHz) {
       throw new Error('Spectrum fixed edge range must satisfy lowHz < highHz');
     }
-    await this.setLevel('SPECTRUM_EDGE_LOW', lowHz);
-    await this.setLevel('SPECTRUM_EDGE_HIGH', 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 [modeId, spanHz, fixedEdges, edgeSlot] = await Promise.all([
+    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() : 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 ?? null;
-    const edgeHighHz = fixedEdges?.highHz ?? null;
+    const edgeLowHz = fixedEdges?.lowHz ?? lineState?.edgeLowHz ?? null;
+    const edgeHighHz = fixedEdges?.highHz ?? lineState?.edgeHighHz ?? null;
     const derivedSpanHz = (edgeLowHz !== null && edgeHighHz !== null) ? (edgeHighHz - edgeLowHz) : null;
 
     return {
@@ -1352,9 +1393,14 @@ class HamLib extends EventEmitter {
    * @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.json

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

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());