hamlib 0.4.1 → 0.4.3

package/src/hamlib.cpp

@@ -40,6 +40,23 @@ struct RigListData {
   Napi::Env env;
 };
 
+struct RigConfigFieldDescriptor {
+  int token;
+  std::string name;
+  std::string label;
+  std::string tooltip;
+  std::string defaultValue;
+  int type;
+  double numericMin;
+  double numericMax;
+  double numericStep;
+  std::vector<std::string> options;
+};
+
+struct RigConfigSchemaData {
+  std::vector<RigConfigFieldDescriptor> fields;
+};
+
 using namespace Napi;
 
 Napi::FunctionReference NodeHamLib::constructor;
@@ -55,6 +72,31 @@ static std::string publicVfoToken(int vfo) {
   return rawToken;
 }
 
+static const char* publicConfTypeName(int type) {
+  switch (type) {
+    case 0:
+      return "string";
+    case 1:
+      return "combo";
+    case 2:
+      return "numeric";
+    case 3:
+      return "checkbutton";
+    case 4:
+      return "button";
+    case 5:
+      return "binary";
+    case 6:
+      return "int";
+    default:
+      return "unknown";
+  }
+}
+
+static bool hasPositiveValue(int value) {
+  return value > 0;
+}
+
 static int parseVfoString(Napi::Env env, const std::string& vfoToken) {
   int vfo = shim_rig_parse_vfo(vfoToken.c_str());
   if (vfo == SHIM_RIG_VFO_NONE) {
@@ -64,6 +106,27 @@ static int parseVfoString(Napi::Env env, const std::string& vfoToken) {
   return vfo;
 }
 
+static int antennaOrdinalToMask(Napi::Env env, int antennaOrdinal) {
+  if (antennaOrdinal < 1 || antennaOrdinal > 30) {
+    Napi::RangeError::New(env, "Antenna number must be between 1 and 30").ThrowAsJavaScriptException();
+    return 0;
+  }
+  return static_cast<int>(1u << (antennaOrdinal - 1));
+}
+
+static int antennaMaskToOrdinal(int antennaMask) {
+  const uint32_t mask = static_cast<uint32_t>(antennaMask);
+  if (mask == 0 || (mask & (mask - 1)) != 0) {
+    return 0;
+  }
+  for (int bit = 0; bit < 30; ++bit) {
+    if (mask == (1u << bit)) {
+      return bit + 1;
+    }
+  }
+  return 0;
+}
+
 // Base AsyncWorker implementation with Promise support
 HamLibAsyncWorker::HamLibAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance)
     : AsyncWorker(env), hamlib_instance_(hamlib_instance), result_code_(0), error_message_(""), deferred_(Napi::Promise::Deferred::New(env)) {}
@@ -1188,9 +1251,9 @@ public:
         } else {
             Napi::Object result = Napi::Object::New(env);
 
-            result.Set("currentAntenna", Napi::Number::New(env, antenna_curr_));
-            result.Set("txAntenna", Napi::Number::New(env, antenna_tx_));
-            result.Set("rxAntenna", Napi::Number::New(env, antenna_rx_));
+            result.Set("currentAntenna", Napi::Number::New(env, antennaMaskToOrdinal(antenna_curr_)));
+            result.Set("txAntenna", Napi::Number::New(env, antennaMaskToOrdinal(antenna_tx_)));
+            result.Set("rxAntenna", Napi::Number::New(env, antennaMaskToOrdinal(antenna_rx_)));
             result.Set("option", Napi::Number::New(env, option_));
 
             deferred_.Resolve(result);
@@ -3726,18 +3789,39 @@ Napi::Value NodeHamLib::SetAntenna(const Napi::CallbackInfo & info) {
     return env.Null();
   }
   
-  int antenna = info[0].As<Napi::Number>().Int32Value();
-  
-  // Support optional VFO parameter: setAntenna(antenna) or setAntenna(antenna, vfo)
-  int vfo = SHIM_RIG_VFO_CURR;
-  if (info.Length() >= 2 && info[1].IsString()) {
-    vfo = parseVfoParameter(info, 1, SHIM_RIG_VFO_CURR);
-    RETURN_NULL_IF_INVALID_VFO(vfo);
+  const int antennaOrdinal = info[0].As<Napi::Number>().Int32Value();
+  const int antenna = antennaOrdinalToMask(env, antennaOrdinal);
+  if (antenna == 0) {
+    return env.Null();
   }
-  
-  // Default option value (can be extended later if needed)
+
+  int vfo = SHIM_RIG_VFO_CURR;
   float option = 0.0f;
 
+  if (info.Length() >= 2) {
+    if (info[1].IsNumber()) {
+      option = info[1].As<Napi::Number>().FloatValue();
+      if (info.Length() >= 3 && info[2].IsString()) {
+        vfo = parseVfoParameter(info, 2, SHIM_RIG_VFO_CURR);
+        RETURN_NULL_IF_INVALID_VFO(vfo);
+      } else if (info.Length() >= 3 && !info[2].IsUndefined()) {
+        Napi::TypeError::New(env, "Expected VFO token as third argument").ThrowAsJavaScriptException();
+        return env.Null();
+      }
+    } else if (info[1].IsString()) {
+      vfo = parseVfoParameter(info, 1, SHIM_RIG_VFO_CURR);
+      RETURN_NULL_IF_INVALID_VFO(vfo);
+    } else if (!info[1].IsUndefined()) {
+      Napi::TypeError::New(env, "Expected antenna option as number or VFO token as string").ThrowAsJavaScriptException();
+      return env.Null();
+    }
+  }
+
+  if (info.Length() >= 3 && info[1].IsString()) {
+    Napi::TypeError::New(env, "Antenna option must come before VFO").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
   SetAntennaAsyncWorker* asyncWorker = new SetAntennaAsyncWorker(env, this, antenna, vfo, option);
   asyncWorker->Queue();
   return asyncWorker->GetPromise();
@@ -3832,6 +3916,8 @@ Napi::Function NodeHamLib::GetClass(Napi::Env env) {
       NodeHamLib::InstanceMethod("setDcdType", & NodeHamLib::SetDcdType),
       NodeHamLib::InstanceMethod("getDcdType", & NodeHamLib::GetDcdType),
       NodeHamLib::InstanceMethod("getSupportedSerialConfigs", & NodeHamLib::GetSupportedSerialConfigs),
+      NodeHamLib::InstanceMethod("getConfigSchema", & NodeHamLib::GetConfigSchema),
+      NodeHamLib::InstanceMethod("getPortCaps", & NodeHamLib::GetPortCaps),
       
       // Power Control
       NodeHamLib::InstanceMethod("setPowerstat", & NodeHamLib::SetPowerstat),
@@ -4220,7 +4306,7 @@ Napi::Value NodeHamLib::GetSupportedSerialConfigs(const Napi::CallbackInfo& info
   pttTypeOptions[5u] = Napi::String::New(env, "GPIO");
   pttTypeOptions[6u] = Napi::String::New(env, "GPION");
   pttTypeOptions[7u] = Napi::String::New(env, "NONE");
-  configs.Set("intype", pttTypeOptions);
+  configs.Set("ptt_type", pttTypeOptions);
   
   // DCD type options
   Napi::Array dcdTypeOptions = Napi::Array::New(env, 9);
@@ -4233,11 +4319,124 @@ Napi::Value NodeHamLib::GetSupportedSerialConfigs(const Napi::CallbackInfo& info
   dcdTypeOptions[6u] = Napi::String::New(env, "GPIO");
   dcdTypeOptions[7u] = Napi::String::New(env, "GPION");
   dcdTypeOptions[8u] = Napi::String::New(env, "NONE");
-  configs.Set("intype", dcdTypeOptions);
+  configs.Set("dcd_type", dcdTypeOptions);
   
   return configs;
 }
 
+int NodeHamLib::rig_config_callback(const shim_confparam_info_t* info, void* data) {
+  RigConfigSchemaData* schema_data = static_cast<RigConfigSchemaData*>(data);
+
+  if (!schema_data || !info) {
+    return 0;
+  }
+
+  RigConfigFieldDescriptor field;
+  field.token = info->token;
+  field.name = info->name;
+  field.label = info->label;
+  field.tooltip = info->tooltip;
+  field.defaultValue = info->dflt;
+  field.type = info->type;
+  field.numericMin = info->numeric_min;
+  field.numericMax = info->numeric_max;
+  field.numericStep = info->numeric_step;
+
+  for (int i = 0; i < info->combo_count; ++i) {
+    field.options.emplace_back(info->combo_options[i]);
+  }
+
+  schema_data->fields.push_back(field);
+  return 1;
+}
+
+Napi::Value NodeHamLib::GetConfigSchema(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RETURN_NULL_IF_RIG_HANDLE_INVALID();
+
+  RigConfigSchemaData schemaData{};
+  int result = shim_rig_cfgparams_foreach(my_rig, rig_config_callback, &schemaData);
+
+  if (result != SHIM_RIG_OK) {
+    Napi::Error::New(env, shim_rigerror(result)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Array schemaArray = Napi::Array::New(env, schemaData.fields.size());
+  for (size_t i = 0; i < schemaData.fields.size(); ++i) {
+    const RigConfigFieldDescriptor& descriptor = schemaData.fields[i];
+    Napi::Object field = Napi::Object::New(env);
+    field.Set("token", Napi::Number::New(env, descriptor.token));
+    field.Set("name", Napi::String::New(env, descriptor.name));
+    field.Set("label", Napi::String::New(env, descriptor.label));
+    field.Set("tooltip", Napi::String::New(env, descriptor.tooltip));
+    field.Set("defaultValue", Napi::String::New(env, descriptor.defaultValue));
+    field.Set("type", Napi::String::New(env, publicConfTypeName(descriptor.type)));
+
+    if (descriptor.type == 2 || descriptor.type == 6) {
+      Napi::Object numeric = Napi::Object::New(env);
+      numeric.Set("min", Napi::Number::New(env, descriptor.numericMin));
+      numeric.Set("max", Napi::Number::New(env, descriptor.numericMax));
+      numeric.Set("step", Napi::Number::New(env, descriptor.numericStep));
+      field.Set("numeric", numeric);
+    }
+
+    if (!descriptor.options.empty()) {
+      Napi::Array options = Napi::Array::New(env, descriptor.options.size());
+      for (size_t optionIndex = 0; optionIndex < descriptor.options.size(); ++optionIndex) {
+        options[static_cast<uint32_t>(optionIndex)] =
+            Napi::String::New(env, descriptor.options[optionIndex]);
+      }
+      field.Set("options", options);
+    }
+
+    schemaArray[static_cast<uint32_t>(i)] = field;
+  }
+
+  return schemaArray;
+}
+
+Napi::Value NodeHamLib::GetPortCaps(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RETURN_NULL_IF_RIG_HANDLE_INVALID();
+
+  shim_rig_port_caps_t caps{};
+  int result = shim_rig_get_port_caps(my_rig, &caps);
+
+  if (result != SHIM_RIG_OK) {
+    Napi::Error::New(env, shim_rigerror(result)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  Napi::Object portCaps = Napi::Object::New(env);
+  portCaps.Set("portType", Napi::String::New(env, caps.port_type));
+  portCaps.Set("writeDelay", Napi::Number::New(env, caps.write_delay));
+  portCaps.Set("postWriteDelay", Napi::Number::New(env, caps.post_write_delay));
+  portCaps.Set("timeout", Napi::Number::New(env, caps.timeout));
+  portCaps.Set("retry", Napi::Number::New(env, caps.retry));
+
+  if (hasPositiveValue(caps.serial_rate_min)) {
+    portCaps.Set("serialRateMin", Napi::Number::New(env, caps.serial_rate_min));
+  }
+  if (hasPositiveValue(caps.serial_rate_max)) {
+    portCaps.Set("serialRateMax", Napi::Number::New(env, caps.serial_rate_max));
+  }
+  if (hasPositiveValue(caps.serial_data_bits)) {
+    portCaps.Set("serialDataBits", Napi::Number::New(env, caps.serial_data_bits));
+  }
+  if (hasPositiveValue(caps.serial_stop_bits)) {
+    portCaps.Set("serialStopBits", Napi::Number::New(env, caps.serial_stop_bits));
+  }
+  if (caps.serial_parity[0] != '\0' && std::string(caps.serial_parity) != "Unknown") {
+    portCaps.Set("serialParity", Napi::String::New(env, caps.serial_parity));
+  }
+  if (caps.serial_handshake[0] != '\0' && std::string(caps.serial_handshake) != "Unknown") {
+    portCaps.Set("serialHandshake", Napi::String::New(env, caps.serial_handshake));
+  }
+
+  return portCaps;
+}
+
 // Power Control Methods
 Napi::Value NodeHamLib::SetPowerstat(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
@@ -6156,11 +6355,7 @@ private:
 
 Napi::Value NodeHamLib::SetConf(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();
-  }
+  RETURN_NULL_IF_RIG_HANDLE_INVALID();
 
   if (info.Length() < 2 || !info[0].IsString() || !info[1].IsString()) {
     Napi::TypeError::New(env, "Expected (name: string, value: string)").ThrowAsJavaScriptException();
@@ -6212,11 +6407,7 @@ private:
 
 Napi::Value NodeHamLib::GetConf(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();
-  }
+  RETURN_NULL_IF_RIG_HANDLE_INVALID();
 
   if (info.Length() < 1 || !info[0].IsString()) {
     Napi::TypeError::New(env, "Expected (name: string)").ThrowAsJavaScriptException();

package/src/hamlib.h

@@ -99,6 +99,8 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
   Napi::Value SetDcdType(const Napi::CallbackInfo&);
   Napi::Value GetDcdType(const Napi::CallbackInfo&);
   Napi::Value GetSupportedSerialConfigs(const Napi::CallbackInfo&);
+  Napi::Value GetConfigSchema(const Napi::CallbackInfo&);
+  Napi::Value GetPortCaps(const Napi::CallbackInfo&);
 
   // Power Control
   Napi::Value SetPowerstat(const Napi::CallbackInfo&);
@@ -242,6 +244,7 @@ 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);
+  static int rig_config_callback(const shim_confparam_info_t* info, void* data);
 
   void EmitSpectrumLine(const shim_spectrum_line_t& line);
   void StopSpectrumStreamInternal();