hamlib 0.4.1 → 0.4.3

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 } = require('hamlib');
 
 async function main() {
   // Create rig instance (model 1035 = FT-991A)
@@ -55,6 +57,13 @@ async function main() {
   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
@@ -136,6 +166,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

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 / 电台型号。
@@ -378,6 +439,62 @@ interface SerialConfigOptions {
   dcd_type: string[];
 }
 
+type HamlibConfigFieldType =
+  | 'string'
+  | 'combo'
+  | 'numeric'
+  | 'checkbutton'
+  | 'button'
+  | 'binary'
+  | 'int'
+  | 'unknown';
+
+interface HamlibConfigFieldDescriptor {
+  token: number;
+  name: string;
+  label: string;
+  tooltip: string;
+  defaultValue: string;
+  type: HamlibConfigFieldType;
+  numeric?: {
+    min: number;
+    max: number;
+    step: number;
+  };
+  options?: string[];
+}
+
+type HamlibPortType =
+  | 'none'
+  | 'serial'
+  | 'network'
+  | 'device'
+  | 'packet'
+  | 'dtmf'
+  | 'ultra'
+  | 'rpc'
+  | 'parallel'
+  | 'usb'
+  | 'udp-network'
+  | 'cm108'
+  | 'gpio'
+  | 'gpion'
+  | 'other';
+
+interface HamlibPortCaps {
+  portType: HamlibPortType;
+  serialRateMin?: number;
+  serialRateMax?: number;
+  serialDataBits?: number;
+  serialStopBits?: number;
+  serialParity?: string;
+  serialHandshake?: string;
+  writeDelay: number;
+  postWriteDelay: number;
+  timeout: number;
+  retry: number;
+}
+
 /**
  * HamLib class - for controlling amateur radio devices
  */
@@ -856,6 +973,18 @@ declare class HamLib extends EventEmitter {
    */
   getSupportedSerialConfigs(): SerialConfigOptions;
 
+  /**
+   * Get backend-specific configuration schema for the current rig model.
+   * This can be queried before opening the connection and is suitable for
+   * driving dynamic configuration UIs.
+   */
+  getConfigSchema(): HamlibConfigFieldDescriptor[];
+
+  /**
+   * Get backend port capabilities and effective connection defaults.
+   */
+  getPortCaps(): HamlibPortCaps;
+
   // Power Control
 
   /**
@@ -1231,6 +1360,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
@@ -1506,6 +1636,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
  */
@@ -1536,16 +1710,19 @@ interface VfoInfo {
  */
 declare const nodeHamlib: {
   HamLib: typeof HamLib;
+  Rotator: typeof Rotator;
 };
 
 // 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, HamLib, Rotator };
 
 // Support both CommonJS and ES module exports
 // @ts-ignore

package/lib/index.js

@@ -589,6 +589,25 @@ class HamLib extends EventEmitter {
     return this._nativeInstance.getSupportedSerialConfigs();
   }
 
+  /**
+   * Get backend-specific configuration schema for the selected rig model.
+   * This can be queried before opening the connection and is intended for
+   * dynamic configuration UIs.
+   * @returns {Array<Object>} List of config field descriptors
+   */
+  getConfigSchema() {
+    return this._nativeInstance.getConfigSchema();
+  }
+
+  /**
+   * Get backend port capabilities and effective connection defaults derived
+   * from Hamlib rig caps for the selected model.
+   * @returns {Object} Port type and default connection parameters
+   */
+  getPortCaps() {
+    return this._nativeInstance.getPortCaps();
+  }
+
   // Power Control
 
   /**
@@ -1054,18 +1073,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);
   }
 
   /**
@@ -1391,7 +1413,143 @@ 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 };
 module.exports.HamLib = HamLib;
-module.exports.default = { HamLib }; 
+module.exports.Rotator = Rotator;
+module.exports.default = { HamLib, Rotator };

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 } = require('./index.js');
 
 // Export for ES modules
-export { HamLib };
-export default { HamLib }; 
+export { HamLib, Rotator };
+export default { HamLib, Rotator }; 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hamlib",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "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)