hamlib 0.3.0 → 0.3.2

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
  */
@@ -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
  * 
@@ -1180,8 +1191,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 +1209,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 +1230,32 @@ 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);
+    await applyLevel('SPECTRUM_EDGE_LOW', config.edgeLowHz);
+    await applyLevel('SPECTRUM_EDGE_HIGH', config.edgeHighHz);
     await applyLevel('SPECTRUM_SPEED', config.speed);
     await applyLevel('SPECTRUM_REF', config.referenceLevel);
     await applyLevel('SPECTRUM_AVG', config.averageMode);
@@ -1222,6 +1263,89 @@ 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 [lowHz, highHz] = await Promise.all([
+      this.getLevel('SPECTRUM_EDGE_LOW'),
+      this.getLevel('SPECTRUM_EDGE_HIGH'),
+    ]);
+    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');
+    }
+    await this.setLevel('SPECTRUM_EDGE_LOW', lowHz);
+    await this.setLevel('SPECTRUM_EDGE_HIGH', highHz);
+    return { lowHz, highHz };
+  }
+
+  async getSpectrumDisplayState() {
+    const summary = await this.getSpectrumSupportSummary();
+    const [modeId, spanHz, 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.supportsEdgeSlotSelection ? this.getSpectrumEdgeSlot().catch(() => null) : Promise.resolve(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 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]

package/package.json

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

package/src/hamlib.cpp

@@ -286,7 +286,11 @@ public:
     void Execute() override {
         CHECK_RIG_VALID();
 
-        result_code_ = shim_rig_set_level_f(hamlib_instance_->my_rig, SHIM_RIG_VFO_CURR, level_type_, value_);
+        if (shim_rig_level_is_float(level_type_)) {
+            result_code_ = shim_rig_set_level_f(hamlib_instance_->my_rig, SHIM_RIG_VFO_CURR, level_type_, value_);
+        } else {
+            result_code_ = shim_rig_set_level_i(hamlib_instance_->my_rig, SHIM_RIG_VFO_CURR, level_type_, static_cast<int>(value_));
+        }
         if (result_code_ != SHIM_RIG_OK) {
             error_message_ = shim_rigerror(result_code_);
         }
@@ -3004,11 +3008,33 @@ Napi::Value NodeHamLib::SetLevel(const Napi::CallbackInfo & info) {
     return env.Null();
   }
   
-  float val = static_cast<float>(levelValue);
+  const bool isSpectrumLevel =
+    levelType == SHIM_RIG_LEVEL_SPECTRUM_MODE
+    || levelType == SHIM_RIG_LEVEL_SPECTRUM_SPAN
+    || levelType == SHIM_RIG_LEVEL_SPECTRUM_EDGE_LOW
+    || levelType == SHIM_RIG_LEVEL_SPECTRUM_EDGE_HIGH
+    || levelType == SHIM_RIG_LEVEL_SPECTRUM_SPEED
+    || levelType == SHIM_RIG_LEVEL_SPECTRUM_REF
+    || levelType == SHIM_RIG_LEVEL_SPECTRUM_AVG
+    || levelType == SHIM_RIG_LEVEL_SPECTRUM_ATT;
+
+  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));
+
+    if (result != SHIM_RIG_OK) {
+      deferred.Reject(Napi::Error::New(env, shim_rigerror(result)).Value());
+    } else {
+      deferred.Resolve(Napi::Number::New(env, result));
+    }
+    return deferred.Promise();
+  }
 
+  float val = static_cast<float>(levelValue);
   SetLevelAsyncWorker* worker = new SetLevelAsyncWorker(env, this, levelType, val);
   worker->Queue();
-  
   return worker->GetPromise();
 }
 
@@ -5970,11 +5996,60 @@ Napi::Value NodeHamLib::GetSpectrumCapabilities(const Napi::CallbackInfo& info)
   Napi::Env env = info.Env();
   Napi::Object result = Napi::Object::New(env);
 
-  result.Set("asyncDataSupported", env.Undefined());
-  result.Set("scopes", Napi::Array::New(env));
-  result.Set("modes", Napi::Array::New(env));
-  result.Set("spans", Napi::Array::New(env));
-  result.Set("avgModes", Napi::Array::New(env));
+  result.Set("asyncDataSupported", Napi::Boolean::New(env, shim_rig_is_async_data_supported(my_rig) != 0));
+
+  Napi::Array scopes = Napi::Array::New(env);
+  int scopeCount = shim_rig_get_caps_spectrum_scope_count(my_rig);
+  for (int i = 0; i < scopeCount; ++i) {
+    shim_spectrum_scope_t scope{};
+    if (shim_rig_get_caps_spectrum_scope(my_rig, i, &scope) != SHIM_RIG_OK) {
+      continue;
+    }
+    Napi::Object scopeObject = Napi::Object::New(env);
+    scopeObject.Set("id", Napi::Number::New(env, scope.id));
+    scopeObject.Set("name", Napi::String::New(env, scope.name));
+    scopes.Set(i, scopeObject);
+  }
+  result.Set("scopes", scopes);
+
+  Napi::Array modes = Napi::Array::New(env);
+  int modeCount = shim_rig_get_caps_spectrum_mode_count(my_rig);
+  for (int i = 0; i < modeCount; ++i) {
+    int modeId = 0;
+    if (shim_rig_get_caps_spectrum_mode(my_rig, i, &modeId) != SHIM_RIG_OK) {
+      continue;
+    }
+    Napi::Object modeObject = Napi::Object::New(env);
+    modeObject.Set("id", Napi::Number::New(env, modeId));
+    modeObject.Set("name", Napi::String::New(env, shim_rig_str_spectrum_mode(modeId)));
+    modes.Set(i, modeObject);
+  }
+  result.Set("modes", modes);
+
+  Napi::Array spans = Napi::Array::New(env);
+  int spanCount = shim_rig_get_caps_spectrum_span_count(my_rig);
+  for (int i = 0; i < spanCount; ++i) {
+    double spanHz = 0;
+    if (shim_rig_get_caps_spectrum_span(my_rig, i, &spanHz) != SHIM_RIG_OK) {
+      continue;
+    }
+    spans.Set(i, Napi::Number::New(env, spanHz));
+  }
+  result.Set("spans", spans);
+
+  Napi::Array avgModes = Napi::Array::New(env);
+  int avgModeCount = shim_rig_get_caps_spectrum_avg_mode_count(my_rig);
+  for (int i = 0; i < avgModeCount; ++i) {
+    shim_spectrum_avg_mode_t avgMode{};
+    if (shim_rig_get_caps_spectrum_avg_mode(my_rig, i, &avgMode) != SHIM_RIG_OK) {
+      continue;
+    }
+    Napi::Object avgModeObject = Napi::Object::New(env);
+    avgModeObject.Set("id", Napi::Number::New(env, avgMode.id));
+    avgModeObject.Set("name", Napi::String::New(env, avgMode.name));
+    avgModes.Set(i, avgModeObject);
+  }
+  result.Set("avgModes", avgModes);
 
   return result;
 }

package/src/shim/hamlib_shim.c

@@ -333,14 +333,20 @@ SHIM_API int shim_rig_get_strength(hamlib_shim_handle_t h, int vfo, int* strengt
 
 /* ===== Level control ===== */
 
+static void shim_ensure_targetable_level(hamlib_shim_handle_t h);
+
 SHIM_API int shim_rig_set_level_f(hamlib_shim_handle_t h, int vfo, uint64_t level, float value) {
+    shim_ensure_targetable_level(h);
     value_t val;
+    memset(&val, 0, sizeof(val));
     val.f = value;
     return rig_set_level((RIG*)h, (vfo_t)vfo, (setting_t)level, val);
 }
 
 SHIM_API int shim_rig_set_level_i(hamlib_shim_handle_t h, int vfo, uint64_t level, int value) {
+    shim_ensure_targetable_level(h);
     value_t val;
+    memset(&val, 0, sizeof(val));
     val.i = value;
     return rig_set_level((RIG*)h, (vfo_t)vfo, (setting_t)level, val);
 }
@@ -383,6 +389,10 @@ SHIM_API int shim_rig_get_level_i(hamlib_shim_handle_t h, int vfo, uint64_t leve
     return ret;
 }
 
+SHIM_API int shim_rig_level_is_float(uint64_t level) {
+    return RIG_LEVEL_IS_FLOAT((setting_t)level) ? 1 : 0;
+}
+
 /*
  * Auto-detect int/float level type using RIG_LEVEL_IS_FLOAT macro.
  * Returns the value as double regardless of the underlying type.

package/src/shim/hamlib_shim.h

@@ -434,6 +434,7 @@ SHIM_API int shim_rig_set_level_f(hamlib_shim_handle_t h, int vfo, uint64_t leve
 SHIM_API int shim_rig_set_level_i(hamlib_shim_handle_t h, int vfo, uint64_t level, int value);
 SHIM_API int shim_rig_get_level_f(hamlib_shim_handle_t h, int vfo, uint64_t level, float* value);
 SHIM_API int shim_rig_get_level_i(hamlib_shim_handle_t h, int vfo, uint64_t level, int* value);
+SHIM_API int shim_rig_level_is_float(uint64_t level);
 /* Auto-detect int/float level type, returns value as double */
 SHIM_API int shim_rig_get_level_auto(hamlib_shim_handle_t h, int vfo, uint64_t level, double* value);