hamlib 0.4.2 → 0.4.4

package/README.md

@@ -8,6 +8,8 @@ Control amateur radio transceivers from Node.js using the [Hamlib](https://hamli
 - **Full Async/Promise API** - Non-blocking operations with async/await support  
 - **Comprehensive Serial Control** - 13 parameters for complete serial port configuration
 - **Multiple Connections** - Serial ports, network (rigctld), direct control
+- **Rotator Bridge** - Control antenna rotators through Hamlib's `rot_*` API with the same Promise-first bridge style
+- **Antenna Switching** - Rig antenna APIs now use true 1-based antenna numbers and optional antenna option values
 - **Official Spectrum Streaming** - Wraps Hamlib's official spectrum callback API with Promise helpers and typed events
 - **TypeScript Ready** - Complete type definitions included
 - **Cross-platform** - Windows, Linux, macOS
@@ -38,7 +40,7 @@ For faster installation or offline environments, you can manually install precom
 ## Quick Start
 
 ```javascript
-const { HamLib } = require('hamlib');
+const { HamLib, Rotator, PASSBAND } = require('hamlib');
 
 async function main() {
   // Create rig instance (model 1035 = FT-991A)
@@ -48,13 +50,20 @@ async function main() {
   
   // Basic operations
   await rig.setFrequency(144390000);  // 144.39 MHz
-  await rig.setMode('FM');
+  await rig.setMode('FM', 'nochange');
   
   const freq = await rig.getFrequency();
   const mode = await rig.getMode();
   console.log(`${freq/1000000} MHz ${mode.mode}`);
   
   await rig.close();
+
+  // Create rotator instance (model 1 = Dummy rotator)
+  const rotator = new Rotator(1);
+  await rotator.open();
+  await rotator.setPosition(180, 30);
+  console.log(await rotator.getPosition());
+  await rotator.close();
 }
 
 main().catch(console.error);
@@ -77,6 +86,27 @@ await rig.open();
 await rig.close();
 ```
 
+### Rotator Control
+
+```javascript
+const rotators = Rotator.getSupportedRotators();
+const dummy = rotators.find(r => r.modelName === 'Dummy');
+
+const rotator = new Rotator(dummy.rotModel);
+await rotator.open();
+
+await rotator.setPosition(135, 20);
+const position = await rotator.getPosition();
+
+await rotator.move('RIGHT', 2);
+await rotator.stop();
+
+const status = await rotator.getStatus();
+const caps = rotator.getRotatorCaps();
+
+await rotator.close();
+```
+
 ### Basic Control
 
 ```javascript
@@ -86,6 +116,9 @@ const freq = await rig.getFrequency();
 
 // Mode
 await rig.setMode('USB');
+await rig.setMode('USB', 'nochange');
+await rig.setMode('USB', PASSBAND.NOCHANGE);
+await rig.setMode('USB', rig.getPassbandNormal('USB'));
 const mode = await rig.getMode();
 
 // VFO
@@ -136,6 +169,12 @@ const audioLevel = await rig.getLevel('AF');
 await rig.setFunction('NB', true);   // Noise blanker on
 const voxEnabled = await rig.getFunction('VOX');
 
+// Antenna switching (1-based antenna number)
+await rig.setAntenna(2);             // Select antenna 2
+await rig.setAntenna(2, 7);          // Select antenna 2 with backend-specific option
+const antenna = await rig.getAntenna();
+console.log(antenna.currentAntenna, antenna.option);
+
 // Split operation
 await rig.setSplit(true);            // Enable split
 await rig.setSplitFreq(144340000);   // TX frequency
@@ -324,7 +363,7 @@ async function repeaterOperation() {
     
     // Set up for 2m repeater
     await rig.setFrequency(145500000);      // 145.500 MHz
-    await rig.setMode('FM');
+    await rig.setMode('FM', 'nochange');
     await rig.setRepeaterShift('MINUS');    // Negative offset
     await rig.setRepeaterOffset(600000);    // 600 kHz offset
     await rig.setTuningStep(12500);         // 12.5 kHz steps

package/binding.gyp

@@ -4,6 +4,7 @@
       "target_name": "hamlib",
       "sources": [
         "src/hamlib.cpp",
+        "src/node_rotator.cpp",
         "src/decoder.cpp",
         "src/addon.cpp"
       ],

package/index.d.ts

@@ -9,11 +9,15 @@ interface ConnectionInfo {
   /** Port path or network address */
   portPath: string;
   /** Connection status */
-  connected: boolean;
+  isOpen: boolean;
   /** Original model number */
   originalModel: number;
   /** Actual model number used */
-  actualModel: number;
+  currentModel: number;
+  /** @deprecated Use isOpen */
+  connected?: boolean;
+  /** @deprecated Use currentModel */
+  actualModel?: number;
 }
 
 /**
@@ -44,6 +48,16 @@ interface SupportedRigInfo {
   rigType: string;
 }
 
+interface SupportedRotatorInfo {
+  rotModel: number;
+  modelName: string;
+  mfgName: string;
+  version: string;
+  status: string;
+  rotType: 'azimuth' | 'elevation' | 'azel' | 'other';
+  rotTypeMask: number;
+}
+
 /**
  * Antenna information interface
  */
@@ -58,6 +72,53 @@ interface AntennaInfo {
   option: number;
 }
 
+interface RotatorConnectionInfo {
+  connectionType: 'serial' | 'network';
+  portPath: string;
+  isOpen: boolean;
+  originalModel: number;
+  currentModel: number;
+}
+
+interface RotatorPosition {
+  azimuth: number;
+  elevation: number;
+}
+
+interface RotatorStatus {
+  mask: number;
+  flags: string[];
+}
+
+type RotatorDirection =
+  | 'UP'
+  | 'DOWN'
+  | 'LEFT'
+  | 'RIGHT'
+  | 'CCW'
+  | 'CW'
+  | 'UP_LEFT'
+  | 'UP_RIGHT'
+  | 'DOWN_LEFT'
+  | 'DOWN_RIGHT'
+  | 'UP_CCW'
+  | 'UP_CW'
+  | 'DOWN_CCW'
+  | 'DOWN_CW'
+  | number;
+
+type RotatorResetType = 'ALL' | number;
+
+interface RotatorCaps {
+  rotType: 'azimuth' | 'elevation' | 'azel' | 'other';
+  rotTypeMask: number;
+  minAz: number;
+  maxAz: number;
+  minEl: number;
+  maxEl: number;
+  supportedStatuses: string[];
+}
+
 /**
  * Hamlib VFO token.
  * 实际支持的 token 取决于具体 backend / 电台型号。
@@ -86,6 +147,13 @@ type VFO =
  */
 type RadioMode = 'USB' | 'LSB' | 'FM' | 'PKTFM' | 'AM' | 'CW' | 'RTTY' | 'DIG' | string;
 
+type PassbandSelector = 'narrow' | 'wide' | 'normal' | 'nochange' | number;
+
+interface PassbandConstants {
+  NORMAL: 0;
+  NOCHANGE: -1;
+}
+
 /**
  * Frequency range information
  */
@@ -543,14 +611,16 @@ declare class HamLib extends EventEmitter {
   /**
    * Set radio mode
    * @param mode Radio mode (such as 'USB', 'LSB', 'FM', 'PKTFM')
-   * @param bandwidth Optional bandwidth setting ('narrow', 'wide', or default)
+   * @param bandwidth Optional bandwidth selector ('narrow', 'wide', 'normal', 'nochange') or width in Hz
    * @param vfo Optional VFO to set mode on ('VFOA' or 'VFOB'). If not specified, uses current VFO
    * @example
    * await rig.setMode('USB');
    * await rig.setMode('FM', 'narrow');
+   * await rig.setMode('USB', 'nochange');
+   * await rig.setMode('USB', PASSBAND.NOCHANGE);
    * await rig.setMode('USB', 'wide', 'VFOA');
    */
-  setMode(mode: RadioMode, bandwidth?: 'narrow' | 'wide', vfo?: VFO): Promise<number>;
+  setMode(mode: RadioMode, bandwidth?: PassbandSelector, vfo?: VFO): Promise<number>;
 
   /**
    * Set PTT (Push-to-Talk) status
@@ -1299,6 +1369,7 @@ declare class HamLib extends EventEmitter {
    * await rig.setAntenna(2); // Select antenna 2
    */
   setAntenna(antenna: number, vfo?: VFO): Promise<number>;
+  setAntenna(antenna: number, option: number, vfo?: VFO): Promise<number>;
 
   /**
    * Get comprehensive antenna information
@@ -1574,6 +1645,50 @@ declare class HamLib extends EventEmitter {
   getVfoInfo(vfo?: VFO): Promise<VfoInfo>;
 }
 
+declare class Rotator extends EventEmitter {
+  constructor(model: number, port?: string);
+
+  static getSupportedRotators(): SupportedRotatorInfo[];
+  static getHamlibVersion(): string;
+  static setDebugLevel(level: RigDebugLevel): void;
+  static getDebugLevel(): never;
+  static getCopyright(): string;
+  static getLicense(): string;
+
+  open(): Promise<number>;
+  close(): Promise<number>;
+  destroy(): Promise<number>;
+  getConnectionInfo(): RotatorConnectionInfo;
+
+  setPosition(azimuth: number, elevation: number): Promise<number>;
+  getPosition(): Promise<RotatorPosition>;
+  move(direction: RotatorDirection, speed: number): Promise<number>;
+  stop(): Promise<number>;
+  park(): Promise<number>;
+  reset(resetType: RotatorResetType): Promise<number>;
+
+  getInfo(): Promise<string>;
+  getStatus(): Promise<RotatorStatus>;
+
+  setConf(name: string, value: string): Promise<number>;
+  getConf(name: string): Promise<string>;
+  getConfigSchema(): HamlibConfigFieldDescriptor[];
+  getPortCaps(): HamlibPortCaps;
+  getRotatorCaps(): RotatorCaps;
+
+  setLevel(level: string, value: number): Promise<number>;
+  getLevel(level: string): Promise<number>;
+  getSupportedLevels(): string[];
+
+  setFunction(func: string, enable: boolean): Promise<number>;
+  getFunction(func: string): Promise<boolean>;
+  getSupportedFunctions(): string[];
+
+  setParm(parm: string, value: number): Promise<number>;
+  getParm(parm: string): Promise<number>;
+  getSupportedParms(): string[];
+}
+
 /**
  * Clock information for rig's internal clock
  */
@@ -1604,17 +1719,22 @@ interface VfoInfo {
  */
 declare const nodeHamlib: {
   HamLib: typeof HamLib;
+  Rotator: typeof Rotator;
+  PASSBAND: PassbandConstants;
 };
 
+declare const PASSBAND: PassbandConstants;
+
 // Export types for use elsewhere
-export { ConnectionInfo, ModeInfo, SupportedRigInfo, AntennaInfo, VFO, RadioMode, MemoryChannelData,
+export { ConnectionInfo, ModeInfo, SupportedRigInfo, SupportedRotatorInfo, AntennaInfo, RotatorConnectionInfo,
+         RotatorPosition, RotatorStatus, RotatorDirection, RotatorResetType, RotatorCaps, VFO, RadioMode, MemoryChannelData,
          MemoryChannelInfo, SplitModeInfo, SplitStatusInfo, LevelType, FunctionType,
          ScanType, VfoOperationType, SerialConfigParam, SerialBaudRate, SerialParity,
          SerialHandshake, SerialControlState, PttType, DcdType, SerialConfigOptions,
          HamlibConfigFieldType, HamlibConfigFieldDescriptor, HamlibPortType, HamlibPortCaps,
          SpectrumScopeInfo, SpectrumModeInfo, SpectrumAverageModeInfo, SpectrumLine,
          SpectrumCapabilities, SpectrumSupportSummary, SpectrumConfig, SpectrumDisplayState,
-         ClockInfo, VfoInfo, HamLib };
+         ClockInfo, VfoInfo, PassbandSelector, PassbandConstants, HamLib, Rotator, PASSBAND };
 
 // Support both CommonJS and ES module exports
 // @ts-ignore

package/lib/index.js

@@ -4,6 +4,11 @@ const nodeGypBuild = require('node-gyp-build');
 // Ensure loader resolves from package root (contains prebuilds/ and build/)
 const nativeModule = nodeGypBuild(path.join(__dirname, '..'));
 
+const PASSBAND = Object.freeze({
+  NORMAL: 0,
+  NOCHANGE: -1,
+});
+
 /**
  * HamLib class for controlling amateur radio devices
  * 
@@ -110,7 +115,7 @@ class HamLib extends EventEmitter {
   /**
    * Set radio mode
    * @param {string} mode - Radio mode ('USB', 'LSB', 'FM', 'PKTFM', etc.)
-   * @param {string} [bandwidth] - Optional bandwidth ('narrow', 'wide')
+   * @param {string|number} [bandwidth] - Optional bandwidth selector ('narrow', 'wide', 'normal', 'nochange') or width in Hz
    * @param {string} [vfo] - Optional VFO ('VFOA' or 'VFOB')
    */
   async setMode(mode, bandwidth, vfo) {
@@ -1073,18 +1078,21 @@ class HamLib extends EventEmitter {
   /**
    * Set antenna selection
    * @param {number} antenna - Antenna number to select (1-based)
+   * @param {number|string} [optionOrVfo] - Optional antenna option or VFO token
    * @param {string} [vfo] - Optional VFO ('VFOA' or 'VFOB')
    * @returns {Promise<number>} Success status
    * @example
    * await rig.setAntenna(1); // Select antenna 1
    * await rig.setAntenna(2); // Select antenna 2
    */
-  async setAntenna(antenna, vfo) {
+  async setAntenna(antenna, optionOrVfo, vfo) {
     if (vfo !== undefined) {
-      return this._nativeInstance.setAntenna(antenna, vfo);
-    } else {
-      return this._nativeInstance.setAntenna(antenna);
+      return this._nativeInstance.setAntenna(antenna, optionOrVfo, vfo);
     }
+    if (optionOrVfo !== undefined) {
+      return this._nativeInstance.setAntenna(antenna, optionOrVfo);
+    }
+    return this._nativeInstance.setAntenna(antenna);
   }
 
   /**
@@ -1410,7 +1418,144 @@ class HamLib extends EventEmitter {
   }
 }
 
+class Rotator extends EventEmitter {
+  constructor(model, port) {
+    super();
+    this._nativeInstance = new nativeModule.Rotator(model, port);
+  }
+
+  static getSupportedRotators() {
+    return nativeModule.Rotator.getSupportedRotators();
+  }
+
+  static getHamlibVersion() {
+    return nativeModule.Rotator.getHamlibVersion();
+  }
+
+  static setDebugLevel(level) {
+    return nativeModule.Rotator.setDebugLevel(level);
+  }
+
+  static getDebugLevel() {
+    return nativeModule.Rotator.getDebugLevel();
+  }
+
+  static getCopyright() {
+    return nativeModule.Rotator.getCopyright();
+  }
+
+  static getLicense() {
+    return nativeModule.Rotator.getLicense();
+  }
+
+  async open() {
+    return this._nativeInstance.open();
+  }
+
+  async close() {
+    return this._nativeInstance.close();
+  }
+
+  async destroy() {
+    return this._nativeInstance.destroy();
+  }
+
+  getConnectionInfo() {
+    return this._nativeInstance.getConnectionInfo();
+  }
+
+  async setPosition(azimuth, elevation) {
+    return this._nativeInstance.setPosition(azimuth, elevation);
+  }
+
+  async getPosition() {
+    return this._nativeInstance.getPosition();
+  }
+
+  async move(direction, speed) {
+    return this._nativeInstance.move(direction, speed);
+  }
+
+  async stop() {
+    return this._nativeInstance.stop();
+  }
+
+  async park() {
+    return this._nativeInstance.park();
+  }
+
+  async reset(resetType) {
+    return this._nativeInstance.reset(resetType);
+  }
+
+  async getInfo() {
+    return this._nativeInstance.getInfo();
+  }
+
+  async getStatus() {
+    return this._nativeInstance.getStatus();
+  }
+
+  async setConf(name, value) {
+    return this._nativeInstance.setConf(name, value);
+  }
+
+  async getConf(name) {
+    return this._nativeInstance.getConf(name);
+  }
+
+  getConfigSchema() {
+    return this._nativeInstance.getConfigSchema();
+  }
+
+  getPortCaps() {
+    return this._nativeInstance.getPortCaps();
+  }
+
+  getRotatorCaps() {
+    return this._nativeInstance.getRotatorCaps();
+  }
+
+  async setLevel(level, value) {
+    return this._nativeInstance.setLevel(level, value);
+  }
+
+  async getLevel(level) {
+    return this._nativeInstance.getLevel(level);
+  }
+
+  getSupportedLevels() {
+    return this._nativeInstance.getSupportedLevels();
+  }
+
+  async setFunction(func, enable) {
+    return this._nativeInstance.setFunction(func, enable);
+  }
+
+  async getFunction(func) {
+    return this._nativeInstance.getFunction(func);
+  }
+
+  getSupportedFunctions() {
+    return this._nativeInstance.getSupportedFunctions();
+  }
+
+  async setParm(parm, value) {
+    return this._nativeInstance.setParm(parm, value);
+  }
+
+  async getParm(parm) {
+    return this._nativeInstance.getParm(parm);
+  }
+
+  getSupportedParms() {
+    return this._nativeInstance.getSupportedParms();
+  }
+}
+
 // Export for CommonJS
-module.exports = { HamLib };
+module.exports = { HamLib, Rotator, PASSBAND };
 module.exports.HamLib = HamLib;
-module.exports.default = { HamLib }; 
+module.exports.Rotator = Rotator;
+module.exports.PASSBAND = PASSBAND;
+module.exports.default = { HamLib, Rotator, PASSBAND };

package/lib/index.mjs

@@ -7,8 +7,8 @@ const __dirname = path.dirname(__filename);
 const require = createRequire(import.meta.url);
 
 // Import the CommonJS module
-const { HamLib } = require('./index.js');
+const { HamLib, Rotator, PASSBAND } = require('./index.js');
 
 // Export for ES modules
-export { HamLib };
-export default { HamLib }; 
+export { HamLib, Rotator, PASSBAND };
+export default { HamLib, Rotator, PASSBAND }; 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hamlib",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Node.js bindings for Hamlib rig control with official spectrum streaming support",
   "main": "index.js",
   "module": "lib/index.mjs",

package/src/addon.cpp

@@ -1,5 +1,6 @@
 #include <napi.h>
 #include "hamlib.h"
+#include "node_rotator.h"
 #include "decoder.h"
 #include "shim/hamlib_shim.h"
 
@@ -11,6 +12,9 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   Napi::String name = Napi::String::New(env, "HamLib");
   exports.Set(name, NodeHamLib::GetClass(env));
 
+  Napi::String rotatorName = Napi::String::New(env, "Rotator");
+  exports.Set(rotatorName, NodeRotator::GetClass(env));
+
 
   // Napi::String decoder_name = Napi::String::New(env, "Decoder");
   // exports.Set(decoder_name, Decoder::GetClass(env));
@@ -18,4 +22,4 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   return exports;
 }
 
-NODE_API_MODULE(radio, Init)
+NODE_API_MODULE(radio, Init)