hamlib 0.2.4 → 0.2.6

package/package.json

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

package/src/hamlib.cpp

@@ -308,12 +308,14 @@ private:
 class GetLevelAsyncWorker : public HamLibAsyncWorker {
 public:
     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.0f) {}
+        : HamLibAsyncWorker(env, hamlib_instance), level_type_(level_type), vfo_(vfo), value_(0.0) {}
 
     void Execute() override {
         CHECK_RIG_VALID();
 
-        result_code_ = shim_rig_get_level_f(hamlib_instance_->my_rig, vfo_, 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_);
         }
@@ -336,7 +338,7 @@ public:
 private:
     uint64_t level_type_;
     int vfo_;
-    float value_;
+    double value_;
 };
 
 class SetFunctionAsyncWorker : public HamLibAsyncWorker {

package/src/shim/hamlib_shim.c

@@ -346,45 +346,91 @@ SHIM_API int shim_rig_set_level_i(hamlib_shim_handle_t h, int vfo, uint64_t leve
 }
 
 /*
- * get_level with automatic fallback:
- * 1. Try standard rig_get_level() (with VFO handling, locking, caching)
- * 2. If it fails with RIG_EINVAL (-1), fall back to direct backend call
- *    to bypass VFO switching issues (e.g. ICOM serial rigs where
- *    icom_set_vfo fails with "unsupported VFO")
+ * 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".
  */
-static int shim_get_level_with_fallback(hamlib_shim_handle_t h, int vfo, uint64_t level, value_t* val) {
+#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;
-    int ret = rig_get_level(rig, (vfo_t)vfo, (setting_t)level, val);
-    if (ret == -1 && rig->caps->get_level) {
-        /* RIG_EINVAL: VFO switching failed, try direct backend call */
-        ret = rig->caps->get_level(rig, (vfo_t)vfo, (setting_t)level, val);
+    if (rig && rig->caps && !(rig->caps->targetable_vfo & RIG_TARGETABLE_LEVEL)) {
+        rig->caps->targetable_vfo |= RIG_TARGETABLE_LEVEL;
     }
-    return ret;
 }
 
 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 = shim_get_level_with_fallback(h, vfo, level, &val);
+    int ret = rig_get_level((RIG*)h, (vfo_t)vfo, (setting_t)level, &val);
     if (value) *value = val.f;
     return ret;
 }
 
 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 = shim_get_level_with_fallback(h, vfo, level, &val);
+    int ret = rig_get_level((RIG*)h, (vfo_t)vfo, (setting_t)level, &val);
     if (value) *value = val.i;
     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 ===== */
 
+/*
+ * Ensure RIG_TARGETABLE_FUNC is set so rig_get_func()/rig_set_func()
+ * skip VFO switching. Same fix as RIG_TARGETABLE_LEVEL for ICOM serial
+ * rigs where icom_set_vfo fails with "unsupported VFO".
+ *
+ * RIG_TARGETABLE_FUNC = (1<<4) tells Hamlib: "this rig can get/set
+ * functions without needing to switch VFO first".
+ */
+#ifndef RIG_TARGETABLE_FUNC
+#define RIG_TARGETABLE_FUNC (1<<4)
+#endif
+
+static void shim_ensure_targetable_func(hamlib_shim_handle_t h) {
+    RIG* rig = (RIG*)h;
+    if (rig && rig->caps && !(rig->caps->targetable_vfo & RIG_TARGETABLE_FUNC)) {
+        rig->caps->targetable_vfo |= RIG_TARGETABLE_FUNC;
+    }
+}
+
 SHIM_API int shim_rig_set_func(hamlib_shim_handle_t h, int vfo, uint64_t func, int enable) {
+    shim_ensure_targetable_func(h);
     return rig_set_func((RIG*)h, (vfo_t)vfo, (setting_t)func, enable);
 }
 
 SHIM_API int shim_rig_get_func(hamlib_shim_handle_t h, int vfo, uint64_t func, int* state) {
+    shim_ensure_targetable_func(h);
     int s = 0;
     int ret = rig_get_func((RIG*)h, (vfo_t)vfo, (setting_t)func, &s);
     if (state) *state = s;
@@ -587,8 +633,20 @@ SHIM_API int shim_rig_scan(hamlib_shim_handle_t h, int vfo, int scan_type, int c
 
 /* ===== VFO operations ===== */
 
+/*
+ * vfo_op with fallback for rigs with VFO switching issues.
+ * There is no RIG_TARGETABLE for vfo_op, so we use the same
+ * fallback pattern as the old getLevel fix: try standard call
+ * first, then direct backend call if RIG_EINVAL (-1).
+ */
 SHIM_API int shim_rig_vfo_op(hamlib_shim_handle_t h, int vfo, int op) {
-    return rig_vfo_op((RIG*)h, (vfo_t)vfo, (vfo_op_t)op);
+    RIG* rig = (RIG*)h;
+    int ret = rig_vfo_op(rig, (vfo_t)vfo, (vfo_op_t)op);
+    if (ret == -1 && rig->caps->vfo_op) {
+        /* RIG_EINVAL: VFO switching failed, try direct backend call */
+        ret = rig->caps->vfo_op(rig, (vfo_t)vfo, (vfo_op_t)op);
+    }
+    return ret;
 }
 
 /* ===== Antenna control ===== */

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 ===== */