hamlib 0.2.3 → 0.2.5

package/index.d.ts

@@ -542,9 +542,10 @@ declare class HamLib {
   /**
    * Get radio level
    * @param levelType Level type ('AF', 'RF', 'SQL', 'STRENGTH', etc.)
+   * @param vfo Optional VFO ('VFO-A', 'VFO-B', 'currVFO'). Defaults to currVFO.
    * @returns Level value
    */
-  getLevel(levelType: LevelType): Promise<number>;
+  getLevel(levelType: LevelType, vfo?: string): Promise<number>;
 
   /**
    * Get list of supported level types

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hamlib",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Node.js wrapper for hamlib radio control library",
   "main": "index.js",
   "module": "lib/index.mjs",

package/src/hamlib.cpp

@@ -280,7 +280,7 @@ public:
     void Execute() override {
         CHECK_RIG_VALID();
 
-        result_code_ = shim_rig_set_level_f(hamlib_instance_->my_rig, SHIM_RIG_VFO_NONE, level_type_, value_);
+        result_code_ = shim_rig_set_level_f(hamlib_instance_->my_rig, SHIM_RIG_VFO_CURR, level_type_, value_);
         if (result_code_ != SHIM_RIG_OK) {
             error_message_ = shim_rigerror(result_code_);
         }
@@ -307,15 +307,15 @@ private:
 
 class GetLevelAsyncWorker : public HamLibAsyncWorker {
 public:
-    GetLevelAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance, uint64_t level_type)
-        : HamLibAsyncWorker(env, hamlib_instance), level_type_(level_type), value_(0.0f) {}
+    GetLevelAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance, uint64_t level_type, int vfo = SHIM_RIG_VFO_CURR)
+        : HamLibAsyncWorker(env, hamlib_instance), level_type_(level_type), vfo_(vfo), value_(0.0) {}
 
     void Execute() override {
         CHECK_RIG_VALID();
 
-        // Use RIG_VFO_NONE to avoid unnecessary VFO switching that fails on
-        // ICOM rigs (e.g. IC-705) where icom_set_vfo returns "unsupported VFO"
-        result_code_ = shim_rig_get_level_f(hamlib_instance_->my_rig, SHIM_RIG_VFO_NONE, level_type_, &value_);
+        // Use auto-detect to handle int levels (STRENGTH, RAWSTR) and
+        // float levels (SWR, ALC, RFPOWER_METER, etc.) correctly
+        result_code_ = shim_rig_get_level_auto(hamlib_instance_->my_rig, vfo_, level_type_, &value_);
         if (result_code_ != SHIM_RIG_OK) {
             error_message_ = shim_rigerror(result_code_);
         }
@@ -337,7 +337,8 @@ public:
 
 private:
     uint64_t level_type_;
-    float value_;
+    int vfo_;
+    double value_;
 };
 
 class SetFunctionAsyncWorker : public HamLibAsyncWorker {
@@ -2974,9 +2975,20 @@ Napi::Value NodeHamLib::GetLevel(const Napi::CallbackInfo & info) {
     return env.Null();
   }
   
-  GetLevelAsyncWorker* worker = new GetLevelAsyncWorker(env, this, levelType);
+  // Optional second parameter: VFO string ('VFO-A', 'VFO-B', 'currVFO')
+  int vfo = SHIM_RIG_VFO_CURR;
+  if (info.Length() >= 2 && info[1].IsString()) {
+    std::string vfoStr = info[1].As<Napi::String>().Utf8Value();
+    if (vfoStr == "VFO-A") {
+      vfo = SHIM_RIG_VFO_A;
+    } else if (vfoStr == "VFO-B") {
+      vfo = SHIM_RIG_VFO_B;
+    }
+  }
+
+  GetLevelAsyncWorker* worker = new GetLevelAsyncWorker(env, this, levelType, vfo);
   worker->Queue();
-  
+
   return worker->GetPromise();
 }
 

package/src/shim/hamlib_shim.c

@@ -345,7 +345,28 @@ SHIM_API int shim_rig_set_level_i(hamlib_shim_handle_t h, int vfo, uint64_t leve
     return rig_set_level((RIG*)h, (vfo_t)vfo, (setting_t)level, val);
 }
 
+/*
+ * Ensure RIG_TARGETABLE_LEVEL is set so rig_get_level() skips VFO
+ * switching but still performs calibration and type conversion.
+ * This fixes ICOM serial rigs where icom_set_vfo fails with
+ * "unsupported VFO" during get_level calls.
+ *
+ * RIG_TARGETABLE_LEVEL = (1<<5) tells Hamlib: "this rig can read
+ * levels without needing to switch VFO first".
+ */
+#ifndef RIG_TARGETABLE_LEVEL
+#define RIG_TARGETABLE_LEVEL (1<<5)
+#endif
+
+static void shim_ensure_targetable_level(hamlib_shim_handle_t h) {
+    RIG* rig = (RIG*)h;
+    if (rig && rig->caps && !(rig->caps->targetable_vfo & RIG_TARGETABLE_LEVEL)) {
+        rig->caps->targetable_vfo |= RIG_TARGETABLE_LEVEL;
+    }
+}
+
 SHIM_API int shim_rig_get_level_f(hamlib_shim_handle_t h, int vfo, uint64_t level, float* value) {
+    shim_ensure_targetable_level(h);
     value_t val;
     val.f = 0.0f;
     int ret = rig_get_level((RIG*)h, (vfo_t)vfo, (setting_t)level, &val);
@@ -354,6 +375,7 @@ SHIM_API int shim_rig_get_level_f(hamlib_shim_handle_t h, int vfo, uint64_t leve
 }
 
 SHIM_API int shim_rig_get_level_i(hamlib_shim_handle_t h, int vfo, uint64_t level, int* value) {
+    shim_ensure_targetable_level(h);
     value_t val;
     val.i = 0;
     int ret = rig_get_level((RIG*)h, (vfo_t)vfo, (setting_t)level, &val);
@@ -361,6 +383,26 @@ SHIM_API int shim_rig_get_level_i(hamlib_shim_handle_t h, int vfo, uint64_t leve
     return ret;
 }
 
+/*
+ * Auto-detect int/float level type using RIG_LEVEL_IS_FLOAT macro.
+ * Returns the value as double regardless of the underlying type.
+ * This avoids the common bug where STRENGTH (int) is read as float.
+ */
+SHIM_API int shim_rig_get_level_auto(hamlib_shim_handle_t h, int vfo, uint64_t level, double* value) {
+    shim_ensure_targetable_level(h);
+    value_t val;
+    memset(&val, 0, sizeof(val));
+    int ret = rig_get_level((RIG*)h, (vfo_t)vfo, (setting_t)level, &val);
+    if (value) {
+        if (RIG_LEVEL_IS_FLOAT((setting_t)level)) {
+            *value = (double)val.f;
+        } else {
+            *value = (double)val.i;
+        }
+    }
+    return ret;
+}
+
 /* ===== Function control ===== */
 
 SHIM_API int shim_rig_set_func(hamlib_shim_handle_t h, int vfo, uint64_t func, int enable) {

package/src/shim/hamlib_shim.h

@@ -182,15 +182,24 @@ typedef void* hamlib_shim_handle_t;
 #define SHIM_RIG_LEVEL_METER        (1ULL << 20)
 #define SHIM_RIG_LEVEL_VOXGAIN      (1ULL << 21)
 #define SHIM_RIG_LEVEL_ANTIVOX      (1ULL << 22)
-#define SHIM_RIG_LEVEL_STRENGTH     (1ULL << 26)
-#define SHIM_RIG_LEVEL_RAWSTR       (1ULL << 28)
-#define SHIM_RIG_LEVEL_SWR          (1ULL << 29)
-#define SHIM_RIG_LEVEL_ALC          (1ULL << 30)
-#define SHIM_RIG_LEVEL_RFPOWER_METER (1ULL << 33)
-#define SHIM_RIG_LEVEL_COMP_METER   (1ULL << 34)
-#define SHIM_RIG_LEVEL_VD_METER     (1ULL << 35)
-#define SHIM_RIG_LEVEL_ID_METER     (1ULL << 36)
-#define SHIM_RIG_LEVEL_TEMP_METER   (1ULL << 42)
+#define SHIM_RIG_LEVEL_SLOPE_LOW    (1ULL << 23)
+#define SHIM_RIG_LEVEL_SLOPE_HIGH   (1ULL << 24)
+#define SHIM_RIG_LEVEL_BKIN_DLYMS   (1ULL << 25)
+#define SHIM_RIG_LEVEL_RAWSTR       (1ULL << 26)
+/* bit 27 reserved (was SQLSTAT, deprecated) */
+#define SHIM_RIG_LEVEL_SWR          (1ULL << 28)
+#define SHIM_RIG_LEVEL_ALC          (1ULL << 29)
+#define SHIM_RIG_LEVEL_STRENGTH     (1ULL << 30)
+/* bit 31 reserved */
+#define SHIM_RIG_LEVEL_RFPOWER_METER (1ULL << 32)
+#define SHIM_RIG_LEVEL_COMP_METER   (1ULL << 33)
+#define SHIM_RIG_LEVEL_VD_METER     (1ULL << 34)
+#define SHIM_RIG_LEVEL_ID_METER     (1ULL << 35)
+#define SHIM_RIG_LEVEL_NOTCHF_RAW   (1ULL << 36)
+#define SHIM_RIG_LEVEL_MONITOR_GAIN (1ULL << 37)
+#define SHIM_RIG_LEVEL_NB           (1ULL << 38)
+#define SHIM_RIG_LEVEL_RFPOWER_METER_WATTS (1ULL << 39)
+#define SHIM_RIG_LEVEL_TEMP_METER   (1ULL << 48)
 
 /* ===== Function constants (bit positions for setting_t / uint64_t) ===== */
 #define SHIM_RIG_FUNC_FAGC    (1ULL << 0)
@@ -383,6 +392,8 @@ 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);
+/* 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);
 
 /* ===== Function control ===== */