hamlib 0.1.8 → 0.1.10

package/README.md

@@ -13,10 +13,27 @@ Control amateur radio transceivers from Node.js using the [Hamlib](https://hamli
 
 ## Installation
 
+### Option 1: NPM Installation (Recommended)
 ```bash
-npm install hamlib
+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
@@ -158,21 +175,29 @@ const offset = await rig.getRepeaterOffset();
 
 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
-// Configure serial parameters
+// 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)
 
-// Read current settings
-const rate = await rig.getSerialConfig('rate');
-const parity = await rig.getSerialConfig('serial_parity');
-
-// PTT/DCD configuration
+// 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

package/lib/index.js

@@ -418,6 +418,10 @@ class HamLib {
 
   /**
    * Set serial port configuration parameter
+   * 
+   * **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'
@@ -426,27 +430,16 @@ class HamLib {
    *   - Advanced: 'flushx'
    * @param {string} paramValue - Parameter value
    * @example
-   * // Basic serial settings
-   * hamlib.setSerialConfig('data_bits', '8');
-   * hamlib.setSerialConfig('stop_bits', '1');
-   * hamlib.setSerialConfig('serial_parity', 'Even');
-   * hamlib.setSerialConfig('serial_handshake', 'Hardware');
+   * // Configure serial settings BEFORE opening connection
+   * const rig = new HamLib(1035, '/dev/ttyUSB0');
    * 
-   * // 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');
+   * // Basic serial settings
+   * await rig.setSerialConfig('data_bits', '8');
+   * await rig.setSerialConfig('rate', '115200');
+   * await rig.setSerialConfig('serial_parity', 'None');
    * 
-   * // Advanced features
-   * hamlib.setSerialConfig('flushx', 'true');
+   * // Now open with configured settings
+   * await rig.open();
    */
   async setSerialConfig(paramName, paramValue) {
     return this._nativeInstance.setSerialConfig(paramName, paramValue);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hamlib",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Node.js wrapper for hamlib radio control library",
   "main": "index.js",
   "module": "lib/index.mjs",
@@ -65,5 +65,6 @@
   "cpu": [
     "x64",
     "arm64"
-  ]
+  ],
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

package/src/hamlib.cpp

@@ -54,7 +54,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -77,7 +81,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -104,7 +112,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, freq_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, freq_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -131,7 +143,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -159,12 +175,16 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        Napi::Object obj = Napi::Object::New(env);
-        // Convert mode to string using rig_strrmode
-        const char* mode_str = rig_strrmode(mode_);
-        obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
-        obj.Set(Napi::String::New(env, "bandwidth"), width_);
-        deferred_.Resolve(obj);
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            // Convert mode to string using rig_strrmode
+            const char* mode_str = rig_strrmode(mode_);
+            obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
+            obj.Set(Napi::String::New(env, "bandwidth"), width_);
+            deferred_.Resolve(obj);
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -191,7 +211,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -217,7 +241,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, strength_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, strength_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -244,7 +272,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -273,7 +305,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, value_.f));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, value_.f));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -300,7 +336,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -327,7 +367,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Boolean::New(env, state_ != 0));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Boolean::New(env, state_ != 0));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -354,7 +398,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -436,7 +484,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -462,7 +514,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -488,7 +544,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, rit_offset_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, rit_offset_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -514,7 +574,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -540,7 +604,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, xit_offset_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, xit_offset_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -574,7 +642,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -597,7 +669,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -624,7 +700,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, tx_freq_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, tx_freq_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -651,7 +731,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -679,16 +763,20 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        Napi::Object obj = Napi::Object::New(env);
-        obj.Set(Napi::String::New(env, "enabled"), Napi::Boolean::New(env, split_ == RIG_SPLIT_ON));
-        
-        const char* vfo_str = "VFO-B";
-        if (tx_vfo_ == RIG_VFO_A) {
-            vfo_str = "VFO-A";
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            obj.Set(Napi::String::New(env, "enabled"), Napi::Boolean::New(env, split_ == RIG_SPLIT_ON));
+            
+            const char* vfo_str = "VFO-B";
+            if (tx_vfo_ == RIG_VFO_A) {
+                vfo_str = "VFO-A";
+            }
+            obj.Set(Napi::String::New(env, "txVfo"), Napi::String::New(env, vfo_str));
+            
+            deferred_.Resolve(obj);
         }
-        obj.Set(Napi::String::New(env, "txVfo"), Napi::String::New(env, vfo_str));
-        
-        deferred_.Resolve(obj);
     }
     
     void OnError(const Napi::Error& e) override {
@@ -716,7 +804,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -805,7 +897,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -833,7 +929,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -857,7 +957,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -885,7 +989,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -909,7 +1017,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -936,7 +1048,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -967,14 +1083,18 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        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("option", Napi::Number::New(env, option_.f));
-        
-        deferred_.Resolve(result);
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } 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("option", Napi::Number::New(env, option_.f));
+            
+            deferred_.Resolve(result);
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1006,7 +1126,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, mwpower_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, mwpower_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1036,7 +1160,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, power_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, power_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1066,7 +1194,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1095,12 +1227,16 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        Napi::Object obj = Napi::Object::New(env);
-        // Convert mode to string using rig_strrmode
-        const char* mode_str = rig_strrmode(tx_mode_);
-        obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
-        obj.Set(Napi::String::New(env, "width"), tx_width_);
-        deferred_.Resolve(obj);
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            // Convert mode to string using rig_strrmode
+            const char* mode_str = rig_strrmode(tx_mode_);
+            obj.Set(Napi::String::New(env, "mode"), Napi::String::New(env, mode_str));
+            obj.Set(Napi::String::New(env, "width"), tx_width_);
+            deferred_.Resolve(obj);
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1254,7 +1390,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1365,7 +1505,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::String::New(env, param_value_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::String::New(env, param_value_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1414,7 +1558,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1469,7 +1617,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::String::New(env, ptt_type_str_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::String::New(env, ptt_type_str_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1519,7 +1671,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1577,7 +1733,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::String::New(env, dcd_type_str_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::String::New(env, dcd_type_str_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1604,7 +1764,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1630,7 +1794,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, static_cast<int>(status_)));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, static_cast<int>(status_)));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1657,7 +1825,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Boolean::New(env, ptt_ == RIG_PTT_ON));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Boolean::New(env, ptt_ == RIG_PTT_ON));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1685,7 +1857,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Boolean::New(env, dcd_ == RIG_DCD_ON));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Boolean::New(env, dcd_ == RIG_DCD_ON));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1713,7 +1889,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1740,7 +1920,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, ts_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, ts_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1768,7 +1952,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1823,7 +2011,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -1850,7 +2042,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, offset_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, offset_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3479,11 +3675,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();
@@ -3501,11 +3692,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();
@@ -3798,7 +3984,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3825,7 +4015,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, tone_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, tone_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3852,7 +4046,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3879,7 +4077,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3906,7 +4108,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3933,7 +4139,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, tone_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, tone_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3960,7 +4170,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -3987,7 +4201,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4015,7 +4233,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4044,7 +4266,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, value_.f));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, value_.f));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4072,7 +4298,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4102,10 +4332,14 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        Napi::Object obj = Napi::Object::New(env);
-        obj.Set(Napi::String::New(env, "digits"), Napi::String::New(env, digits_.substr(0, length_)));
-        obj.Set(Napi::String::New(env, "length"), Napi::Number::New(env, length_));
-        deferred_.Resolve(obj);
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            obj.Set(Napi::String::New(env, "digits"), Napi::String::New(env, digits_.substr(0, length_)));
+            obj.Set(Napi::String::New(env, "length"), Napi::Number::New(env, length_));
+            deferred_.Resolve(obj);
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4135,7 +4369,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, ch_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, ch_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4162,7 +4400,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4192,7 +4434,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, count_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, count_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4219,7 +4465,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4246,7 +4496,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4272,7 +4526,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4299,7 +4557,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4333,7 +4595,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4369,7 +4635,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4405,11 +4675,15 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        Napi::Object obj = Napi::Object::New(env);
-        obj.Set(Napi::String::New(env, "txFrequency"), Napi::Number::New(env, static_cast<double>(tx_freq_)));
-        obj.Set(Napi::String::New(env, "txMode"), Napi::String::New(env, rig_strrmode(tx_mode_)));
-        obj.Set(Napi::String::New(env, "txWidth"), Napi::Number::New(env, static_cast<double>(tx_width_)));
-        deferred_.Resolve(obj);
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            Napi::Object obj = Napi::Object::New(env);
+            obj.Set(Napi::String::New(env, "txFrequency"), Napi::Number::New(env, static_cast<double>(tx_freq_)));
+            obj.Set(Napi::String::New(env, "txMode"), Napi::String::New(env, rig_strrmode(tx_mode_)));
+            obj.Set(Napi::String::New(env, "txWidth"), Napi::Number::New(env, static_cast<double>(tx_width_)));
+            deferred_.Resolve(obj);
+        }
     }
     
     void OnError(const Napi::Error& e) override {
@@ -4439,7 +4713,11 @@ public:
     
     void OnOK() override {
         Napi::Env env = Env();
-        deferred_.Resolve(Napi::Number::New(env, result_code_));
+        if (result_code_ != RIG_OK && !error_message_.empty()) {
+            deferred_.Reject(Napi::Error::New(env, error_message_).Value());
+        } else {
+            deferred_.Resolve(Napi::Number::New(env, result_code_));
+        }
     }
     
     void OnError(const Napi::Error& e) override {