hamlib 0.2.7 → 0.3.1

package/src/hamlib.cpp

@@ -4,6 +4,9 @@
 #include <vector>
 #include <memory>
 #include <algorithm>
+#include <chrono>
+#include <cstdio>
+#include <exception>
 
 // 安全宏 - 检查RIG指针有效性，防止空指针解引用和已销毁对象访问
 #define CHECK_RIG_VALID() \
@@ -45,10 +48,13 @@ public:
         } else {
             shim_rig_set_freq_callback(hamlib_instance_->my_rig, NodeHamLib::freq_change_cb, hamlib_instance_);
             auto ppt_cb = +[](void* handle, int vfo, int ptt, void* arg) -> int {
-                printf("PPT pushed!");
+                (void)handle;
+                (void)vfo;
+                (void)ptt;
+                (void)arg;
                 return 0;
             };
-            int cb_result = shim_rig_set_ptt_callback(hamlib_instance_->my_rig, ppt_cb, NULL);
+            shim_rig_set_ptt_callback(hamlib_instance_->my_rig, ppt_cb, NULL);
             shim_rig_set_trn(hamlib_instance_->my_rig, SHIM_RIG_TRN_POLL);
             hamlib_instance_->rig_is_open = true;
         }
@@ -280,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_);
         }
@@ -2170,7 +2180,7 @@ private:
 
 // Helper function to parse VFO parameter from JavaScript
 int parseVfoParameter(const Napi::CallbackInfo& info, int index, int defaultVfo = SHIM_RIG_VFO_CURR) {
-    if (info.Length() > index && info[index].IsString()) {
+    if (info.Length() > static_cast<size_t>(index) && info[index].IsString()) {
         std::string vfoStr = info[index].As<Napi::String>().Utf8Value();
         if (vfoStr == "VFO-A") {
             return SHIM_RIG_VFO_A;
@@ -2268,6 +2278,8 @@ NodeHamLib::NodeHamLib(const Napi::CallbackInfo & info): ObjectWrap(info) {
 
 // 析构函数 - 确保资源正确清理
 NodeHamLib::~NodeHamLib() {
+  StopSpectrumStreamInternal();
+
   // 如果rig指针存在，执行清理
   if (my_rig) {
     // 如果rig是打开状态，先关闭
@@ -2281,10 +2293,70 @@ NodeHamLib::~NodeHamLib() {
   }
 }
 
+int NodeHamLib::spectrum_line_cb(void* handle, const shim_spectrum_line_t* line, void* arg) {
+  (void)handle;
+  NodeHamLib* instance = static_cast<NodeHamLib*>(arg);
+  if (!instance || !line) {
+    return 0;
+  }
+  instance->EmitSpectrumLine(*line);
+  return 0;
+}
+
+void NodeHamLib::EmitSpectrumLine(const shim_spectrum_line_t& line) {
+  if (!spectrum_tsfn_) {
+    return;
+  }
+
+  auto* line_copy = new shim_spectrum_line_t(line);
+  napi_status status = spectrum_tsfn_.BlockingCall(
+    line_copy,
+    [](Napi::Env env, Napi::Function callback, shim_spectrum_line_t* data) {
+      Napi::Object lineObject = Napi::Object::New(env);
+      lineObject.Set("scopeId", Napi::Number::New(env, data->id));
+      lineObject.Set("dataLevelMin", Napi::Number::New(env, data->data_level_min));
+      lineObject.Set("dataLevelMax", Napi::Number::New(env, data->data_level_max));
+      lineObject.Set("signalStrengthMin", Napi::Number::New(env, data->signal_strength_min));
+      lineObject.Set("signalStrengthMax", Napi::Number::New(env, data->signal_strength_max));
+      lineObject.Set("mode", Napi::Number::New(env, data->spectrum_mode));
+      lineObject.Set("centerFreq", Napi::Number::New(env, data->center_freq));
+      lineObject.Set("spanHz", Napi::Number::New(env, data->span_freq));
+      lineObject.Set("lowEdgeFreq", Napi::Number::New(env, data->low_edge_freq));
+      lineObject.Set("highEdgeFreq", Napi::Number::New(env, data->high_edge_freq));
+      lineObject.Set("dataLength", Napi::Number::New(env, data->data_length));
+      lineObject.Set("timestamp", Napi::Number::New(env, static_cast<double>(std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::system_clock::now().time_since_epoch()).count())));
+      lineObject.Set("data", Napi::Buffer<unsigned char>::Copy(env, data->data, static_cast<size_t>(data->data_length)));
+      callback.Call({ lineObject });
+      delete data;
+    });
+
+  if (status != napi_ok) {
+    delete line_copy;
+    return;
+  }
+}
+
+void NodeHamLib::StopSpectrumStreamInternal() {
+  std::lock_guard<std::mutex> lock(spectrum_mutex_);
+  if (spectrum_stream_running_) {
+    shim_rig_set_spectrum_callback(my_rig, nullptr, nullptr);
+    spectrum_stream_running_ = false;
+  }
+  if (spectrum_tsfn_) {
+    spectrum_tsfn_.Release();
+    spectrum_tsfn_ = Napi::ThreadSafeFunction();
+  }
+}
+
 int NodeHamLib::freq_change_cb(void *handle, int vfo, double freq, void* arg) {
+      (void)handle;
+      (void)vfo;
+      (void)freq;
       auto instance = static_cast<NodeHamLib*>(arg);
-      printf("Rig changed freq to %0.7f Hz\n", freq);
-      Napi::Env env = instance->m_currentInfo->Env();
+      if (!instance) {
+        return 0;
+      }
       //Napi::Function emit = instance->m_currentInfo[0].Get("emit").As<Napi::Function>();
 			// Napi::Function emit = instance->m_currentInfo[0]->This().As<Napi::Object>().Get("emit").As<Napi::Function>();
       //emit.Call(instance->m_currentInfo->This(), { Napi::String::New(env, "frequency_change"), Napi::Number::New(env, freq) });
@@ -2293,7 +2365,6 @@ int NodeHamLib::freq_change_cb(void *handle, int vfo, double freq, void* arg) {
         //auto fn = global.Get("process").As<Napi::Object>().Get("emit").As<Napi::Function>();
         //fn.Call({Napi::Number::New(env, freq)});
         return 0;
-  return 0;
 }
 
 Napi::Value NodeHamLib::Open(const Napi::CallbackInfo & info) {
@@ -2565,6 +2636,8 @@ Napi::Value NodeHamLib::Close(const Napi::CallbackInfo & info) {
       .ThrowAsJavaScriptException();
     return env.Null();
   }
+
+  StopSpectrumStreamInternal();
   
   CloseAsyncWorker* worker = new CloseAsyncWorker(env, this);
   worker->Queue();
@@ -2574,6 +2647,8 @@ Napi::Value NodeHamLib::Close(const Napi::CallbackInfo & info) {
 
 Napi::Value NodeHamLib::Destroy(const Napi::CallbackInfo & info) {
   Napi::Env env = info.Env();
+
+  StopSpectrumStreamInternal();
   
   DestroyAsyncWorker* worker = new DestroyAsyncWorker(env, this);
   worker->Queue();
@@ -2912,16 +2987,54 @@ Napi::Value NodeHamLib::SetLevel(const Napi::CallbackInfo & info) {
     levelType = SHIM_RIG_LEVEL_VOXDELAY;
   } else if (levelTypeStr == "ANTIVOX") {
     levelType = SHIM_RIG_LEVEL_ANTIVOX;
+  } else if (levelTypeStr == "SPECTRUM_MODE") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_MODE;
+  } else if (levelTypeStr == "SPECTRUM_SPAN") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_SPAN;
+  } else if (levelTypeStr == "SPECTRUM_EDGE_LOW") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_EDGE_LOW;
+  } else if (levelTypeStr == "SPECTRUM_EDGE_HIGH") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_EDGE_HIGH;
+  } else if (levelTypeStr == "SPECTRUM_SPEED") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_SPEED;
+  } else if (levelTypeStr == "SPECTRUM_REF") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_REF;
+  } else if (levelTypeStr == "SPECTRUM_AVG") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_AVG;
+  } else if (levelTypeStr == "SPECTRUM_ATT") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_ATT;
   } else {
     Napi::TypeError::New(env, "Invalid level type").ThrowAsJavaScriptException();
     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();
 }
 
@@ -2972,6 +3085,50 @@ Napi::Value NodeHamLib::GetLevel(const Napi::CallbackInfo & info) {
     levelType = SHIM_RIG_LEVEL_ID_METER;
   } else if (levelTypeStr == "TEMP_METER") {
     levelType = SHIM_RIG_LEVEL_TEMP_METER;
+  } else if (levelTypeStr == "NR") {
+    levelType = SHIM_RIG_LEVEL_NR;
+  } else if (levelTypeStr == "AF") {
+    levelType = SHIM_RIG_LEVEL_AF;
+  } else if (levelTypeStr == "RF") {
+    levelType = SHIM_RIG_LEVEL_RF;
+  } else if (levelTypeStr == "SQL") {
+    levelType = SHIM_RIG_LEVEL_SQL;
+  } else if (levelTypeStr == "RFPOWER") {
+    levelType = SHIM_RIG_LEVEL_RFPOWER;
+  } else if (levelTypeStr == "MICGAIN") {
+    levelType = SHIM_RIG_LEVEL_MICGAIN;
+  } else if (levelTypeStr == "VOXDELAY") {
+    levelType = SHIM_RIG_LEVEL_VOXDELAY;
+  } else if (levelTypeStr == "PBT_IN") {
+    levelType = SHIM_RIG_LEVEL_PBT_IN;
+  } else if (levelTypeStr == "PBT_OUT") {
+    levelType = SHIM_RIG_LEVEL_PBT_OUT;
+  } else if (levelTypeStr == "CWPITCH") {
+    levelType = SHIM_RIG_LEVEL_CWPITCH;
+  } else if (levelTypeStr == "COMP") {
+    levelType = SHIM_RIG_LEVEL_COMP;
+  } else if (levelTypeStr == "AGC") {
+    levelType = SHIM_RIG_LEVEL_AGC;
+  } else if (levelTypeStr == "VOXGAIN") {
+    levelType = SHIM_RIG_LEVEL_VOXGAIN;
+  } else if (levelTypeStr == "ANTIVOX") {
+    levelType = SHIM_RIG_LEVEL_ANTIVOX;
+  } else if (levelTypeStr == "SPECTRUM_MODE") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_MODE;
+  } else if (levelTypeStr == "SPECTRUM_SPAN") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_SPAN;
+  } else if (levelTypeStr == "SPECTRUM_EDGE_LOW") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_EDGE_LOW;
+  } else if (levelTypeStr == "SPECTRUM_EDGE_HIGH") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_EDGE_HIGH;
+  } else if (levelTypeStr == "SPECTRUM_SPEED") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_SPEED;
+  } else if (levelTypeStr == "SPECTRUM_REF") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_REF;
+  } else if (levelTypeStr == "SPECTRUM_AVG") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_AVG;
+  } else if (levelTypeStr == "SPECTRUM_ATT") {
+    levelType = SHIM_RIG_LEVEL_SPECTRUM_ATT;
   } else {
     Napi::TypeError::New(env, "Invalid level type").ThrowAsJavaScriptException();
     return env.Null();
@@ -3032,6 +3189,14 @@ Napi::Value NodeHamLib::GetSupportedLevels(const Napi::CallbackInfo & info) {
   if (levels & SHIM_RIG_LEVEL_COMP_METER) levelArray[index++] = Napi::String::New(env, "COMP_METER");
   if (levels & SHIM_RIG_LEVEL_VD_METER) levelArray[index++] = Napi::String::New(env, "VD_METER");
   if (levels & SHIM_RIG_LEVEL_ID_METER) levelArray[index++] = Napi::String::New(env, "ID_METER");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_MODE) levelArray[index++] = Napi::String::New(env, "SPECTRUM_MODE");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_SPAN) levelArray[index++] = Napi::String::New(env, "SPECTRUM_SPAN");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_EDGE_LOW) levelArray[index++] = Napi::String::New(env, "SPECTRUM_EDGE_LOW");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_EDGE_HIGH) levelArray[index++] = Napi::String::New(env, "SPECTRUM_EDGE_HIGH");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_SPEED) levelArray[index++] = Napi::String::New(env, "SPECTRUM_SPEED");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_REF) levelArray[index++] = Napi::String::New(env, "SPECTRUM_REF");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_AVG) levelArray[index++] = Napi::String::New(env, "SPECTRUM_AVG");
+  if (levels & SHIM_RIG_LEVEL_SPECTRUM_ATT) levelArray[index++] = Napi::String::New(env, "SPECTRUM_ATT");
   if (levels & SHIM_RIG_LEVEL_TEMP_METER) levelArray[index++] = Napi::String::New(env, "TEMP_METER");
   
   return levelArray;
@@ -3112,6 +3277,12 @@ Napi::Value NodeHamLib::SetFunction(const Napi::CallbackInfo & info) {
     funcType = SHIM_RIG_FUNC_RESUME;
   } else if (funcTypeStr == "TBURST") {
     funcType = SHIM_RIG_FUNC_TBURST;
+  } else if (funcTypeStr == "TRANSCEIVE") {
+    funcType = SHIM_RIG_FUNC_TRANSCEIVE;
+  } else if (funcTypeStr == "SPECTRUM") {
+    funcType = SHIM_RIG_FUNC_SPECTRUM;
+  } else if (funcTypeStr == "SPECTRUM_HOLD") {
+    funcType = SHIM_RIG_FUNC_SPECTRUM_HOLD;
   } else {
     Napi::TypeError::New(env, "Invalid function type").ThrowAsJavaScriptException();
     return env.Null();
@@ -3196,6 +3367,12 @@ Napi::Value NodeHamLib::GetFunction(const Napi::CallbackInfo & info) {
     funcType = SHIM_RIG_FUNC_RESUME;
   } else if (funcTypeStr == "TBURST") {
     funcType = SHIM_RIG_FUNC_TBURST;
+  } else if (funcTypeStr == "TRANSCEIVE") {
+    funcType = SHIM_RIG_FUNC_TRANSCEIVE;
+  } else if (funcTypeStr == "SPECTRUM") {
+    funcType = SHIM_RIG_FUNC_SPECTRUM;
+  } else if (funcTypeStr == "SPECTRUM_HOLD") {
+    funcType = SHIM_RIG_FUNC_SPECTRUM_HOLD;
   } else {
     Napi::TypeError::New(env, "Invalid function type").ThrowAsJavaScriptException();
     return env.Null();
@@ -3244,6 +3421,9 @@ Napi::Value NodeHamLib::GetSupportedFunctions(const Napi::CallbackInfo & info) {
   if (functions & SHIM_RIG_FUNC_SCOPE) funcArray[index++] = Napi::String::New(env, "SCOPE");
   if (functions & SHIM_RIG_FUNC_RESUME) funcArray[index++] = Napi::String::New(env, "RESUME");
   if (functions & SHIM_RIG_FUNC_TBURST) funcArray[index++] = Napi::String::New(env, "TBURST");
+  if (functions & SHIM_RIG_FUNC_TRANSCEIVE) funcArray[index++] = Napi::String::New(env, "TRANSCEIVE");
+  if (functions & SHIM_RIG_FUNC_SPECTRUM) funcArray[index++] = Napi::String::New(env, "SPECTRUM");
+  if (functions & SHIM_RIG_FUNC_SPECTRUM_HOLD) funcArray[index++] = Napi::String::New(env, "SPECTRUM_HOLD");
   
   return funcArray;
 }
@@ -3730,9 +3910,12 @@ Napi::Function NodeHamLib::GetClass(Napi::Env env) {
       // VFO Info (Hamlib >= 4.7.0)
       NodeHamLib::InstanceMethod("getVfoInfo", & NodeHamLib::GetVfoInfo),
 
-      // Rig Info / Raw / Conf (async)
+      // Rig Info / Spectrum / Conf (async)
       NodeHamLib::InstanceMethod("getInfo", & NodeHamLib::GetInfo),
       NodeHamLib::InstanceMethod("sendRaw", & NodeHamLib::SendRaw),
+      NodeHamLib::InstanceMethod("getSpectrumCapabilities", & NodeHamLib::GetSpectrumCapabilities),
+      NodeHamLib::InstanceMethod("startSpectrumStream", & NodeHamLib::StartSpectrumStream),
+      NodeHamLib::InstanceMethod("stopSpectrumStream", & NodeHamLib::StopSpectrumStream),
       NodeHamLib::InstanceMethod("setConf", & NodeHamLib::SetConf),
       NodeHamLib::InstanceMethod("getConf", & NodeHamLib::GetConf),
 
@@ -5809,6 +5992,104 @@ Napi::Value NodeHamLib::SendRaw(const Napi::CallbackInfo& info) {
   return asyncWorker->GetPromise();
 }
 
+Napi::Value NodeHamLib::GetSpectrumCapabilities(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::Object result = Napi::Object::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;
+}
+
+Napi::Value NodeHamLib::StartSpectrumStream(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (!rig_is_open) {
+    Napi::TypeError::New(env, "Rig is not open!").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  if (info.Length() < 1 || !info[0].IsFunction()) {
+    Napi::TypeError::New(env, "Expected (callback: Function)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::lock_guard<std::mutex> lock(spectrum_mutex_);
+  if (spectrum_stream_running_) {
+    Napi::Error::New(env, "Spectrum stream is already running").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Function callback = info[0].As<Napi::Function>();
+  spectrum_tsfn_ = Napi::ThreadSafeFunction::New(env, callback, "HamLibSpectrumStream", 0, 1);
+  int ret = shim_rig_set_spectrum_callback(my_rig, &NodeHamLib::spectrum_line_cb, this);
+  if (ret != SHIM_RIG_OK) {
+    spectrum_tsfn_.Release();
+    spectrum_tsfn_ = Napi::ThreadSafeFunction();
+    Napi::Error::New(env, shim_rigerror(ret)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  spectrum_stream_running_ = true;
+  return Napi::Boolean::New(env, true);
+}
+
+Napi::Value NodeHamLib::StopSpectrumStream(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  StopSpectrumStreamInternal();
+  return Napi::Boolean::New(env, true);
+}
+
 // ===== SetConf (async) =====
 
 class SetConfAsyncWorker : public HamLibAsyncWorker {

package/src/hamlib.h

@@ -4,6 +4,10 @@
 #include "shim/hamlib_shim.h"
 #include <memory>
 #include <string>
+#include <atomic>
+#include <mutex>
+#include <vector>
+#include <cstdint>
 
 // Forward declaration
 class NodeHamLib;
@@ -173,6 +177,9 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
   // Rig Info / Raw / Conf (async)
   Napi::Value GetInfo(const Napi::CallbackInfo&);
   Napi::Value SendRaw(const Napi::CallbackInfo&);
+  Napi::Value GetSpectrumCapabilities(const Napi::CallbackInfo&);
+  Napi::Value StartSpectrumStream(const Napi::CallbackInfo&);
+  Napi::Value StopSpectrumStream(const Napi::CallbackInfo&);
   Napi::Value SetConf(const Napi::CallbackInfo&);
   Napi::Value GetConf(const Napi::CallbackInfo&);
 
@@ -217,6 +224,7 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
 
   // Frequency change callback (uses basic C types via shim)
   static int freq_change_cb(void* handle, int vfo, double freq, void* arg);
+  static int spectrum_line_cb(void* handle, const shim_spectrum_line_t* line, void* arg);
 
  public:
   hamlib_shim_handle_t my_rig;  // Opaque handle instead of RIG*
@@ -234,4 +242,10 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
 
   // Static callback helper for shim_rig_list_foreach
   static int rig_list_callback(const shim_rig_info_t* info, void* data);
+
+  void EmitSpectrumLine(const shim_spectrum_line_t& line);
+  void StopSpectrumStreamInternal();
+  std::atomic<bool> spectrum_stream_running_{false};
+  Napi::ThreadSafeFunction spectrum_tsfn_;
+  std::mutex spectrum_mutex_;
 };

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.
@@ -837,9 +847,15 @@ struct shim_ptt_cb_adapter {
     void* user_arg;
 };
 
+struct shim_spectrum_cb_adapter {
+    shim_spectrum_cb_t user_cb;
+    void* user_arg;
+};
+
 /* We store adapters statically (one per rig handle - simplified) */
 static struct shim_freq_cb_adapter freq_cb_adapter = {NULL, NULL};
 static struct shim_ptt_cb_adapter ptt_cb_adapter = {NULL, NULL};
+static struct shim_spectrum_cb_adapter spectrum_cb_adapter = {NULL, NULL};
 
 static int shim_freq_cb_thunk(RIG *rig, vfo_t vfo, freq_t freq, rig_ptr_t arg) {
     struct shim_freq_cb_adapter *adapter = (struct shim_freq_cb_adapter*)arg;
@@ -857,6 +873,33 @@ static int shim_ptt_cb_thunk(RIG *rig, vfo_t vfo, ptt_t ptt, rig_ptr_t arg) {
     return 0;
 }
 
+static int shim_spectrum_cb_thunk(RIG *rig, struct rig_spectrum_line *line, rig_ptr_t arg) {
+    struct shim_spectrum_cb_adapter *adapter = (struct shim_spectrum_cb_adapter*)arg;
+    shim_spectrum_line_t safe_line;
+
+    if (!adapter || !adapter->user_cb || !line) {
+        return 0;
+    }
+
+    memset(&safe_line, 0, sizeof(safe_line));
+    safe_line.id = line->id;
+    safe_line.data_level_min = line->data_level_min;
+    safe_line.data_level_max = line->data_level_max;
+    safe_line.signal_strength_min = line->signal_strength_min;
+    safe_line.signal_strength_max = line->signal_strength_max;
+    safe_line.spectrum_mode = (int)line->spectrum_mode;
+    safe_line.center_freq = (double)line->center_freq;
+    safe_line.span_freq = (double)line->span_freq;
+    safe_line.low_edge_freq = (double)line->low_edge_freq;
+    safe_line.high_edge_freq = (double)line->high_edge_freq;
+    safe_line.data_length = (int)((line->spectrum_data_length > sizeof(safe_line.data)) ? sizeof(safe_line.data) : line->spectrum_data_length);
+    if (safe_line.data_length > 0 && line->spectrum_data) {
+        memcpy(safe_line.data, line->spectrum_data, (size_t)safe_line.data_length);
+    }
+
+    return adapter->user_cb((void*)rig, &safe_line, adapter->user_arg);
+}
+
 SHIM_API int shim_rig_set_freq_callback(hamlib_shim_handle_t h, shim_freq_cb_t cb, void* arg) {
     freq_cb_adapter.user_cb = cb;
     freq_cb_adapter.user_arg = arg;
@@ -869,6 +912,12 @@ SHIM_API int shim_rig_set_ptt_callback(hamlib_shim_handle_t h, shim_ptt_cb_t cb,
     return rig_set_ptt_callback((RIG*)h, shim_ptt_cb_thunk, &ptt_cb_adapter);
 }
 
+SHIM_API int shim_rig_set_spectrum_callback(hamlib_shim_handle_t h, shim_spectrum_cb_t cb, void* arg) {
+    spectrum_cb_adapter.user_cb = cb;
+    spectrum_cb_adapter.user_arg = arg;
+    return rig_set_spectrum_callback((RIG*)h, cb ? shim_spectrum_cb_thunk : NULL, cb ? &spectrum_cb_adapter : NULL);
+}
+
 /* rig_set_trn: deprecated in Hamlib 4.7.0, may be removed in future versions. */
 #ifdef __GNUC__
 #pragma GCC diagnostic push
@@ -908,6 +957,92 @@ SHIM_API uint64_t shim_rig_get_caps_has_set_func(hamlib_shim_handle_t h) {
     return (uint64_t)(rig->caps->has_set_func);
 }
 
+SHIM_API int shim_rig_is_async_data_supported(hamlib_shim_handle_t h) {
+    RIG* rig = (RIG*)h;
+    if (!rig || !rig->caps) return 0;
+    return rig->caps->async_data_supported ? 1 : 0;
+}
+
+SHIM_API int shim_rig_get_caps_spectrum_scope_count(hamlib_shim_handle_t h) {
+    int count = 0;
+    RIG* rig = (RIG*)h;
+    if (!rig || !rig->caps) return 0;
+    while (count < HAMLIB_MAX_SPECTRUM_SCOPES && rig->caps->spectrum_scopes[count].name) {
+        count++;
+    }
+    return count;
+}
+
+SHIM_API int shim_rig_get_caps_spectrum_scope(hamlib_shim_handle_t h, int index, shim_spectrum_scope_t* out) {
+    RIG* rig = (RIG*)h;
+    if (!rig || !rig->caps || !out || index < 0 || index >= HAMLIB_MAX_SPECTRUM_SCOPES) return -RIG_EINVAL;
+    if (!rig->caps->spectrum_scopes[index].name) return -RIG_ENAVAIL;
+    memset(out, 0, sizeof(*out));
+    out->id = rig->caps->spectrum_scopes[index].id;
+    strncpy(out->name, rig->caps->spectrum_scopes[index].name, sizeof(out->name) - 1);
+    return RIG_OK;
+}
+
+SHIM_API int shim_rig_get_caps_spectrum_mode_count(hamlib_shim_handle_t h) {
+    int count = 0;
+    RIG* rig = (RIG*)h;
+    if (!rig || !rig->caps) return 0;
+    while (count < HAMLIB_MAX_SPECTRUM_MODES && rig->caps->spectrum_modes[count] != RIG_SPECTRUM_MODE_NONE) {
+        count++;
+    }
+    return count;
+}
+
+SHIM_API int shim_rig_get_caps_spectrum_mode(hamlib_shim_handle_t h, int index, int* out) {
+    RIG* rig = (RIG*)h;
+    if (!rig || !rig->caps || !out || index < 0 || index >= HAMLIB_MAX_SPECTRUM_MODES) return -RIG_EINVAL;
+    if (rig->caps->spectrum_modes[index] == RIG_SPECTRUM_MODE_NONE) return -RIG_ENAVAIL;
+    *out = (int)rig->caps->spectrum_modes[index];
+    return RIG_OK;
+}
+
+SHIM_API int shim_rig_get_caps_spectrum_span_count(hamlib_shim_handle_t h) {
+    int count = 0;
+    RIG* rig = (RIG*)h;
+    if (!rig || !rig->caps) return 0;
+    while (count < HAMLIB_MAX_SPECTRUM_SPANS && rig->caps->spectrum_spans[count] != 0) {
+        count++;
+    }
+    return count;
+}
+
+SHIM_API int shim_rig_get_caps_spectrum_span(hamlib_shim_handle_t h, int index, double* out) {
+    RIG* rig = (RIG*)h;
+    if (!rig || !rig->caps || !out || index < 0 || index >= HAMLIB_MAX_SPECTRUM_SPANS) return -RIG_EINVAL;
+    if (rig->caps->spectrum_spans[index] == 0) return -RIG_ENAVAIL;
+    *out = (double)rig->caps->spectrum_spans[index];
+    return RIG_OK;
+}
+
+SHIM_API int shim_rig_get_caps_spectrum_avg_mode_count(hamlib_shim_handle_t h) {
+    int count = 0;
+    RIG* rig = (RIG*)h;
+    if (!rig || !rig->caps) return 0;
+    while (count < HAMLIB_MAX_SPECTRUM_AVG_MODES && rig->caps->spectrum_avg_modes[count].name) {
+        count++;
+    }
+    return count;
+}
+
+SHIM_API int shim_rig_get_caps_spectrum_avg_mode(hamlib_shim_handle_t h, int index, shim_spectrum_avg_mode_t* out) {
+    RIG* rig = (RIG*)h;
+    if (!rig || !rig->caps || !out || index < 0 || index >= HAMLIB_MAX_SPECTRUM_AVG_MODES) return -RIG_EINVAL;
+    if (!rig->caps->spectrum_avg_modes[index].name) return -RIG_ENAVAIL;
+    memset(out, 0, sizeof(*out));
+    out->id = rig->caps->spectrum_avg_modes[index].id;
+    strncpy(out->name, rig->caps->spectrum_avg_modes[index].name, sizeof(out->name) - 1);
+    return RIG_OK;
+}
+
+SHIM_API const char* shim_rig_str_spectrum_mode(int mode) {
+    return rig_strspectrummode((enum rig_spectrum_mode_e)mode);
+}
+
 SHIM_API int shim_rig_sprintf_mode(uint64_t modes, char* buf, int buflen) {
     if (!buf || buflen <= 0) return 0;
     buf[0] = '\0';