hamlib 0.1.2 → 0.1.4

package/index.d.ts

@@ -24,6 +24,24 @@ interface ModeInfo {
   width: number;
 }
 
+/**
+ * Supported rig information interface
+ */
+interface SupportedRigInfo {
+  /** Rig model number */
+  rigModel: number;
+  /** Model name */
+  modelName: string;
+  /** Manufacturer name */
+  mfgName: string;
+  /** Driver version */
+  version: string;
+  /** Driver status (Alpha, Beta, Stable, etc.) */
+  status: string;
+  /** Rig type (Transceiver, Handheld, Mobile, etc.) */
+  rigType: string;
+}
+
 /**
  * VFO type
  */
@@ -34,6 +52,96 @@ type VFO = 'VFO-A' | 'VFO-B';
  */
 type RadioMode = 'USB' | 'LSB' | 'FM' | 'PKTFM' | 'AM' | 'CW' | 'RTTY' | 'DIG' | string;
 
+/**
+ * Memory channel data interface
+ */
+interface MemoryChannelData {
+  /** Channel frequency in Hz */
+  frequency?: number;
+  /** Radio mode */
+  mode?: RadioMode;
+  /** Bandwidth */
+  bandwidth?: number;
+  /** Channel description */
+  description?: string;
+  /** TX frequency for split operation */
+  txFrequency?: number;
+  /** CTCSS tone frequency */
+  ctcssTone?: number;
+}
+
+/**
+ * Memory channel info interface
+ */
+interface MemoryChannelInfo {
+  /** Channel number */
+  channelNumber: number;
+  /** Channel frequency */
+  frequency: number;
+  /** Radio mode */
+  mode: string;
+  /** Bandwidth */
+  bandwidth: number;
+  /** Channel description */
+  description: string;
+  /** Split operation enabled */
+  split: boolean;
+  /** TX frequency (if split enabled) */
+  txFrequency?: number;
+  /** CTCSS tone frequency */
+  ctcssTone?: number;
+}
+
+/**
+ * Split mode info interface
+ */
+interface SplitModeInfo {
+  /** TX mode */
+  mode: string;
+  /** TX bandwidth */
+  width: number;
+}
+
+/**
+ * Split status info interface
+ */
+interface SplitStatusInfo {
+  /** Split enabled status */
+  enabled: boolean;
+  /** TX VFO */
+  txVfo: string;
+}
+
+/**
+ * Level type
+ */
+type LevelType = 'AF' | 'RF' | 'SQL' | 'RFPOWER' | 'MICGAIN' | 'IF' | 'APF' | 'NR' | 
+                 'PBT_IN' | 'PBT_OUT' | 'CWPITCH' | 'KEYSPD' | 'NOTCHF' | 'COMP' | 
+                 'AGC' | 'BKINDL' | 'BALANCE' | 'VOXGAIN' | 'VOXDELAY' | 'ANTIVOX' |
+                 'STRENGTH' | 'RAWSTR' | 'SWR' | 'ALC' | 'RFPOWER_METER' | 
+                 'COMP_METER' | 'VD_METER' | 'ID_METER' | 'TEMP_METER' | string;
+
+/**
+ * Function type
+ */
+type FunctionType = 'FAGC' | 'NB' | 'COMP' | 'VOX' | 'TONE' | 'TSQL' | 'SBKIN' | 
+                    'FBKIN' | 'ANF' | 'NR' | 'AIP' | 'APF' | 'TUNER' | 'XIT' | 
+                    'RIT' | 'LOCK' | 'MUTE' | 'VSC' | 'REV' | 'SQL' | 'ABM' | 
+                    'BC' | 'MBC' | 'AFC' | 'SATMODE' | 'SCOPE' | 'RESUME' | 
+                    'TBURST' | string;
+
+/**
+ * Scan type
+ */
+type ScanType = 'VFO' | 'MEM' | 'PROG' | 'DELTA' | 'PRIO';
+
+/**
+ * VFO operation type
+ */
+type VfoOperationType = 'CPY' | 'XCHG' | 'FROM_VFO' | 'TO_VFO' | 'MCL' | 'UP' | 
+                        'DOWN' | 'BAND_UP' | 'BAND_DOWN' | 'LEFT' | 'RIGHT' | 
+                        'TUNE' | 'TOGGLE';
+
 /**
  * HamLib class - for controlling amateur radio devices
  */
@@ -57,6 +165,19 @@ declare class HamLib {
    */
   constructor(model: number, port?: string);
 
+  /**
+   * Get list of all supported radio models
+   * @returns Array of supported radio models with details
+   * @static
+   * @example
+   * const supportedRigs = HamLib.getSupportedRigs();
+   * console.log(`Found ${supportedRigs.length} supported rigs`);
+   * supportedRigs.forEach(rig => {
+   *   console.log(`${rig.rigModel}: ${rig.mfgName} ${rig.modelName} (${rig.status})`);
+   * });
+   */
+  static getSupportedRigs(): SupportedRigInfo[];
+
   /**
    * Open connection to device
    * Must be called before other operations
@@ -148,6 +269,181 @@ declare class HamLib {
    * @returns Object containing connection type, port path, connection status, and model numbers
    */
   getConnectionInfo(): ConnectionInfo;
+
+  // Memory Channel Management
+
+  /**
+   * Set memory channel data
+   * @param channelNumber Memory channel number
+   * @param channelData Channel data (frequency, mode, description, etc.)
+   */
+  setMemoryChannel(channelNumber: number, channelData: MemoryChannelData): void;
+
+  /**
+   * Get memory channel data
+   * @param channelNumber Memory channel number
+   * @param readOnly Whether to read in read-only mode (default: true)
+   * @returns Channel data
+   */
+  getMemoryChannel(channelNumber: number, readOnly?: boolean): MemoryChannelInfo;
+
+  /**
+   * Select memory channel for operation
+   * @param channelNumber Memory channel number to select
+   */
+  selectMemoryChannel(channelNumber: number): void;
+
+  // RIT/XIT Control
+
+  /**
+   * Set RIT (Receiver Incremental Tuning) offset
+   * @param offsetHz RIT offset in Hz
+   */
+  setRit(offsetHz: number): void;
+
+  /**
+   * Get current RIT offset
+   * @returns RIT offset in Hz
+   */
+  getRit(): number;
+
+  /**
+   * Set XIT (Transmitter Incremental Tuning) offset
+   * @param offsetHz XIT offset in Hz
+   */
+  setXit(offsetHz: number): void;
+
+  /**
+   * Get current XIT offset
+   * @returns XIT offset in Hz
+   */
+  getXit(): number;
+
+  /**
+   * Clear both RIT and XIT offsets
+   * @returns Success status
+   */
+  clearRitXit(): boolean;
+
+  // Scanning Operations
+
+  /**
+   * Start scanning operation
+   * @param scanType Scan type ('VFO', 'MEM', 'PROG', 'DELTA', 'PRIO')
+   * @param channel Optional channel number for some scan types
+   */
+  startScan(scanType: ScanType, channel?: number): void;
+
+  /**
+   * Stop scanning operation
+   */
+  stopScan(): void;
+
+  // Level Controls
+
+  /**
+   * Set radio level (gain, volume, etc.)
+   * @param levelType Level type ('AF', 'RF', 'SQL', 'RFPOWER', etc.)
+   * @param value Level value (0.0-1.0 typically)
+   */
+  setLevel(levelType: LevelType, value: number): void;
+
+  /**
+   * Get radio level
+   * @param levelType Level type ('AF', 'RF', 'SQL', 'STRENGTH', etc.)
+   * @returns Level value
+   */
+  getLevel(levelType: LevelType): number;
+
+  /**
+   * Get list of supported level types
+   * @returns Array of supported level types
+   */
+  getSupportedLevels(): string[];
+
+  // Function Controls
+
+  /**
+   * Set radio function on/off
+   * @param functionType Function type ('NB', 'COMP', 'VOX', 'TONE', etc.)
+   * @param enable true to enable, false to disable
+   */
+  setFunction(functionType: FunctionType, enable: boolean): void;
+
+  /**
+   * Get radio function status
+   * @param functionType Function type ('NB', 'COMP', 'VOX', 'TONE', etc.)
+   * @returns Function enabled status
+   */
+  getFunction(functionType: FunctionType): boolean;
+
+  /**
+   * Get list of supported function types
+   * @returns Array of supported function types
+   */
+  getSupportedFunctions(): string[];
+
+  // Split Operations
+
+  /**
+   * Set split mode TX frequency
+   * @param txFrequency TX frequency in Hz
+   */
+  setSplitFreq(txFrequency: number): void;
+
+  /**
+   * Get split mode TX frequency
+   * @returns TX frequency in Hz
+   */
+  getSplitFreq(): number;
+
+  /**
+   * Set split mode TX mode
+   * @param txMode TX mode ('USB', 'LSB', 'FM', etc.)
+   * @param txWidth Optional TX bandwidth
+   */
+  setSplitMode(txMode: RadioMode, txWidth?: number): void;
+
+  /**
+   * Get split mode TX mode
+   * @returns TX mode and width
+   */
+  getSplitMode(): SplitModeInfo;
+
+  /**
+   * Enable/disable split operation
+   * @param enable true to enable split, false to disable
+   * @param txVfo TX VFO ('VFO-A' or 'VFO-B')
+   */
+  setSplit(enable: boolean, txVfo?: VFO): void;
+
+  /**
+   * Get split operation status
+   * @returns Split status and TX VFO
+   */
+  getSplit(): SplitStatusInfo;
+
+  // VFO Operations
+
+  /**
+   * Perform VFO operation
+   * @param operation VFO operation ('CPY', 'XCHG', 'FROM_VFO', 'TO_VFO', etc.)
+   */
+  vfoOperation(operation: VfoOperationType): void;
+
+  // Antenna Selection
+
+  /**
+   * Set antenna
+   * @param antenna Antenna number (1, 2, 3, etc.)
+   */
+  setAntenna(antenna: number): void;
+
+  /**
+   * Get current antenna
+   * @returns Current antenna number
+   */
+  getAntenna(): number;
 }
 
 /**
@@ -158,7 +454,9 @@ declare const nodeHamlib: {
 };
 
 // Export types for use elsewhere
-export { ConnectionInfo, ModeInfo, VFO, RadioMode, HamLib };
+export { ConnectionInfo, ModeInfo, SupportedRigInfo, VFO, RadioMode, MemoryChannelData, 
+         MemoryChannelInfo, SplitModeInfo, SplitStatusInfo, LevelType, FunctionType, 
+         ScanType, VfoOperationType, HamLib };
 
 // Support both CommonJS and ES module exports
 export = nodeHamlib;

package/lib/binary-loader.js

@@ -35,11 +35,11 @@ function getPlatformBinaryPath() {
  */
 function loadNativeModule() {
   const possiblePaths = [
-    // First try prebuilt binary
-    getPlatformBinaryPath(),
-    // Fallback to locally compiled binary
+    // First try locally compiled binary (prioritize latest features)
     path.join(__dirname, '..', 'build', 'Release', 'hamlib.node'),
     path.join(__dirname, '..', 'build', 'Debug', 'hamlib.node'),
+    // Fallback to prebuilt binary
+    getPlatformBinaryPath(),
     // Try different possible locations
     path.join(__dirname, '..', 'hamlib.node'),
     path.join(process.cwd(), 'hamlib.node'),

package/lib/index.js

@@ -21,6 +21,15 @@ class HamLib {
     this._nativeInstance = new nativeModule.HamLib(model, port);
   }
 
+  /**
+   * Get list of all supported radio models
+   * @returns {Array} Array of supported radio models with details
+   * @static
+   */
+  static getSupportedRigs() {
+    return nativeModule.HamLib.getSupportedRigs();
+  }
+
   /**
    * Open connection to the radio device
    * Must be called before other operations
@@ -130,6 +139,234 @@ class HamLib {
   getConnectionInfo() {
     return this._nativeInstance.getConnectionInfo();
   }
+
+  // Memory Channel Management
+  
+  /**
+   * Set memory channel data
+   * @param {number} channelNumber - Memory channel number
+   * @param {Object} channelData - Channel data (frequency, mode, description, etc.)
+   */
+  setMemoryChannel(channelNumber, channelData) {
+    return this._nativeInstance.setMemoryChannel(channelNumber, channelData);
+  }
+
+  /**
+   * Get memory channel data
+   * @param {number} channelNumber - Memory channel number
+   * @param {boolean} [readOnly=true] - Whether to read in read-only mode
+   * @returns {Object} Channel data
+   */
+  getMemoryChannel(channelNumber, readOnly = true) {
+    return this._nativeInstance.getMemoryChannel(channelNumber, readOnly);
+  }
+
+  /**
+   * Select memory channel for operation
+   * @param {number} channelNumber - Memory channel number to select
+   */
+  selectMemoryChannel(channelNumber) {
+    return this._nativeInstance.selectMemoryChannel(channelNumber);
+  }
+
+  // RIT/XIT Control
+
+  /**
+   * Set RIT (Receiver Incremental Tuning) offset
+   * @param {number} offsetHz - RIT offset in Hz
+   */
+  setRit(offsetHz) {
+    return this._nativeInstance.setRit(offsetHz);
+  }
+
+  /**
+   * Get current RIT offset
+   * @returns {number} RIT offset in Hz
+   */
+  getRit() {
+    return this._nativeInstance.getRit();
+  }
+
+  /**
+   * Set XIT (Transmitter Incremental Tuning) offset
+   * @param {number} offsetHz - XIT offset in Hz
+   */
+  setXit(offsetHz) {
+    return this._nativeInstance.setXit(offsetHz);
+  }
+
+  /**
+   * Get current XIT offset
+   * @returns {number} XIT offset in Hz
+   */
+  getXit() {
+    return this._nativeInstance.getXit();
+  }
+
+  /**
+   * Clear both RIT and XIT offsets
+   * @returns {boolean} Success status
+   */
+  clearRitXit() {
+    return this._nativeInstance.clearRitXit();
+  }
+
+  // Scanning Operations
+
+  /**
+   * Start scanning operation
+   * @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) {
+    return this._nativeInstance.startScan(scanType, channel);
+  }
+
+  /**
+   * Stop scanning operation
+   */
+  stopScan() {
+    return this._nativeInstance.stopScan();
+  }
+
+  // Level Controls
+
+  /**
+   * Set radio level (gain, volume, etc.)
+   * @param {string} levelType - Level type ('AF', 'RF', 'SQL', 'RFPOWER', etc.)
+   * @param {number} value - Level value (0.0-1.0 typically)
+   */
+  setLevel(levelType, value) {
+    return this._nativeInstance.setLevel(levelType, value);
+  }
+
+  /**
+   * Get radio level
+   * @param {string} levelType - Level type ('AF', 'RF', 'SQL', 'STRENGTH', etc.)
+   * @returns {number} Level value
+   */
+  getLevel(levelType) {
+    return this._nativeInstance.getLevel(levelType);
+  }
+
+  /**
+   * Get list of supported level types
+   * @returns {Array<string>} Array of supported level types
+   */
+  getSupportedLevels() {
+    return this._nativeInstance.getSupportedLevels();
+  }
+
+  // Function Controls
+
+  /**
+   * Set radio function on/off
+   * @param {string} functionType - Function type ('NB', 'COMP', 'VOX', 'TONE', etc.)
+   * @param {boolean} enable - true to enable, false to disable
+   */
+  setFunction(functionType, enable) {
+    return this._nativeInstance.setFunction(functionType, enable);
+  }
+
+  /**
+   * Get radio function status
+   * @param {string} functionType - Function type ('NB', 'COMP', 'VOX', 'TONE', etc.)
+   * @returns {boolean} Function enabled status
+   */
+  getFunction(functionType) {
+    return this._nativeInstance.getFunction(functionType);
+  }
+
+  /**
+   * Get list of supported function types
+   * @returns {Array<string>} Array of supported function types
+   */
+  getSupportedFunctions() {
+    return this._nativeInstance.getSupportedFunctions();
+  }
+
+  // Split Operations
+
+  /**
+   * Set split mode TX frequency
+   * @param {number} txFrequency - TX frequency in Hz
+   */
+  setSplitFreq(txFrequency) {
+    return this._nativeInstance.setSplitFreq(txFrequency);
+  }
+
+  /**
+   * Get split mode TX frequency
+   * @returns {number} TX frequency in Hz
+   */
+  getSplitFreq() {
+    return this._nativeInstance.getSplitFreq();
+  }
+
+  /**
+   * Set split mode TX mode
+   * @param {string} txMode - TX mode ('USB', 'LSB', 'FM', etc.)
+   * @param {number} [txWidth] - Optional TX bandwidth
+   */
+  setSplitMode(txMode, txWidth) {
+    if (txWidth !== undefined) {
+      return this._nativeInstance.setSplitMode(txMode, txWidth);
+    }
+    return this._nativeInstance.setSplitMode(txMode);
+  }
+
+  /**
+   * Get split mode TX mode
+   * @returns {Object} TX mode and width
+   */
+  getSplitMode() {
+    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')
+   */
+  setSplit(enable, txVfo = 'VFO-B') {
+    return this._nativeInstance.setSplit(enable, txVfo);
+  }
+
+  /**
+   * Get split operation status
+   * @returns {Object} Split status and TX VFO
+   */
+  getSplit() {
+    return this._nativeInstance.getSplit();
+  }
+
+  // VFO Operations
+
+  /**
+   * 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) {
+    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();
+  }
 }
 
 // Export for CommonJS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hamlib",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Node.js wrapper for hamlib radio control library",
   "main": "index.js",
   "module": "lib/index.mjs",
@@ -30,6 +30,7 @@
     "lib/",
     "prebuilds/",
     "src/",
+    "scripts/",
     "index.js",
     "index.d.ts",
     "binding.gyp",