hamlib 0.1.6 → 0.1.8

package/lib/index.js

@@ -36,15 +36,7 @@ class HamLib {
    * @throws {Error} Throws error when connection fails
    */
   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);
-        }
-      });
-    });
+    return this._nativeInstance.open();
   }
 
   /**
@@ -53,15 +45,7 @@ class HamLib {
    * @throws {Error} Throws error when device doesn't support or operation fails
    */
   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);
-        }
-      });
-    });
+    return this._nativeInstance.setVfo(vfo);
   }
 
   /**
@@ -70,52 +54,31 @@ class HamLib {
    * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
    */
   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);
-          }
-        });
-      }
-    });
+    if (vfo) {
+      return this._nativeInstance.setFrequency(frequency, vfo);
+    } else {
+      return this._nativeInstance.setFrequency(frequency);
+    }
   }
 
   /**
    * Set radio mode
    * @param {string} mode - Radio mode ('USB', 'LSB', 'FM', 'PKTFM', etc.)
    * @param {string} [bandwidth] - Optional bandwidth ('narrow', 'wide')
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
    */
-  async setMode(mode, bandwidth) {
-    return new Promise((resolve, reject) => {
+  async setMode(mode, bandwidth, vfo) {
+    if (vfo !== undefined) {
       if (bandwidth) {
-        this._nativeInstance.setMode(mode, bandwidth, (err, result) => {
-          if (err) {
-            reject(new Error(err.message || 'Failed to set mode'));
-          } else {
-            resolve(result);
-          }
-        });
+        return this._nativeInstance.setMode(mode, bandwidth, vfo);
       } else {
-        this._nativeInstance.setMode(mode, (err, result) => {
-          if (err) {
-            reject(new Error(err.message || 'Failed to set mode'));
-          } else {
-            resolve(result);
-          }
-        });
+        return this._nativeInstance.setMode(mode, vfo);
       }
-    });
+    } else if (bandwidth) {
+      return this._nativeInstance.setMode(mode, bandwidth);
+    } else {
+      return this._nativeInstance.setMode(mode);
+    }
   }
 
   /**
@@ -123,31 +86,22 @@ class HamLib {
    * @param {boolean} state - true to enable PTT, false to disable
    */
   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);
-        }
-      });
-    });
+    return this._nativeInstance.setPtt(state);
   }
 
   /**
    * Get current VFO
-   * @returns {string} Current VFO identifier
+   * @param {Object} [options] - Options for VFO query
+   * @param {boolean} [options.fallbackToDefault=false] - Return default VFO instead of throwing error if not supported
+   * @returns {string} Current VFO identifier ('VFO-A', 'VFO-B', or 'VFO-CURR')
    */
-  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);
-        }
-      });
-    });
+  async getVfo(options = {}) {
+    try {
+      return await this._nativeInstance.getVfo();
+    } catch (error) {
+      // 如果无线电不支持VFO查询，且用户要求回退到默认值
+      return 'VFO-CURR';  // 返回合理的默认值
+    }
   }
 
   /**
@@ -156,25 +110,11 @@ class HamLib {
    * @returns {number} Current frequency in hertz
    */
   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);
-          }
-        });
-      }
-    });
+    if (vfo) {
+      return this._nativeInstance.getFrequency(vfo);
+    } else {
+      return this._nativeInstance.getFrequency();
+    }
   }
 
   /**
@@ -182,31 +122,20 @@ class HamLib {
    * @returns {Object} Object containing mode and bandwidth information
    */
   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);
-        }
-      });
-    });
+    return this._nativeInstance.getMode();
   }
 
   /**
    * Get current signal strength
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
    * @returns {number} Signal strength value
    */
-  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);
-        }
-      });
-    });
+  async getStrength(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getStrength(vfo);
+    } else {
+      return this._nativeInstance.getStrength();
+    }
   }
 
   /**
@@ -214,15 +143,7 @@ class HamLib {
    * Connection can be re-established by calling open()
    */
   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);
-        }
-      });
-    });
+    return this._nativeInstance.close();
   }
 
   /**
@@ -230,15 +151,7 @@ class HamLib {
    * Object reference should be deleted after calling this
    */
   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);
-        }
-      });
-    });
+    return this._nativeInstance.destroy();
   }
 
   /**
@@ -256,7 +169,7 @@ class HamLib {
    * @param {number} channelNumber - Memory channel number
    * @param {Object} channelData - Channel data (frequency, mode, description, etc.)
    */
-  setMemoryChannel(channelNumber, channelData) {
+  async setMemoryChannel(channelNumber, channelData) {
     return this._nativeInstance.setMemoryChannel(channelNumber, channelData);
   }
 
@@ -266,7 +179,7 @@ class HamLib {
    * @param {boolean} [readOnly=true] - Whether to read in read-only mode
    * @returns {Object} Channel data
    */
-  getMemoryChannel(channelNumber, readOnly = true) {
+  async getMemoryChannel(channelNumber, readOnly = true) {
     return this._nativeInstance.getMemoryChannel(channelNumber, readOnly);
   }
 
@@ -274,7 +187,7 @@ class HamLib {
    * Select memory channel for operation
    * @param {number} channelNumber - Memory channel number to select
    */
-  selectMemoryChannel(channelNumber) {
+  async selectMemoryChannel(channelNumber) {
     return this._nativeInstance.selectMemoryChannel(channelNumber);
   }
 
@@ -284,7 +197,7 @@ class HamLib {
    * Set RIT (Receiver Incremental Tuning) offset
    * @param {number} offsetHz - RIT offset in Hz
    */
-  setRit(offsetHz) {
+  async setRit(offsetHz) {
     return this._nativeInstance.setRit(offsetHz);
   }
 
@@ -292,7 +205,7 @@ class HamLib {
    * Get current RIT offset
    * @returns {number} RIT offset in Hz
    */
-  getRit() {
+  async getRit() {
     return this._nativeInstance.getRit();
   }
 
@@ -300,7 +213,7 @@ class HamLib {
    * Set XIT (Transmitter Incremental Tuning) offset
    * @param {number} offsetHz - XIT offset in Hz
    */
-  setXit(offsetHz) {
+  async setXit(offsetHz) {
     return this._nativeInstance.setXit(offsetHz);
   }
 
@@ -308,7 +221,7 @@ class HamLib {
    * Get current XIT offset
    * @returns {number} XIT offset in Hz
    */
-  getXit() {
+  async getXit() {
     return this._nativeInstance.getXit();
   }
 
@@ -316,7 +229,7 @@ class HamLib {
    * Clear both RIT and XIT offsets
    * @returns {boolean} Success status
    */
-  clearRitXit() {
+  async clearRitXit() {
     return this._nativeInstance.clearRitXit();
   }
 
@@ -327,14 +240,14 @@ class HamLib {
    * @param {string} scanType - Scan type ('VFO', 'MEM', 'PROG', 'DELTA', 'PRIO')
    * @param {number} [channel=0] - Optional channel number for some scan types
    */
-  startScan(scanType, channel = 0) {
+  async startScan(scanType, channel = 0) {
     return this._nativeInstance.startScan(scanType, channel);
   }
 
   /**
    * Stop scanning operation
    */
-  stopScan() {
+  async stopScan() {
     return this._nativeInstance.stopScan();
   }
 
@@ -345,7 +258,7 @@ class HamLib {
    * @param {string} levelType - Level type ('AF', 'RF', 'SQL', 'RFPOWER', etc.)
    * @param {number} value - Level value (0.0-1.0 typically)
    */
-  setLevel(levelType, value) {
+  async setLevel(levelType, value) {
     return this._nativeInstance.setLevel(levelType, value);
   }
 
@@ -354,7 +267,7 @@ class HamLib {
    * @param {string} levelType - Level type ('AF', 'RF', 'SQL', 'STRENGTH', etc.)
    * @returns {number} Level value
    */
-  getLevel(levelType) {
+  async getLevel(levelType) {
     return this._nativeInstance.getLevel(levelType);
   }
 
@@ -373,7 +286,7 @@ class HamLib {
    * @param {string} functionType - Function type ('NB', 'COMP', 'VOX', 'TONE', etc.)
    * @param {boolean} enable - true to enable, false to disable
    */
-  setFunction(functionType, enable) {
+  async setFunction(functionType, enable) {
     return this._nativeInstance.setFunction(functionType, enable);
   }
 
@@ -382,7 +295,7 @@ class HamLib {
    * @param {string} functionType - Function type ('NB', 'COMP', 'VOX', 'TONE', etc.)
    * @returns {boolean} Function enabled status
    */
-  getFunction(functionType) {
+  async getFunction(functionType) {
     return this._nativeInstance.getFunction(functionType);
   }
 
@@ -399,54 +312,92 @@ class HamLib {
   /**
    * Set split mode TX frequency
    * @param {number} txFrequency - TX frequency in Hz
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
    */
-  setSplitFreq(txFrequency) {
-    return this._nativeInstance.setSplitFreq(txFrequency);
+  async setSplitFreq(txFrequency, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setSplitFreq(txFrequency, vfo);
+    } else {
+      return this._nativeInstance.setSplitFreq(txFrequency);
+    }
   }
 
   /**
    * Get split mode TX frequency
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
    * @returns {number} TX frequency in Hz
    */
-  getSplitFreq() {
-    return this._nativeInstance.getSplitFreq();
+  async getSplitFreq(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getSplitFreq(vfo);
+    } else {
+      return this._nativeInstance.getSplitFreq();
+    }
   }
 
   /**
    * Set split mode TX mode
    * @param {string} txMode - TX mode ('USB', 'LSB', 'FM', etc.)
    * @param {number} [txWidth] - Optional TX bandwidth
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
    */
-  setSplitMode(txMode, txWidth) {
-    if (txWidth !== undefined) {
+  async setSplitMode(txMode, txWidth, vfo) {
+    if (vfo !== undefined) {
+      if (txWidth !== undefined) {
+        return this._nativeInstance.setSplitMode(txMode, txWidth, vfo);
+      } else {
+        return this._nativeInstance.setSplitMode(txMode, vfo);
+      }
+    } else if (txWidth !== undefined) {
       return this._nativeInstance.setSplitMode(txMode, txWidth);
+    } else {
+      return this._nativeInstance.setSplitMode(txMode);
     }
-    return this._nativeInstance.setSplitMode(txMode);
   }
 
   /**
    * Get split mode TX mode
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
    * @returns {Object} TX mode and width
    */
-  getSplitMode() {
-    return this._nativeInstance.getSplitMode();
+  async getSplitMode(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getSplitMode(vfo);
+    } else {
+      return this._nativeInstance.getSplitMode();
+    }
   }
 
   /**
    * Enable/disable split operation
    * @param {boolean} enable - true to enable split, false to disable
-   * @param {string} [txVfo='VFO-B'] - TX VFO ('VFO-A' or 'VFO-B')
+   * @param {string} [rxVfo] - RX VFO ('VFO-A' or 'VFO-B'). Default: current VFO
+   * @param {string} [txVfo] - TX VFO ('VFO-A' or 'VFO-B'). Default: VFO-B
    */
-  setSplit(enable, txVfo = 'VFO-B') {
-    return this._nativeInstance.setSplit(enable, txVfo);
+  async setSplit(enable, rxVfo, txVfo) {
+    if (txVfo !== undefined) {
+      // 3-parameter version: setSplit(enable, rxVfo, txVfo) - matches Hamlib API order
+      return this._nativeInstance.setSplit(enable, rxVfo, txVfo);
+    } else if (rxVfo !== undefined) {
+      // 2-parameter version: setSplit(enable, rxVfo)
+      return this._nativeInstance.setSplit(enable, rxVfo);
+    } else {
+      // 1-parameter version: setSplit(enable)
+      return this._nativeInstance.setSplit(enable);
+    }
   }
 
   /**
    * Get split operation status
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
    * @returns {Object} Split status and TX VFO
    */
-  getSplit() {
-    return this._nativeInstance.getSplit();
+  async getSplit(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getSplit(vfo);
+    } else {
+      return this._nativeInstance.getSplit();
+    }
   }
 
   // VFO Operations
@@ -455,60 +406,75 @@ class HamLib {
    * Perform VFO operation
    * @param {string} operation - VFO operation ('CPY', 'XCHG', 'FROM_VFO', 'TO_VFO', 'MCL', 'UP', 'DOWN', 'BAND_UP', 'BAND_DOWN', 'LEFT', 'RIGHT', 'TUNE', 'TOGGLE')
    */
-  vfoOperation(operation) {
+  async vfoOperation(operation) {
     return this._nativeInstance.vfoOperation(operation);
   }
 
   // Antenna Selection
 
-  /**
-   * Set antenna
-   * @param {number} antenna - Antenna number (1, 2, 3, etc.)
-   */
-  setAntenna(antenna) {
-    return this._nativeInstance.setAntenna(antenna);
-  }
-
-  /**
-   * Get current antenna
-   * @returns {number} Current antenna number
-   */
-  getAntenna() {
-    return this._nativeInstance.getAntenna();
-  }
+  // Note: setAntenna and getAntenna are defined later in the file with full VFO support
 
   // 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} 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');
    */
-  setSerialConfig(paramName, paramValue) {
+  async setSerialConfig(paramName, paramValue) {
     return this._nativeInstance.setSerialConfig(paramName, paramValue);
   }
 
   /**
    * 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');
    */
-  getSerialConfig(paramName) {
+  async getSerialConfig(paramName) {
     return this._nativeInstance.getSerialConfig(paramName);
   }
 
@@ -525,7 +491,7 @@ class HamLib {
    * // Use CAT command for PTT
    * hamlib.setPttType('RIG');
    */
-  setPttType(pttType) {
+  async setPttType(pttType) {
     return this._nativeInstance.setPttType(pttType);
   }
 
@@ -533,7 +499,7 @@ class HamLib {
    * Get current PTT type
    * @returns {string} Current PTT type
    */
-  getPttType() {
+  async getPttType() {
     return this._nativeInstance.getPttType();
   }
 
@@ -550,7 +516,7 @@ class HamLib {
    * // Use CAT command for DCD
    * hamlib.setDcdType('RIG');
    */
-  setDcdType(dcdType) {
+  async setDcdType(dcdType) {
     return this._nativeInstance.setDcdType(dcdType);
   }
 
@@ -558,7 +524,7 @@ class HamLib {
    * Get current DCD type
    * @returns {string} Current DCD type
    */
-  getDcdType() {
+  async getDcdType() {
     return this._nativeInstance.getDcdType();
   }
 
@@ -573,6 +539,545 @@ class HamLib {
   getSupportedSerialConfigs() {
     return this._nativeInstance.getSupportedSerialConfigs();
   }
+
+  // Power Control
+
+  /**
+   * Set radio power status
+   * @param {number} status - Power status (0=OFF, 1=ON, 2=STANDBY, 4=OPERATE, 8=UNKNOWN)
+   * @returns {Promise<number>} Success status
+   * @example
+   * await rig.setPowerstat(1); // Power on
+   * await rig.setPowerstat(0); // Power off
+   * await rig.setPowerstat(2); // Standby mode
+   */
+  async setPowerstat(status) {
+    return this._nativeInstance.setPowerstat(status);
+  }
+
+  /**
+   * Get current radio power status
+   * @returns {Promise<number>} Power status (0=OFF, 1=ON, 2=STANDBY, 4=OPERATE, 8=UNKNOWN)
+   * @example
+   * const powerStatus = await rig.getPowerstat();
+   * if (powerStatus === 1) {
+   *   console.log('Radio is powered on');
+   * }
+   */
+  async getPowerstat() {
+    return this._nativeInstance.getPowerstat();
+  }
+
+  // PTT Status Detection
+
+  /**
+   * Get current PTT status
+   * @param {string} [vfo] - Optional VFO to get PTT status from ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
+   * @returns {Promise<boolean>} PTT status (true if transmitting, false if receiving)
+   * @example
+   * const isTransmitting = await rig.getPtt();
+   * if (isTransmitting) {
+   *   console.log('Radio is transmitting');
+   * }
+   */
+  async getPtt(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getPtt(vfo);
+    } else {
+      return this._nativeInstance.getPtt();
+    }
+  }
+
+  // Data Carrier Detect
+
+  /**
+   * Get current DCD (Data Carrier Detect) status
+   * @param {string} [vfo] - Optional VFO to get DCD status from ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
+   * @returns {Promise<boolean>} DCD status (true if carrier detected, false if no carrier)
+   * @example
+   * const carrierDetected = await rig.getDcd();
+   * if (carrierDetected) {
+   *   console.log('Carrier detected');
+   * }
+   */
+  async getDcd(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getDcd(vfo);
+    } else {
+      return this._nativeInstance.getDcd();
+    }
+  }
+
+  // Tuning Step Control
+
+  /**
+   * Set tuning step
+   * @param {number} step - Tuning step in Hz
+   * @param {string} [vfo] - Optional VFO to set tuning step on ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
+   * @returns {Promise<number>} Success status
+   * @example
+   * await rig.setTuningStep(25000); // 25 kHz steps
+   * await rig.setTuningStep(12500); // 12.5 kHz steps
+   * await rig.setTuningStep(100);   // 100 Hz steps for HF
+   */
+  async setTuningStep(step, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setTuningStep(step, vfo);
+    } else {
+      return this._nativeInstance.setTuningStep(step);
+    }
+  }
+
+  /**
+   * Get current tuning step
+   * @param {string} [vfo] - Optional VFO to get tuning step from ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
+   * @returns {Promise<number>} Current tuning step in Hz
+   * @example
+   * const step = await rig.getTuningStep();
+   * console.log(`Current tuning step: ${step} Hz`);
+   */
+  async getTuningStep(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getTuningStep(vfo);
+    } else {
+      return this._nativeInstance.getTuningStep();
+    }
+  }
+
+  // Repeater Control
+
+  /**
+   * Set repeater shift direction
+   * @param {string} shift - Repeater shift direction ('NONE', 'MINUS', 'PLUS', '-', '+')
+   * @param {string} [vfo] - Optional VFO to set repeater shift on ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
+   * @returns {Promise<number>} Success status
+   * @example
+   * await rig.setRepeaterShift('PLUS');  // Positive shift (+)
+   * await rig.setRepeaterShift('MINUS'); // Negative shift (-)
+   * await rig.setRepeaterShift('NONE');  // No shift (simplex)
+   */
+  async setRepeaterShift(shift, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setRepeaterShift(shift, vfo);
+    } else {
+      return this._nativeInstance.setRepeaterShift(shift);
+    }
+  }
+
+  /**
+   * Get current repeater shift direction
+   * @param {string} [vfo] - Optional VFO to get repeater shift from ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
+   * @returns {Promise<string>} Current repeater shift direction
+   * @example
+   * const shift = await rig.getRepeaterShift();
+   * console.log(`Repeater shift: ${shift}`); // 'None', 'Minus', or 'Plus'
+   */
+  async getRepeaterShift(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getRepeaterShift(vfo);
+    } else {
+      return this._nativeInstance.getRepeaterShift();
+    }
+  }
+
+  /**
+   * Set repeater offset frequency
+   * @param {number} offset - Repeater offset in Hz
+   * @param {string} [vfo] - Optional VFO to set repeater offset on ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
+   * @returns {Promise<number>} Success status
+   * @example
+   * await rig.setRepeaterOffset(600000);  // 600 kHz offset (2m band)
+   * await rig.setRepeaterOffset(5000000); // 5 MHz offset (70cm band)
+   */
+  async setRepeaterOffset(offset, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setRepeaterOffset(offset, vfo);
+    } else {
+      return this._nativeInstance.setRepeaterOffset(offset);
+    }
+  }
+
+  /**
+   * Get current repeater offset frequency
+   * @param {string} [vfo] - Optional VFO to get repeater offset from ('VFO-A' or 'VFO-B'). If not specified, uses current VFO
+   * @returns {Promise<number>} Current repeater offset in Hz
+   * @example
+   * const offset = await rig.getRepeaterOffset();
+   * console.log(`Repeater offset: ${offset} Hz`);
+   */
+  async getRepeaterOffset(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getRepeaterOffset(vfo);
+    } else {
+      return this._nativeInstance.getRepeaterOffset();
+    }
+  }
+
+  // CTCSS/DCS Tone Control
+
+  /**
+   * Set CTCSS tone frequency
+   * @param {number} tone - CTCSS tone frequency in tenths of Hz (e.g., 1000 for 100.0 Hz)
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async setCtcssTone(tone, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setCtcssTone(tone, vfo);
+    } else {
+      return this._nativeInstance.setCtcssTone(tone);
+    }
+  }
+
+  /**
+   * Get current CTCSS tone frequency
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   * @returns {number} Current CTCSS tone frequency in tenths of Hz
+   */
+  async getCtcssTone(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getCtcssTone(vfo);
+    } else {
+      return this._nativeInstance.getCtcssTone();
+    }
+  }
+
+  /**
+   * Set DCS code
+   * @param {number} code - DCS code (e.g., 23, 174, 754)
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async setDcsCode(code, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setDcsCode(code, vfo);
+    } else {
+      return this._nativeInstance.setDcsCode(code);
+    }
+  }
+
+  /**
+   * Get current DCS code
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   * @returns {number} Current DCS code
+   */
+  async getDcsCode(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getDcsCode(vfo);
+    } else {
+      return this._nativeInstance.getDcsCode();
+    }
+  }
+
+  /**
+   * Set CTCSS SQL (squelch) tone frequency
+   * @param {number} tone - CTCSS SQL tone frequency in tenths of Hz (e.g., 1000 for 100.0 Hz)
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async setCtcssSql(tone, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setCtcssSql(tone, vfo);
+    } else {
+      return this._nativeInstance.setCtcssSql(tone);
+    }
+  }
+
+  /**
+   * Get current CTCSS SQL tone frequency
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   * @returns {number} Current CTCSS SQL tone frequency in tenths of Hz
+   */
+  async getCtcssSql(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getCtcssSql(vfo);
+    } else {
+      return this._nativeInstance.getCtcssSql();
+    }
+  }
+
+  /**
+   * Set DCS SQL (squelch) code
+   * @param {number} code - DCS SQL code (e.g., 23, 174, 754)
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async setDcsSql(code, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setDcsSql(code, vfo);
+    } else {
+      return this._nativeInstance.setDcsSql(code);
+    }
+  }
+
+  /**
+   * Get current DCS SQL code
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   * @returns {number} Current DCS SQL code
+   */
+  async getDcsSql(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getDcsSql(vfo);
+    } else {
+      return this._nativeInstance.getDcsSql();
+    }
+  }
+
+  // Parameter Control
+
+  /**
+   * Set radio parameter
+   * @param {string} paramName - Parameter name (e.g., 'ANN', 'APO', 'BACKLIGHT', 'BEEP', 'TIME', 'BAT')
+   * @param {number} value - Parameter value (numeric)
+   */
+  async setParm(paramName, value) {
+    return this._nativeInstance.setParm(paramName, value);
+  }
+
+  /**
+   * Get radio parameter value
+   * @param {string} paramName - Parameter name (e.g., 'ANN', 'APO', 'BACKLIGHT', 'BEEP', 'TIME', 'BAT')
+   * @returns {number} Parameter value
+   */
+  async getParm(paramName) {
+    return this._nativeInstance.getParm(paramName);
+  }
+
+  // DTMF Support
+
+  /**
+   * Send DTMF digits
+   * @param {string} digits - DTMF digits to send (0-9, A-D, *, #)
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async sendDtmf(digits, vfo) {
+    if (vfo) {
+      return this._nativeInstance.sendDtmf(digits, vfo);
+    } else {
+      return this._nativeInstance.sendDtmf(digits);
+    }
+  }
+
+  /**
+   * Receive DTMF digits
+   * @param {number} [maxLength=32] - Maximum number of digits to receive
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   * @returns {Object} Object containing digits and length
+   */
+  async recvDtmf(maxLength, vfo) {
+    if (vfo) {
+      return this._nativeInstance.recvDtmf(maxLength || 32, vfo);
+    } else {
+      return this._nativeInstance.recvDtmf(maxLength || 32);
+    }
+  }
+
+  // Memory Channel Advanced Operations
+
+  /**
+   * Get current memory channel number
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   * @returns {number} Current memory channel number
+   */
+  async getMem(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getMem(vfo);
+    } else {
+      return this._nativeInstance.getMem();
+    }
+  }
+
+  /**
+   * Set memory bank
+   * @param {number} bank - Bank number to select
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async setBank(bank, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setBank(bank, vfo);
+    } else {
+      return this._nativeInstance.setBank(bank);
+    }
+  }
+
+  /**
+   * Get total number of memory channels available
+   * @returns {number} Total number of memory channels
+   */
+  async memCount() {
+    return this._nativeInstance.memCount();
+  }
+
+  // Morse Code Support
+
+  /**
+   * Send Morse code message
+   * @param {string} message - Morse code message to send (text will be converted to Morse)
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async sendMorse(message, vfo) {
+    if (vfo) {
+      return this._nativeInstance.sendMorse(message, vfo);
+    } else {
+      return this._nativeInstance.sendMorse(message);
+    }
+  }
+
+  /**
+   * Stop current Morse code transmission
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async stopMorse(vfo) {
+    if (vfo) {
+      return this._nativeInstance.stopMorse(vfo);
+    } else {
+      return this._nativeInstance.stopMorse();
+    }
+  }
+
+  /**
+   * Wait for Morse code transmission to complete
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async waitMorse(vfo) {
+    if (vfo) {
+      return this._nativeInstance.waitMorse(vfo);
+    } else {
+      return this._nativeInstance.waitMorse();
+    }
+  }
+
+  // Voice Memory Support
+
+  /**
+   * Play voice memory channel
+   * @param {number} channel - Voice memory channel number to play
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async sendVoiceMem(channel, vfo) {
+    if (vfo) {
+      return this._nativeInstance.sendVoiceMem(channel, vfo);
+    } else {
+      return this._nativeInstance.sendVoiceMem(channel);
+    }
+  }
+
+  /**
+   * Stop voice memory playback
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async stopVoiceMem(vfo) {
+    if (vfo) {
+      return this._nativeInstance.stopVoiceMem(vfo);
+    } else {
+      return this._nativeInstance.stopVoiceMem();
+    }
+  }
+
+  // Complex Split Frequency/Mode Operations
+
+  /**
+   * Set split frequency and mode simultaneously
+   * @param {number} txFrequency - TX frequency in Hz
+   * @param {string} txMode - TX mode ('USB', 'LSB', 'FM', etc.)
+   * @param {number} txWidth - TX bandwidth in Hz
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   */
+  async setSplitFreqMode(txFrequency, txMode, txWidth, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setSplitFreqMode(txFrequency, txMode, txWidth, vfo);
+    } else {
+      return this._nativeInstance.setSplitFreqMode(txFrequency, txMode, txWidth);
+    }
+  }
+
+  /**
+   * Get split frequency and mode information
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   * @returns {Object} Object containing TX frequency, mode, and width
+   */
+  async getSplitFreqMode(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getSplitFreqMode(vfo);
+    } else {
+      return this._nativeInstance.getSplitFreqMode();
+    }
+  }
+
+  // Antenna Control
+
+  /**
+   * Set antenna selection
+   * @param {number} antenna - Antenna number to select (1-based)
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   * @returns {Promise<number>} Success status
+   * @example
+   * await rig.setAntenna(1); // Select antenna 1
+   * await rig.setAntenna(2); // Select antenna 2
+   */
+  async setAntenna(antenna, vfo) {
+    if (vfo) {
+      return this._nativeInstance.setAntenna(antenna, vfo);
+    } else {
+      return this._nativeInstance.setAntenna(antenna);
+    }
+  }
+
+  /**
+   * Get comprehensive antenna information
+   * @param {string} [vfo] - Optional VFO ('VFO-A' or 'VFO-B')
+   * @returns {Promise<Object>} Antenna information object containing:
+   *   - currentAntenna: Currently selected antenna
+   *   - txAntenna: TX antenna selection
+   *   - rxAntenna: RX antenna selection  
+   *   - option: Additional antenna option/parameter
+   * @example
+   * const antennaInfo = await rig.getAntenna();
+   * console.log(`Current: ${antennaInfo.currentAntenna}, TX: ${antennaInfo.txAntenna}, RX: ${antennaInfo.rxAntenna}`);
+   */
+  async getAntenna(vfo) {
+    if (vfo) {
+      return this._nativeInstance.getAntenna(vfo);
+    } else {
+      return this._nativeInstance.getAntenna();
+    }
+  }
+
+  // Power Conversion Functions
+
+  /**
+   * Convert power level to milliwatts
+   * @param {number} power - Power level (0.0-1.0)
+   * @param {number} frequency - Frequency in Hz
+   * @param {string} mode - Radio mode ('USB', 'LSB', 'FM', etc.)
+   * @returns {Promise<number>} Power in milliwatts
+   * @example
+   * const milliwatts = await rig.power2mW(0.5, 14205000, 'USB');
+   * console.log(`50% power = ${milliwatts} mW`);
+   */
+  async power2mW(power, frequency, mode) {
+    return this._nativeInstance.power2mW(power, frequency, mode);
+  }
+
+  /**
+   * Convert milliwatts to power level
+   * @param {number} milliwatts - Power in milliwatts
+   * @param {number} frequency - Frequency in Hz
+   * @param {string} mode - Radio mode ('USB', 'LSB', 'FM', etc.)
+   * @returns {Promise<number>} Power level (0.0-1.0)
+   * @example
+   * const powerLevel = await rig.mW2power(5000, 14205000, 'USB');
+   * console.log(`5000 mW = ${(powerLevel * 100).toFixed(1)}% power`);
+   */
+  async mW2power(milliwatts, frequency, mode) {
+    return this._nativeInstance.mW2power(milliwatts, frequency, mode);
+  }
+
+  // Reset Function
+
+  /**
+   * Reset radio to default state
+   * @param {string} [resetType='SOFT'] - Reset type ('NONE', 'SOFT', 'VFO', 'MCALL', 'MASTER')
+   */
+  async reset(resetType = 'SOFT') {
+    return this._nativeInstance.reset(resetType);
+  }
 }
 
 // Export for CommonJS