hamlib 0.1.7 → 0.1.9

package/README.md

@@ -5,17 +5,35 @@ Control amateur radio transceivers from Node.js using the [Hamlib](https://hamli
 ## Features
 
 - **300+ Supported Radios** - Yaesu, Icom, Kenwood, Elecraft, FlexRadio, and more
-- **Full Async/Promise API** - Non-blocking operations with async/await support
+- **Full Async/Promise API** - Non-blocking operations with async/await support  
+- **Comprehensive Serial Control** - 13 parameters for complete serial port configuration
 - **Multiple Connections** - Serial ports, network (rigctld), direct control
 - **TypeScript Ready** - Complete type definitions included
 - **Cross-platform** - Windows, Linux, macOS
 
 ## Installation
 
+### Option 1: NPM Installation (Recommended)
 ```bash
 npm install node-hamlib
 ```
 
+The package will automatically use precompiled binaries if available for your platform, otherwise it will build from source.
+
+### Option 2: Manual Prebuilds Installation
+
+For faster installation or offline environments, you can manually install precompiled binaries:
+
+1. **Download Prebuilds**: Go to [Releases](../../releases) and download `node-hamlib-prebuilds.zip`
+2. **Extract**: Unzip to your project's `node_modules/node-hamlib/prebuilds/` directory
+3. **Install**: Run `npm install node-hamlib --ignore-scripts`
+
+**Supported Prebuilt Platforms:**
+- ✅ Linux x64
+- ✅ Linux ARM64
+- ✅ macOS ARM64 (Apple Silicon)
+- ✅ Windows x64
+
 ## Quick Start
 
 ```javascript
@@ -155,17 +173,50 @@ const offset = await rig.getRepeaterOffset();
 
 ### Serial Configuration
 
+Node-hamlib provides **comprehensive serial port configuration** with **13 parameters** covering all aspects of serial communication from basic data format to advanced timing control and device-specific features.
+
+**Important**: Serial configuration must be done **before** calling `rig.open()`.
+
 ```javascript
-// Basic serial settings
-await rig.setSerialConfig('data_bits', '8');
-await rig.setSerialConfig('stop_bits', '1');
-await rig.setSerialConfig('serial_parity', 'None');
-
-// PTT/DCD methods
-await rig.setPttType('RIG');         // Use CAT command
-await rig.setDcdType('RIG');         // Use software squelch
+// Create rig instance
+const rig = new HamLib(1035, '/dev/ttyUSB0');
+
+// Configure serial parameters BEFORE opening connection
+await rig.setSerialConfig('rate', '115200');           // Baud rate: 150 to 4000000 bps
+await rig.setSerialConfig('data_bits', '8');           // Data bits: 5, 6, 7, 8
+await rig.setSerialConfig('serial_parity', 'None');    // Parity: None, Even, Odd, Mark, Space
+await rig.setSerialConfig('timeout', '1000');          // Timeout in milliseconds
+await rig.setSerialConfig('write_delay', '10');        // Inter-byte delay (ms)
+
+// PTT/DCD configuration (also before opening)
+await rig.setPttType('DTR');                           // PTT: RIG, DTR, RTS, NONE, etc.
+await rig.setDcdType('RIG');                           // DCD: RIG, DSR, CTS, NONE, etc.
+
+// Now open the connection with configured settings
+await rig.open();
+
+// Read current settings (can be done anytime)
+const rate = await rig.getSerialConfig('rate');
+const parity = await rig.getSerialConfig('serial_parity');
 ```
 
+#### Complete Serial Configuration Reference
+
+| Category | Parameter | Description | Supported Values |
+|----------|-----------|-------------|------------------|
+| **Basic Serial** | `data_bits` | Number of data bits | `5`, `6`, `7`, `8` |
+| | `stop_bits` | Number of stop bits | `1`, `2` |
+| | `serial_parity` | Parity checking | `None`, `Even`, `Odd`, `Mark`, `Space` |
+| | `serial_handshake` | Flow control | `None`, `Hardware`, `Software` |
+| **Control Signals** | `rts_state` | RTS line state | `ON`, `OFF`, `UNSET` |
+| | `dtr_state` | DTR line state | `ON`, `OFF`, `UNSET` |
+| **Communication** | `rate` | Baud rate (bps) | `150` to `4000000` |
+| | `timeout` | I/O timeout (ms) | Any non-negative integer |
+| | `retry` | Max retry count | Any non-negative integer |
+| **Timing** | `write_delay` | Inter-byte delay (ms) | Any non-negative integer |
+| | `post_write_delay` | Inter-command delay (ms) | Any non-negative integer |
+| **Advanced** | `flushx` | MicroHam flush mode | `true`, `false` |
+
 ## Complete Example
 
 ```javascript

package/index.d.ts

@@ -156,11 +156,43 @@ type VfoOperationType = 'CPY' | 'XCHG' | 'FROM_VFO' | 'TO_VFO' | 'MCL' | 'UP' |
                         'DOWN' | 'BAND_UP' | 'BAND_DOWN' | 'LEFT' | 'RIGHT' | 
                         'TUNE' | 'TOGGLE';
 
+/**
+ * Supported baud rates for serial communication
+ */
+type SerialBaudRate = '150' | '300' | '600' | '1200' | '2400' | '4800' | '9600' | '19200' | 
+                      '38400' | '57600' | '115200' | '230400' | '460800' | '500000' | 
+                      '576000' | '921600' | '1000000' | '1152000' | '1500000' | '2000000' | 
+                      '2500000' | '3000000' | '3500000' | '4000000';
+
+/**
+ * Serial parity values
+ */
+type SerialParity = 'None' | 'Even' | 'Odd' | 'Mark' | 'Space';
+
+/**
+ * Serial handshake values
+ */
+type SerialHandshake = 'None' | 'Hardware' | 'Software';
+
+/**
+ * Serial control signal states
+ */
+type SerialControlState = 'ON' | 'OFF' | 'UNSET';
+
 /**
  * Serial configuration parameter names
  */
-type SerialConfigParam = 'data_bits' | 'stop_bits' | 'serial_parity' | 'serial_handshake' | 
-                        'rts_state' | 'dtr_state';
+type SerialConfigParam = 
+  // Basic serial settings
+  'data_bits' | 'stop_bits' | 'serial_parity' | 'serial_handshake' |
+  // Control signals
+  'rts_state' | 'dtr_state' |
+  // Communication settings
+  'rate' | 'timeout' | 'retry' |
+  // Timing control
+  'write_delay' | 'post_write_delay' |
+  // Advanced features
+  'flushx';
 
 /**
  * PTT (Push-to-Talk) types
@@ -523,30 +555,55 @@ declare class HamLib {
 
   /**
    * 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
+   * @param paramName Parameter name for serial configuration
+   * @param paramValue Parameter value as string
    * @example
-   * // Set data bits to 8
+   * // Basic serial settings
    * await hamlib.setSerialConfig('data_bits', '8');
-   * 
-   * // Set parity to even
+   * await hamlib.setSerialConfig('stop_bits', '1');
    * await hamlib.setSerialConfig('serial_parity', 'Even');
-   * 
-   * // Set handshake to hardware
    * await hamlib.setSerialConfig('serial_handshake', 'Hardware');
+   * 
+   * // Control signals
+   * await hamlib.setSerialConfig('rts_state', 'ON');
+   * await hamlib.setSerialConfig('dtr_state', 'OFF');
+   * 
+   * // Communication settings
+   * await hamlib.setSerialConfig('rate', '115200');
+   * await hamlib.setSerialConfig('timeout', '1000');
+   * await hamlib.setSerialConfig('retry', '3');
+   * 
+   * // Timing control
+   * await hamlib.setSerialConfig('write_delay', '10');
+   * await hamlib.setSerialConfig('post_write_delay', '50');
+   * 
+   * // Advanced features
+   * await hamlib.setSerialConfig('flushx', 'true');
    */
   setSerialConfig(paramName: SerialConfigParam, paramValue: string): Promise<number>;
 
   /**
    * Get serial port configuration parameter
-   * @param paramName Parameter name to retrieve
-   * @returns Parameter value
+   * @param paramName Parameter name to retrieve (any SerialConfigParam)
+   * @returns Parameter value as string
    * @example
-   * // Get current data bits setting
+   * // Get basic serial settings
    * const dataBits = await hamlib.getSerialConfig('data_bits');
-   * 
-   * // Get current parity setting
    * const parity = await hamlib.getSerialConfig('serial_parity');
+   * const handshake = await hamlib.getSerialConfig('serial_handshake');
+   * 
+   * // Get communication settings
+   * const rate = await hamlib.getSerialConfig('rate');
+   * const timeout = await hamlib.getSerialConfig('timeout');
+   * const retry = await hamlib.getSerialConfig('retry');
+   * 
+   * // Get control signals
+   * const rtsState = await hamlib.getSerialConfig('rts_state');
+   * const dtrState = await hamlib.getSerialConfig('dtr_state');
+   * 
+   * // Get timing and advanced settings
+   * const writeDelay = await hamlib.getSerialConfig('write_delay');
+   * const flushx = await hamlib.getSerialConfig('flushx');
    */
   getSerialConfig(paramName: SerialConfigParam): Promise<string>;
 
@@ -1045,7 +1102,8 @@ declare const nodeHamlib: {
 // Export types for use elsewhere
 export { ConnectionInfo, ModeInfo, SupportedRigInfo, AntennaInfo, VFO, RadioMode, MemoryChannelData, 
          MemoryChannelInfo, SplitModeInfo, SplitStatusInfo, LevelType, FunctionType, 
-         ScanType, VfoOperationType, SerialConfigParam, PttType, DcdType, SerialConfigOptions, HamLib };
+         ScanType, VfoOperationType, SerialConfigParam, SerialBaudRate, SerialParity, 
+         SerialHandshake, SerialControlState, PttType, DcdType, SerialConfigOptions, HamLib };
 
 // Support both CommonJS and ES module exports
 // @ts-ignore

package/lib/index.js

@@ -418,17 +418,28 @@ class HamLib {
 
   /**
    * Set serial port configuration parameter
-   * @param {string} paramName - Parameter name ('data_bits', 'stop_bits', 'serial_parity', 'serial_handshake', 'rts_state', 'dtr_state')
+   * 
+   * **IMPORTANT: Must be called BEFORE rig.open()**
+   * Serial configuration cannot be changed after connection is established.
+   * 
+   * @param {string} paramName - Parameter name: 
+   *   - Serial settings: 'data_bits', 'stop_bits', 'serial_parity', 'serial_handshake'
+   *   - Control signals: 'rts_state', 'dtr_state'
+   *   - Communication: 'rate', 'timeout', 'retry'
+   *   - Timing: 'write_delay', 'post_write_delay'
+   *   - Advanced: 'flushx'
    * @param {string} paramValue - Parameter value
    * @example
-   * // Set data bits to 8
-   * hamlib.setSerialConfig('data_bits', '8');
+   * // Configure serial settings BEFORE opening connection
+   * const rig = new HamLib(1035, '/dev/ttyUSB0');
    * 
-   * // Set parity to even
-   * hamlib.setSerialConfig('serial_parity', 'Even');
+   * // Basic serial settings
+   * await rig.setSerialConfig('data_bits', '8');
+   * await rig.setSerialConfig('rate', '115200');
+   * await rig.setSerialConfig('serial_parity', 'None');
    * 
-   * // Set handshake to hardware
-   * hamlib.setSerialConfig('serial_handshake', 'Hardware');
+   * // Now open with configured settings
+   * await rig.open();
    */
   async setSerialConfig(paramName, paramValue) {
     return this._nativeInstance.setSerialConfig(paramName, paramValue);
@@ -436,14 +447,25 @@ class HamLib {
 
   /**
    * Get serial port configuration parameter
-   * @param {string} paramName - Parameter name to retrieve
+   * @param {string} paramName - Parameter name to retrieve (same as setSerialConfig)
    * @returns {string} Parameter value
    * @example
-   * // Get current data bits setting
+   * // Get basic serial settings
    * const dataBits = hamlib.getSerialConfig('data_bits');
-   * 
-   * // Get current parity setting
    * const parity = hamlib.getSerialConfig('serial_parity');
+   * const handshake = hamlib.getSerialConfig('serial_handshake');
+   * 
+   * // Get communication settings
+   * const rate = hamlib.getSerialConfig('rate');
+   * const timeout = hamlib.getSerialConfig('timeout');
+   * 
+   * // Get control signals state
+   * const rtsState = hamlib.getSerialConfig('rts_state');
+   * const dtrState = hamlib.getSerialConfig('dtr_state');
+   * 
+   * // Get timing settings
+   * const writeDelay = hamlib.getSerialConfig('write_delay');
+   * const flushx = hamlib.getSerialConfig('flushx');
    */
   async getSerialConfig(paramName) {
     return this._nativeInstance.getSerialConfig(paramName);

package/package.json

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

package/src/hamlib.cpp

@@ -3,6 +3,7 @@
 #include <string>
 #include <vector>
 #include <memory>
+#include <algorithm>
 
 // Cross-platform compatibility for hamlib token types
 // Linux versions use token_t, some others use hamlib_token_t
@@ -1185,6 +1186,66 @@ public:
             }
             hamlib_instance_->my_rig->state.rigport.parm.serial.dtr_state = state;
             result_code_ = RIG_OK;
+        } else if (param_name_ == "rate") {
+            int rate = std::stoi(param_value_);
+            // Validate supported baud rates based on common values in Hamlib
+            std::vector<int> valid_rates = {150, 300, 600, 1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 
+                                          230400, 460800, 500000, 576000, 921600, 1000000, 1152000, 1500000, 
+                                          2000000, 2500000, 3000000, 3500000, 4000000};
+            if (std::find(valid_rates.begin(), valid_rates.end(), rate) != valid_rates.end()) {
+                hamlib_instance_->my_rig->state.rigport.parm.serial.rate = rate;
+                result_code_ = RIG_OK;
+            } else {
+                result_code_ = -RIG_EINVAL;
+                error_message_ = "Invalid baud rate value";
+            }
+        } else if (param_name_ == "timeout") {
+            int timeout_val = std::stoi(param_value_);
+            if (timeout_val >= 0) {
+                hamlib_instance_->my_rig->state.rigport.timeout = timeout_val;
+                result_code_ = RIG_OK;
+            } else {
+                result_code_ = -RIG_EINVAL;
+                error_message_ = "Timeout must be non-negative";
+            }
+        } else if (param_name_ == "retry") {
+            int retry_val = std::stoi(param_value_);
+            if (retry_val >= 0) {
+                hamlib_instance_->my_rig->state.rigport.retry = (short)retry_val;
+                result_code_ = RIG_OK;
+            } else {
+                result_code_ = -RIG_EINVAL;
+                error_message_ = "Retry count must be non-negative";
+            }
+        } else if (param_name_ == "write_delay") {
+            int delay = std::stoi(param_value_);
+            if (delay >= 0) {
+                hamlib_instance_->my_rig->state.rigport.write_delay = delay;
+                result_code_ = RIG_OK;
+            } else {
+                result_code_ = -RIG_EINVAL;
+                error_message_ = "Write delay must be non-negative";
+            }
+        } else if (param_name_ == "post_write_delay") {
+            int delay = std::stoi(param_value_);
+            if (delay >= 0) {
+                hamlib_instance_->my_rig->state.rigport.post_write_delay = delay;
+                result_code_ = RIG_OK;
+            } else {
+                result_code_ = -RIG_EINVAL;
+                error_message_ = "Post write delay must be non-negative";
+            }
+        } else if (param_name_ == "flushx") {
+            if (param_value_ == "true" || param_value_ == "1") {
+                hamlib_instance_->my_rig->state.rigport.flushx = 1;
+                result_code_ = RIG_OK;
+            } else if (param_value_ == "false" || param_value_ == "0") {
+                hamlib_instance_->my_rig->state.rigport.flushx = 0;
+                result_code_ = RIG_OK;
+            } else {
+                result_code_ = -RIG_EINVAL;
+                error_message_ = "Flushx must be true/false or 1/0";
+            }
         } else {
             result_code_ = -RIG_EINVAL;
             error_message_ = "Unknown serial configuration parameter";
@@ -1278,6 +1339,24 @@ public:
                     break;
             }
             result_code_ = RIG_OK;
+        } else if (param_name_ == "rate") {
+            param_value_ = std::to_string(hamlib_instance_->my_rig->state.rigport.parm.serial.rate);
+            result_code_ = RIG_OK;
+        } else if (param_name_ == "timeout") {
+            param_value_ = std::to_string(hamlib_instance_->my_rig->state.rigport.timeout);
+            result_code_ = RIG_OK;
+        } else if (param_name_ == "retry") {
+            param_value_ = std::to_string(hamlib_instance_->my_rig->state.rigport.retry);
+            result_code_ = RIG_OK;
+        } else if (param_name_ == "write_delay") {
+            param_value_ = std::to_string(hamlib_instance_->my_rig->state.rigport.write_delay);
+            result_code_ = RIG_OK;
+        } else if (param_name_ == "post_write_delay") {
+            param_value_ = std::to_string(hamlib_instance_->my_rig->state.rigport.post_write_delay);
+            result_code_ = RIG_OK;
+        } else if (param_name_ == "flushx") {
+            param_value_ = hamlib_instance_->my_rig->state.rigport.flushx ? "true" : "false";
+            result_code_ = RIG_OK;
         } else {
             result_code_ = -RIG_EINVAL;
             error_message_ = "Unknown serial configuration parameter";
@@ -3400,11 +3479,6 @@ Napi::Value NodeHamLib::GetSupportedRigs(const Napi::CallbackInfo& info) {
 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();
@@ -3422,11 +3496,6 @@ Napi::Value NodeHamLib::SetSerialConfig(const Napi::CallbackInfo& info) {
 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();