hamlib 0.4.2 → 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 / 电台型号。
@@ -1299,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
@@ -1574,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
  */
@@ -1604,17 +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

@@ -1073,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);
   }
 
   /**
@@ -1410,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.2",
+  "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)

package/src/hamlib.cpp

@@ -106,6 +106,27 @@ static int parseVfoString(Napi::Env env, const std::string& vfoToken) {
   return vfo;
 }
 
+static int antennaOrdinalToMask(Napi::Env env, int antennaOrdinal) {
+  if (antennaOrdinal < 1 || antennaOrdinal > 30) {
+    Napi::RangeError::New(env, "Antenna number must be between 1 and 30").ThrowAsJavaScriptException();
+    return 0;
+  }
+  return static_cast<int>(1u << (antennaOrdinal - 1));
+}
+
+static int antennaMaskToOrdinal(int antennaMask) {
+  const uint32_t mask = static_cast<uint32_t>(antennaMask);
+  if (mask == 0 || (mask & (mask - 1)) != 0) {
+    return 0;
+  }
+  for (int bit = 0; bit < 30; ++bit) {
+    if (mask == (1u << bit)) {
+      return bit + 1;
+    }
+  }
+  return 0;
+}
+
 // Base AsyncWorker implementation with Promise support
 HamLibAsyncWorker::HamLibAsyncWorker(Napi::Env env, NodeHamLib* hamlib_instance)
     : AsyncWorker(env), hamlib_instance_(hamlib_instance), result_code_(0), error_message_(""), deferred_(Napi::Promise::Deferred::New(env)) {}
@@ -1230,9 +1251,9 @@ public:
         } else {
             Napi::Object result = Napi::Object::New(env);
 
-            result.Set("currentAntenna", Napi::Number::New(env, antenna_curr_));
-            result.Set("txAntenna", Napi::Number::New(env, antenna_tx_));
-            result.Set("rxAntenna", Napi::Number::New(env, antenna_rx_));
+            result.Set("currentAntenna", Napi::Number::New(env, antennaMaskToOrdinal(antenna_curr_)));
+            result.Set("txAntenna", Napi::Number::New(env, antennaMaskToOrdinal(antenna_tx_)));
+            result.Set("rxAntenna", Napi::Number::New(env, antennaMaskToOrdinal(antenna_rx_)));
             result.Set("option", Napi::Number::New(env, option_));
 
             deferred_.Resolve(result);
@@ -3768,18 +3789,39 @@ Napi::Value NodeHamLib::SetAntenna(const Napi::CallbackInfo & info) {
     return env.Null();
   }
   
-  int antenna = info[0].As<Napi::Number>().Int32Value();
-  
-  // Support optional VFO parameter: setAntenna(antenna) or setAntenna(antenna, vfo)
-  int vfo = SHIM_RIG_VFO_CURR;
-  if (info.Length() >= 2 && info[1].IsString()) {
-    vfo = parseVfoParameter(info, 1, SHIM_RIG_VFO_CURR);
-    RETURN_NULL_IF_INVALID_VFO(vfo);
+  const int antennaOrdinal = info[0].As<Napi::Number>().Int32Value();
+  const int antenna = antennaOrdinalToMask(env, antennaOrdinal);
+  if (antenna == 0) {
+    return env.Null();
   }
-  
-  // Default option value (can be extended later if needed)
+
+  int vfo = SHIM_RIG_VFO_CURR;
   float option = 0.0f;
 
+  if (info.Length() >= 2) {
+    if (info[1].IsNumber()) {
+      option = info[1].As<Napi::Number>().FloatValue();
+      if (info.Length() >= 3 && info[2].IsString()) {
+        vfo = parseVfoParameter(info, 2, SHIM_RIG_VFO_CURR);
+        RETURN_NULL_IF_INVALID_VFO(vfo);
+      } else if (info.Length() >= 3 && !info[2].IsUndefined()) {
+        Napi::TypeError::New(env, "Expected VFO token as third argument").ThrowAsJavaScriptException();
+        return env.Null();
+      }
+    } else if (info[1].IsString()) {
+      vfo = parseVfoParameter(info, 1, SHIM_RIG_VFO_CURR);
+      RETURN_NULL_IF_INVALID_VFO(vfo);
+    } else if (!info[1].IsUndefined()) {
+      Napi::TypeError::New(env, "Expected antenna option as number or VFO token as string").ThrowAsJavaScriptException();
+      return env.Null();
+    }
+  }
+
+  if (info.Length() >= 3 && info[1].IsString()) {
+    Napi::TypeError::New(env, "Antenna option must come before VFO").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
   SetAntennaAsyncWorker* asyncWorker = new SetAntennaAsyncWorker(env, this, antenna, vfo, option);
   asyncWorker->Queue();
   return asyncWorker->GetPromise();