hamlib 0.1.4 → 0.1.5

package/Readme.md

@@ -284,6 +284,109 @@ rig.setAntenna(2);            // Select antenna 2
 const antenna = rig.getAntenna();
 ```
 
+### ⚙️ Serial Port Configuration
+
+#### `getSupportedSerialConfigs()`
+Get available serial configuration options
+```javascript
+const configs = rig.getSupportedSerialConfigs();
+console.log('Data bits:', configs.serial.data_bits);     // ['5', '6', '7', '8']
+console.log('Stop bits:', configs.serial.stop_bits);     // ['1', '2']
+console.log('Parity:', configs.serial.serial_parity);    // ['None', 'Even', 'Odd']
+console.log('Handshake:', configs.serial.serial_handshake); // ['None', 'Hardware', 'Software']
+console.log('PTT types:', configs.ptt_type);             // ['RIG', 'DTR', 'RTS', 'PARALLEL', ...]
+console.log('DCD types:', configs.dcd_type);             // ['RIG', 'DSR', 'CTS', 'CD', ...]
+```
+
+#### `setSerialConfig(param, value)` / `getSerialConfig(param)`
+Configure serial port parameters
+```javascript
+// Basic serial configuration (most common)
+rig.setSerialConfig('data_bits', '8');        // 8 data bits
+rig.setSerialConfig('stop_bits', '1');        // 1 stop bit
+rig.setSerialConfig('serial_parity', 'None'); // No parity
+rig.setSerialConfig('serial_handshake', 'None'); // No flow control
+
+// Hardware flow control (if supported)
+rig.setSerialConfig('serial_handshake', 'Hardware');
+
+// Control line states
+rig.setSerialConfig('rts_state', 'ON');       // Set RTS high
+rig.setSerialConfig('dtr_state', 'OFF');      // Set DTR low
+
+// Get current configuration
+const dataBits = rig.getSerialConfig('data_bits');
+const parity = rig.getSerialConfig('serial_parity');
+```
+
+#### `setPttType(type)` / `getPttType()`
+Configure PTT (Push-to-Talk) method
+```javascript
+// Use CAT command for PTT (recommended)
+rig.setPttType('RIG');
+
+// Use DTR line for PTT (legacy interfaces)
+rig.setPttType('DTR');
+
+// Use RTS line for PTT (alternative)
+rig.setPttType('RTS');
+
+// Disable PTT control
+rig.setPttType('NONE');
+
+// Get current PTT type
+const pttType = rig.getPttType();
+console.log('PTT method:', pttType);
+```
+
+#### `setDcdType(type)` / `getDcdType()`
+Configure DCD (Data Carrier Detect) method
+```javascript
+// Use CAT command for DCD (software squelch)
+rig.setDcdType('RIG');
+
+// Use DSR line for DCD (hardware squelch)
+rig.setDcdType('DSR');
+
+// Use CTS line for DCD (alternative)
+rig.setDcdType('CTS');
+
+// Get current DCD type
+const dcdType = rig.getDcdType();
+console.log('DCD method:', dcdType);
+```
+
+#### Common Serial Configurations
+
+**Yaesu Radios:**
+```javascript
+rig.setSerialConfig('data_bits', '8');
+rig.setSerialConfig('stop_bits', '1');
+rig.setSerialConfig('serial_parity', 'None');
+rig.setSerialConfig('serial_handshake', 'None');
+rig.setPttType('RIG');  // Use CAT command
+// Baud rate: 4800/9600 (set in constructor)
+```
+
+**Kenwood Radios:**
+```javascript
+rig.setSerialConfig('data_bits', '8');
+rig.setSerialConfig('stop_bits', '2');        // Note: 2 stop bits
+rig.setSerialConfig('serial_parity', 'None');
+rig.setSerialConfig('serial_handshake', 'None');
+rig.setPttType('RIG');
+// Baud rate: 9600
+```
+
+**Legacy Interface (DTR/RTS PTT):**
+```javascript
+rig.setSerialConfig('data_bits', '8');
+rig.setSerialConfig('stop_bits', '1');
+rig.setSerialConfig('serial_parity', 'None');
+rig.setPttType('DTR');                        // Use DTR for PTT
+rig.setDcdType('DSR');                        // Use DSR for squelch
+```
+
 ## 🎯 Complete Example
 
 ```javascript

package/index.d.ts

@@ -142,6 +142,47 @@ type VfoOperationType = 'CPY' | 'XCHG' | 'FROM_VFO' | 'TO_VFO' | 'MCL' | 'UP' |
                         'DOWN' | 'BAND_UP' | 'BAND_DOWN' | 'LEFT' | 'RIGHT' | 
                         'TUNE' | 'TOGGLE';
 
+/**
+ * Serial configuration parameter names
+ */
+type SerialConfigParam = 'data_bits' | 'stop_bits' | 'serial_parity' | 'serial_handshake' | 
+                        'rts_state' | 'dtr_state';
+
+/**
+ * PTT (Push-to-Talk) types
+ */
+type PttType = 'RIG' | 'DTR' | 'RTS' | 'PARALLEL' | 'CM108' | 'GPIO' | 'GPION' | 'NONE';
+
+/**
+ * DCD (Data Carrier Detect) types
+ */
+type DcdType = 'RIG' | 'DSR' | 'CTS' | 'CD' | 'PARALLEL' | 'CM108' | 'GPIO' | 'GPION' | 'NONE';
+
+/**
+ * Serial configuration options interface
+ */
+interface SerialConfigOptions {
+  /** Serial port basic parameters */
+  serial: {
+    /** Data bits options */
+    data_bits: string[];
+    /** Stop bits options */
+    stop_bits: string[];
+    /** Parity options */
+    serial_parity: string[];
+    /** Handshake options */
+    serial_handshake: string[];
+    /** RTS state options */
+    rts_state: string[];
+    /** DTR state options */
+    dtr_state: string[];
+  };
+  /** PTT type options */
+  ptt_type: string[];
+  /** DCD type options */
+  dcd_type: string[];
+}
+
 /**
  * HamLib class - for controlling amateur radio devices
  */
@@ -444,6 +485,89 @@ declare class HamLib {
    * @returns Current antenna number
    */
   getAntenna(): number;
+
+  // Serial Port Configuration
+
+  /**
+   * Set serial port configuration parameter
+   * @param paramName Parameter name ('data_bits', 'stop_bits', 'serial_parity', 'serial_handshake', 'rts_state', 'dtr_state')
+   * @param paramValue Parameter value
+   * @example
+   * // Set data bits to 8
+   * hamlib.setSerialConfig('data_bits', '8');
+   * 
+   * // Set parity to even
+   * hamlib.setSerialConfig('serial_parity', 'Even');
+   * 
+   * // Set handshake to hardware
+   * hamlib.setSerialConfig('serial_handshake', 'Hardware');
+   */
+  setSerialConfig(paramName: SerialConfigParam, paramValue: string): void;
+
+  /**
+   * Get serial port configuration parameter
+   * @param paramName Parameter name to retrieve
+   * @returns Parameter value
+   * @example
+   * // Get current data bits setting
+   * const dataBits = hamlib.getSerialConfig('data_bits');
+   * 
+   * // Get current parity setting
+   * const parity = hamlib.getSerialConfig('serial_parity');
+   */
+  getSerialConfig(paramName: SerialConfigParam): string;
+
+  /**
+   * Set PTT (Push-to-Talk) type
+   * @param pttType PTT type ('RIG', 'DTR', 'RTS', 'PARALLEL', 'CM108', 'GPIO', 'GPION', 'NONE')
+   * @example
+   * // Use DTR line for PTT
+   * hamlib.setPttType('DTR');
+   * 
+   * // Use RTS line for PTT
+   * hamlib.setPttType('RTS');
+   * 
+   * // Use CAT command for PTT
+   * hamlib.setPttType('RIG');
+   */
+  setPttType(pttType: PttType): void;
+
+  /**
+   * Get current PTT type
+   * @returns Current PTT type
+   */
+  getPttType(): string;
+
+  /**
+   * Set DCD (Data Carrier Detect) type
+   * @param dcdType DCD type ('RIG', 'DSR', 'CTS', 'CD', 'PARALLEL', 'CM108', 'GPIO', 'GPION', 'NONE')
+   * @example
+   * // Use DSR line for DCD
+   * hamlib.setDcdType('DSR');
+   * 
+   * // Use CTS line for DCD
+   * hamlib.setDcdType('CTS');
+   * 
+   * // Use CAT command for DCD
+   * hamlib.setDcdType('RIG');
+   */
+  setDcdType(dcdType: DcdType): void;
+
+  /**
+   * Get current DCD type
+   * @returns Current DCD type
+   */
+  getDcdType(): string;
+
+  /**
+   * Get supported serial configuration options
+   * @returns Object containing all supported configuration parameters and their possible values
+   * @example
+   * const configs = hamlib.getSupportedSerialConfigs();
+   * console.log('Supported data bits:', configs.serial.data_bits);
+   * console.log('Supported PTT types:', configs.ptt_type);
+   */
+  getSupportedSerialConfigs(): SerialConfigOptions;
 }
 
 /**
@@ -456,7 +580,7 @@ declare const nodeHamlib: {
 // Export types for use elsewhere
 export { ConnectionInfo, ModeInfo, SupportedRigInfo, VFO, RadioMode, MemoryChannelData, 
          MemoryChannelInfo, SplitModeInfo, SplitStatusInfo, LevelType, FunctionType, 
-         ScanType, VfoOperationType, HamLib };
+         ScanType, VfoOperationType, SerialConfigParam, PttType, DcdType, SerialConfigOptions, HamLib };
 
 // Support both CommonJS and ES module exports
 export = nodeHamlib;

package/lib/index.js

@@ -367,6 +367,103 @@ class HamLib {
   getAntenna() {
     return this._nativeInstance.getAntenna();
   }
+
+  // Serial Port Configuration
+
+  /**
+   * Set serial port configuration parameter
+   * @param {string} paramName - Parameter name ('data_bits', 'stop_bits', 'serial_parity', 'serial_handshake', 'rts_state', 'dtr_state')
+   * @param {string} paramValue - Parameter value
+   * @example
+   * // Set data bits to 8
+   * hamlib.setSerialConfig('data_bits', '8');
+   * 
+   * // Set parity to even
+   * hamlib.setSerialConfig('serial_parity', 'Even');
+   * 
+   * // Set handshake to hardware
+   * hamlib.setSerialConfig('serial_handshake', 'Hardware');
+   */
+  setSerialConfig(paramName, paramValue) {
+    return this._nativeInstance.setSerialConfig(paramName, paramValue);
+  }
+
+  /**
+   * Get serial port configuration parameter
+   * @param {string} paramName - Parameter name to retrieve
+   * @returns {string} Parameter value
+   * @example
+   * // Get current data bits setting
+   * const dataBits = hamlib.getSerialConfig('data_bits');
+   * 
+   * // Get current parity setting
+   * const parity = hamlib.getSerialConfig('serial_parity');
+   */
+  getSerialConfig(paramName) {
+    return this._nativeInstance.getSerialConfig(paramName);
+  }
+
+  /**
+   * Set PTT (Push-to-Talk) type
+   * @param {string} pttType - PTT type ('RIG', 'DTR', 'RTS', 'PARALLEL', 'CM108', 'GPIO', 'GPION', 'NONE')
+   * @example
+   * // Use DTR line for PTT
+   * hamlib.setPttType('DTR');
+   * 
+   * // Use RTS line for PTT
+   * hamlib.setPttType('RTS');
+   * 
+   * // Use CAT command for PTT
+   * hamlib.setPttType('RIG');
+   */
+  setPttType(pttType) {
+    return this._nativeInstance.setPttType(pttType);
+  }
+
+  /**
+   * Get current PTT type
+   * @returns {string} Current PTT type
+   */
+  getPttType() {
+    return this._nativeInstance.getPttType();
+  }
+
+  /**
+   * Set DCD (Data Carrier Detect) type
+   * @param {string} dcdType - DCD type ('RIG', 'DSR', 'CTS', 'CD', 'PARALLEL', 'CM108', 'GPIO', 'GPION', 'NONE')
+   * @example
+   * // Use DSR line for DCD
+   * hamlib.setDcdType('DSR');
+   * 
+   * // Use CTS line for DCD
+   * hamlib.setDcdType('CTS');
+   * 
+   * // Use CAT command for DCD
+   * hamlib.setDcdType('RIG');
+   */
+  setDcdType(dcdType) {
+    return this._nativeInstance.setDcdType(dcdType);
+  }
+
+  /**
+   * Get current DCD type
+   * @returns {string} Current DCD type
+   */
+  getDcdType() {
+    return this._nativeInstance.getDcdType();
+  }
+
+  /**
+   * Get supported serial configuration options
+   * @returns {Object} Object containing all supported configuration parameters and their possible values
+   * @example
+   * const configs = hamlib.getSupportedSerialConfigs();
+   * console.log('Supported data bits:', configs.serial.data_bits);
+   * console.log('Supported PTT types:', configs.ptt_type);
+   */
+  getSupportedSerialConfigs() {
+    return this._nativeInstance.getSupportedSerialConfigs();
+  }
 }
 
 // Export for CommonJS

package/package.json

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

package/src/hamlib.cpp

@@ -2,6 +2,16 @@
 #include <string>
 #include <vector>
 
+// Cross-platform compatibility for hamlib token types
+// Linux versions use token_t, some others use hamlib_token_t
+#ifndef HAMLIB_TOKEN_T
+#ifdef __linux__
+#define HAMLIB_TOKEN_T token_t
+#else
+#define HAMLIB_TOKEN_T hamlib_token_t
+#endif
+#endif
+
 // Structure to hold rig information for the callback
 struct RigListData {
   std::vector<Napi::Object> rigList;
@@ -1485,6 +1495,15 @@ Napi::Function NodeHamLib::GetClass(Napi::Env env) {
       // Antenna Selection
       NodeHamLib::InstanceMethod("setAntenna", & NodeHamLib::SetAntenna),
       NodeHamLib::InstanceMethod("getAntenna", & NodeHamLib::GetAntenna),
+      
+      // Serial Port Configuration
+      NodeHamLib::InstanceMethod("setSerialConfig", & NodeHamLib::SetSerialConfig),
+      NodeHamLib::InstanceMethod("getSerialConfig", & NodeHamLib::GetSerialConfig),
+      NodeHamLib::InstanceMethod("setPttType", & NodeHamLib::SetPttType),
+      NodeHamLib::InstanceMethod("getPttType", & NodeHamLib::GetPttType),
+      NodeHamLib::InstanceMethod("setDcdType", & NodeHamLib::SetDcdType),
+      NodeHamLib::InstanceMethod("getDcdType", & NodeHamLib::GetDcdType),
+      NodeHamLib::InstanceMethod("getSupportedSerialConfigs", & NodeHamLib::GetSupportedSerialConfigs),
 
       NodeHamLib::InstanceMethod("close", & NodeHamLib::Close),
       NodeHamLib::InstanceMethod("destroy", & NodeHamLib::Destroy),
@@ -1601,3 +1620,250 @@ Napi::Value NodeHamLib::GetSupportedRigs(const Napi::CallbackInfo& info) {
   return rigArray;
 }
 
+// Serial Port Configuration Methods
+
+// Set serial configuration parameter (data_bits, stop_bits, parity, handshake, etc.)
+Napi::Value NodeHamLib::SetSerialConfig(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() < 2 || !info[0].IsString() || !info[1].IsString()) {
+    Napi::TypeError::New(env, "Expected parameter name and value as strings").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  std::string paramName = info[0].As<Napi::String>().Utf8Value();
+  std::string paramValue = info[1].As<Napi::String>().Utf8Value();
+  
+  // Get configuration token from parameter name
+  HAMLIB_TOKEN_T token = rig_token_lookup(my_rig, paramName.c_str());
+  if (token == RIG_CONF_END) {
+    Napi::Error::New(env, "Unknown configuration parameter").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  // Use rig_set_conf to set configuration parameter
+  int retcode = rig_set_conf(my_rig, token, paramValue.c_str());
+  if (retcode != RIG_OK) {
+    Napi::Error::New(env, rigerror(retcode)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  return Napi::Number::New(env, retcode);
+}
+
+// Get serial configuration parameter
+Napi::Value NodeHamLib::GetSerialConfig(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].IsString()) {
+    Napi::TypeError::New(env, "Expected parameter name as string").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  std::string paramName = info[0].As<Napi::String>().Utf8Value();
+  char value[256];
+  
+  // Get configuration token from parameter name
+  HAMLIB_TOKEN_T token = rig_token_lookup(my_rig, paramName.c_str());
+  if (token == RIG_CONF_END) {
+    Napi::Error::New(env, "Unknown configuration parameter").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  // Use rig_get_conf to get configuration parameter
+  int retcode = rig_get_conf(my_rig, token, value);
+  if (retcode != RIG_OK) {
+    Napi::Error::New(env, rigerror(retcode)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  return Napi::String::New(env, value);
+}
+
+// Set PTT type
+Napi::Value NodeHamLib::SetPttType(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Expected PTT type as string").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  std::string pttTypeStr = info[0].As<Napi::String>().Utf8Value();
+  
+  // Get configuration token for ptt_type
+  HAMLIB_TOKEN_T token = rig_token_lookup(my_rig, "ptt_type");
+  if (token == RIG_CONF_END) {
+    Napi::Error::New(env, "PTT type configuration not supported").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  // Set PTT type through configuration
+  int retcode = rig_set_conf(my_rig, token, pttTypeStr.c_str());
+  if (retcode != RIG_OK) {
+    Napi::Error::New(env, rigerror(retcode)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  return Napi::Number::New(env, retcode);
+}
+
+// Get PTT type
+Napi::Value NodeHamLib::GetPttType(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  char value[256];
+  
+  // Get configuration token for ptt_type
+  HAMLIB_TOKEN_T token = rig_token_lookup(my_rig, "ptt_type");
+  if (token == RIG_CONF_END) {
+    Napi::Error::New(env, "PTT type configuration not supported").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  // Get PTT type through configuration
+  int retcode = rig_get_conf(my_rig, token, value);
+  if (retcode != RIG_OK) {
+    Napi::Error::New(env, rigerror(retcode)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  return Napi::String::New(env, value);
+}
+
+// Set DCD type
+Napi::Value NodeHamLib::SetDcdType(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  if (info.Length() < 1 || !info[0].IsString()) {
+    Napi::TypeError::New(env, "Expected DCD type as string").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  std::string dcdTypeStr = info[0].As<Napi::String>().Utf8Value();
+  
+  // Get configuration token for dcd_type
+  HAMLIB_TOKEN_T token = rig_token_lookup(my_rig, "dcd_type");
+  if (token == RIG_CONF_END) {
+    Napi::Error::New(env, "DCD type configuration not supported").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  // Set DCD type through configuration
+  int retcode = rig_set_conf(my_rig, token, dcdTypeStr.c_str());
+  if (retcode != RIG_OK) {
+    Napi::Error::New(env, rigerror(retcode)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  return Napi::Number::New(env, retcode);
+}
+
+// Get DCD type
+Napi::Value NodeHamLib::GetDcdType(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  char value[256];
+  
+  // Get configuration token for dcd_type
+  HAMLIB_TOKEN_T token = rig_token_lookup(my_rig, "dcd_type");
+  if (token == RIG_CONF_END) {
+    Napi::Error::New(env, "DCD type configuration not supported").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  // Get DCD type through configuration
+  int retcode = rig_get_conf(my_rig, token, value);
+  if (retcode != RIG_OK) {
+    Napi::Error::New(env, rigerror(retcode)).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  
+  return Napi::String::New(env, value);
+}
+
+// Get supported serial configuration options
+Napi::Value NodeHamLib::GetSupportedSerialConfigs(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  
+  // Return object with supported configuration parameters and their possible values
+  Napi::Object configs = Napi::Object::New(env);
+  
+  // Serial basic parameters
+  Napi::Object serialParams = Napi::Object::New(env);
+  
+  // Data bits options
+  Napi::Array dataBitsOptions = Napi::Array::New(env, 4);
+  dataBitsOptions[0u] = Napi::String::New(env, "5");
+  dataBitsOptions[1u] = Napi::String::New(env, "6");
+  dataBitsOptions[2u] = Napi::String::New(env, "7");
+  dataBitsOptions[3u] = Napi::String::New(env, "8");
+  serialParams.Set("data_bits", dataBitsOptions);
+  
+  // Stop bits options
+  Napi::Array stopBitsOptions = Napi::Array::New(env, 2);
+  stopBitsOptions[0u] = Napi::String::New(env, "1");
+  stopBitsOptions[1u] = Napi::String::New(env, "2");
+  serialParams.Set("stop_bits", stopBitsOptions);
+  
+  // Parity options
+  Napi::Array parityOptions = Napi::Array::New(env, 3);
+  parityOptions[0u] = Napi::String::New(env, "None");
+  parityOptions[1u] = Napi::String::New(env, "Even");
+  parityOptions[2u] = Napi::String::New(env, "Odd");
+  serialParams.Set("serial_parity", parityOptions);
+  
+  // Handshake options
+  Napi::Array handshakeOptions = Napi::Array::New(env, 3);
+  handshakeOptions[0u] = Napi::String::New(env, "None");
+  handshakeOptions[1u] = Napi::String::New(env, "Hardware");
+  handshakeOptions[2u] = Napi::String::New(env, "Software");
+  serialParams.Set("serial_handshake", handshakeOptions);
+  
+  // Control line state options
+  Napi::Array stateOptions = Napi::Array::New(env, 2);
+  stateOptions[0u] = Napi::String::New(env, "ON");
+  stateOptions[1u] = Napi::String::New(env, "OFF");
+  serialParams.Set("rts_state", stateOptions);
+  serialParams.Set("dtr_state", stateOptions);
+  
+  configs.Set("serial", serialParams);
+  
+  // PTT type options
+  Napi::Array pttTypeOptions = Napi::Array::New(env, 8);
+  pttTypeOptions[0u] = Napi::String::New(env, "RIG");
+  pttTypeOptions[1u] = Napi::String::New(env, "DTR");
+  pttTypeOptions[2u] = Napi::String::New(env, "RTS");
+  pttTypeOptions[3u] = Napi::String::New(env, "PARALLEL");
+  pttTypeOptions[4u] = Napi::String::New(env, "CM108");
+  pttTypeOptions[5u] = Napi::String::New(env, "GPIO");
+  pttTypeOptions[6u] = Napi::String::New(env, "GPION");
+  pttTypeOptions[7u] = Napi::String::New(env, "NONE");
+  configs.Set("ptt_type", pttTypeOptions);
+  
+  // DCD type options
+  Napi::Array dcdTypeOptions = Napi::Array::New(env, 9);
+  dcdTypeOptions[0u] = Napi::String::New(env, "RIG");
+  dcdTypeOptions[1u] = Napi::String::New(env, "DSR");
+  dcdTypeOptions[2u] = Napi::String::New(env, "CTS");
+  dcdTypeOptions[3u] = Napi::String::New(env, "CD");
+  dcdTypeOptions[4u] = Napi::String::New(env, "PARALLEL");
+  dcdTypeOptions[5u] = Napi::String::New(env, "CM108");
+  dcdTypeOptions[6u] = Napi::String::New(env, "GPIO");
+  dcdTypeOptions[7u] = Napi::String::New(env, "GPION");
+  dcdTypeOptions[8u] = Napi::String::New(env, "NONE");
+  configs.Set("dcd_type", dcdTypeOptions);
+  
+  return configs;
+}
+

package/src/hamlib.h

@@ -66,6 +66,15 @@ class NodeHamLib : public Napi::ObjectWrap<NodeHamLib> {
   Napi::Value SetAntenna(const Napi::CallbackInfo&);
   Napi::Value GetAntenna(const Napi::CallbackInfo&);
   
+  // Serial Port Configuration
+  Napi::Value SetSerialConfig(const Napi::CallbackInfo&);
+  Napi::Value GetSerialConfig(const Napi::CallbackInfo&);
+  Napi::Value SetPttType(const Napi::CallbackInfo&);
+  Napi::Value GetPttType(const Napi::CallbackInfo&);
+  Napi::Value SetDcdType(const Napi::CallbackInfo&);
+  Napi::Value GetDcdType(const Napi::CallbackInfo&);
+  Napi::Value GetSupportedSerialConfigs(const Napi::CallbackInfo&);
+  
   // Static method to get supported rig models
   static Napi::Value GetSupportedRigs(const Napi::CallbackInfo&);