hamlib 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hamlib",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "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);