hamlib 0.1.4 → 0.1.6

package/lib/index.js

@@ -35,8 +35,16 @@ class HamLib {
    * Must be called before other operations
    * @throws {Error} Throws error when connection fails
    */
-  open() {
-    return this._nativeInstance.open();
+  async open() {
+    return new Promise((resolve, reject) => {
+      this._nativeInstance.open((err, result) => {
+        if (err) {
+          reject(new Error(err.message || 'Failed to open connection'));
+        } else {
+          resolve(result);
+        }
+      });
+    });
   }
 
   /**
@@ -44,8 +52,16 @@ class HamLib {
    * @param {string} vfo - VFO identifier ('VFO-A' or 'VFO-B')
    * @throws {Error} Throws error when device doesn't support or operation fails
    */
-  setVfo(vfo) {
-    return this._nativeInstance.setVfo(vfo);
+  async setVfo(vfo) {
+    return new Promise((resolve, reject) => {
+      this._nativeInstance.setVfo(vfo, (err, result) => {
+        if (err) {
+          reject(new Error(err.message || 'Failed to set VFO'));
+        } else {
+          resolve(result);
+        }
+      });
+    });
   }
 
   /**
@@ -53,11 +69,26 @@ class HamLib {
    * @param {number} frequency - Frequency in hertz
    * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
    */
-  setFrequency(frequency, vfo) {
-    if (vfo) {
-      return this._nativeInstance.setFrequency(frequency, vfo);
-    }
-    return this._nativeInstance.setFrequency(frequency);
+  async setFrequency(frequency, vfo) {
+    return new Promise((resolve, reject) => {
+      if (vfo) {
+        this._nativeInstance.setFrequency(frequency, vfo, (err, result) => {
+          if (err) {
+            reject(new Error(err.message || 'Failed to set frequency'));
+          } else {
+            resolve(result);
+          }
+        });
+      } else {
+        this._nativeInstance.setFrequency(frequency, (err, result) => {
+          if (err) {
+            reject(new Error(err.message || 'Failed to set frequency'));
+          } else {
+            resolve(result);
+          }
+        });
+      }
+    });
   }
 
   /**
@@ -65,27 +96,58 @@ class HamLib {
    * @param {string} mode - Radio mode ('USB', 'LSB', 'FM', 'PKTFM', etc.)
    * @param {string} [bandwidth] - Optional bandwidth ('narrow', 'wide')
    */
-  setMode(mode, bandwidth) {
-    if (bandwidth) {
-      return this._nativeInstance.setMode(mode, bandwidth);
-    }
-    return this._nativeInstance.setMode(mode);
+  async setMode(mode, bandwidth) {
+    return new Promise((resolve, reject) => {
+      if (bandwidth) {
+        this._nativeInstance.setMode(mode, bandwidth, (err, result) => {
+          if (err) {
+            reject(new Error(err.message || 'Failed to set mode'));
+          } else {
+            resolve(result);
+          }
+        });
+      } else {
+        this._nativeInstance.setMode(mode, (err, result) => {
+          if (err) {
+            reject(new Error(err.message || 'Failed to set mode'));
+          } else {
+            resolve(result);
+          }
+        });
+      }
+    });
   }
 
   /**
    * Set PTT (Push-to-Talk) status
    * @param {boolean} state - true to enable PTT, false to disable
    */
-  setPtt(state) {
-    return this._nativeInstance.setPtt(state);
+  async setPtt(state) {
+    return new Promise((resolve, reject) => {
+      this._nativeInstance.setPtt(state, (err, result) => {
+        if (err) {
+          reject(new Error(err.message || 'Failed to set PTT'));
+        } else {
+          resolve(result);
+        }
+      });
+    });
   }
 
   /**
    * Get current VFO
    * @returns {string} Current VFO identifier
    */
-  getVfo() {
-    return this._nativeInstance.getVfo();
+  async getVfo() {
+    return new Promise((resolve, reject) => {
+      this._nativeInstance.getVfo((err, result) => {
+        if (err) {
+          reject(new Error(err.message || 'Failed to get VFO'));
+        } else {
+          resolve(result);
+        }
+      });
+    });
   }
 
   /**
@@ -93,43 +155,90 @@ class HamLib {
    * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
    * @returns {number} Current frequency in hertz
    */
-  getFrequency(vfo) {
-    if (vfo) {
-      return this._nativeInstance.getFrequency(vfo);
-    }
-    return this._nativeInstance.getFrequency();
+  async getFrequency(vfo) {
+    return new Promise((resolve, reject) => {
+      if (vfo) {
+        this._nativeInstance.getFrequency(vfo, (err, result) => {
+          if (err) {
+            reject(new Error(err.message || 'Failed to get frequency'));
+          } else {
+            resolve(result);
+          }
+        });
+      } else {
+        this._nativeInstance.getFrequency((err, result) => {
+          if (err) {
+            reject(new Error(err.message || 'Failed to get frequency'));
+          } else {
+            resolve(result);
+          }
+        });
+      }
+    });
   }
 
   /**
    * Get current radio mode
    * @returns {Object} Object containing mode and bandwidth information
    */
-  getMode() {
-    return this._nativeInstance.getMode();
+  async getMode() {
+    return new Promise((resolve, reject) => {
+      this._nativeInstance.getMode((err, result) => {
+        if (err) {
+          reject(new Error(err.message || 'Failed to get mode'));
+        } else {
+          resolve(result);
+        }
+      });
+    });
   }
 
   /**
    * Get current signal strength
    * @returns {number} Signal strength value
    */
-  getStrength() {
-    return this._nativeInstance.getStrength();
+  async getStrength() {
+    return new Promise((resolve, reject) => {
+      this._nativeInstance.getStrength((err, result) => {
+        if (err) {
+          reject(new Error(err.message || 'Failed to get signal strength'));
+        } else {
+          resolve(result);
+        }
+      });
+    });
   }
 
   /**
    * Close connection to device
    * Connection can be re-established by calling open()
    */
-  close() {
-    return this._nativeInstance.close();
+  async close() {
+    return new Promise((resolve, reject) => {
+      this._nativeInstance.close((err, result) => {
+        if (err) {
+          reject(new Error(err.message || 'Failed to close connection'));
+        } else {
+          resolve(result);
+        }
+      });
+    });
   }
 
   /**
    * Destroy connection to device
    * Object reference should be deleted after calling this
    */
-  destroy() {
-    return this._nativeInstance.destroy();
+  async destroy() {
+    return new Promise((resolve, reject) => {
+      this._nativeInstance.destroy((err, result) => {
+        if (err) {
+          reject(new Error(err.message || 'Failed to destroy connection'));
+        } else {
+          resolve(result);
+        }
+      });
+    });
   }
 
   /**
@@ -367,6 +476,103 @@ class HamLib {
   getAntenna() {
     return this._nativeInstance.getAntenna();
   }
+
+  // Serial Port Configuration
+
+  /**
+   * Set serial port configuration parameter
+   * @param {string} paramName - Parameter name ('data_bits', 'stop_bits', 'serial_parity', 'serial_handshake', 'rts_state', 'dtr_state')
+   * @param {string} paramValue - Parameter value
+   * @example
+   * // Set data bits to 8
+   * hamlib.setSerialConfig('data_bits', '8');
+   * 
+   * // Set parity to even
+   * hamlib.setSerialConfig('serial_parity', 'Even');
+   * 
+   * // Set handshake to hardware
+   * hamlib.setSerialConfig('serial_handshake', 'Hardware');
+   */
+  setSerialConfig(paramName, paramValue) {
+    return this._nativeInstance.setSerialConfig(paramName, paramValue);
+  }
+
+  /**
+   * Get serial port configuration parameter
+   * @param {string} paramName - Parameter name to retrieve
+   * @returns {string} Parameter value
+   * @example
+   * // Get current data bits setting
+   * const dataBits = hamlib.getSerialConfig('data_bits');
+   * 
+   * // Get current parity setting
+   * const parity = hamlib.getSerialConfig('serial_parity');
+   */
+  getSerialConfig(paramName) {
+    return this._nativeInstance.getSerialConfig(paramName);
+  }
+
+  /**
+   * Set PTT (Push-to-Talk) type
+   * @param {string} pttType - PTT type ('RIG', 'DTR', 'RTS', 'PARALLEL', 'CM108', 'GPIO', 'GPION', 'NONE')
+   * @example
+   * // Use DTR line for PTT
+   * hamlib.setPttType('DTR');
+   * 
+   * // Use RTS line for PTT
+   * hamlib.setPttType('RTS');
+   * 
+   * // Use CAT command for PTT
+   * hamlib.setPttType('RIG');
+   */
+  setPttType(pttType) {
+    return this._nativeInstance.setPttType(pttType);
+  }
+
+  /**
+   * Get current PTT type
+   * @returns {string} Current PTT type
+   */
+  getPttType() {
+    return this._nativeInstance.getPttType();
+  }
+
+  /**
+   * Set DCD (Data Carrier Detect) type
+   * @param {string} dcdType - DCD type ('RIG', 'DSR', 'CTS', 'CD', 'PARALLEL', 'CM108', 'GPIO', 'GPION', 'NONE')
+   * @example
+   * // Use DSR line for DCD
+   * hamlib.setDcdType('DSR');
+   * 
+   * // Use CTS line for DCD
+   * hamlib.setDcdType('CTS');
+   * 
+   * // Use CAT command for DCD
+   * hamlib.setDcdType('RIG');
+   */
+  setDcdType(dcdType) {
+    return this._nativeInstance.setDcdType(dcdType);
+  }
+
+  /**
+   * Get current DCD type
+   * @returns {string} Current DCD type
+   */
+  getDcdType() {
+    return this._nativeInstance.getDcdType();
+  }
+
+  /**
+   * Get supported serial configuration options
+   * @returns {Object} Object containing all supported configuration parameters and their possible values
+   * @example
+   * const configs = hamlib.getSupportedSerialConfigs();
+   * console.log('Supported data bits:', configs.serial.data_bits);
+   * console.log('Supported PTT types:', configs.ptt_type);
+   */
+  getSupportedSerialConfigs() {
+    return this._nativeInstance.getSupportedSerialConfigs();
+  }
 }
 
 // Export for CommonJS

package/package.json

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