hamlib 0.1.7 → 0.1.8

package/README.md

@@ -5,7 +5,8 @@ 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
@@ -13,7 +14,7 @@ Control amateur radio transceivers from Node.js using the [Hamlib](https://hamli
 ## Installation
 
 ```bash
-npm install node-hamlib
+npm install hamlib
 ```
 
 ## Quick Start
@@ -155,17 +156,42 @@ 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.
+
 ```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
+// Configure serial parameters
+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)
+
+// Read current settings
+const rate = await rig.getSerialConfig('rate');
+const parity = await rig.getSerialConfig('serial_parity');
+
+// PTT/DCD configuration
+await rig.setPttType('DTR');                           // PTT: RIG, DTR, RTS, NONE, etc.
+await rig.setDcdType('RIG');                           // DCD: RIG, DSR, CTS, NONE, etc.
 ```
 
+#### 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,35 @@ class HamLib {
 
   /**
    * Set serial port configuration parameter
-   * @param {string} paramName - Parameter name ('data_bits', 'stop_bits', 'serial_parity', 'serial_handshake', 'rts_state', 'dtr_state')
+   * @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
+   * // Basic serial settings
    * hamlib.setSerialConfig('data_bits', '8');
-   * 
-   * // Set parity to even
+   * hamlib.setSerialConfig('stop_bits', '1');
    * hamlib.setSerialConfig('serial_parity', 'Even');
-   * 
-   * // Set handshake to hardware
    * hamlib.setSerialConfig('serial_handshake', 'Hardware');
+   * 
+   * // Control signals
+   * hamlib.setSerialConfig('rts_state', 'ON');
+   * hamlib.setSerialConfig('dtr_state', 'OFF');
+   * 
+   * // Communication settings
+   * hamlib.setSerialConfig('rate', '115200');
+   * hamlib.setSerialConfig('timeout', '1000');
+   * hamlib.setSerialConfig('retry', '3');
+   * 
+   * // Timing control
+   * hamlib.setSerialConfig('write_delay', '10');
+   * hamlib.setSerialConfig('post_write_delay', '50');
+   * 
+   * // Advanced features
+   * hamlib.setSerialConfig('flushx', 'true');
    */
   async setSerialConfig(paramName, paramValue) {
     return this._nativeInstance.setSerialConfig(paramName, paramValue);
@@ -436,14 +454,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.8",
   "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";