hamlib 0.1.3 → 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.3",
+  "version": "0.1.5",
   "description": "Node.js wrapper for hamlib radio control library",
   "main": "index.js",
   "module": "lib/index.mjs",
@@ -30,6 +30,7 @@
     "lib/",
     "prebuilds/",
     "src/",
+    "scripts/",
     "index.js",
     "index.d.ts",
     "binding.gyp",

package/scripts/install.js

@@ -0,0 +1,262 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { getPlatformBinaryPath } = require('../lib/binary-loader');
+
+/**
+ * Check if a prebuilt binary exists for the current platform
+ */
+function checkPrebuiltBinary() {
+  try {
+    const binaryPath = getPlatformBinaryPath();
+    return fs.existsSync(binaryPath);
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Check if we can build from source
+ */
+function canBuildFromSource() {
+  try {
+    // Check if binding.gyp exists
+    const bindingGypPath = path.join(__dirname, '..', 'binding.gyp');
+    if (!fs.existsSync(bindingGypPath)) {
+      return false;
+    }
+
+    // Check if source files exist
+    const srcPath = path.join(__dirname, '..', 'src');
+    if (!fs.existsSync(srcPath)) {
+      return false;
+    }
+
+    // Check if node-gyp is available
+    try {
+      execSync('node-gyp --version', { stdio: 'ignore' });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Check if we're in a MinGW environment
+ */
+function isMinGWEnvironment() {
+  return process.env.HAMLIB_ROOT === '/mingw64' ||
+         process.env.HAMLIB_ROOT === 'C:\\msys64\\mingw64' || 
+         process.env.MSYSTEM === 'MINGW64' ||
+         process.env.MINGW_PREFIX === '/mingw64' ||
+         process.env.MINGW_PREFIX === 'C:\\msys64\\mingw64';
+}
+
+/**
+ * Check if hamlib is available in the system
+ */
+function checkHamlibAvailable() {
+  try {
+    if (isMinGWEnvironment()) {
+      // In MinGW environment, try to use pkg-config to check hamlib
+      try {
+        execSync('pkg-config --exists hamlib', { stdio: 'ignore' });
+        console.log('✓ Hamlib found via pkg-config');
+        return true;
+      } catch (pkgConfigError) {
+        // If pkg-config fails, try to check for specific files
+        // Note: In MSYS2, /mingw64 might be mapped differently for Node.js
+        console.log('pkg-config check failed, trying direct file checks...');
+        
+        // Try common MSYS2 paths
+        const possiblePaths = [
+          '/mingw64/include/hamlib',
+          'C:/msys64/mingw64/include/hamlib',
+          'C:\\msys64\\mingw64\\include\\hamlib',
+          process.env.MINGW_PREFIX + '/include/hamlib',
+          process.env.HAMLIB_ROOT + '/include/hamlib'
+        ].filter(Boolean);
+        
+        for (const includePath of possiblePaths) {
+          try {
+            if (fs.existsSync(includePath)) {
+              console.log(`✓ Hamlib headers found at: ${includePath}`);
+              return true;
+            }
+          } catch (e) {
+            // Continue to next path
+          }
+        }
+        
+        // If all file checks fail, assume hamlib is available since we're in MinGW
+        // and the build process showed it was installed
+        console.log('Direct file checks failed, but assuming hamlib is available in MinGW environment');
+        return true;
+      }
+    } else {
+      // Check if hamlib is available in standard locations
+      const locations = [
+        '/usr/include/hamlib',
+        '/usr/local/include/hamlib',
+        '/opt/homebrew/include/hamlib'
+      ];
+      return locations.some(location => fs.existsSync(location));
+    }
+  } catch (error) {
+    console.log('Error checking hamlib availability:', error.message);
+    // In MinGW environment, be more lenient since paths might be mapped differently
+    return isMinGWEnvironment();
+  }
+}
+
+/**
+ * Setup Windows dependencies if needed
+ */
+async function setupWindowsDependencies() {
+  // Skip if we're in MinGW environment - dependencies should already be set up
+  if (isMinGWEnvironment()) {
+    console.log('✓ MinGW environment detected, skipping Windows dependency setup...');
+    return checkHamlibAvailable();
+  }
+  
+  // Check if dependencies are already set up
+  if (process.env.HAMLIB_ROOT && fs.existsSync(process.env.HAMLIB_ROOT)) {
+    console.log('✓ Windows dependencies already set up, skipping...');
+    return true;
+  }
+  
+  console.log('Setting up Windows dependencies...');
+  
+  try {
+    // Call PowerShell script instead of Node.js script
+    const scriptPath = path.join(__dirname, 'setup-windows-deps.ps1');
+    const command = `powershell -ExecutionPolicy Bypass -File "${scriptPath}"`;
+    
+    console.log(`Running: ${command}`);
+    execSync(command, { stdio: 'inherit' });
+    
+    console.log('✓ Windows dependencies setup completed');
+    return true;
+  } catch (error) {
+    console.error('✗ Failed to setup Windows dependencies:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Try to build from source
+ */
+async function buildFromSource() {
+  console.log('Building hamlib from source...');
+  
+  try {
+    // Setup Windows dependencies first if on Windows and not in MinGW environment
+    if (process.platform === 'win32' && !isMinGWEnvironment()) {
+      const success = await setupWindowsDependencies();
+      if (!success) {
+        throw new Error('Windows dependencies setup failed');
+      }
+    }
+    
+    // For MinGW environment, verify hamlib is available
+    if (isMinGWEnvironment()) {
+      if (!checkHamlibAvailable()) {
+        throw new Error('Hamlib not found in MinGW environment. Please install hamlib first.');
+      }
+      console.log('✓ Hamlib found in MinGW environment');
+    }
+    
+    // Build with node-gyp
+    execSync('node-gyp configure', { stdio: 'inherit' });
+    execSync('node-gyp build', { stdio: 'inherit' });
+    
+    console.log('✓ Built hamlib successfully');
+    return true;
+  } catch (error) {
+    console.error('✗ Failed to build hamlib from source:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Main installation logic
+ */
+async function main() {
+  console.log('Installing node-hamlib...');
+  
+  try {
+    // Try to find prebuilt binary first
+    const prebuiltPath = path.join(__dirname, '..', 'prebuilds');
+    const platform = process.platform;
+    const arch = process.arch;
+    
+    let targetDir = '';
+    if (platform === 'win32' && arch === 'x64') {
+      targetDir = 'win32-x64';
+    } else if (platform === 'linux' && arch === 'x64') {
+      targetDir = 'linux-x64';
+    } else if (platform === 'linux' && arch === 'arm64') {
+      targetDir = 'linux-arm64';
+    } else if (platform === 'darwin' && arch === 'arm64') {
+      targetDir = 'darwin-arm64';
+    }
+    
+    const prebuiltBinary = path.join(prebuiltPath, targetDir, 'hamlib.node');
+    
+    if (fs.existsSync(prebuiltBinary)) {
+      console.log('✓ Found prebuilt binary');
+      
+      // Copy to build directory
+      const buildDir = path.join(__dirname, '..', 'build', 'Release');
+      if (!fs.existsSync(buildDir)) {
+        fs.mkdirSync(buildDir, { recursive: true });
+      }
+      
+      const targetPath = path.join(buildDir, 'hamlib.node');
+      fs.copyFileSync(prebuiltBinary, targetPath);
+      
+      console.log('✓ Installation completed successfully');
+      return;
+    }
+    
+    console.log('⚠ No prebuilt binary found for your platform');
+    
+    // Build from source
+    const success = await buildFromSource();
+    if (!success) {
+      throw new Error('Failed to build from source');
+    }
+    
+    console.log('✓ Installation completed successfully');
+    
+  } catch (error) {
+    console.error('❌ Installation failed!');
+    console.error('This could be due to:');
+    console.error('1. No prebuilt binary available for your platform');
+    console.error('2. Missing system dependencies (libhamlib-dev)');
+    console.error('3. Missing build tools (node-gyp, compiler)');
+    console.error('');
+    console.error('To resolve this:');
+    console.error('System dependencies:');
+    console.error('  Linux: sudo apt-get install libhamlib-dev');
+    console.error('  macOS: brew install hamlib');
+    console.error('  Windows: Install hamlib via vcpkg or from source');
+    console.error('');
+    console.error('Build tools:');
+    console.error('  npm install -g node-gyp');
+    console.error('  # Follow node-gyp platform-specific setup instructions');
+    
+    process.exit(1);
+  }
+}
+
+// Run only if this script is called directly
+if (require.main === module) {
+  main().catch(error => {
+    console.error('Installation failed:', error);
+    process.exit(1);
+  });
+} 

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&);